CODEWITHSUNDEEP
scalaakka
Aranir
Aranir

Reputation: 818

[Akka]: Passing generic type function without type loss

I have a actor message of the following type:

case class RetrieveEntities[A](func:(Vector[A]) => Vector[A])

I then would like to handle the message in the following way:

def receive = {
    case RetrieveEntities(parameters, func) =>
          context.become(retrieveEntities(func))


def retrieveEntities(func:(Vector[T]) => Vector[T])(implicit mf: Manifest[T]){
    case _ => ...
}

And I instantiate the actor in the following way:

TestActorRef(new RetrieveEntitiesService[Picture])

The problem is I receive the following compiler error: 

type mismatch;
[error]  found   : Vector[Any] => Vector[Any]
[error]  required: Vector[T] => Vector[T]
[error]       context.become(retrieveEntities(func))

Which I suppose means I lost the type information but I am unsure why and how to prevent it.

Upvotes: 0

Views: 563

Answers (2)

Aranir
Aranir

Reputation: 818

johanandren's answer was certainly helpful, but at the end I found a way that it could compile and it is working for now.

I needed to give the compiler a more precise type annotation to make it work:

case RetrieveEntities(parameters, func:(Vector[T]) => Vector[T])

I still will continue to use Manifest instead of the new Reflection API (TypeTag and ClassTag) mainly because the library I am using (json4s) uses internally also the Manifest implementation, and I assume it will lead to less problems this way.

Upvotes: 0

johanandren
johanandren

Reputation: 11479

Your example code is a bit to short to give you a solution, but from what you show it seems like what you are trying to do is not possible.

This is why

In Scala (and Java) the type parameters are erased, which means they disappear after compilation, so during runtime they are no longer available. This means that your pattern match on RetrieveEntities(parameters, func) is really a match where A can be anything. You then go on and call a method that is typed with T and there is no way for the compiler to know what you mean with that.

Manifest (which is deprecated), TypeTag and ClassTag are a mechanism that tells the compiler to create an object that provides type information for those after compilation but you have to "save" that information.

To be able to know what A you typed your RetrieveEntitiesService with you would need to take an implicit ClassTag to the constructor to base any logic on it (since when calling the constructor is the time that you know what A is): 

import scala.reflect.ClassTag
case class RetrieveEntities[A](func:(Vector[A]) => Vector[A])(implicit val tag: ClassTag[A])

You could then call runtimeClass on the tag to get the type of A:

scala> val retrieve = RetrieveEntities[String](identity)
scala> retrieve.tag.runtimeClass
res2: Class[_] = class java.lang.String

Note that this still would not let you type a method call with since we are now in runtime, but it would let you use that instance of Class to compare with the runtimeClass of E of the actor and then do a safe cast to RetrieveEntities[E] if you like. (and also regular runtime conditional flows, reflection etc.).

Two important notes before you start doing that

I would not advice you to go down that path until you are more confident with the type system and really really know that there is no other reasonable design that solves your problem. Again I can not help you towards such a solution with the sparse example code given. (Maybe your actor does not really need to know about the type of A for example, or there is a limited set of E:s that you might match on with concrete types)

As an additional warning, type and class tags are not thread safe in Scala 2.10, and might not be safe in 2.11 either, so mixing them with actors might be a bad idea. (http://docs.scala-lang.org/overviews/reflection/thread-safety.html)

Upvotes: 1

Related Questions