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

Direct Known Subclasses:
  Nil, ::

Constructor Summary
| `def` this

Def Summary
| `def` :: [b >: a] (x: b) : scala.List[b] Add an element `x` at the beginning of this list. Example:
          1 :: List(2, 3) = List(2, 3).::(1) = List(1, 2, 3)
| `def` ::: [b >: a] (prefix: scala.List[b]) : scala.List[b] Returns a list resulting from the concatenation of the given list `prefix` and this list. Example:
          List(1, 2) ::: List(3, 4) = List(3, 4).:::(List(1, 2)) = List(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 [b >: a] (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 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 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).
`abstract` | `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 [b >: a] (that: scala.List[b]) : scala.List[b] Computes the intersection between this list and the given list `that`.
`abstract` `override` | `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 [b >: a] (f: (b, b) => b) : b Example:
          val xs = List(1, 2, 3, 4)
          0 :: xs reduceLeft ((x:int, y:int) => x + y) = 10 //sum
          1 :: xs reduceLeft ((x:int, y:int) => x * y) = 24 //prod
| `def` reduceRight [b >: a] (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. Example:
          List(1, 2, 3) reverse = List(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_::: [b >: a] (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`. Example:
          List("Steve", "Tom", "John", "Bob")
            .sort((e1, e2) => (e1 compareTo e2) < 0) =
          List("Bob", "John", "Steve", "Tom")
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
`abstract` | `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 [b >: a] (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, c >: a, d >: b] (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.
| `def` zipWithIndex : scala.List[scala.Tuple2[a, scala.Int]] Returns a list that pairs each element of this list with its index, counting from 0.

Def inherited from scala.Seq[a]
concat , copyToArray, drop, indexOf, isDefinedAt, isEmpty, lastIndexOf, length, mkString, stringPrefix, subseq, take, toArray, toString

Constructor Detail

`def` this

Def Detail

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

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

            1 :: List(2, 3) = List(2, 3).::(1) = List(1, 2, 3)

Parameters:
  `x -` the element to append.
Returns:
  the list with `x` appended at the beginning.

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

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

            List(1, 2) ::: List(3, 4) = List(3, 4).:::(List(1, 2)) = List(1, 2, 3, 4)

Parameters:
  `prefix -` the list to concatenate at the beginning of this list.
Returns:
  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.

Parameters:
  `n -` index of the element to return
Returns:
  the element at position `n` in this list.
Throws:
  `Predef.NoSuchElementException -` 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.

Parameters:
  `elem -` element whose membership has to be tested.
Returns:
  `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.

Parameters:
  `p -` the predicate for which to count
Returns:
  the number of elements satisfying the predicate `p`.

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

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

Parameters:
  `that -` the list of elements to remove from this list.
Returns:
  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.

Parameters:
  `n -` the number of elements to drop.
Returns:
  the list without its `n` first elements.

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

  Returns the list wihout its rightmost `n` elements.

Parameters:
  `n -` the number of elements to take
Returns:
  the suffix of length `n` of the list

`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`.

Parameters:
  `p -` the test predicate.
Returns:
  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

Returns:
  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`.

Parameters:
  `p -` the test predicate.
Returns:
  `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.

Parameters:
  `p -` the redicate used to filter the list.
Returns:
  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.

Parameters:
  `p -` the predicate
Returns:
  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.

Parameters:
  `f -` the function to apply on each element.
Returns:
  `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 function `f`, from left to right, and starting with the value `z`.

Returns:
  `f(... (f(f(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 function `f`, from rigth to left, and starting with the value `z`.

Returns:
  `f(a0, f(a1, f(..., f(an, 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.

Parameters:
  `p -` the test predicate.
Returns:
  `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).

Parameters:
  `f -` the treatment to apply to each element.

`abstract def` head : a

  Returns this first element of the list.

Returns:
  the first element of this list.
Throws:
  `Predef.NoSuchElementException -` 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)`.

Returns:
  a list of all indices in the list.

`def` init : scala.List[a]

  Returns the list without its last element.

Returns:
  the list without its last element.
Throws:
  `Predef.UnsupportedOperationException -` if the list is empty.

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

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

Parameters:
  `that -` the list to intersect.
Returns:
  the list of elements contained both in this list and in the given list `that`.

`abstract override def` isEmpty : scala.Boolean

  Returns true if the list does not contain any elements.

Returns:
  `true`, iff the list is empty.

`def` last : a

  Returns the last element of this list.

Returns:
  the last element of the list.
Throws:
  `Predef.UnsupportedOperationException -` if the list is empty.

`def` length : scala.Int

  Returns the number of elements in the list.

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.

Parameters:
  `f -` function to apply to each element.
Returns:
  `[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.

Parameters:
  `p -` the predicate on which to partition
Returns:
  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 [b >: a](f: (b, b) => b): b

  Example:

            val xs = List(1, 2, 3, 4)
            0 :: xs reduceLeft ((x:int, y:int) => x + y) = 10 //sum
            1 :: xs reduceLeft ((x:int, y:int) => x * y) = 24 //prod

Returns:
  ...
Throws:
  `Predef.UnsupportedOperationException -` if the list is empty.

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

Returns:
  ...
Throws:
  `Predef.UnsupportedOperationException -` if the list is empty.

`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.

Parameters:
  `p -` the predicate to use to test elements
Returns:
  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.

Returns:
  the list without doubles.

`def` reverse : scala.List[a]

  Reverses the elements of this list. Example:

            List(1, 2, 3) reverse = List(3, 2, 1)

Returns:
  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.

Parameters:
  `f -` the function to apply to each elements.
Returns:
  the reversed list of results.

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

Parameters:
  `prefix -` the prefix to reverse and then prepend
Returns:
  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`. Example:

            List("Steve", "Tom", "John", "Bob")
              .sort((e1, e2) => (e1 compareTo e2) < 0) =
            List("Bob", "John", "Steve", "Tom")

  Note: The current implementation is inefficent for already sorted lists.

Parameters:
  `lt -` the comparison function
Returns:
  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.

Parameters:
  `p -` the test predicate
Returns:
  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.

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

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

`abstract def` tail : scala.List[a]

  Returns this list without its first element.

Returns:
  this list without its first element.
Throws:
  `Predef.NoSuchElementException -` if the list is empty.

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

  Returns the `n` first elements of this list.

Parameters:
  `n -` the number of elements to take.
Returns:
  the `n` first elements of this list.

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

  Returns the rightmost `n` elements from this list.

Parameters:
  `n -` the number of elements to take
Returns:
  the suffix of length `n` of the list

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

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

Parameters:
  `p -` the test predicate.
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.

Returns:
  the list itself

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

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

Parameters:
  `that -` the list of elements to add to the list.
Returns:
  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.

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

`def` zipAll [b, c >: a, d >: b](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.

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

`def` zipWithIndex : scala.List[scala.Tuple2[a, scala.Int]]

  Returns a list that pairs each element of this list with its index, counting from 0.

Parameters:
  `start -` the index of the first element
Returns:
  an iterator yielding `(a0,0), (a0,1)...` where `ai` are the elements from this iterator.