Why do we need Nil while creating List in scala? [duplicate]

Answer 1

Exactly because of this reason.

value :: is not a member of Int

In Scala, the operators are actually functions on objects. In this case, :: is a function on Nil object, which is actually an Empty list object.

scala> Nil
res0: scala.collection.immutable.Nil.type = List()

When you do 1::2, Scala looks for the function named :: on 2 and it doesn't find that. That is why it fails with that error.

---

Note: In Scala, if the last character of the operator is not colon, then the operator is invoked on the first operand. For example, 1 + 2 is basically 1.+(2). But, if the last character is colon, the the operator is invoked on the right hand side operand. So in this case, 1 :: Nil is actually Nil.::(1). Since, the :: returns another list object, you can chain it, like this 1 :: 2 :: Nil is actually, Nil.::(2).::(1).

Answer 2

Any operator in Scala ending with a colon : is defined on the right operand. So, when you write 1::2 means :: should be defined on 2 i.e on Int which is not the case.

Nil is a Value of List and has a method defined :: on it. So when you write 1 :: 2 :: Nil it is evaluated as (Nil.::(2)).::(1).

Answer 3

Infix operators whose names end with : are interpreted as method calls on the right operand. So 1 :: 2 is 2.::(1), i.e. it calls the method :: on 2. Similarly 1 :: 2 :: Nil is Nil.::(2).::(1).

The reason that the first one does not work is that 2 is an Int and Ints do not have a :: method. The reason that the second one does work is that Nil is a list and lists do have a :: method. And since the result of List.:: is also a list, you can still call :: on the result of the first ::.

Answer 4

Nil is basic building block for creating List as a recursive data structure. List is useful datastructure that provides constant time access O(1) to the head (first element).

List at it's bare minimum core, is built on top of 3 operations head, tail, and isEmpty. Nil is singleton sub-class of List, so it is a special one-of-its-kind instance representing an empty list. The cons operator :: is defined on List to build a list recursively, by prepending one element in the List.

See the definition of trait List and object Nil (highly simplified)

trait List[A] {
    def head: A
    def tail: List[A]
    def isEmpty: Boolean
}
case object Nil extends List[Nothing] {
    def head = throw new NoSuchElementException("head of empty list")
    def tail = throw new UnsupportedOperationException("tail of empty list")
    def isEmpty = true
}

Since any identifier/operator that ends with a :, associates to the right, :: operator also associates to the right.

When you write 1::2::3, scala tries to rewrite this calls as 3.::(2.::(1)). i.e 3 becomes the receiver of the first invocation of ::, which doesn't exist on any arbitrary data-type (Int in this case).

This is why, you always build up on an Empty List - Nil. Think of it as prepending each element, one by one over the empty List Nil.