So far implicit parameters in Scala do not look good for me -- it is too close to global variables, however since Scala seems like rather strict language I start doubting in my own opinion :-).

Question: could you show a real-life (or close) good example when implicit parameters really work. IOW: something more serious than showPrompt, that would justify such language design.

Or contrary -- could you show reliable language design (can be imaginary) that would make implicit not neccessary. I think that even no mechanism is better than implicits because code is clearer and there is no guessing.

Please note, I am asking about parameters, not implicit functions (conversions)!

Updates

Global variables

Thank you for all great answers. Maybe I clarify my "global variables" objection. Consider such function:

max(x : Int,y : Int) : Int

you call it

max(5,6);

you could (!) do it like this:

max(x:5,y:6);

but in my eyes implicits works like this:

x = 5;
y = 6;
max()

it is not very different from such construct (PHP-like)

max() : Int
{
  global x : Int;
  global y : Int;
  ...
}

Derek's answer

This is great example, however if you can think of as flexible usage of sending message not using implicit please post an counter-example. I am really curious about purity in language design ;-).

scala parameters implicit

Edit Report

1 Answer

In a sense, yes, implicits represent global state. However, they are not mutable, which is the true problem with global variables -- you don't see people complaining about global constants, do you? In fact, coding standards usually dictate that you transform any constants in your code into constants or enums, which are usually global.

Note also that implicits are not in a flat namespace, which is also a common problem with globals. They are explicitly tied to types and, therefore, to the package hierarchy of those types.

So, take your globals, make them immutable and initialized at the declaration site, and put them on namespaces. Do they still look like globals? Do they still look problematic?

But let's not stop there. Implicits are tied to types, and they are just as much "global" as types are. Does the fact that types are global bother you?

As for use cases, they are many, but we can do a brief review based on their history. Originally, afaik, Scala did not have implicits. What Scala had were view types, a feature many other languages had. We can still see that today whenever you write something like T <% Ordered[T], which means the type T can be viewed as a type Ordered[T]. View types are a way of making automatic casts available on type parameters (generics).

Scala then generalized that feature with implicits. Automatic casts no longer exist, and, instead, you have implicit conversions -- which are just Function1 values and, therefore, can be passed as parameters. From then on, T <% Ordered[T] meant a value for an implicit conversion would be passed as parameter. Since the cast is automatic, the caller of the function is not required to explicitly pass the parameter -- so those parameters became implicit parameters.

Note that there are two concepts -- implicit conversions and implicit parameters -

answered 2012-03-02T18:04:52.077

Good example of implicit parameter in Scala?

Updates

Global variables

Derek's answer

1 Answer

Your Answer