Daily scala

A commenter (Brian Howard) on the post Overcoming Type Erasure in Matching 1 made a very good point:

Is there a way to deal with some type arguments being contravariant? Try the following:

class A

class B extends A

val AAFunction = new Def[Function1[A,A]]

((a:A) => a) match {case AAFunction(f) => Some(f(new A)); case _ => None} // this is OK

((a:A) => new B) match {case AAFunction(f) => Some(f(new A)); case _ => None} // this is OK

((b:B) => b) match {case AAFunction(f) => Some(f(new A)); case _ => None} // gives a ClassCastException, since new A is not a B

There is a way to do this, however the information is not captured in the Manifest. A manifest is not designed to do full reflection it is by design very light and has little impact on performance. So to provide the functionality requested by Brian one needs to add that information to the Extractor Definition. Have have a possible solution below.

1. scala> class A
2. defined class A
3. scala> class B extends A
4. defined class B
5. scala> object Variance extends Enumeration {
6.      |     val Co, Contra, No = Value
7.      | }
8. defined module Variance
9. scala> import Variance._
10. import Variance._
11. scala> class Def[C](variance:Variance.Value*)(implicit desired : Manifest[C]) {
12.      |     def unapply[X](c : X)(implicit m : Manifest[X]) : Option[C] = {
13.      |         val typeArgsTriplet = desired.typeArguments.zip(m.typeArguments).
14.      |                                                     zipWithIndex
15.      |         def sameArgs = typeArgsTriplet forall {
16.      |             case ((desired,actual),index) if(getVariance(index) == Contra) => 
17.      |                 desired <:< actual 
18.      |             case ((desired,actual),index) if(getVariance(index) == No) => 
19.      |                 desired == actual 
20.      |             case ((desired,actual),index) => 
21.      |                 desired >:> actual
22.      |         }
23.      |         
24.      |         val isAssignable = desired.erasure.isAssignableFrom(m.erasure) || (desired >:> m)
25.      |         if (isAssignable && sameArgs) Some(c.asInstanceOf[C])
26.      |         else None
27.      |     }
28.      |     def getVariance(i:Int) = if(variance.length > i) variance(i) else No
29.      | }
30. defined class Def
31. scala> val AAFunction = new Def[Function1[A,A]]
32. AAFunction: Def[(A) => A] = Def@64a65760
33. scala> ((a:A) => a) match {case AAFunction(f) => Some(f(new A)); case _ => None}
34. res0: Option[A] = Some(A@1bd4f279)
35. scala> ((a:A) => new B) match {case AAFunction(f) => Some(f(new A)); case _ => None}
36. res1: Option[A] = None
37. scala> ((b:B) => b) match {case AAFunction(f) => Some(f(new A)); case _ => None}
38. res2: Option[A] = None
39. scala> val BAFunction = new Def[Function1[B,A]](Contra,Co)
40. BAFunction: Def[(B) => A] = Def@26114629
41. scala> ((b:A) => b) match {case BAFunction(f) => Some(f(new B)); case _ => None}
42. res3: Option[A] = Some(B@15dcc3ca)

Since Scala runs on the JVM (it also runs on .NET but we this tip is aimed at Scala on the JVM) much of the type information that is available at compile-time is lost during runtime. This means certain types of matching are not possible. For example it would be nice to be able to do the following:

1. scala> val x : List[Any] = List(1.0,2.0,3.0)
2. x: List[Any] = List(1, 2, 3)
3. scala> x match { case l : List[Boolean] => l(0) }

If you run this code the list matches the list of ints which is incorrect (I have ran the following with -unchecked so it will print the warning about erasure):

1. scala> val x : List[Any] = List(1.0,2.0,3.0)
2. x: List[Any] = List(1, 2, 3)
3. scala> x match { case l : List[Boolean] => l(0) }         
4. < console>:6: warning: non variable type-argument Boolean in type pattern List[Boolean] is unchecked since it is eliminated by erasure
5.        x match { case l : List[Boolean] => l(0) }
6.                           ^
7. java.lang.ClassCastException: java.lang.Double cannot be cast to java.lang.Boolean
8. at scala.runtime.BoxesRunTime.unboxToBoolean(Unknown Source)
9. at .< init>(< console>:6)

Another example is trying to match on structural types. Wouldn't it be nice to be able to do the following (We will solve this in a future post):

1. scala> "a string" match {
2.      | case l : {def length : Int} => l.length
3.      | }
4. < console>:6: warning: refinement AnyRef{def length: Int} in type pattern AnyRef{def length: Int} is unchecked since it is eliminated by erasure
5.        case l : {def length : Int} => l.length
6.                 ^
7. res5: Int = 8

So lets see what we can do about this. My proposed solution is to create an class that can be used as an extractor when instantiated to do the check.

This is a fairly advanced tip so make sure you have read up on Matchers and Manifests:

• Extractor 1
• Manifests
• Comparing Manifests

The key parts of the next examples are the Def class and the function 'func'. 'func' is defined in the comments in the code block.

The Def class is the definition of what we want to match. Once we have the definition we can use it as an Extractor to match List[Int] instances.

The Def solution is quite generic so it will satisfy may cases where you might want to do matching but erasure is getting in the way.

The secret is to use manifests:

• When the class is created the manifest for the class we want is captured.
• Each time a match is attempted the manifest of the class being matched is captured
• In the unapply method, the two manifests are compared and when they match we can return the matched element but cast to the desired type for the compiler

It is critical to notice the use of the typeArguments of the manifest. This returns a list of the manifests of each typeArgument. You cannot simply compare desired == m because manifest comparisons are not deep. There is a weakness in this code in that it only handles generics that are 1 level deep. For example:

List[Int] can be matched with the following code but List[List[Int]] will match anything that is List[List[_]]. Making the method more generic is an exercise left to the reader.

1. scala> import reflect._ 
2. import reflect._
3. /*
4. This is the key class
5. */
6. scala> class Def[C](implicit desired : Manifest[C]) {
7.      | def unapply[X](c : X)(implicit m : Manifest[X]) : Option[C] = {
8.      |   def sameArgs = desired.typeArguments.zip(m.typeArguments).forall {case (desired,actual) => desired >:> actual}
9.      |   if (desired >:> m && sameArgs) Some(c.asInstanceOf[C])
10.      |   else None
11.      | }
12.      | }
13. defined class Def
14. // first define what we want to match
15. scala> val IntList = new Def[List[Int]]
16. IntList: Def[List[Int]] = Def@6997f7f4
17. /*
18. Now use the object as an extractor.  the variable l will be a typesafe List[Int]
19. */
20. scala> List(1,2,3) match { case IntList(l) => l(1) : Int ; case _ => -1 }
21. res36: Int = 2
22. scala> List(1.0,2,3) match { case IntList(l) => l(1) : Int ; case _ => -1 }
23. res37: Int = -1
24. // 32 is not a list so it will fail to match
25. scala> 32 match { case IntList(l) => l(1) : Int ; case _ => -1 }
26. res2: Int = -1
27. scala> Map(1 -> 3) match { case IntList(l) => l(1) : Int ; case _ => -1 }
28. res3: Int = -1
29. /*
30. The Def class can be used with any Generic type it is not restricted to collections
31. */
32. scala> val IntIntFunction = new Def[Function1[Int,Int]]
33. IntIntFunction: Def[(Int) => Int] = Def@5675e2b4
34. // this will match because it is a function
35. scala> ((i:Int) => 10) match { case IntIntFunction(f) => f(3); case _ => -1}
36. res38: Int = 10
37. // no match because 32 is not a function
38. scala> 32 match { case IntIntFunction(f) => f(3); case _ => -1}
39. res39: Int = -1
40. // Cool Map is a function so it will match
41. scala> Map(3 -> 100) match { case IntIntFunction(f) => f(3); case _ => -1}
42. res6: Int = 100
43. /*
44. Now we see both the power and the limitations of this solution.
46. One might expect that:
47.    def func(a:Any) = {...} 
48. would work.  
50. However, if the function is defined with 'Any' the compiler does not pass in the required information so the manifest that will be created will be a Any manifest object.  Because of this the more convoluted method declaration must be used so the type information is passed in. 
52. I will discuss implicit parameters in some other post
53. */
54. scala> def func[A](a:A)(implicit m:Manifest[A]) = {
55.      |   a match {
56.      |     case IntList(l) => l.head                   
57.      |     case IntIntFunction(f) => f(32)             
58.      |     case i:Int => i                             
59.      |     case _ => -1                                
60.      |   } 
61.      | }
62. func: [A](a: A)(implicit m: Manifest[A])Int
63. scala> func(List(1,2,3))                           
64. res16: Int = 1
65. scala> func('i')                                   
66. res17: Int = -1
67. scala> func(4)
68. res18: Int = 4
69. scala> func((i:Int) => i+2)
70. res19: Int = 34
71. scala> func(Map(32 -> 2))
72. res20: Int = 2

Manifests are Scala's solution to Java's type erasure. It is not a complete solution as of yet but it does have several useful applications. Manifests were originally added to Scala 2.7 in an extremely limited form but have been improved a great deal for Scala 2.8. Now more powerful comparisons of manifests are possible. For another introduction to Manifests (2.7 manifests) see Manifests.

This post looks at a few ways to create manifests as well as how to compare manifests. The goal is to create a method that can be used in testing to require that a certain exception is thrown during a code block:

1. scala> intercepts[Exception] {println("hi :)")}                                            
2. hi :)
3. Expected java.lang.Exception but instead no exception was raised

The code snippet above is a failure because println does not throw an exception. In addition to requiring manifests this code snippet also is a custom control structure, for more information on those see Control Structure Tag

But before writing the intercepts methods a short inspection of the new manifest comparison operators:

1. scala> import scala.reflect.{
2.      |   Manifest, ClassManifest
3.      | }
4. import scala.reflect.{Manifest, ClassManifest}
5. // from class creates a manifest object given a class object
6. scala> import ClassManifest.fromClass
7. import ClassManifest.fromClass
8. // several comparisons using <:<
9. scala> fromClass(classOf[Exception]) <:< fromClass(classOf[Exception])
10. res4: Boolean = true
11. scala> fromClass(classOf[Exception]) <:< fromClass(classOf[RuntimeException])
12. res5: Boolean = false
13. scala> fromClass(classOf[Exception]) <:< fromClass(classOf[AssertionError])         
14. res6: Boolean = false
15. // now the opposite operator >:>
16. scala> fromClass(classOf[Exception]) >:> fromClass(classOf[AssertionError])
17. res7: Boolean = false
18. scala> fromClass(classOf[Exception]) >:> fromClass(classOf[RuntimeException])
19. res8: Boolean = true
20. scala> fromClass(classOf[Exception]) >:> fromClass(classOf[Error])           
21. res9: Boolean = false
22. scala> fromClass(classOf[Exception]) >:> fromClass(classOf[Throwable])
23. res10: Boolean = false
24. // the method singleType creates a manifest given an object
25. scala> ClassManifest.singleType(new RuntimeException())
26. res12: scala.reflect.Manifest[Nothing] = java.lang.RuntimeException.type
27. scala> ClassManifest.singleType(new RuntimeException()) <:< fromClass(classOf[Throwable])
28. res13: Boolean = true
29. scala> fromClass(classOf[Exception]) <:< fromClass(classOf[Throwable])                   
30. res14: Boolean = true

Now the implementation of intercepts:

1. scala> import scala.reflect.{
2.      |   Manifest, ClassManifest
3.      | }
4. import scala.reflect.{Manifest, ClassManifest}
5. scala> 
6. scala> import ClassManifest.singleType
7. import ClassManifest.singleType
8. scala>  def intercepts[E <: Throwable](test : => Unit)(implicit m:Manifest[E]) : Unit = {
9.      |     import Predef.{println => fail}
10.      |     try {
11.      |       test
12.      |       // this is a failure because test is expected to throw an exception
13.      |       fail("Expected "+m.toString+" but instead no exception was raised")
14.      |     }catch{
15.      |       // this checks that the expected type (m) is a superclass of the class of e
16.      |       case e if (m >:> singleType(e)) => ()
17.      |       // any other error is handled here
18.      |       case e => fail("Expected "+m.toString+" but instead got "+e.getClass)
19.      |     }
20.      |   }
21. intercepts: [E <: Throwable](test: => Unit)(implicit m: scala.reflect.Manifest[E])Unit
22. scala> intercepts[Exception] {println("hi :)")}                                            
23. hi :)
24. Expected java.lang.Exception but instead no exception was raised
25. scala> intercepts[Exception] { throw new IllegalArgumentException("why not throw this :)")}
26. scala> intercepts[Exception] { throw new AssertionError("The method should complain")}     
27. Expected java.lang.Exception but instead got class java.lang.AssertionError

Added in Scala 2.7 as an experimental feature is the manifest class it is a handy class allowing for very limited type reification. Take the following example:
def inspect[T](l:List[T])
If you want to know they type of T in Java you are out of luck because that type information is gone. However, Scala offers help through manifests.

1. def inspect[T](l:List[T])(implicit manifest : scala.reflect.Manifest[T]) = println(manifest.toString)

This code snippet will print out the string representation of type T.

More Examples:

1. scala> def inspect[T](l:List[T])(implicit manifest : scala.reflect.Manifest[T]) = println(manifest.toString)
2. inspect: [T](List[T])(implicit scala.reflect.Manifest[T])Unit
3. scala> inspect(List(1,2,3,4))
4. int
5. scala> inspect(List(List(1,2),List(3,4)))
6. scala.List[int]
7. scala> inspect(List(List(List(1),List(2)),List(List(3),List(4))))
8. scala.List[scala.List[int]]
9. scala> val l:List[Iterable[Int]] = List(List(1,2))  
10. l: List[Iterable[Int]] = List(List(1, 2))
11. scala> inspect(l)                                                                                           
12. scala.collection.Iterable[Int]
13. scala> class MV[T](val v:T)(implicit m:scala.reflect.Manifest[T]) { println(m.toString) }
14. defined class MV
15. scala> new MV(1)
16. Int
17. res1: MV[Int] = MV@180e6899
18. scala> class MV2[T](val v:T)(implicit m:scala.reflect.Manifest[T]) {                     
19.      | def isA[A](implicit testManifest:scala.reflect.Manifest[A]) = m.toString == testManifest.toString
20.      | }
21. defined class MV2
22. scala> val x = new MV2(19)
23. x: MV2[Int] = MV2@41ff8506
24. scala> x.isA[String]
25. res2: Boolean = false
26. scala> x.isA[Int]   
27. res3: Boolean = true
28. scala> def isA[A](o:Object)(implicit m:Manifest[A]) = {
29.      | val `class` = Class.forName(m.toString)         
30.      | `class`.isAssignableFrom(o.getClass)            
31.      | }
32. isA: [A](o: java.lang.Object)(implicit m: scala.reflect.Manifest[A])Boolean
33. scala> isA[java.lang.Integer](java.lang.Integer.valueOf(19))
34. res6: Boolean = true