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

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.

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.
param:
start the index of the first element
return:
an iterator yielding (a0,0), (a0,1)... where ai are the elements from this iterator.