in scala
class List

sealed abstract `class` List [ a ]
  `extends` java.lang.Object
  `with` scala.Seq[a]
  `with` scala.ScalaObject

  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

Constructor Summary
| `def` this

Def Summary
| `def` :: [ a <: b ] ( x : b ) : scala.List[b] Add an element `x` at the beginning of this list. Ex: `1 :: [2, 3] = [2, 3].::(1) = [1, 2, 3]`.
| `def` ::: [ a <: b ] ( prefix : scala.List[b] ) : scala.List[b] Returns a list resulting from the concatenation of the given list `prefix` and this list. Ex: `[1, 2] ::: [3, 4] = [3, 4].:::([1, 2]) = [1, 2, 3, 4]`.
| `def` apply ( n : scala.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) => scala.Boolean ) : scala.Tuple2[scala.List[a],scala.List[a]] Like `span` but with the predicate inverted.
| `def` contains ( elem : scala.Any ) : scala.Boolean Tests if the given value `elem` is a member of this iterable object.
| `def` count ( p : (a) => scala.Boolean ) : scala.Int Count the number of elements in the list which satisfy a predicate.
| `def` diff [ a <: b ] ( that : scala.List[b] ) : scala.List[b] Computes the difference between this list and the given list `that`.
`override` | `def` drop ( n : scala.Int ) : scala.List[a] Returns the list without its `n` first elements.
| `def` dropRight ( n : scala.Int ) : scala.List[a] Returns the list wihout its rightmost `n` elements.
| `def` dropWhile ( p : (a) => scala.Boolean ) : scala.List[a] Returns the longest suffix of this list whose first element does not satisfy the predicate `p`.
| `def` elements : scala.Iterator[a] Returns the elements in the list as an iterator
`override` | `def` exists ( p : (a) => scala.Boolean ) : scala.Boolean Tests the existence in this list of an element that satisfies the predicate `p`.
| `def` filter ( p : (a) => scala.Boolean ) : scala.List[a] Returns all the elements of this list that satisfy the predicate `p`. The order of the elements is preserved.
`override` | `def` find ( p : (a) => scala.Boolean ) : scala.Option[a] Find and return the first element of the list satisfying a predicate, if any.
| `def` flatMap [ b ] ( f : (a) => scala.List[b] ) : scala.List[b] Applies the given function `f` to each element of this list, then concatenates the results.
`override` | `def` foldLeft [ b ] ( z : b ) ( f : (b, a) => b ) : b Combines the elements of this list together using the binary operator `op`, 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 operator `op`, from rigth to left, and starting with the value `z`.
`override` | `def` forall ( p : (a) => scala.Boolean ) : scala.Boolean Tests if the predicate `p` is satisfied by all elements in this list.
`override` | `def` foreach ( f : (a) => scala.Unit ) : scala.Unit Apply the given function `f` to each element of this list (while respecting the order of the elements).
| `def` head : a Returns this first element of the list.
| `def` indices : scala.List[scala.Int] Creates a list with all indices in the list. This is equivalent to a call to `List.range(0, xs.length)`.
| `def` init : scala.List[a] Returns the list without its last element.
| `def` intersect [ a <: b ] ( that : scala.List[b] ) : scala.List[b] Computes the intersection between this list and the given list `that`.
| `def` isEmpty : scala.Boolean Returns true if the list does not contain any elements.
| `def` last : a Returns the last element of this list.
| `def` length : scala.Int Returns the number of elements in the list.
| `def` map [ b ] ( f : (a) => b ) : scala.List[b] Returns the list resulting from applying the given function `f` to each element of this list.
| `def` partition ( p : (a) => scala.Boolean ) : scala.Tuple2[scala.List[a],scala.List[a]] Partition the list in two sub-lists according to a predicate.
| `def` reduceLeft [ a <: b ] ( f : (b, b) => b ) : b
| `def` reduceRight [ a <: b ] ( f : (b, b) => b ) : b
| `def` remove ( p : (a) => scala.Boolean ) : scala.List[a] Removes all elements of the list which satisfy the predicate `p`. This is like `filter` with the predicate inversed.
| `def` removeDuplicates : scala.List[a] Removes redundant elements from the list. Uses the method `==` to decide if two elements are identical.
| `def` reverse : scala.List[a] Reverses the elements of this list. Ex: `[1, 2, 3] reverse = [3, 2, 1]`.
| `def` reverseMap [ b ] ( f : (a) => b ) : scala.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_::: [ a <: b ] ( prefix : scala.List[b] ) : scala.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).
| `def` sort ( lt : (a, a) => scala.Boolean ) : scala.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. Note: The current implementation is inefficent for already sorted lists.
| `def` span ( p : (a) => scala.Boolean ) : scala.Tuple2[scala.List[a],scala.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 : scala.Int ) : scala.Tuple2[scala.List[a],scala.List[a]] Split the list at a given point and return the two parts thus created.
`override` `protected` | `def` stringPrefix : java.lang.String
| `def` tail : scala.List[a] Returns this list without its first element.
`override` | `def` take ( n : scala.Int ) : scala.List[a] Returns the `n` first elements of this list.
| `def` takeRight ( n : scala.Int ) : scala.List[a] Returns the rightmost `n` elements from this list.
| `def` takeWhile ( p : (a) => scala.Boolean ) : scala.List[a] Returns the longest prefix of this list whose elements satisfy the predicate `p`.
`override` | `def` toList : scala.List[a] Overrides the method in Iterable for efficiency.
| `def` union [ a <: b ] ( that : scala.List[b] ) : scala.List[b] Computes the union of this list and the given list `that`.
| `def` zip [ b ] ( that : scala.List[b] ) : scala.List[scala.Tuple2[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.
| `def` zipAll [ b , a <: c , b <: d ] ( that : scala.List[b] , thisElem : c , thatElem : d ) : scala.List[scala.Tuple2[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.

Constructor Detail

`def` this

Def Detail

`def` :: [ a <: b ]( x : b ) : scala.List[b]

  Add an element `x` at the beginning of this list.

  Ex:
  `1 :: [2, 3] = [2, 3].::(1) = [1, 2, 3]`.

param:
  x the element to append.
return:
  the list with `x` appended at the beginning.

`def` ::: [ a <: b ]( prefix : scala.List[b] ) : scala.List[b]

  Returns a list resulting from the concatenation of the given list `prefix` and this list.

  Ex:
  `[1, 2] ::: [3, 4] = [3, 4].:::([1, 2]) = [1, 2, 3, 4]`.

param:
  prefix the list to concatenate at the beginning of this list.
return:
  the concatenation of the two lists.

`def` apply ( n : scala.Int ) : a

  Returns the `n`-th element of this list. The first element (head of the list) is at position 0.

param:
  n index of the element to return
return:
  the element at position `n` in this list.
throws:
  `java.lang.RuntimeException` if the list is too short.

`def` break ( p : (a) => scala.Boolean ) : scala.Tuple2[scala.List[a],scala.List[a]]

  Like `span` but with the predicate inverted.

`def` contains ( elem : scala.Any ) : scala.Boolean

  Tests if the given value `elem` is a member of this iterable object.

param:
  elem element whose membership has to be tested.
return:
  True iff there is an element of this list which is equal (w.r.t. `==`) to `elem`.

`def` count ( p : (a) => scala.Boolean ) : scala.Int

  Count the number of elements in the list which satisfy a predicate.

param:
  p the predicate for which to count
return:
  the number of elements satisfying the predicate `p`.

`def` diff [ a <: b ]( that : scala.List[b] ) : scala.List[b]

  Computes the difference between this list and the given list `that`.

param:
  that the list of elements to remove from this list.
return:
  this list without the elements of the given list `that`.

override `def` drop ( n : scala.Int ) : scala.List[a]

  Returns the list without its `n` first elements.

param:
  n the number of elements to drop.
return:
  the list without its `n` first elements.

`def` dropRight ( n : scala.Int ) : scala.List[a]

  Returns the list wihout its rightmost `n` elements.

param:
  n the number of elements to take
return:
  the suffix of length `n` of the list
throws:
  `java.lang.RuntimeException` if the list is too short.

`def` dropWhile ( p : (a) => scala.Boolean ) : scala.List[a]

  Returns the longest suffix of this list whose first element does not satisfy the predicate `p`.

param:
  p the test predicate.
return:
  the longest suffix of the list whose first element does not satisfy the predicate `p`.

`def` elements : scala.Iterator[a]

  Returns the elements in the list as an iterator

return:
  an iterator on the list elements.

override `def` exists ( p : (a) => scala.Boolean ) : scala.Boolean

  Tests the existence in this list of an element that satisfies the predicate `p`.

param:
  p the test predicate.
return:
  true iff there exists an element in this list that satisfies the predicate `p`.

`def` filter ( p : (a) => scala.Boolean ) : scala.List[a]

  Returns all the elements of this list that satisfy the predicate `p`. The order of the elements is preserved.

param:
  p the redicate used to filter the list.
return:
  the elements of this list satisfying `p`.

override `def` find ( p : (a) => scala.Boolean ) : scala.Option[a]

  Find and return the first element of the list satisfying a predicate, if any.

param:
  p the predicate
return:
  the first element in the list satisfying `p`, or `None` if none exists.

`def` flatMap [ b ]( f : (a) => scala.List[b] ) : scala.List[b]

  Applies the given function `f` to each element of this list, then concatenates the results.

param:
  f the function to apply on each element.
return:
  `f(a0) ::: ... ::: f(an)` if this list is `[a0, ..., an]`.

override `def` foldLeft [ b ]( z : b ) ( f : (b, a) => b ) : b

  Combines the elements of this list together using the binary operator `op`, from left to right, and starting with the value `z`.

return:
  `op(... (op(op(z,a0),a1) ...), an)` if the list is `[a0, a1, ..., an]`.

override `def` foldRight [ b ]( z : b ) ( f : (a, b) => b ) : b

  Combines the elements of this list together using the binary operator `op`, from rigth to left, and starting with the value `z`.

return:
  `a0 op (... op (an op z)...)` if the list is `[a0, a1, ..., an]`.

override `def` forall ( p : (a) => scala.Boolean ) : scala.Boolean

  Tests if the predicate `p` is satisfied by all elements in this list.

param:
  p the test predicate.
return:
  True iff all elements of this list satisfy the predicate `p`.

override `def` foreach ( f : (a) => scala.Unit ) : scala.Unit

  Apply the given function `f` to each element of this list (while respecting the order of the elements).

param:
  f the treatment to apply to each element.

`def` head : a

  Returns this first element of the list.

return:
  the first element of this list.
throws:
  `java.lang.RuntimeException` if the list is empty.

`def` indices : scala.List[scala.Int]

  Creates a list with all indices in the list. This is equivalent to a call to `List.range(0, xs.length)`.

return:
  a list of all indices in the list.

`def` init : scala.List[a]

  Returns the list without its last element.

return:
  the list without its last element.
throws:
  `java.lang.RuntimeException` if the list is empty.

`def` intersect [ a <: b ]( that : scala.List[b] ) : scala.List[b]

  Computes the intersection between this list and the given list `that`.

param:
  that the list to intersect.
return:
  the list of elements contained both in this list and in the given list `that`.

`def` isEmpty : scala.Boolean

  Returns true if the list does not contain any elements.

return:
  true, iff the list is empty.

`def` last : a

  Returns the last element of this list.

return:
  the last element of the list.
throws:
  `java.lang.RuntimeException` if the list is empty.

`def` length : scala.Int

  Returns the number of elements in the list.

return:
  the number of elements in the list.

`def` map [ b ]( f : (a) => b ) : scala.List[b]

  Returns the list resulting from applying the given function `f` to each element of this list.

param:
  f function to apply to each element.
return:
  `[f(a0), ..., f(an)]` if this list is `[a0, ..., an]`.

`def` partition ( p : (a) => scala.Boolean ) : scala.Tuple2[scala.List[a],scala.List[a]]

  Partition the list in two sub-lists according to a predicate.

param:
  p the predicate on which to partition
return:
  a pair of lists: the list of all elements which satisfy `p` and the list of all elements which do not. The relative order of the elements in the sub-lists is the same as in the original list.

`def` reduceLeft [ a <: b ]( f : (b, b) => b ) : b

`def` reduceRight [ a <: b ]( f : (b, b) => b ) : b

`def` remove ( p : (a) => scala.Boolean ) : scala.List[a]

  Removes all elements of the list which satisfy the predicate `p`. This is like `filter` with the predicate inversed.

param:
  p the predicate to use to test elements
return:
  the list without all elements which satisfy `p`

`def` removeDuplicates : scala.List[a]

  Removes redundant elements from the list. Uses the method `==` to decide if two elements are identical.

return:
  the list without doubles.

`def` reverse : scala.List[a]

  Reverses the elements of this list.

  Ex:
  `[1, 2, 3] reverse = [3, 2, 1]`.

return:
  the elements of this list in reverse order.

`def` reverseMap [ b ]( f : (a) => b ) : scala.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.

param:
  f the function to apply to each elements.
return:
  the reversed list of results.

`def` reverse_::: [ a <: b ]( prefix : scala.List[b] ) : scala.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).

param:
  prefix the prefix to reverse and then prepend
return:
  the concatenation of the reversed prefix and the current list.

`def` sort ( lt : (a, a) => scala.Boolean ) : scala.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. Note: The current implementation is inefficent for already sorted lists.

param:
  lt the comparison function
return:
  a list sorted according to the comparison function `<(e1: a, e2: a) => Boolean`.

`def` span ( p : (a) => scala.Boolean ) : scala.Tuple2[scala.List[a],scala.List[a]]

  Returns the longest prefix of the list whose elements all satisfy the given predicate, and the rest of the list.

param:
  p the test predicate
return:
  a pair consisting of the longest prefix of the list whose elements all satisfy `p`, and the rest of the list.

`def` splitAt ( n : scala.Int ) : scala.Tuple2[scala.List[a],scala.List[a]]

  Split the list at a given point and return the two parts thus created.

param:
  n the position at which to split
return:
  a pair of lists composed of the first `n` elements, and the other elements.

override protected `def` stringPrefix : java.lang.String

`def` tail : scala.List[a]

  Returns this list without its first element.

return:
  this list without its first element.
throws:
  `java.lang.RuntimeException` if the list is empty.

override `def` take ( n : scala.Int ) : scala.List[a]

  Returns the `n` first elements of this list.

param:
  n the number of elements to take.
return:
  the `n` first elements of this list.

`def` takeRight ( n : scala.Int ) : scala.List[a]

  Returns the rightmost `n` elements from this list.

param:
  n the number of elements to take
return:
  the suffix of length `n` of the list
throws:
  `java.lang.RuntimeException` if the list is too short.

`def` takeWhile ( p : (a) => scala.Boolean ) : scala.List[a]

  Returns the longest prefix of this list whose elements satisfy the predicate `p`.

param:
  p the test predicate.
return:
  the longest prefix of this list whose elements satisfy the predicate `p`.

override `def` toList : scala.List[a]

  Overrides the method in Iterable for efficiency.

return:
  the list itself

`def` union [ a <: b ]( that : scala.List[b] ) : scala.List[b]

  Computes the union of this list and the given list `that`.

param:
  that the list of elements to add to the list.
return:
  a list without doubles containing the elements of this list and those of the given list `that`.

`def` zip [ b ]( that : scala.List[b] ) : scala.List[scala.Tuple2[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.

param:
  `that` must have the same length as the self list.
return:
  `[(a0,b0), ..., (an,bn)]` when `[a0, ..., an] zip [b0, ..., bn]` is invoked.

`def` zipAll [ b , a <: c , b <: d ]( that : scala.List[b] , thisElem : c , thatElem : d ) : scala.List[scala.Tuple2[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.

param:
  `that` may have a different length as the self list.
param:
  `thisElem` is used to fill up the resulting list if the self list is shorter than `that`
param:
  `thatElem` is used to fill up the resulting list if `that` is shorter than the self list
return:
  `[(a0,b0), ..., (an,bn), (elem,bn+1), ..., (elem,bm)]` when `[a0, ..., an] zip [b0, ..., bm]` is invoked where `m > n`.