In Scala, I can make a caseclass, case class Foo(x:Int)
, and then put it in a list like so:
List(Foo(42))
Now, nothing strange here. The following is strange to me. The operator ::
is a function on a list, right? With any function with one argument in Scala, I can call it with infix notation.
An example is 1 + 2
is a function (+)
on the object Int
. The class Foo
I just defined does not have the ::
operator, so how is the following possible?
Foo(40) :: List(Foo(2))
In Scala 2.8 RC1, I get the following output from the interactive prompt:
scala> case class Foo(x:Int)
defined class Foo
scala> Foo(40) :: List(Foo(2))
res2: List[Foo] = List(Foo(40), Foo(2))
I can go on and use it, but what is the explanation?
From the Spec:
You can always see how these rules are applied in Scala by printing the program after it has been through the 'typer' phase of the compiler:
If the method name ends with a colon (
:
) the method is invoked on the right operand, which is the case here. If the method name doesn't end with colon, the method is invoked on the left operand. For example,a + b
,+
is invoked ona
.So, in your example,
::
is a method on its right operand, which is aList
.One aspect missing in the answers given is that to support
::
in pattern matching expressions:A class :: is defined :
so
case ::(x,xs)
would produce the same result. The expressioncase x :: xs
works because the default extractor::
is defined for the case class and it can be used infix.It ends with a
:
. And that is the sign, that this function is defined in the class to the right (inList
class here).So, it's
List(Foo(2)).::(Foo(40))
, notFoo(40).::(List(Foo(2)))
in your example.