I am also in favor of keeping the
implicit keyword. The
given keyword looks nice in parameters, but it’s strictly less informative. Probably harder to google, too. All previous Scala material use “implicit” and it’s already known outside the community as a distinguishing feature of Scala. Also, other languages like Haskell, Agda and Coq have adopted similar terminology for arguments that can be passed implicitly (though their own versions of the concept work differently).
One problem was that people confused implicit parameters with implicit conversions, lumping them together. I think this is already addressed by using the
Conversion type class, and the change of keyword achieves nothing more here. It does makes more sense and sounds more precise to talk about an
Conversion[A,B] than to talk about a
Conversion[A,B]. The “given” conversion still is fundamentally implicit, as it’s applied implicitly. C++ and C# also have such implicit conversions. Changing the name of the concept to
given does not seem to achieve anything useful.
Another invoked reason was that “implicit” feels wrong in definitions and arguments because… these are not implicit themselves; in fact they are explicitly written in the source. I never really bought this argument. It’s sufficient to understand that defining an
implicit def is like defining a
def that will be used implicitly, and that passing an
(implicit arg) is like passing an argument, but for an implicit parameter (which will, in fact, be used implicitly in the body of the function). As long as there is a notion of “implicit parameter”, it’s fine to pass “implicit arguments” for them, even when doing so explicitly. I do not think that using a less specific keyword actively improves things here, either.