Scala try all typeclasses in scope - scala

Question

I've got a typeclass pattern in scala and I'd like a method that can be called against any type and return an option based on whether there is an appropriate typeclass available in scope. Concretely, I have:
trait Truthy[A] {
def toBoolean(a:A):Boolean
def unapply(a:Any):Option[Boolean]
}
object Truthy {
implicit object IntTruthy extends Truthy[Int] {
def toBoolean(i:Int) = i == 1
def unapply(a:Any) = a match {
case i:Int => Some(toBoolean(i))
case _ => None
}
}
implicit object BoolTruthy extends Truthy[Boolean] {
def toBoolean(b:Boolean) = b
def unapply(a:Any) = a match {
case i:Boolean => Some(toBoolean(i))
case _ => None
}
}
implicit object StringTruthy extends Truthy[String] {
def toBoolean(s:String) = Set("t", "true", "yes", "y").contains(s.toLowerCase)
def unapply(a:Any) = a match {
case i:String => Some(toBoolean(i))
case _ => None
}
}
def truthy[A](a:A)(implicit ev:Truthy[A]) = ev.toBoolean(a)
}
The truthy method is fine when I know the type of my argument, but I'm consuming data from a source that lacks that type info, so I'd like a function with signature Any => Option[Boolean] that will try all of the Truthy implementations in scope and return the result if one can be found. Obviously I could write
def getTruth(a:Any) = a match {
case IntTruthy(b) => Some(b)
case BoolTruthy(b) => Some(b)
case StringTruthy(b) => Some(b)
case _ => None
}
but that would defeat the whole purpose of the 'openness' of typeclasses.

Answer 1

The ability of the compiler to determine a valid implicit Truthy is limited by the available information at compile time. That means, from the moment you're working with an Any, which says nothing at all of the type, you'll have to "manually" identify the A type, so the compiler can find the Truthy you need.
Then your getTruth would look like:
def getTruth(any: Any): Option[Boolean] = any match {
case i : Int => Some(truthy(i))
case b : Boolean => Some(truthy(b))
...
case _ => None
}

Answer 2

Chirlo's answer is correct. I would add for clarification that the logic to "try all of the Truthy implementations in scope" does not exist. In principle, the compiler should not instantiate every possible object just because it is in scope, unless it is actually referenced or required in some way. Hence, what is "in scope" at compile time due to adding an import would not be there in runtime at all. This can be easily tested:
object Foo {
println("initializing foo")
def sayHello() = println("hello!")
}
object Test2 {
def main(args: Array[String]): Unit = {
val me = "Daniel"
println(s"Hey, I'm $me")
Foo.sayHello()
}
}
Prints:
Hey, I'm Daniel
initializing foo
hello!
If you comment Foo.sayHello() you will see how initializing foo goes away too. The object will not be there in runtime.
In your case, adding a type explicitly allows the compiler to statically define what implicit will be instantiated and referenced (if any).
These java specs might help clarify too.