// Starting with version 2.10, Scala has added support for
// *generics*, also known as *type parameters*.

import scala.reflect.ClassTag

// As an example of a generic function, `slicesIndex` takes
// a sequence of any type and an element of that type and
// returns the index of the first occurrence of v in s,
// or -1 if not present. The `ClassTag` context bound
// allows us to create arrays of type T.
def slicesIndex[T: ClassTag](s: Seq[T], v: T): Int = {
  s.indexOf(v)
}

// As an example of a generic type, `List` is a
// singly-linked list with values of any type.
class List[T] {
  private class Node(var value: T, var next: Node)
  private var head: Node = _
  private var tail: Node = _

  // We can define methods on generic types just like we
  // do on regular types, but we keep the type
  // parameter in place. The type is `List[T]`, not `List`.
  def push(v: T): Unit = {
    if (tail == null) {
      head = new Node(v, null)
      tail = head
    } else {
      tail.next = new Node(v, null)
      tail = tail.next
    }
  }

  // AllElements returns all the List elements as a sequence.
  def allElements: Seq[T] = {
    var elems = Seq.empty[T]
    var current = head
    while (current != null) {
      elems = elems :+ current.value
      current = current.next
    }
    elems
  }
}

object GenericsExample {
  def main(args: Array[String]): Unit = {
    val s = Seq("foo", "bar", "zoo")

    // When invoking generic functions, we can often rely
    // on *type inference*. Note that we don't have to
    // specify the type for `T` when calling `slicesIndex` - 
    // the compiler infers it automatically.
    println(s"index of zoo: ${slicesIndex(s, "zoo")}")

    // … though we could also specify it explicitly.
    val _ = slicesIndex[String](s, "zoo")

    val lst = new List[Int]
    lst.push(10)
    lst.push(13)
    lst.push(23)
    println(s"list: ${lst.allElements}")
  }
}