scala library 2.7.2.final API : scala.Seq

scala.Seq

trait Seq

trait Seq[+ A]


        

 extends
        PartialFunction[Int, A] with Collection[A]

Class Seq[A] represents finite sequences of elements of type A.

author: - Matthias Zenger; - Martin Odersky
version: - 1.0, 16/07/2003

Companion: Seq

Source: Seq.scala(134)

Direct Known Subclasses

MutableList, MutableSeq, Projection, List, Queue, RandomAccessSeq, Stack, Stack, SingleLinkedList, Buffer, NodeSeq, SeqProxy,

Fields

elements	`abstract def elements` Creates a new iterator over all elements contained in this object [details] return - the new iterator	Iterator[A]	Iterable
first	`def first` Returns the first element of this list [details] return - the first element of the list. throws `Predef.UnsupportedOperationException` - if the list is empty.	A
firstOption	`def firstOption` Returns as an option the first element of this list or `None` if list is empty [details] return - the first element as an option.	Option[A]
hasDefiniteSize	`def hasDefiniteSize` returns true iff this collection has a bound size [details] Many APIs in this trait will not work on collections of unbound sizes.	Boolean	Iterable
headOption	`def headOption`	Option[A]
isEmpty	`override def isEmpty` Returns true if length == 0	Boolean
last	`def last` Returns the last element of this list [details] return - the last element of the list. throws `Predef.NoSuchElementException` - if the list is empty.	A
lastOption	`def lastOption` Returns as an option the last element of this list or `None` if list is empty [details] return - the last element as an option.	Option[A]
length	`abstract def length` Returns the length of the sequence [details] return - the sequence length.	Int
mkString	`def mkString` Converts a collection into a flat `String` by each element's toString method [details] note - Will not terminate for infinite-sized collections.	String	Iterable
projection	`override def projection` returns a projection that can be used to call non-strict `filter`, `map`, and `flatMap` methods that build projections of the collection	Projection[A]
reverse	`def reverse` A sequence consisting of all elements of this sequence in reverse order	Seq[A]
size	`def size` should always be `length`	Int
stringPrefix	`protected def stringPrefix` Defines the prefix of this object's `toString` representation	String	Collection
toList	`def toList` Returns a list containing all of the elements in this iterable object [details] note - Will not terminate for infinite-sized collections.	List[A]	Iterable
toSeq	`override def toSeq` Overridden for efficiency [details] return - the sequence itself	Seq[A]
toStream	`def toStream` Returns a stream containing all of the elements in this iterable object [details] note - consider using `projection` for lazy behavior.	Stream[A]	Iterable

Methods

!=	`final def !=(arg0 : Any)` `o != arg0` is the same as `!(o == (arg0))` [details] 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.	Boolean	Any
!=	`final def !=(arg0 : Object)`	Boolean	AnyRef
++	`override def ++[B >: A](that : Iterable[B])` Appends two iterable objects	Seq[B]
/:	`def /:[B](z : B)(op : (B, A) => B)` Similar to `foldLeft` but can be used as an operator with the order of list and zero arguments reversed [details] That is, `z /: xs` is the same as `xs foldLeft z` note - Will not terminate for infinite-sized collections.	B	Iterable
:\	`def :\[B](z : B)(op : (A, B) => B)` An alias for `foldRight` [details] That is, `xs :\ z` is the same as `xs foldRight z` note - Will not terminate for infinite-sized collections.	B	Iterable
==	`final def ==(arg0 : Object)` `o == arg0` is the same as `if (o eq null) arg0 eq null else o [details]` `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.	Boolean	AnyRef
==	`final def ==(arg0 : Any)` `o == arg0` is the same as `o [details]` `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.	Boolean	Any
addString	`def addString(buf : StringBuilder)` Write all elements of this string into given string builder, with no separator string between elements [details] note - Will not terminate for infinite-sized collections. param `buf` - the StringBuilder to which elements are appended return - the `buf` StringBuilder object	StringBuilder	Iterable
addString	`def addString(buf : StringBuilder, start : String, sep : String, end : String)` Write all elements of this string into given string builder [details] 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	StringBuilder	Iterable
addString	`def addString(buf : StringBuilder, sep : String)` Write all elements of this string into given string builder [details] 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	StringBuilder	Iterable
andThen	`override def andThen[C](k : (B) => C)` (f andThen g)(x) == g(f(x))	PartialFunction[A, C]	PartialFunction
apply	`abstract def apply(v1 : T1)`	R	Function1
asInstanceOf	`final def asInstanceOf[T0]` This method is used to cast the receiver object to be of type `T0` [details] 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`.	T0	Any
clone	`protected def clone` This method creates and returns a copy of the receiver object [details] The default implementation of the `clone` method is platform dependent. return - a copy of the receiver object.	Object	AnyRef
compose	`def compose[A](g : (A) => T1)` (f compose g)(x) == f(g(x))	(A) => R	Function1
concat	`override def concat[B >: A](that : Iterable[B])` Appends two iterable objects [details] deprecated - use `++` instead return - the new iterable object	Seq[B]
contains	`def contains(elem : Any)` Tests if the given value `elem` is a member of this sequence [details] 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`.	Boolean
containsSlice	`def containsSlice[B](that : Seq[B])` Is `that` a slice in this?	Boolean
copyToArray	`def copyToArray[B >: A](xs : Array[B], start : Int)` Fills the given array `xs` with the elements of this sequence starting at position `start` [details] 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.	Unit	Iterable
copyToBuffer	`def copyToBuffer[B >: A](dest : Buffer[B])` Copy all elements to a given buffer [details] note - Will not terminate if not finite. - Will not terminate for infinite-sized collections. param `dest` - The buffer to which elements are copied	Unit	Iterable
drop	`override def drop(n : Int)` Returns this sequence without its `n` first elements If this sequence has less than `n` elements, the empty sequence is returned [details] (non-strict) param `n` - the number of elements to drop return - the new sequence	Seq[A]
dropWhile	`override def dropWhile(p : (A) => Boolean)` Returns the longest suffix of this sequence whose first element does not satisfy the predicate `p` [details] param `p` - the test predicate. return - the longest suffix of the sequence whose first element does not satisfy the predicate `p`.	Seq[A]
endsWith	`def endsWith[B](that : Seq[B])` [details] return - true if this sequence end with that sequence see - String.endsWith	Boolean
eq	`final def eq(arg0 : Object)` This method is used to test whether the argument (`arg0`) is a reference to the receiver object (`this`) [details] 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.	Boolean	AnyRef
equals	`def equals(arg0 : Any)` This method is used to compare the receiver object (`this`) with the argument object (`arg0`) for equivalence [details] The default implementations of this method is an equivalence relation: It is reflexive: for any instance `x` of type `Any`, `x.equals(x)` should return `true`. It is symmetric: for any instances `x` and `y` of type `Any`, `x.equals(y)` should return `true` if and only if `y.equals(x)` returns `true`. It is transitive: for any instances `x`, `y`, and `z` of type `AnyRef` if `x.equals(y)` returns `true` and `y.equals(z)` returns `true`, then `x.equals(z)` should return `true`. If you override this method, you should verify that your implementation remains an equivalence relation. Additionally, when overriding this method it is often necessary to override `hashCode` to ensure that objects that are "equal" (`o1.equals(o2)` returns `true`) hash to the same `Int` (`o1.hashCode.equals(o2.hashCode)`). param `arg0` - the object to compare against this object for equality. return - `true` if the receiver object is equivalent to the argument; `false` otherwise.	Boolean	AnyRef
equalsWith	`def equalsWith[B](that : Seq[B])(f : (A, B) => Boolean)`	Boolean
exists	`def exists(p : (A) => Boolean)` Apply a predicate `p` to all elements of this iterable object and return true, iff there is at least one element for which `p` yields true [details] note - May not terminate for infinite-sized collections. param `p` - the predicate return - true, iff the predicate yields true for at least one element.	Boolean	Iterable
filter	`override def filter(p : (A) => Boolean)` Returns all the elements of this sequence that satisfy the predicate `p` [details] The order of the elements is preserved. param `p` - the predicate used to filter the list. return - the elements of this list satisfying `p`.	Seq[A]
finalize	`protected def finalize` This method is called by the garbage collector on the receiver object when garbage collection determines that there are no more references to the object [details] 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.	Unit	AnyRef
find	`def find(p : (A) => Boolean)` Find and return the first element of the iterable object satisfying a predicate, if any [details] note - may not terminate for infinite-sized collections. param `p` - the predicate return - the first element in the iterable object satisfying `p`, or `None` if none exists.	Option[A]	Iterable
findIndexOf	`override def findIndexOf(p : (A) => Boolean)` Returns index of the first element satisying a predicate, or -1 [details] 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	Int
flatMap	`override def flatMap[B](f : (A) => Iterable[B])` Applies the given function `f` to each element of this sequence, then concatenates the results [details] param `f` - the function to apply on each element. return - `f(a₀) ::: ... ::: f(a_n)` if this sequence is `a₀, ..., a_n`.	Seq[B]
foldLeft	`def foldLeft[B](z : B)(op : (B, A) => B)` Combines the elements of this iterable object together using the binary function `f`, from left to right, and starting with the value `z` [details] note - Will not terminate for infinite-sized collections. return - `f(... (f(f(z, a₀), a₁) ...), a_n)` if the list is `[a₀, a₁, ..., a_n]`.	B	Iterable
foldRight	`def foldRight[B](z : B)(op : (A, B) => B)` Combines the elements of this list together using the binary function `f`, from right to left, and starting with the value `z` [details] note - Will not terminate for infinite-sized collections. return - `f(a₀, f(a₁, f(..., f(a_n, z)...)))` if the list is `[a₀, a1, ..., a_n]`.	B	Iterable
forall	`def forall(p : (A) => Boolean)` Apply a predicate `p` to all elements of this iterable object and return true, iff the predicate yields true for all elements [details] note - May not terminate for infinite-sized collections. param `p` - the predicate return - true, iff the predicate yields true for all elements.	Boolean	Iterable
foreach	`def foreach(f : (A) => Unit)` Apply a function `f` to all elements of this iterable object [details] note - Will not terminate for infinite-sized collections. param `f` - a function that is applied to every element.	Unit	Iterable
getClass	`final def getClass` Returns a representation that corresponds to the dynamic class of the receiver object [details] The nature of the representation is platform dependent. return - a representation that corresponds to the dynamic class of the receiver object.	Class[Any]	AnyRef
hashCode	`def hashCode` Returns a hash code value for the object [details] The default hashing algorithm is platform dependent. Note that it is allowed for two objects to have identical hash codes (`o1.hashCode.equals(o2.hashCode)`) yet not be equal (`o1.equals(o2)` returns `false`). A degenerate implementation could always return `0`. However, it is required that if two objects are equal (`o1.equals(o2)` returns `true`) that they have identical hash codes (`o1.hashCode.equals(o2.hashCode)`). Therefore, when overriding this method, be sure to verify that the behavior is consistent with the `equals` method. return - the hash code value for the object.	Int	AnyRef
indexOf	`def indexOf[B >: A](that : Seq[B])` Searches for the argument sequence in the receiver object, returning the smallest index where a match occurs [details] 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	Int
indexOf	`override def indexOf[B >: A](elem : B)` Returns the index of the first occurence of the specified object in this iterable object [details] 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.	Int
isDefinedAt	`def isDefinedAt(x : Int)` Is this partial function defined for the index `x`? [details] param `x` - .. return - `true`, iff `x` is a legal sequence index.	Boolean
isInstanceOf	`final def isInstanceOf[T0]` This method is used to test whether the dynamic type of the receiver object is `T0` [details] 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.	Boolean	Any
lastIndexOf	`def lastIndexOf[B >: A](elem : B)` Returns the index of the last occurence of the specified element in this sequence, or -1 if the sequence does not contain this element [details] 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.	Int
lengthCompare	`def lengthCompare(l : Int)` Result of comparing `length` with operand `l` [details] 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. Lazy sequences should override this method if length forces evaluation of the stream.	Int
map	`override def map[B](f : (A) => B)` Returns the sequence resulting from applying the given function `f` to each element of this sequence [details] param `f` - function to apply to each element. return - `f(a₀), ..., f(a_n)` if this sequence is `a₀, ..., a_n`.	Seq[B]
mkString	`def mkString(start : String, sep : String, end : String)` Returns a string representation of this iterable object [details] 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.	String	Iterable
mkString	`def mkString(sep : String)` Returns a string representation of this iterable object [details] 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.	String	Iterable
ne	`final def ne(arg0 : Object)` `o [details]` `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.	Boolean	AnyRef
notify	`final def notify` Wakes up a single thread that is waiting on the receiver object's monitor	Unit	AnyRef
notifyAll	`final def notifyAll` Wakes up all threads that are waiting on the receiver object's monitor	Unit	AnyRef
orElse	`def orElse[A1 <: A, B1 >: B](that : PartialFunction[A1, B1])`	PartialFunction[A1, B1]	PartialFunction
partition	`def partition(p : (A) => Boolean)` Partitions this iterable in two iterables according to a predicate [details] param `p` - the predicate on which to partition return - a pair of iterables: the iterable that satisfy the predicate `p` and the iterable that do not. The relative order of the elements in the resulting iterables is the same as in the original iterable.	(Iterable[A], Iterable[A])	Iterable
reduceLeft	`def reduceLeft[B >: A](op : (B, A) => B)` Combines the elements of this iterable object together using the binary operator `op`, from left to right [details] note - Will not terminate for infinite-sized collections. param `op` - The operator to apply return - `op(... op(a₀,a₁), ..., a_n)` if the iterable object has elements `a₀, a₁, ..., a_n`. throws `Predef.UnsupportedOperationException` - if the iterable object is empty.	B	Iterable
reduceRight	`def reduceRight[B >: A](op : (A, B) => B)` Combines the elements of this iterable object together using the binary operator `op`, from right to left [details] note - Will not terminate for infinite-sized collections. param `op` - The operator to apply return - `a₀ op (... op (a_n-1 op a_n)...)` if the iterable object has elements `a₀, a₁, ..., a_n`. throws `Predef.UnsupportedOperationException` - if the iterator is empty.	B	Iterable
sameElements	`def sameElements[B >: A](that : Iterable[B])` Checks if the other iterable object contains the same elements [details] note - will not terminate for infinite-sized collections. param `that` - the other iterable object return - true, iff both iterable objects contain the same elements.	Boolean	Iterable
slice	`def slice(from : Int)` A sub-sequence starting at index `from` and extending up to the length of the current sequence (non-strict) [details] deprecated - Use `drop(n: Int): Seq[A]` instead. param `from` - The index of the first element of the slice throws `IndexOutOfBoundsException` - if `from < 0`	Seq[A]
slice	`def slice(from : Int, until : Int)` A sub-sequence starting at index `from` and ending (non-inclusive) at index `until` (non-strict) [details] param `until` - The index of the element following the slice `from` - The index of the first element of the slice throws `IndexOutOfBoundsException` - if `from < 0` or `length < from + len`	Seq[A]
startsWith	`def startsWith[B](that : Seq[B])` Check whether the receiver object starts with the argument sequence [details] return - true if `that` is a prefix of `this`, otherwise false see - Seq.startsWith	Boolean
startsWith	`def startsWith[B](that : Seq[B], offset : Int)` Checks whether the argument sequence is contained at the specified index within the receiver object [details] 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	Boolean
subseq	`def subseq(from : Int, end : Int)` Returns a subsequence starting from index `from` consisting of `len` elements [details] deprecated - use `slice` instead	Seq[A]
synchronized	`final def synchronized[T0](arg0 : T0)`	T0	AnyRef
take	`override def take(n : Int)` Returns a sequence consisting only over the first `n` elements of this sequence, or else the whole sequence, if it has less than `n` elements [details] (non-strict) param `n` - the number of elements to take return - a possibly projected sequence	Seq[A]
takeWhile	`override def takeWhile(p : (A) => Boolean)` Returns the longest prefix of this sequence whose elements satisfy the predicate `p` [details] param `p` - the test predicate. return - the longest prefix of this sequence whose elements satisfy the predicate `p`.	Seq[A]
toArray	`override def toArray[B >: A]` Converts this sequence to a fresh Array with `length` elements	Array[B]
toString	`override def toString` Returns a string representation of the object [details] The default representation is platform dependent. return - a string representation of the object.	String	Collection
wait	`final def wait(arg0 : Long)`	Unit	AnyRef
wait	`final def wait`	Unit	AnyRef
wait	`final def wait(arg0 : Long, arg1 : Int)`	Unit	AnyRef

scala.Seq trait Seq

Direct Known Subclasses

Fields

Methods

scala.Seq

trait Seq