Maybe a disagreement here is fueled by the power level difference in these two features. Beyond the superficial injection examples, Scala implicits also support injecting values constructed dynamically and also recursive/derived implicits.
You can also do this with default arguments, e.g. like so:
let f x y =
let g (a = x+1) b = ...
...
let bump ?(step = 1) x =
let waa ?( a = step+17 ) b = a * b in
x + step + waa 666;;
> recursive/derived implicits
Recursion is quite restricted, for example this is not valid Scala:
def f ( x : Int ) ( implicit y : Int ) : Int = {
implicit val a = 17
f ( x+1 ) }The example you give to justify "recursion is quite restricted" is not a restriction on recursion at all, it's an ambiguity problem. Define `a` as `y` to shadow the function parameter, and it compiles.
I did not claim it did. The first example disproved ionforce's claim that default values cannot be constructed dynamically.
> Define `a` as `y` to shadow the function parameter,
Whoops, yes that's correct. I didn't realise this was possible.
But I don't think that is what they meant. I think they meant something along the lines of what I said above:
> an expression with an arbitrary number of subexpressions may be synthesized, the shape of which depends on the types involves