Scala 2.2.0.9025
in scala
class List
sealed abstract class List [a]
extends java.lang.Object
with scala.Seq[a]
with scala.CaseClass
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 :: [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: scala.Function1[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: scala.Function1[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: scala.Function1[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: scala.Function1[a, scala.Boolean]) : scala.Boolean
Tests the existence in this list of an element that satisfies the predicate p.
def filter (p: scala.Function1[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: scala.Function1[a, scala.Boolean]) : scala.Option[a]
Find and return the first element of the list satisfying a predicate, if any.
def flatMap [b] (f: scala.Function1[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: scala.Function2[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: scala.Function2[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: scala.Function1[a, scala.Boolean]) : scala.Boolean
Tests if the predicate p is satisfied by all elements in this list.
override def foreach (f: scala.Function1[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 [a <: b] (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: scala.Function1[a, b]) : scala.List[b]
Returns the list resulting from applying the given function f to each element of this list.
def partition (p: scala.Function1[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: scala.Function2[b, b, b]) : b

def reduceRight [a <: b] (f: scala.Function2[b, b, b]) : b

def remove (p: scala.Function1[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: scala.Function1[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: scala.Function2[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: scala.Function1[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: scala.Function1[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.
def zipWithIndex : scala.List[scala.Tuple2[a, scala.Int]]
Return an list that pairs each element of this list with its index, counting from 0.


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

Parameters:
x - the element to append.
Returns:
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].

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:
- java.lang.RuntimeException if the list is too short.
def break (p: scala.Function1[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: scala.Function1[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 [a <: b](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
Throws:
- java.lang.RuntimeException if the list is too short.
def dropWhile (p: scala.Function1[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: scala.Function1[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: scala.Function1[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: scala.Function1[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: scala.Function1[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: scala.Function2[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: scala.Function2[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: scala.Function1[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: scala.Function1[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:
- 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).
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:
- 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.
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:
- java.lang.RuntimeException 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: scala.Function1[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: scala.Function1[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 [a <: b](f: scala.Function2[b, b, b]): b
def reduceRight [a <: b](f: scala.Function2[b, b, b]): b
def remove (p: scala.Function1[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.

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

Returns:
the elements of this list in reverse order.
def reverseMap [b](f: scala.Function1[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_::: [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).
Parameters:
prefix - the prefix to reverse and then prepend
Returns:
the concatenation of the reversed prefix and the current list.
def sort (lt: scala.Function2[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.
Parameters:
lt - the comparison function
Returns:
a list sorted according to the comparison function <(e1: a, e2: a) => Boolean.
def span (p: scala.Function1[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:
- 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.
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
Throws:
- java.lang.RuntimeException if the list is too short.
def takeWhile (p: scala.Function1[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 [a <: b](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 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, 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.
Parameters:
- that may have a different length as the self list.
Parameters:
- thisElem is used to fill up the resulting list if the self list is shorter than that
Parameters:
- 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]]
Return an 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.