return

- an iterator on the list elements.

return

- the first element of the list.

throws

Predef.UnsupportedOperationException - if the list is empty.

return

- the first element as an option.

Many APIs in this trait will not work on collections of unbound sizes.

This is equivalent to a call to List.range(0, xs.length).

return

- a list of all indices in the list.

return

- the list without its last element.

throws

Predef.UnsupportedOperationException - if the list is empty.

return

- the last element of the list.

throws

Predef.NoSuchElementException - if the list is empty.

return

- the last element as an option.

return

- the number of elements in the list.

note

- Will not terminate for infinite-sized collections.

Uses the method == to decide if two elements are identical.

return

- the list without doubles.

return

- the list itself

return

- the sequence itself

note

- consider using projection for lazy behavior.

param

arg0 - the object to compare against this object for dis-equality.

return

- false if the receiver object is equivalent to the argument; true otherwise.

param

x - the object to remove from this list.

return

- this list without the elements of the given object x.

param

that - the list of elements to remove from this list.

return

- this list without the elements of the given list that.

That is, z /: xs is the same as xs foldLeft z

note

- Will not terminate for infinite-sized collections.

ex

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

param

x - the element to prepend.

return

- the list with x added at the beginning.

ex

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

param

prefix - the list to concatenate at the beginning of this list.

return

- the concatenation of the two lists.

That is, xs :\ z is the same as xs foldRight z

note

- Will not terminate for infinite-sized collections.

equals(arg0).

param

arg0 - the object to compare against this object for equality.

return

- true if the receiver object is equivalent to the argument; false otherwise.

equals(arg0).

param

arg0 - the object to compare against this object for equality.

return

- true if the receiver object is equivalent to the argument; false otherwise.

note

- Will not terminate for infinite-sized collections.

param

sep - separator string.

buf - the StringBuilder to which elements are appended

start - starting string.

end - ending string.

return

- the buf StringBuilder object

note

- Will not terminate for infinite-sized collections.

param

buf - the StringBuilder to which elements are appended

return

- the buf StringBuilder object

note

- Will not terminate for infinite-sized collections.

param

buf - the StringBuilder to which elements are appended

sep - separator string.

return

- the buf StringBuilder object

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

Predef.NoSuchElementException - if the list is too short.

Note that the success of a cast at runtime is modulo Scala's erasure semantics. Therefore the expression 1.asInstanceOf[String] will throw a ClassCastException at runtime, while the expression List(1).asInstanceOf[List[String]] will not. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the requested typed.

return

- the receiver object.

throws

ClassCastException - if the receiver object is not an instance of erasure of type T0.

The default implementation of the clone method is platform dependent.

return

- a copy of the receiver object.

param

elem - element whose membership has to be tested.

return

- true iff there is an element of this sequence which is equal (w.r.t. ==) to elem.

note

- Will not terminate for infinite-sized collections.

param

xs - the array to fill.

start - starting index.

pre

- the array must be large enough to hold all elements.

note

- Will not terminate if not finite.

- Will not terminate for infinite-sized collections.

param

dest - The buffer to which elements are copied

param

p - the predicate for which to count

return

- the number of elements satisfying the predicate p.

If this list has less than n elements, the empty list is returned.

param

n - the number of elements to drop.

return

- the list without its n first elements.

param

n - the number of elements to take

return

- the suffix of length n of the list

param

p - the test predicate.

return

- the longest suffix of the list whose first element does not satisfy the predicate p.

return

- true if this sequence end with that sequence

see

- String.endsWith

The eq method implements an equivalence relation on non-null instances of AnyRef:

• It is reflexive: for any non-null instance x of type AnyRef, x.eq(x) returns true.
• It is symmetric: for any non-null instances x and y of type AnyRef, x.eq(y) returns true if and only if y.eq(x) returns true.
• It is transitive: for any non-null instances x, y, and z of type AnyRef if x.eq(y) returns true and y.eq(z) returns true, then x.eq(z) returns true.

Additionally, the eq method has three other properties.

• It is consistent: for any non-null instances x and y of type AnyRef, multiple invocations of x.eq(y) consistently returns true or consistently returns false.
• For any non-null instance x of type AnyRef, x.eq(null) and null.eq(x) returns false.
• null.eq(null) returns true.

When overriding the equals or hashCode methods, it is important to ensure that their behavior is consistent with reference equality. Therefore, if two objects are references to each other (o1 eq o2), they should be equal to each other (o1 == o2) and they should hash to the same value (o1.hashCode == o2.hashCode).

param

arg0 - the object to compare against this object for reference equality.

return

- true if the argument is a reference to the receiver object; false otherwise.

param

p - the test predicate.

return

- true iff there exists an element in this list that satisfies 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

param

p - the predicate used to filter the list.

return

- the elements of this list satisfying p.

The details of when and if the finalize method are invoked, as well as the interaction between finalize and non-local returns and exceptions, are all platform dependent.

param

p - the predicate

return

- the first element in the list satisfying p, or None if none exists.

note

- may not terminate for infinite-sized collections.

param

p - the predicate

return

- the index of the first element satisfying p, or -1 if such an element does not exist

param

f - the function to apply on each element.

return

- f(a0) ::: ... ::: f(an) if this list is [a0, ..., an].

The elements of this list should be a Iterables. Note: The compiler might not be able to infer the type parameter.

param

f - An implicit conversion to an Iterable instance.

return

- The concatenation of all elements of iterables in this list.

return

- f(... (f(f(z, a0), a1) ...), an) if the list is [a0, a1, ..., an].

return

- f(a0, f(a1, f(..., f(an, z)...))) if the list is [a0, a1, ..., an].

param

p - the test predicate.

return

- true iff all elements of this list satisfy the predicate p.

param

f - the treatment to apply to each element.

The nature of the representation is platform dependent.

return

- a representation that corresponds to the dynamic class of the receiver object.

note

- may not terminate for infinite-sized collections.

param

elem - element to search for.

return

- the index in this sequence of the first occurence of the specified element, or -1 if the sequence does not contain this element.

If the receiver object, this, is an infinite sequence this method will not terminate if there is no match. Similarly, if the both the receiver object and the argument, that are infinite sequences this method will not terminate. Because both the receiver object and the argument can both potentially be an infinite sequences, we do not attempt to use an optimized searching algorithm. Therefore, the running time will be proportional to the length of the receiver object and the argument. Subclasses and traits can potentially provide an optimized implementation.

return

- -1 if that not contained in this, otherwise the smallest index where that is found.

see

- String.indexOf

param

that - the list to intersect.

return

- the list of elements contained both in this list and in the given list that.

param

x - ..

return

- true, iff x is a legal sequence index.

Note that the test result of the test is modulo Scala's erasure semantics. Therefore the expression 1.isInstanceOf[String] will return false, while the expression List(1).isInstanceOf[List[String]] will return true. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the requested typed.

return

- true if the receiver object is an instance of erasure of type T0; false otherwise.

param

elem - element to search for.

return

- the index in this sequence of the last occurence of the specified element, or -1 if the sequence does not contain this element.

returns x where x < 0 iff this.length < l x == 0 iff this.length == l x > 0 iff this.length > that. This method is used by matching streams against right-ignoring (...,_*) patterns. This method does not call List.length, it works for O(l), not for O(length).

param

f - function to apply to each element.

return

- [f(a0), ..., f(an)] if this list is [a0, ..., an].

The resulting string begins with the string start and is finished by the string end. Inside, the string representations of elements (w.r.t. the method toString()) are separated by the string sep.

ex

- List(1, 2, 3).mkString("(", "; ", ")") = "(1; 2; 3)"

note

- Will not terminate for infinite-sized collections.

param

sep - separator string.

start - starting string.

end - ending string.

return

- a string representation of this iterable object.

The string representations of elements (w.r.t. the method toString()) are separated by the string sep.

note

- Will not terminate for infinite-sized collections.

param

sep - separator string.

return

- a string representation of this iterable object.

ne(arg0) is the same as !(o.eq(arg0)).

param

arg0 - the object to compare against this object for reference dis-equality.

return

- false if the argument is not a reference to the receiver object; true otherwise.

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.

param

op - The operator to apply

return

- op(... op(a0,a1), ..., an) if the list has elements a0, a1, ..., an.

throws

Predef.UnsupportedOperationException - if the list is empty.

param

op - The operator to apply

return

- a0 op (... op (an-1 op an)...) if the list has elements a0, a1, ..., an.

throws

Predef.UnsupportedOperationException - if the list is empty.

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

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.

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.

note

- will not terminate for infinite-sized collections.

param

that - the other iterable object

return

- true, iff both iterable objects contain the same elements.

param

end - the end position (exclusive) of the list slice.

start - the start position of the list slice.

return

- the list with elements belonging to the given index range.

ex

-

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

param

lt - the comparison function

return

- a list sorted according to the comparison function <(e1: a, e2: a) => Boolean.

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.

param

n - the position at which to split

return

- a pair of lists composed of the first n elements, and the other elements.

If the both the receiver object, this and the argument, that are infinite sequences this method may not terminate.

return

- true if that is contained in this, at the specified index, otherwise false

see

- String.startsWith

return

- true if that is a prefix of this, otherwise false

see

- Seq.startsWith

param

n - the number of elements to take.

return

- the n first elements of this list.

param

n - the number of elements to take

return

- the suffix of length n of the list

param

p - the test predicate.

return

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

The default representation is platform dependent.

return

- a string representation of the object.

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.

If one of the two lists is longer than the other, its remaining elements are ignored.

return

- List((a0,b0), ..., (amin(m,n),bmin(m,n))) when List(a0, ..., am) zip List(b0, ..., bn) is invoked.

param

thisElem - element thisElem is used to fill up the resulting list if the self list is shorter than that

thatElem - element thatElem is used to fill up the resulting list if that is shorter than the self list

that - list that may have a different length as the self list.

return

- List((a0,b0), ..., (an,bn), (elem,bn+1), ..., {elem,bm}) when [a0, ..., an] zip [b0, ..., bm] is invoked where m > n.

return

- the list List((a0,0), (a1,1), ...) where ai are the elements of this list.