implementing List tail method in Scala

Question

I am teaching myself Scala. In particular, I am following the book Functional programming in Scala by Chiusano et al. Chapter 3 presents you with an implementation of a linked list:

sealed trait List[+A]
case object Nil extends List[Nothing]
case class Cons[+A](head: A, tail: List[A]) extends List[A]

object List{
  def sum(ints: List[Int]): Int = ints match{
  case Nil => 0
  case Cons(x, xs) => x + sum(xs)
  }

def product(ds: List[Double]): Double = ds match {
  case Nil => 1.0
  case Cons(0.0, _) => 0.0
  case Cons(x, xs) => x*product(xs)
  }      

def apply[A](as: A*): List[A] =
  if (as.isEmpty) Nil
  else Cons(as.head, apply(as.tail: _*))
}

and asks you to implement the function tail, that should return a list with all values but the first. I have implemented it in the following way:

def tail(ints: List[Int]): List[Int] = ints match {
  case Cons(x, xs) => xs
  }

(Partly, because I do not know how to implement the case in which the passed list is Nil). However, when I have tested it on List(1,2,3) , the following is returned:

Cons(2,Cons(3,Nil))

instead of:

List(2, 3)  

which is what I was expecting. Besides, I am using intellij, and the IDE won't let me write List(1,2,3).tail , but only tail(List(1,2,3)) .

Can anyone tell me what I am doing wrong? Why is my tail implementation giving me such a strange return value? Why won't the IDE let me write List(1,2,3).tail ? How to implement the case in which the list passed is Nil?

Answer 1

Why won't the IDE let me write List(1,2,3).tail ?

What you've written is a stand-alone method that takes a List as a passed-in parameter. If what you want is to have a List return its own tail then you're actually half way there.

The Cons already has a tail member, you just have to promote it to the List definition and give the Nil a reasonable implementation.

sealed trait List[+A] {
  val tail: List[A]
}
case object Nil extends List[Nothing] {
  lazy val tail =
    throw new UnsupportedOperationException("tail of empty List")
}
case class Cons[+A](head: A, tail: List[A]) extends List[A]