Reflection with Typeclasses - scala

Question

I'm writing a little registration module for some application and doing this with typeclasses. Main logic is based on Spray routing:
val api = post {
path("register" / Rest) { rest =>
rest match {
case "user" => register[User]
// ... other cases
}
}
}
}
To simplify i have the following data type for User:
case class User(id: String, email: String)
And to extract entity from POST request i'm using typeclass:
trait EntityExtractor[T] {
def extractFromRequest: Directive[T :: String :: HNil]
}
implementation for user:
object User {
implicit val extractor = new EntityExtractor[User] {
def extractFromRequest: Directive[User :: String :: HNil] =
formFields('email, 'pass).hmap {
case email :: pass :: HNil =>
val id = UID.genId
User(id, email) :: pass :: HNil
}
}
}
The problem arises in my register method which uses a typeclass directive:
def register[T] =
extractEntity[T].apply { entity => // fails here
validateEntity(entity) {
completeRegistration(entity)
}
}
}
def extractEntity[T: EntityExtractor]: Directive[Entity[T] :: HNil] = {
implicitly[EntityExtractor[T]].extractFromRequest.hmap {
case entity :: pass :: HNil => Entity(entity, pass) :: HNil
}
}
And it fail with an exception: could not find implicit value for evidence parameter of type EntityExtractor[T].
Is there any way to fix this with reflection (TypeTags or Manifest) without pattern matching?

Answer 1

Hope the following somewhat contrived example will clarify the whole matter a bit.
Consider this code (which corresponds to your current one):
object Main {
def main(args: Array[String]) {
implicit val intIntable = new Intable[Int] {
def toInt(obj: Int) = obj
}
println(squareAndDouble(10: Int))
}
// Corresponds to your register[T] function
def squareAndDouble[T](obj: T) = {
val d = double[T](obj)
d*d
}
// Corresponds to your extractEntity[T] function
def double[T: Intable](obj: T) = {
implicitly[Intable[T]].toInt(obj)*2
}
}
trait Intable[T] {
def toInt(obj: T): Int
}
This code does not compile with the following error:
test.scala:11: error: could not find implicit value for evidence parameter of type Intable[T]
val d = double[T](obj)
Now let's rewrite it using implicit parameters (that's what the compiler do for us when it sees context bound):
object Main {
def main(args: Array[String]) {
implicit val intIntable = new Intable[Int] {
def toInt(obj: Int) = obj
}
println(squareAndDouble(10: Int))
}
def squareAndDouble[T](obj: T) = {
val d = double[T](obj)
d*d
}
def double[T](obj: T)(implicit intable: Intable[T]) = {
intable.toInt(obj)*2
}
}
trait Intable[T] {
def toInt(obj: T): Int
}
This program does not compile as well:
test.scala:11: error: could not find implicit value for parameter intable: Intable[T]
val d = double[T](obj)
And now it should be more obvious why it does not compile. It fails simply because there is no implicit value ('evidence') for T type parameter inside squareAndDouble function which is required by square function. Since double function need an evidence for its type parameter (which can be anything) the only way for this evidence to appear in scope inside squareAndDouble is from an implicit parameter again, but now in squareAndDouble function.
Basically, that means that you have to 'pass through' the evidence for your generic parameter in order to use the typeclass.
Let's fix it:
object Main {
def main(args: Array[String]) {
implicit val intIntable = new Intable[Int] {
def toInt(obj: Int) = obj
}
println(squareAndDouble(10: Int))
}
// Added context bound here
def squareAndDouble[T: Intable](obj: T) = {
val d = double[T](obj)
d*d
}
def double[T: Intable](obj: T) = {
implicitly[Intable[T]].toInt(obj)*2
}
}
trait Intable[T] {
def toInt(obj: T): Int
}
Now it compiles and runs successfully:
% scalac test.scala
% scala Main
400
Another (may be more simple) way to understand the problem is as follows. Our squareAndDouble[T] function accepts unbounded type parameter T, but then it tries to call another function, double[T: Intable], whose type parameter is bounded. This is not allowed: if it was legal, then it would be possible to call squareAndDouble[T] with any type, even with that which does not have Intable typeclass instance, and this would consequently break double function. Hence we have to add Intable boundary to squareAndDouble function too in order for it to compile: squareAndDouble[T: Intable], and then it works perfectly.
This is in fact very similar to upper/lower bounds which work with class inheritance instead of implicit values.