Implicit Parameters

Evidently the topic of implicit parameters has not yet been correctly addressed. There have been several topic that refer to implicit parameters but none that directly discuss them. So before I continue with the topic of implicit parameter resolution I will discuss implicit parameters.

First, implicit parameters are not the same as implicit object conversions. Implicit parameters provide a way to allow parameters of a method to be "found". This is similar to default parameters at a glance but in fact is a different mechanism for finding the "default" value. It differs from implicit object conversion in that it is only a way for parameters for a method to be resolved. Implicit object conversion allows methods to appear to be called on one object when in fact that object is being converted behind the scenes to another type. (more or less)

An implicit parameter is a parameter to method or constructor that is marked as implicit. This means that if a parameter value is not supplied then the compiler will search for an "implicit" value defined within scope (according to resolution rules.) Implicit parameter resolution rules will be discussed soon.

Example:

1. scala> def p(implicit i:Int) = print(i)
2. p: (implicit i: Int)Unit
4. // defining a val/var/def as implicit 
5. // means that it will be considered during implicit resolution
6. scala> implicit val v=2
7. v: Int = 2
9. // scope is searched for a implicit value to sue
10. // v is found as marked implicit
11. scala> p               
12. 2
14. // explicit declarations always overrides implicit values
15. scala> p(1)
16. 1

Implicit parameters are very nice for simplifying APIs. For example the collections use implicit parameters to supply CanBuildFrom objects for many of the collection methods. This is because normally the user does not need to be concerned with those parameters. Another example is supplying an encoding to an IO library so the encoding is defined once (perhaps in a package object) and all methods can use the same encoding without having to define it for every method call.

One important restriction is that there can only be a single implicit keyword per method. It must be at the start of a parameter list (which also makes all values of that parameter list be implicit). I further understand that only the last parameter list may be implicit.

Here are several illegal examples:

1. // implicit is not in last parameter list
2. scala> def pp(implicit i:Int, a:Int)(b:Int) = println(a,i)                 
3. < console>:1: error: '=' expected but '(' found.
4.        def pp(implicit i:Int, a:Int)(b:Int) = println(a,i)
6. // there are 2 implicit parameters
7. scala> def pp(implicit j:Int, a:Int)(implicit i:Int,b:Int) = println(a,i)
8. < console>:1: error: '=' expected but '(' found.
9.       def pp(implicit j:Int, a:Int)(implicit i:Int,b:Int) = println(a,i)
11. // implicit is not the first parameter of the parameter list
12. scala> def pp(a:Int, implicit i:Int) = println(i,j)         
13. < console>:1: error: identifier expected but 'implicit' found.
14.        def pp(a:Int, implicit i:Int) = println(i,j)
15.                      ^

Here are several legal examples (Updated with useage examples):

1. scala> implicit def v = 7
2. v: Int
4. scala> implicit var x = 10L
5. x: Long
7. // i is implicit
8. scala> def pp(a:Int)(implicit i:Int) = println(a,i)
9. pp: (a: Int)(implicit i: Int)Unit
11. scala> pp(3)
12. (3,7)
14. // both i and b are implicit
15. scala> def pp(a:Int)(implicit i:Int, b:Long) = println(a,i,b) 
16. pp: (a: Int)(implicit i: Int,implicit b: Long)Unit
18. scala> pp(4)               
19. (4,7,10)
21. // both i and b are implicit
22. scala> def pp(implicit i:Int, b:Long) = println(i,b)  
23. pp: (implicit i: Int,implicit b: Long)Unit
25. scala> pp
26. (7,10)
28. // all or none of the parameters must be supplied
29. scala> pp(2)
30. < console>:13: error: not enough arguments for method pp: (implicit i: Int,implicit b: Long)Unit.
31. Unspecified value parameter b.
32.        pp(2)
34. // This is syntactically legal but I cannot seem to implicitly invoke this
35. // I would recommend: def pp(b:Long*)(implicit i:Int) = println(i,b)
36. scala> def pp(implicit i:Int, b:Long*) = println(i,b)
37. pp: (implicit i: Int,implicit b: Long*)Unit
39. scala> pp(3,1,2,3)
40. (3,WrappedArray(1, 2, 3))
42. scala> def pp(b:Long*)(implicit i:Int) = println(i,b)
43. pp: (b: Long*)(implicit i: Int)Unit
45. scala> pp(1,2,3)
46. (7,WrappedArray(1, 2, 3))

A related topic is Companion Object implicits.