Selection with Implicit Methods

This tip is a cool tip based on Daniel's Use Implicits to Select Types post. That post goes into more detail.

The idea is that depending on a given parameter of type T a particular type of object is required. There are several ways to do this. One would be to use matching to match the type T and create the correct object. Most likely the biggest draw back to matching is caused by type erasure. The following solution gets around that issue.

Two very interesting points.

1. Implicit methods do not require parameters. They can be selected based only on type parameters
2. Implicit methods are not subject to type erasure

1. // the base class we need
2. scala> abstract class X[T] { def id :Unit }
3. defined class X
5. /*
6. One of the types we need created.  It is the catch all case
7. */
8. scala> implicit def a[T] =new X[T] { def id =println("generic") }
9. a: [T]X[T]
11. /*
12. A specific subclass for integers
13. */
14. scala> implicit def b =new X[Int] { def id =println("Int") }
15. b: X[Int]
17. /*
18. One simple usage.  The most specific implicit will be used to 
19. create the object to be passed to g.  
20. */
21. scala> def f[T](a :T)(implicit g :X[T]) = g.id
22. f: [T](a: T)(implicit g: X[T])Unit
24. scala> f(5)
25. Int
27. scala> f('c')
28. generic
30. /*
31. This example demonstrates how erasure is not an issue because 
32. the selection of the implicit is done at compile time so 
33. the correct type is selected.  If a match was used instead 
34. then a more complicated solution would be required
35. */
36. scala> def g[T](l:List[T])(implicit i:X[T]) = i.id          
37. g: [T](l: List[T])(implicit i: X[T])Unit
39. scala> g(List(1,2,3))
40. Int
42. scala> g(List("a",2,3))
43. generic