scala
trait Seq

[source: `scala/Seq.scala`]

`` `trait` Seq[+A]
  `extends` PartialFunction[Int, A]`with` Collection[A]

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

Author
  Martin Odersky
  Matthias Zenger
Version
  1.0, 16/07/2003

Direct Known Subclasses:
  List, RandomAccessSeq, Seq.Projection, SeqProxy, Queue, Stack, MutableSeq, Buffer, MutableList, SingleLinkedList, NodeSeq

Method Summary
`override def` | ++ [B >: A](that : Iterable[B]) : Seq[B] Appends two iterable objects.
`override def` | concat [B >: A](that : Iterable[B]) : Seq[B] Appends two iterable objects.
`def` | contains (elem : Any) : Boolean Tests if the given value `elem` is a member of this sequence.
`def` | containsSlice [B](that : Seq[B]) : Boolean Is `that` a slice in this?
`override def` | drop (n : Int) : Seq[A] Returns this sequence without its `n` first elements If this sequence has less than `n` elements, the empty sequence is returned. (non-strict)
`override def` | dropWhile (p : (A) => Boolean) : Seq[A] Returns the longest suffix of this sequence whose first element does not satisfy the predicate `p`.
`def` | endsWith [B](that : Seq[B]) : Boolean
`def` | equalsWith [B](that : Seq[B])(f : (A, B) => Boolean) : Boolean
`override def` | filter (p : (A) => Boolean) : Seq[A] Returns all the elements of this sequence that satisfy the predicate `p`. The order of the elements is preserved.
`override def` | flatMap [B](f : (A) => Iterable[B]) : Seq[B] Applies the given function `f` to each element of this sequence, then concatenates the results.
`def` | headOption : Option[A] Returns as an option the first element of this list or None if list is empty.
`def` | indexOf [B >: A](that : Seq[B]) : Int
`def` | isDefinedAt (x : Int) : Boolean Is this partial function defined for the index `x`?
`override def` | isEmpty : Boolean Returns true if length == 0
`def` | last : A Returns the last element of this list.
`def` | lastIndexOf [B >: A](elem : B) : Int Returns the index of the last occurence of the specified element in this sequence, or -1 if the sequence does not contain this element.
`def` | lastOption : Option[A] Returns as an option the last element of this list or None if list is empty.
`abstract def` | length : Int Returns the length of the sequence.
`def` | lengthCompare (l : Int) : Int Returns length - l. This method is used by matching streams against right-ignoring (...,_) patterns. Lazy sequences should override this method if length forces evaluation of the stream.
`override def` | map [B](f : (A) => B) : Seq[B] Returns the sequence resulting from applying the given function `f` to each element of this sequence.
`override def` | projection : Projection[A] returns a projection that can be used to call non-strict `filter`, `map`, and `flatMap` methods that build projections of the collection.
`def` | reverse : Seq[A] A sequence consisting of all elements of this sequence in reverse order.
`def` | size : Int should always be `length`
`def` | slice (from : Int, until : Int) : Seq[A] A sub-sequence of `len` elements starting at index `from` (non-strict)
`def` | startsWith [B](that : Seq[B]) : Boolean
`def` | subseq (from : Int, end : Int) : Seq[A] Returns a subsequence starting from index `from` consisting of `len` elements.
`override def` | take (n : Int) : Seq[A] 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. (non-strict)
`override def` | takeWhile (p : (A) => Boolean) : Seq[A] Returns the longest prefix of this sequence whose elements satisfy the predicate `p`.
`override def` | toArray [B >: A] : Array[B] Converts this sequence to a fresh Array with `length` elements.

Methods inherited from Collection
toString, stringPrefix

Methods inherited from Iterable
elements (abstract), foreach, forall, exists, find, findIndexOf, indexOf, foldLeft, foldRight, /:, :\, reduceLeft, reduceRight, copyToBuffer, sameElements, toList, toStream, mkString, mkString, mkString, addString, addString, copyToArray, hasDefiniteSize

Methods inherited from PartialFunction
orElse, andThen

Methods inherited from Function1
apply (abstract), compose

Methods inherited from AnyRef
getClass, hashCode, equals, clone, notify, notifyAll, wait, wait, wait, finalize, ==, !=, eq, ne, synchronized

Methods inherited from Any
==, !=, isInstanceOf, asInstanceOf

Method Details

`abstract` `def` length : Int

  Returns the length of the sequence.

Returns
  the sequence length.

`` `def` lengthCompare(l : Int) : Int

  Returns length - l. This method is used by matching streams against right-ignoring (...,_) patterns. Lazy sequences should override this method if length forces evaluation of the stream.

`` `def` size : Int

  should always be `length`

Overrides
  Collection.size

`override` `def` isEmpty : Boolean

  Returns true if length == 0

@deprecated
`override` `def` concat[B >: A](that : Iterable[B]) : Seq[B]

  Appends two iterable objects.

Returns
  the new iterable object
Deprecated
  use `++` instead

`` `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` lastOption : Option[A]

  Returns as an option the last element of this list or None if list is empty.

`` `def` headOption : Option[A]

  Returns as an option the first element of this list or None if list is empty.

`override` `def` ++[B >: A](that : Iterable[B]) : Seq[B]

  Appends two iterable objects.

`` `def` isDefinedAt(x : Int) : Boolean

  Is this partial function defined for the index `x`?

Parameters
  `x -` ..
Returns
  `true`, iff `x` is a legal sequence index.

Overrides
  PartialFunction.isDefinedAt

`` `def` lastIndexOf[B >: A](elem : B) : Int

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

Parameters
  `elem -` element to search for.
Returns
  the index in this sequence of the last occurence of the specified element, or -1 if the sequence does not contain this element.

`override` `def` map[B](f : (A) => B) : Seq[B]

  Returns the sequence resulting from applying the given function `f` to each element of this sequence.

Parameters
  `f -` function to apply to each element.
Returns
  `f(a0), ..., f(an)` if this sequence is `a0, ..., an`.

`override` `def` flatMap[B](f : (A) => Iterable[B]) : Seq[B]

  Applies the given function `f` to each element of this sequence, then concatenates the results.

Parameters
  `f -` the function to apply on each element.
Returns
  `f(a0) ::: ... ::: f(an)` if this sequence is `a0, ..., an`.

`override` `def` filter(p : (A) => Boolean) : Seq[A]

  Returns all the elements of this sequence that satisfy the predicate `p`. The order of the elements is preserved.

Parameters
  `p -` the predicate used to filter the list.
Returns
  the elements of this list satisfying `p`.

`override` `def` take(n : Int) : Seq[A]

  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. (non-strict)

Parameters
  `n -` the number of elements to take
Returns
  a possibly projected sequence

`override` `def` drop(n : Int) : Seq[A]

  Returns this sequence without its `n` first elements If this sequence has less than `n` elements, the empty sequence is returned. (non-strict)

Parameters
  `n -` the number of elements to drop
Returns
  the new sequence

`` `def` slice(from : Int, until : Int) : Seq[A]

  A sub-sequence of `len` elements starting at index `from` (non-strict)

Parameters
  `from -` The index of the first element of the slice
  `until -` The index of the element following the slice
Throws
  `IndexOutOfBoundsException -` if `from < 0` or `length < from + len```

`override` `def` takeWhile(p : (A) => Boolean) : Seq[A]

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

Parameters
  `p -` the test predicate.
Returns
  the longest prefix of this sequence whose elements satisfy the predicate `p`.

`override` `def` dropWhile(p : (A) => Boolean) : Seq[A]

  Returns the longest suffix of this sequence whose first element does not satisfy the predicate `p`.

Parameters
  `p -` the test predicate.
Returns
  the longest suffix of the sequence whose first element does not satisfy the predicate `p`.

`` `def` reverse : Seq[A]

  A sequence consisting of all elements of this sequence in reverse order.

`` `def` contains(elem : Any) : Boolean

  Tests if the given value `elem` is a member of this sequence.

Parameters
  `elem -` element whose membership has to be tested.
Returns
  `true` iff there is an element of this sequence which is equal (w.r.t. `==`) to `elem`.

@deprecated
`` `def` subseq(from : Int, end : Int) : Seq[A]

  Returns a subsequence starting from index `from` consisting of `len` elements.

Deprecated
  use `slice` instead

`override` `def` toArray[B >: A] : Array[B]

  Converts this sequence to a fresh Array with `length` elements.

Overrides
  Collection.toArray

`override` `def` projection : Projection[A]

  returns a projection that can be used to call non-strict `filter`, `map`, and `flatMap` methods that build projections of the collection.

`` `def` equalsWith[B](that : Seq[B])(f : (A, B) => Boolean) : Boolean

`` `def` startsWith[B](that : Seq[B]) : Boolean

Returns
  s true if this sequence start with that sequences
See Also
  String.startsWith

`` `def` endsWith[B](that : Seq[B]) : Boolean

Returns
  s true if this sequence end with that sequence
See Also
  String.endsWith

`` `def` indexOf[B >: A](that : Seq[B]) : Int

Returns
  s -1 if `that` not contained in this, otherwise the index where `that` is contained
See Also
  String.indexOf

`` `def` containsSlice[B](that : Seq[B]) : Boolean

  Is `that` a slice in this?