Implicit Methods

Scala is designed to be a scalable language and one if the features that assist in realizing this goal are implicit methods. I have seen it occasionally referred to as static duck typing (although I personally think that describes structural typing better).

The idea is to be able to extend an existing class with new methods in a type safe manner. Essentially what happens is a developer defines an implicit method (or imports an implicit method) which converts one object from one type to another type. Once the implicit method is within scope all methods are available from both types.

Note: The conversion is one way. If you want bi-directional conversion you need 2 methods.

1. scala> class MyInteger( i:Int ) {
2.      | def myNewMethod = println("hello from myNewMethod")
3.      | }
4. defined class MyInteger
7. // an integer is not a "MyInteger" so you cannot call the myNewMethod on it
8. scala> 1.myNewMethod
9. :5: error: value myNewMethod is not a member of Int
10.        1.myNewMethod
11.          ^
14. // define an implicit conversion and now we can call all MyInteger methods on integers
15. scala> implicit def int2MyInt( i:Int ) = new MyInteger(i)
16. int2MyInt: (Int)MyInteger
18. scala> 1.myNewMethod
19. hello from myNewMethod
21. scala> class MyInteger2( val i:Int ) {
22.      | def inc = new MyInteger2( i+1 )
23.      | }
24. defined class MyInteger2
26. // you can define several implicits in an object and import later
27. scala> object Conversions{
28.      | implicit def int2MyInt2(i:Int) = new MyInteger2(i)
29.      | implicit def myInt2Int( mI:MyInteger2) = mI.i
30.      | }
31. defined module Conversions
33. // you can import all implicits    or just    one (although interpreter only allows all for some reason)
34. scala> import Conversions._
35. import Conversions._
37. // inc returns a MyInteger2 instance
38. scala> val j = 1.inc
39. j: MyInteger2 = MyInteger2@37f808e6
40. // test    the bi-directionality of it all    so create a method
41. // that takes and int
42. scala> def takesInt( i:Int ) = println(i)
43. takesInt: (Int)Unit
45. // j is a MyInteger2 but thanks to the implicit it can be converted back to an int
46. scala> takesInt( j )
47. 2
50. scala> takesInt ( 5.inc )
51. 6