Question

In all the examples I am ready this kind of function definition keeps popping up:

def firstElementInList[T](l: List[T]): T

I’m used to seeing List[Int] so it would be a list of integers. In this case I’m assuming that T is any type (please correct me if im wrong). What I’m really getting caught up on is the [T] right after firstElementInList

Answer 1

IT is just a way to tell: this function references one generic type T (you are right T is any type).

If you have multiple methods inside one class:

def firstElementInList[T](l: List[T]): T = l.head
def  lastElementInList[T](l: List[T]): T = l.last

then each method has its own T type, so you can call first method with a list of Strings and a second one with a list of Ints.

However the whole class enclosing both of these methods can have type as well:

class Foo[T] {
  def firstElementInList(l: List[T]): T = l.head
  def  lastElementInList(l: List[T]): T = l.last
}

In this case you pick type during Foo object creation:

val foo = new Foo[String]

and the compiler will prevent you from calling instance methods of foo with any other type than List[String]. Also note that in this case you no longer need type [T] for a method – it is taken from the enclosing class.