scala
class List

[source: `scala/List.scala`]

`sealed abstract` `class` List[+A]
  `extends` Seq[A]

  A class representing an ordered collection of elements of type `a`. This class comes with two implementing case classes `scala.Nil` and `scala.::` that implement the abstract members `isEmpty`, `head` and `tail`.

Author
  Martin Odersky and others
Version
  1.0, 16/07/2003

Direct Known Subclasses:
  Nil, ::

Method Summary
`def` | :: [B >: A](x : B) : List[B] Add an element `x` at the beginning of this list.
`def` | ::: [B >: A](prefix : List[B]) : List[B] Returns a list resulting from the concatenation of the given list `prefix` and this list.
`def` | apply (n : Int) : A Returns the `n`-th element of this list. The first element (head of the list) is at position 0.
`def` | break (p : (A) => Boolean) : (List[A], List[A]) Like `span` but with the predicate inverted.
`def` | count (p : (A) => Boolean) : Int Count the number of elements in the list which satisfy a predicate.
`def` | diff [B >: A](that : List[B]) : List[B] Computes the difference between this list and the given list `that`.
`override def` | drop (n : Int) : List[A] Returns the list without its `n` first elements. If this list has less than `n` elements, the empty list is returned.
`def` | dropRight (n : Int) : List[A] Returns the list wihout its rightmost `n` elements.
`override def` | dropWhile (p : (A) => Boolean) : List[A] Returns the longest suffix of this list whose first element does not satisfy the predicate `p`.
`override def` | elements : Iterator[A] Returns the elements in the list as an iterator
`override def` | exists (p : (A) => Boolean) : Boolean Tests the existence in this list of an element that satisfies the predicate `p`.
`override final def` | filter (p : (A) => Boolean) : List[A] Returns all the elements of this list that satisfy the predicate `p`. The order of the elements is preserved. It is guarenteed that the receiver list itself is returned iff all its elements satisfy the predicate `p'. Hence the following equality is valid: (xs filter p) eq xs == xs forall p
`override def` | find (p : (A) => Boolean) : Option[A] Find and return the first element of the list satisfying a predicate, if any.
`override final def` | flatMap [B](f : (A) => Iterable[B]) : List[B] Applies the given function `f` to each element of this list, then concatenates the results.
`def` | flatten [B](`implicit` f : (A) => Iterable[B]) : List[B]
`override def` | foldLeft [B](z : B)(f : (B, A) => B) : B Combines the elements of this list together using the binary function `f`, from left to right, and starting with the value `z`.
`override def` | foldRight [B](z : B)(f : (A, B) => B) : B Combines the elements of this list together using the binary function `f`, from right to left, and starting with the value `z`.
`override def` | forall (p : (A) => Boolean) : Boolean Tests if the predicate `p` is satisfied by all elements in this list.
`override final def` | foreach (f : (A) => Unit) : Unit Apply the given function `f` to each element of this list (while respecting the order of the elements).
`abstract def` | head : A Returns this first element of the list.
`def` | indices : List[Int] Creates a list with all indices in the list. This is equivalent to a call to `List.range(0, xs.length)`.
`def` | init : List[A] Returns the list without its last element.
`def` | intersect [B >: A](that : List[B]) : List[B] Computes the intersection between this list and the given list `that`.
`override abstract def` | isEmpty : Boolean Returns true if the list does not contain any elements.
`override def` | last : A Returns the last element of this list.
`def` | length : Int Returns the number of elements in the list.
`override final def` | map [B](f : (A) => B) : List[B] Returns the list resulting from applying the given function `f` to each element of this list.
`def` | partition (p : (A) => Boolean) : (List[A], List[A]) Partition the list in two sub-lists according to a predicate.
`override def` | projection : Stream[A] returns a projection that can be used to call non-strict `filter`, `map`, and `flatMap` methods that build projections of the collection.
`override def` | reduceLeft [B >: A](f : (B, B) => B) : B Combines the elements of this list together using the binary operator `op`, from left to right
`override def` | reduceRight [B >: A](f : (B, B) => B) : B Combines the elements of this list together using the binary operator `op`, from right to left
`def` | remove (p : (A) => Boolean) : List[A] Removes all elements of the list which satisfy the predicate `p`. This is like `filter` with the predicate inversed.
`def` | removeDuplicates : List[A] Removes redundant elements from the list. Uses the method `==` to decide if two elements are identical.
`override def` | reverse : List[A] A list consisting of all elements of this list in reverse order.
`def` | reverseMap [B](f : (A) => B) : List[B] Apply a function to all the elements of the list, and return the reversed list of results. This is equivalent to a call to `map` followed by a call to `reverse`, but more efficient.
`def` | reverse_::: [B >: A](prefix : List[B]) : List[B] Reverse the given prefix and append the current list to that. This function is equivalent to an application of `reverse` on the prefix followed by a call to `:::`, but more efficient (and tail recursive).
`override def` | slice (from : Int, until : Int) : List[A] A sub-sequence of `len` elements starting at index `from` (non-strict)
`def` | sort (lt : (A, A) => Boolean) : List[A] Sort the list according to the comparison function `<(e1: a, e2: a) => Boolean`, which should be true iff `e1` is smaller than `e2`.
`def` | span (p : (A) => Boolean) : (List[A], List[A]) Returns the longest prefix of the list whose elements all satisfy the given predicate, and the rest of the list.
`def` | splitAt (n : Int) : (List[A], List[A]) Split the list at a given point and return the two parts thus created.
`protected override def` | stringPrefix : String Defines the prefix of this object's `toString` representation.
`abstract def` | tail : List[A] Returns this list without its first element.
`override def` | take (n : Int) : List[A] Returns the `n` first elements of this list, or else the whole list, if it has less than `n` elements.
`def` | takeRight (n : Int) : List[A] Returns the rightmost `n` elements from this list.
`override def` | takeWhile (p : (A) => Boolean) : List[A] Returns the longest prefix of this list whose elements satisfy the predicate `p`.
`override def` | toList : List[A] Overrides the method in Iterable for efficiency.
`override def` | toStream : Stream[A] Create a stream which contains all the elements of this iterable object.
`def` | union [B >: A](that : List[B]) : List[B] Computes the union of this list and the given list `that`.
`def` | zip [B](that : List[B]) : List[(A, B)] Returns a list formed from this list and the specified list `that` by associating each element of the former with the element at the same position in the latter. If one of the two lists is longer than the other, its remaining elements are ignored.
`def` | zipAll [B, C >: A, D >: B](that : List[B], thisElem : C, thatElem : D) : List[(C, D)] Returns a list formed from this list and the specified list `that` by associating each element of the former with the element at the same position in the latter.
`def` | zipWithIndex : List[(A, Int)] Returns a list that pairs each element of this list with its index, counting from 0.

Methods inherited from Seq
size, concat, lastOption, headOption, ++, isDefinedAt, lastIndexOf, contains, subseq, toArray, equalsWith, startsWith, endsWith, indexOf, containsSlice

Methods inherited from Collection
toString

Methods inherited from Iterable
findIndexOf, indexOf, /:, :\, copyToBuffer, sameElements, mkString, mkString, mkString, addString, addString, copyToArray, hasDefiniteSize

Methods inherited from PartialFunction
orElse, andThen

Methods inherited from Function1
compose

Methods inherited from AnyRef
getClass, hashCode, equals, clone, notify, notifyAll, wait, wait, wait, finalize, ==, !=, eq, ne, synchronized

Methods inherited from Any
==, !=, isInstanceOf, asInstanceOf