case class ::[+A](x: A, next: List[A]) extends List[A] with Product with Serializable

Linear Supertypes
Product, List[A], Serializable, Serializable, StrictOptimizedSeqOps[A, List, List[A]], StrictOptimizedIterableOps[A, List, List[A]], LinearSeq[A], LinearSeqOps[A, List, List[A]], collection.LinearSeq[A], collection.LinearSeqOps[A, List, List[A]], Seq[A], SeqOps[A, List, List[A]], collection.Seq[A], collection.SeqOps[A, List, List[A]], Equals, ArrayLike[A], Iterable[A], collection.Iterable[A], IterableOps[A, List, List[A]], IterableOnce[A], AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ::
  2. Product
  3. List
  4. Serializable
  5. Serializable
  6. StrictOptimizedSeqOps
  7. StrictOptimizedIterableOps
  8. LinearSeq
  9. LinearSeqOps
  10. LinearSeq
  11. LinearSeqOps
  12. Seq
  13. SeqOps
  14. Seq
  15. SeqOps
  16. Equals
  17. ArrayLike
  18. Iterable
  19. Iterable
  20. IterableOps
  21. IterableOnce
  22. AnyRef
  23. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new ::(x: A, next: List[A])

Type Members

  1. class WithFilter extends AnyRef

    A template trait that contains just the map, flatMap, foreach and withFilter methods of trait Iterable.

    A template trait that contains just the map, flatMap, foreach and withFilter methods of trait Iterable.

    Definition Classes
    IterableOps

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ++[B >: A](suffix: IterableOnce[B]): List[B]

    Alias for concat

    Alias for concat

    Definition Classes
    IterableOps
    Annotations
    @inline()
  4. final def ++:[B >: A](prefix: collection.Iterable[B]): List[B]

    Alias for prependAll

    Alias for prependAll

    Definition Classes
    IterableOps
    Annotations
    @inline()
  5. final def +:[B >: A](elem: B): List[B]

    Alias for prepend.

    Alias for prepend.

    Note that :-ending operators are right associative (see example). A mnemonic for +: vs. :+ is: the COLon goes on the COLlection side.

    Definition Classes
    SeqOps
    Annotations
    @inline()
  6. final def :+[B >: A](elem: B): List[B]

    Alias for append

    Alias for append

    Note that :-ending operators are right associative (see example). A mnemonic for +: vs. :+ is: the COLon goes on the COLlection side.

    Definition Classes
    SeqOps
    Annotations
    @inline()
  7. def ::(elem: A): List[A]

    [use case] Adds an element at the beginning of this list.

    [use case]

    Adds an element at the beginning of this list.

    Example:

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

    the element to prepend.

    returns

    a list which contains x as first element and which continues with this list.

    Definition Classes
    List
    Full Signature

    def ::[B >: A](elem: B): List[B]

  8. def :::[B >: A](prefix: List[B]): List[B]

    Adds the elements of a given list in front of this list.

    Adds the elements of a given list in front of this list.

    Example:

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

    The list elements to prepend.

    returns

    a list resulting from the concatenation of the given list prefix and this list.

    Definition Classes
    List
  9. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  10. def append[B >: A](elem: B): List[B]

    A copy of this $coll with an element appended.

    A copy of this $coll with an element appended.

    B

    the element type of the returned $coll.

    elem

    the appended element

    returns

    a new $coll consisting of all elements of this $coll followed by value.

    Definition Classes
    StrictOptimizedSeqOps → SeqOps
  11. def apply(n: Int): A

    apply is defined in terms of drop, which is in turn defined in terms of tail.

    apply is defined in terms of drop, which is in turn defined in terms of tail.

    Definition Classes
    LinearSeqOps → ArrayLike
    Annotations
    @throws( ... )
  12. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  13. def c: ::.this.type
    Attributes
    protected[this]
    Definition Classes
    Seq → SeqOps
  14. def canEqual(that: Any): Boolean

    Method called from equality methods, so that user-defined subclasses can refuse to be equal to other collections of the same kind.

    Method called from equality methods, so that user-defined subclasses can refuse to be equal to other collections of the same kind.

    that

    The object with which this $coll should be compared

    returns

    true, if this $coll can possibly equal that, false otherwise. The test takes into consideration only the run-time types of objects but ignores their elements.

    Definition Classes
    SeqOps → Equals
  15. def className: String

    The class name of this collection.

    The class name of this collection. To be used for converting to string. Collections generally print like this:

    <className>(elem_1, ..., elem_n)

    Definition Classes
    List → IterableOps
  16. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  17. def coll: ::.this.type

    The collection itself

    The collection itself

    Attributes
    protected[this]
    Definition Classes
    Iterable → IterableOps
  18. final def collect[B](pf: PartialFunction[A, B]): List[B]
    Definition Classes
    List → IterableOps
  19. def combinations(n: Int): Iterator[List[A]]

    Iterates over combinations.

    Iterates over combinations. A _combination_ of length n is a subsequence of the original sequence, with the elements taken in order. Thus, "xy" and "yy" are both length-2 combinations of "xyy", but "yx" is not. If there is more than one way to generate the same subsequence, only one will be returned.

    For example, "xyyy" has three different ways to generate "xy" depending on whether the first, second, or third "y" is selected. However, since all are identical, only one will be chosen. Which of the three will be taken is an implementation detail that is not defined.

    returns

    An Iterator which traverses the possible n-element combinations of this $coll.

    Definition Classes
    SeqOps
    Example:

    1. "abbbc".combinations(2) = Iterator(ab, ac, bb, bc)

  20. def concat[B >: A](suffix: IterableOnce[B]): List[B]

    Returns a new list containing the elements from the left hand operand followed by the elements from the right hand operand.

    Returns a new list containing the elements from the left hand operand followed by the elements from the right hand operand. The element type of the list is the most specific superclass encompassing the element types of the two operands.

    B

    the element type of the returned collection.

    suffix

    the traversable to append.

    returns

    a new collection of type CC[B] which contains all elements of this list followed by all elements of suffix.

    Definition Classes
    List → IterableOps
  21. def contains[A1 >: A](elem: A1): Boolean

    Tests whether this $coll contains a given value as an element.

    Tests whether this $coll contains a given value as an element. $mayNotTerminateInf

    elem

    the element to test.

    returns

    true if this $coll has an element that is equal (as determined by ==) to elem, false otherwise.

    Definition Classes
    SeqOps
  22. def containsSlice[B](that: collection.Seq[B]): Boolean

    Tests whether this $coll contains a given sequence as a slice.

    Tests whether this $coll contains a given sequence as a slice. $mayNotTerminateInf

    that

    the sequence to test

    returns

    true if this $coll contains a slice with the same elements as that, otherwise false.

    Definition Classes
    SeqOps
  23. def copyToArray[B >: A](xs: Array[B], start: Int = 0): xs.type

    Copy all elements of this collection to array xs, starting at start.

    Copy all elements of this collection to array xs, starting at start.

    Definition Classes
    IterableOps
  24. def count(p: (A) ⇒ Boolean): Int

    Counts the number of elements in the $coll which satisfy a predicate.

    Counts the number of elements in the $coll which satisfy a predicate.

    p

    the predicate used to test elements.

    returns

    the number of elements satisfying the predicate p.

    Definition Classes
    IterableOps
  25. def drop(n: Int): List[A]

    Optimized version of drop that avoids copying Note: drop is defined here, rather than in a trait like LinearSeqMonoTransforms, because the ...MonoTransforms traits make no assumption about the type of Repr whereas we need to assume here that Repr is the same as the underlying collection type.

    Optimized version of drop that avoids copying Note: drop is defined here, rather than in a trait like LinearSeqMonoTransforms, because the ...MonoTransforms traits make no assumption about the type of Repr whereas we need to assume here that Repr is the same as the underlying collection type.

    Definition Classes
    List → LinearSeqOps → IterableOps
  26. def dropRight(n: Int): List[A]

    The rest of the collection without its n last elements.

    The rest of the collection without its n last elements. For linear, immutable collections this should avoid making a copy.

    Definition Classes
    IterableOps
  27. final def dropWhile(p: (A) ⇒ Boolean): List[A]

    Skips longest sequence of elements of this iterator which satisfy given predicate p, and returns an iterator of the remaining elements.

    Skips longest sequence of elements of this iterator which satisfy given predicate p, and returns an iterator of the remaining elements.

    p

    the predicate used to skip elements.

    returns

    an iterator consisting of the remaining elements

    Definition Classes
    List → IterableOps
    Annotations
    @inline()
    Note

    Reuse: $consumesAndProducesIterator

  28. def endsWith[B >: A](that: collection.Seq[B]): Boolean

    Tests whether this $coll ends with the given sequence.

    Tests whether this $coll ends with the given sequence. $willNotTerminateInf

    that

    the sequence to test

    returns

    true if this $coll has that as a suffix, false otherwise.

    Definition Classes
    SeqOps
  29. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  30. def equals(o: Any): Boolean
    Definition Classes
    SeqOps → Equals → Any
  31. def exists(p: (A) ⇒ Boolean): Boolean

    Tests whether a predicate holds for at least one element of this $coll.

    Tests whether a predicate holds for at least one element of this $coll.

    $mayNotTerminateInf

    p

    the predicate used to test elements.

    returns

    true if the given predicate p is satisfied by at least one element of this $coll, otherwise false

    Definition Classes
    IterableOps
  32. def filter(pred: (A) ⇒ Boolean): List[A]

    Selects all elements of this $coll which satisfy a predicate.

    Selects all elements of this $coll which satisfy a predicate.

    pred

    the predicate used to test elements.

    returns

    a new $coll consisting of all elements of this $coll that satisfy the given predicate pred. Their order may not be preserved.

    Definition Classes
    IterableOps
  33. def filterNot(pred: (A) ⇒ Boolean): List[A]

    Selects all elements of this $coll which do not satisfy a predicate.

    Selects all elements of this $coll which do not satisfy a predicate.

    pred

    the predicate used to test elements.

    returns

    a new $coll consisting of all elements of this $coll that do not satisfy the given predicate pred. Their order may not be preserved.

    Definition Classes
    IterableOps
  34. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  35. def find(p: (A) ⇒ Boolean): Option[A]

    Finds the first element of the $coll satisfying a predicate, if any.

    Finds the first element of the $coll satisfying a predicate, if any.

    $mayNotTerminateInf $orderDependent

    p

    the predicate used to test elements.

    returns

    an option value containing the first element in the $coll that satisfies p, or None if none exists.

    Definition Classes
    IterableOps
  36. final def flatMap[B](f: (A) ⇒ IterableOnce[B]): List[B]

    Flatmap

    Flatmap

    Definition Classes
    List → IterableOps
  37. def flatten[B](implicit ev: (A) ⇒ IterableOnce[B]): List[B]
    Definition Classes
    IterableOps
  38. def foldLeft[B](z: B)(op: (B, A) ⇒ B): B

    Fold left

    Fold left

    Definition Classes
    IterableOps
  39. def foldRight[B](z: B)(op: (A, B) ⇒ B): B

    Fold right

    Fold right

    Definition Classes
    List → IterableOps
  40. def forall(p: (A) ⇒ Boolean): Boolean

    Tests whether a predicate holds for all elements of this $coll.

    Tests whether a predicate holds for all elements of this $coll.

    $mayNotTerminateInf

    p

    the predicate used to test elements.

    returns

    true if this $coll is empty or the given predicate p holds for all elements of this $coll, otherwise false.

    Definition Classes
    IterableOps
  41. final def foreach[U](f: (A) ⇒ U): Unit

    Apply f to each element for its side effects Note: [U] parameter needed to help scalac's type inference.

    Apply f to each element for its side effects Note: [U] parameter needed to help scalac's type inference.

    Definition Classes
    List → IterableOps
    Annotations
    @inline()
  42. def fromIterable[E](it: collection.Iterable[E]): List[E]
    Attributes
    protected[this]
    Definition Classes
    IterableOps
  43. def fromSpecificIterable(coll: collection.Iterable[A]): List[A]
    Attributes
    protected[this]
    Definition Classes
    List → IterableOps
  44. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
  45. def groupBy[K](f: (A) ⇒ K): Map[K, List[A]]

    Partitions this $coll into a map of ${coll}s according to some discriminator function.

    Partitions this $coll into a map of ${coll}s according to some discriminator function.

    Note: When applied to a view or a lazy collection it will always force the elements.

    K

    the type of keys returned by the discriminator function.

    f

    the discriminator function.

    returns

    A map from keys to ${coll}s such that the following invariant holds:

    (xs groupBy f)(k) = xs filter (x => f(x) == k)

    That is, every key k is bound to a $coll of those elements x for which f(x) equals k.

    Definition Classes
    IterableOps
  46. def grouped(size: Int): Iterator[List[A]]

    Partitions elements in fixed size ${coll}s.

    Partitions elements in fixed size ${coll}s.

    size

    the number of elements per group

    returns

    An iterator producing ${coll}s of size size, except the last will be less than size size if the elements don't divide evenly.

    Definition Classes
    IterableOps
    See also

    scala.collection.Iterator, method grouped

  47. def hashCode(): Int
    Definition Classes
    SeqOps → Any
  48. def head: A

    The first element of the collection.

    The first element of the collection.

    Definition Classes
    :: → LinearSeqOps → IterableOps
  49. def indexOf[B >: A](elem: B, from: Int = 0): Int

    Finds index of first occurrence of some value in this $coll after or at some start index.

    Finds index of first occurrence of some value in this $coll after or at some start index.

    B

    the type of the element elem.

    elem

    the element value to search for.

    from

    the start index

    returns

    the index >= from of the first element of this $coll that is equal (as determined by ==) to elem, or -1, if none exists.

    Definition Classes
    SeqOps
  50. def indexOfSlice[B >: A](that: collection.Seq[B], from: Int = 0): Int

    Finds first index after or at a start index where this $coll contains a given sequence as a slice.

    Finds first index after or at a start index where this $coll contains a given sequence as a slice. $mayNotTerminateInf

    that

    the sequence to test

    from

    the start index

    returns

    the first index >= from such that the elements of this $coll starting at this index match the elements of sequence that, or -1 of no such subsequence exists.

    Definition Classes
    SeqOps
  51. def indexWhere(p: (A) ⇒ Boolean, from: Int = 0): Int

    Finds index of the first element satisfying some predicate after or at some start index.

    Finds index of the first element satisfying some predicate after or at some start index.

    $mayNotTerminateInf

    p

    the predicate used to test elements.

    from

    the start index

    returns

    the index >= from of the first element of this $coll that satisfies the predicate p, or -1, if none exists.

    Definition Classes
    SeqOps
  52. def indices: Range

    Produces the range of all indices of this sequence.

    Produces the range of all indices of this sequence.

    returns

    a Range value from 0 to one less than the length of this $coll.

    Definition Classes
    SeqOps
  53. def init: List[A]

    The initial part of the collection without its last element.

    The initial part of the collection without its last element.

    Definition Classes
    IterableOps
  54. def isEmpty: Boolean

    To be overridden in implementations:

    To be overridden in implementations:

    Definition Classes
    :: → LinearSeqOps → IterableOps
  55. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  56. def iterableFactory: List.type
    Definition Classes
    List → IterableOps
  57. def iterator(): Iterator[A]

    iterator is implemented in terms of head and tail

    iterator is implemented in terms of head and tail

    Definition Classes
    LinearSeqOps
  58. def knownSize: Int

    The number of elements in this collection, if it can be cheaply computed, -1 otherwise.

    The number of elements in this collection, if it can be cheaply computed, -1 otherwise. Cheaply usually means: Not requiring a collection traversal.

    Definition Classes
    IterableOps
  59. def last: A

    Selects the last element.

    Selects the last element. $orderDependent

    returns

    The last element of this $coll.

    Definition Classes
    IterableOps
    Exceptions thrown

    NoSuchElementException If the $coll is empty.

  60. def lastIndexOf[B >: A](elem: B, end: Int = length - 1): Int

    Finds index of last occurrence of some value in this $coll before or at a given end index.

    Finds index of last occurrence of some value in this $coll before or at a given end index.

    B

    the type of the element elem.

    elem

    the element value to search for.

    end

    the end index.

    returns

    the index <= end of the last element of this $coll that is equal (as determined by ==) to elem, or -1, if none exists.

    Definition Classes
    SeqOps
  61. def lastIndexOfSlice[B >: A](that: collection.Seq[B], end: Int = length - 1): Int

    Finds last index before or at a given end index where this $coll contains a given sequence as a slice.

    Finds last index before or at a given end index where this $coll contains a given sequence as a slice.

    that

    the sequence to test

    end

    the end index

    returns

    the last index <= end such that the elements of this $coll starting at this index match the elements of sequence that, or -1 of no such subsequence exists.

    Definition Classes
    SeqOps
  62. def lastIndexWhere(p: (A) ⇒ Boolean, end: Int = length - 1): Int

    Finds index of last element satisfying some predicate before or at given end index.

    Finds index of last element satisfying some predicate before or at given end index.

    p

    the predicate used to test elements.

    returns

    the index <= end of the last element of this $coll that satisfies the predicate p, or -1, if none exists.

    Definition Classes
    SeqOps
  63. def lastOption: Option[A]

    Optionally selects the last element.

    Optionally selects the last element. $orderDependent

    returns

    the last element of this $coll$ if it is nonempty, None if it is empty.

    Definition Classes
    IterableOps
  64. final def length: Int
    Definition Classes
    LinearSeqOps → ArrayLike
  65. final def map[B](f: (A) ⇒ B): List[B]

    Builds a new collection by applying a function to all elements of this list.

    Builds a new collection by applying a function to all elements of this list.

    B

    the element type of the returned collection.

    f

    the function to apply to each element.

    returns

    a new list resulting from applying the given function f to each element of this list and collecting the results.

    Definition Classes
    List → IterableOps
  66. def max: A

    [use case] Finds the largest element.

    [use case]

    Finds the largest element.

    returns

    the largest element of this list.

    Definition Classes
    IterableOps
    Full Signature

    def max[B >: A](implicit ord: Ordering[B]): A

  67. def maxBy[B](f: (A) ⇒ B): A

    [use case] Finds the first element which yields the largest value measured by function f.

    [use case]

    Finds the first element which yields the largest value measured by function f.

    B

    The result type of the function f.

    f

    The measuring function.

    returns

    the first element of this list with the largest value measured by function f.

    Definition Classes
    IterableOps
    Full Signature

    def maxBy[B](f: (A) ⇒ B)(implicit cmp: Ordering[B]): A

  68. def min: A

    [use case] Finds the smallest element.

    [use case]

    Finds the smallest element.

    returns

    the smallest element of this list

    Definition Classes
    IterableOps
    Full Signature

    def min[B >: A](implicit ord: Ordering[B]): A

  69. def minBy[B](f: (A) ⇒ B): A

    [use case] Finds the first element which yields the smallest value measured by function f.

    [use case]

    Finds the first element which yields the smallest value measured by function f.

    B

    The result type of the function f.

    f

    The measuring function.

    returns

    the first element of this list with the smallest value measured by function f.

    Definition Classes
    IterableOps
    Full Signature

    def minBy[B](f: (A) ⇒ B)(implicit cmp: Ordering[B]): A

  70. def mkString: String
    Definition Classes
    IterableOps
  71. def mkString(sep: String): String
    Definition Classes
    IterableOps
  72. def mkString(start: String, sep: String, end: String): String

    A string showing all elements of this collection, separated by string sep.

    A string showing all elements of this collection, separated by string sep.

    Definition Classes
    IterableOps
  73. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  74. def newSpecificBuilder(): Builder[A, List[A]]

    returns

    a strict builder for the same collection type. Note that in the case of lazy collections (e.g. View or immutable.LazyList), it is possible to implement this method but the resulting Builder will break laziness. As a consequence, operations should preferably be implemented on top of views rather than builders.

    Attributes
    protected[this]
    Definition Classes
    List → IterableOps
  75. def nonEmpty: Boolean

    Is the collection not empty?

    Is the collection not empty?

    Definition Classes
    :: → IterableOps
  76. final def notify(): Unit
    Definition Classes
    AnyRef
  77. final def notifyAll(): Unit
    Definition Classes
    AnyRef
  78. def padTo[B >: A](len: Int, elem: B): List[B]

    A copy of this $coll with an element value appended until a given target length is reached.

    A copy of this $coll with an element value appended until a given target length is reached.

    B

    the element type of the returned $coll.

    len

    the target length

    elem

    the padding value

    returns

    a new collection of type $Coll consisting of all elements of this $coll followed by the minimal number of occurrences of elem so that the resulting collection has a length of at least len.

    Definition Classes
    SeqOps
  79. def partition(p: (A) ⇒ Boolean): (List[A], List[A])

    Optimized, push-based version of partition.

    Optimized, push-based version of partition.

    Definition Classes
    StrictOptimizedIterableOps → IterableOps
  80. def permutations: Iterator[List[A]]

    Iterates over distinct permutations.

    Iterates over distinct permutations.

    returns

    An Iterator which traverses the distinct permutations of this $coll.

    Definition Classes
    SeqOps
    Example:

    1. "abb".permutations = Iterator(abb, bab, bba)

  81. def prepend[B >: A](elem: B): List[B]

    A copy of the list with an element prepended.

    A copy of the list with an element prepended.

    B

    the element type of the returned list.

    elem

    the prepended element

    returns

    a new list consisting of value followed by all elements of this list.

    Definition Classes
    List → StrictOptimizedSeqOps → SeqOps
  82. def prependAll[B](that: <error>): <error>

    [use case] As with ++, returns a new collection containing the elements from the left operand followed by the elements from the right operand.

    [use case]

    As with ++, returns a new collection containing the elements from the left operand followed by the elements from the right operand.

    It differs from ++ in that the right operand determines the type of the resulting collection rather than the left one. Mnemonic: the COLon is on the side of the new COLlection type.

    Example:

    scala> val x = List(1)
x: List[Int] = List(1)

scala> val y = Vector(2)
y: scala.collection.immutable.Vector[Int] = Vector(2)

scala> val z = x ++: y
z: scala.collection.immutable.Vector[Int] = Vector(1, 2)
    B

    the element type of the returned collection.

    returns

    a new list which contains all elements of prefix followed by all the elements of this list.

    Definition Classes
    List → IterableOps
    Full Signature

    def prependAll[B >: A](prefix: collection.Iterable[B]): List[B]

  83. def product: A

    [use case] Multiplies up the elements of this collection.

    [use case]

    Multiplies up the elements of this collection.

    returns

    the product of all elements in this list of numbers of type Int. Instead of Int, any other type T with an implicit Numeric[T] implementation can be used as element type of the list and as result type of product. Examples of such types are: Long, Float, Double, BigInt.

    Definition Classes
    IterableOps
    Full Signature

    def product[B >: A](implicit num: Numeric[B]): B

  84. def reduce[B >: A](op: (B, B) ⇒ B): B

    Reduces the elements of this $coll using the specified associative binary operator.

    Reduces the elements of this $coll using the specified associative binary operator.

    $undefinedorder

    B

    A type parameter for the binary operator, a supertype of A.

    op

    A binary operator that must be associative.

    returns

    The result of applying reduce operator op between all the elements if the $coll is nonempty.

    Definition Classes
    IterableOps
    Exceptions thrown

    UnsupportedOperationException if this $coll is empty.

  85. def reduceLeft[B >: A](op: (B, A) ⇒ B): B

    Applies a binary operator to all elements of this $coll, going left to right.

    Applies a binary operator to all elements of this $coll, going left to right. $willNotTerminateInf $orderDependentFold

    B

    the result type of the binary operator.

    op

    the binary operator.

    returns

    the result of inserting op between consecutive elements of this $coll, going left to right:

    op( op( ... op(x_1, x_2) ..., x_{n-1}), x_n)

    where x1, ..., xn are the elements of this $coll.

    Definition Classes
    IterableOps
    Exceptions thrown

    UnsupportedOperationException if this $coll is empty.

  86. def reduceLeftOption[B >: A](op: (B, A) ⇒ B): Option[B]

    Optionally applies a binary operator to all elements of this $coll, going left to right.

    Optionally applies a binary operator to all elements of this $coll, going left to right. $willNotTerminateInf $orderDependentFold

    B

    the result type of the binary operator.

    op

    the binary operator.

    returns

    an option value containing the result of reduceLeft(op) if this $coll is nonempty, None otherwise.

    Definition Classes
    IterableOps
  87. def reduceOption[B >: A](op: (B, B) ⇒ B): Option[B]

    Reduces the elements of this $coll, if any, using the specified associative binary operator.

    Reduces the elements of this $coll, if any, using the specified associative binary operator.

    $undefinedorder

    B

    A type parameter for the binary operator, a supertype of A.

    op

    A binary operator that must be associative.

    returns

    An option value containing result of applying reduce operator op between all the elements if the collection is nonempty, and None otherwise.

    Definition Classes
    IterableOps
  88. def reduceRight[B >: A](op: (A, B) ⇒ B): B

    Applies a binary operator to all elements of this $coll, going right to left.

    Applies a binary operator to all elements of this $coll, going right to left. $willNotTerminateInf $orderDependentFold

    B

    the result type of the binary operator.

    op

    the binary operator.

    returns

    the result of inserting op between consecutive elements of this $coll, going right to left:

    op(x_1, op(x_2, ..., op(x_{n-1}, x_n)...))

    where x1, ..., xn are the elements of this $coll.

    Definition Classes
    IterableOps
    Exceptions thrown

    UnsupportedOperationException if this $coll is empty.

  89. def reduceRightOption[B >: A](op: (A, B) ⇒ B): Option[B]

    Optionally applies a binary operator to all elements of this $coll, going right to left.

    Optionally applies a binary operator to all elements of this $coll, going right to left. $willNotTerminateInf $orderDependentFold

    B

    the result type of the binary operator.

    op

    the binary operator.

    returns

    an option value containing the result of reduceRight(op) if this $coll is nonempty, None otherwise.

    Definition Classes
    IterableOps
  90. def reverse: List[A]

    Returns new list with elements in reversed order.

    Returns new list with elements in reversed order.

    returns

    A new list with all elements of this list in reversed order.

    Definition Classes
    List → SeqOps
  91. def reverseIterator(): Iterator[A]

    An iterator yielding elements in reversed order.

    An iterator yielding elements in reversed order.

    $willNotTerminateInf

    Note: xs.reverseIterator is the same as xs.reverse.iterator but might be more efficient.

    returns

    an iterator yielding the elements of this $coll in reversed order

    Definition Classes
    SeqOps
  92. def reverse_:::[B >: A](prefix: List[B]): List[B]

    Adds the elements of a given list in reverse order in front of this list.

    Adds the elements of a given list in reverse order in front of this list. xs reverse_::: ys is equivalent to xs.reverse ::: ys but is more efficient.

    prefix

    the prefix to reverse and then prepend

    returns

    the concatenation of the reversed prefix and the current list.

    Definition Classes
    List
  93. def reversed: collection.Iterable[A]
    Attributes
    protected[this]
    Definition Classes
    IterableOps
  94. def sameElements[B >: A](that: IterableOnce[B]): Boolean

    Are the elements of this collection the same (and in the same order) as those of that?

    Are the elements of this collection the same (and in the same order) as those of that?

    Definition Classes
    SeqOps
  95. def scan[B >: A](z: B)(op: (B, B) ⇒ B): List[B]

    Computes a prefix scan of the elements of the collection.

    Computes a prefix scan of the elements of the collection.

    Note: The neutral element z may be applied more than once.

    B

    element type of the resulting collection

    z

    neutral element for the operator op

    op

    the associative operator for the scan

    returns

    a new $coll containing the prefix scan of the elements in this $coll

    Definition Classes
    IterableOps
  96. def scanLeft[B](z: B)(op: (B, A) ⇒ B): List[B]

    Produces a collection containing cumulative results of applying the operator going left to right.

    Produces a collection containing cumulative results of applying the operator going left to right.

    $willNotTerminateInf $orderDependent

    B

    the type of the elements in the resulting collection

    z

    the initial value

    op

    the binary operator applied to the intermediate result and the element

    returns

    collection with intermediate results

    Definition Classes
    IterableOps
  97. def scanRight[B](z: B)(op: (A, B) ⇒ B): List[B]

    Produces a collection containing cumulative results of applying the operator going right to left.

    Produces a collection containing cumulative results of applying the operator going right to left. The head of the collection is the last cumulative result. $willNotTerminateInf $orderDependent

    Example:

    List(1, 2, 3, 4).scanRight(0)(_ + _) == List(10, 9, 7, 4, 0)
    B

    the type of the elements in the resulting collection

    z

    the initial value

    op

    the binary operator applied to the intermediate result and the element

    returns

    collection with intermediate results

    Definition Classes
    IterableOps
  98. def seq: ::.this.type
    Attributes
    protected[this]
    Definition Classes
    Seq → SeqOps
  99. def size: Int

    The number of elements in this collection.

    The number of elements in this collection. Does not terminate for infinite collections.

    Definition Classes
    LinearSeqOps → IterableOps
  100. def slice(from: Int, until: Int): List[A]

    from

    the lowest index to include from this list.

    until

    the lowest index to EXCLUDE from this list.

    returns

    a list containing the elements greater than or equal to index from extending up to (but not including) index until of this list.

    Definition Classes
    List → IterableOps
    Example: 

    1. // Given a list
val letters = List('a','b','c','d','e')

// `slice` returns all elements beginning at index `from` and afterwards,
// up until index `until` (excluding index `until`.)
letters.slice(1,3) // Returns List('b','c')
  101. def sliding(size: Int, step: Int): Iterator[List[A]]

    Groups elements in fixed size blocks by passing a "sliding window" over them (as opposed to partitioning them, as is done in grouped.)

    Groups elements in fixed size blocks by passing a "sliding window" over them (as opposed to partitioning them, as is done in grouped.)

    size

    the number of elements per group

    step

    the distance between the first elements of successive groups

    returns

    An iterator producing ${coll}s of size size, except the last element (which may be the only element) will be truncated if there are fewer than size elements remaining to be grouped.

    Definition Classes
    IterableOps
    See also

    scala.collection.Iterator, method sliding

  102. def sliding(size: Int): Iterator[List[A]]

    Groups elements in fixed size blocks by passing a "sliding window" over them (as opposed to partitioning them, as is done in grouped.) The "sliding window" step is set to one.

    Groups elements in fixed size blocks by passing a "sliding window" over them (as opposed to partitioning them, as is done in grouped.) The "sliding window" step is set to one.

    size

    the number of elements per group

    returns

    An iterator producing ${coll}s of size size, except the last element (which may be the only element) will be truncated if there are fewer than size elements remaining to be grouped.

    Definition Classes
    IterableOps
    See also

    scala.collection.Iterator, method sliding

  103. def sortBy[B](f: (A) ⇒ B)(implicit ord: Ordering[B]): List[A]

    Sorts this $Coll according to the Ordering which results from transforming an implicitly given Ordering with a transformation function.

    Sorts this $Coll according to the Ordering which results from transforming an implicitly given Ordering with a transformation function.

    B

    the target type of the transformation f, and the type where the ordering ord is defined.

    f

    the transformation function mapping elements to some other domain B.

    ord

    the ordering assumed on domain B.

    returns

    a $coll consisting of the elements of this $coll sorted according to the ordering where x < y if ord.lt(f(x), f(y)).

    Definition Classes
    SeqOps
    Example: 

    1. val words = "The quick brown fox jumped over the lazy dog".split(' ')
// this works because scala.Ordering will implicitly provide an Ordering[Tuple2[Int, Char]]
words.sortBy(x => (x.length, x.head))
res0: Array[String] = Array(The, dog, fox, the, lazy, over, brown, quick, jumped)
    See also

    scala.math.Ordering $willNotTerminateInf

  104. def sortWith(lt: (A, A) ⇒ Boolean): List[A]

    Sorts this $coll according to a comparison function.

    Sorts this $coll according to a comparison function. $willNotTerminateInf

    The sort is stable. That is, elements that are equal (as determined by lt) appear in the same order in the sorted sequence as in the original.

    lt

    the comparison function which tests whether its first argument precedes its second argument in the desired ordering.

    returns

    a $coll consisting of the elements of this $coll sorted according to the comparison function lt.

    Definition Classes
    SeqOps
    Example: 

    1. List("Steve", "Tom", "John", "Bob").sortWith(_.compareTo(_) < 0) =
List("Bob", "John", "Steve", "Tom")
  105. def sorted[B >: A](implicit ord: Ordering[B]): List[A]

    Sorts this $coll according to an Ordering.

    Sorts this $coll according to an Ordering.

    The sort is stable. That is, elements that are equal (as determined by lt) appear in the same order in the sorted sequence as in the original.

    ord

    the ordering to be used to compare elements.

    returns

    a $coll consisting of the elements of this $coll sorted according to the ordering ord.

    Definition Classes
    SeqOps
    See also

    scala.math.Ordering

  106. final def span(p: (A) ⇒ Boolean): (List[A], List[A])

    Splits this list into a prefix/suffix pair according to a predicate.

    Splits this list into a prefix/suffix pair according to a predicate.

    Note: c span p is equivalent to (but possibly more efficient than) (c takeWhile p, c dropWhile p), provided the evaluation of the predicate p does not cause any side-effects.

    p

    the test predicate

    returns

    a pair consisting of the longest prefix of this list whose elements all satisfy p, and the rest of this list.

    Definition Classes
    List → StrictOptimizedIterableOps → IterableOps
    Annotations
    @inline()
  107. def splitAt(n: Int): (List[A], List[A])

    Splits this list into two at a given position.

    Splits this list into two at a given position. Note: c splitAt n is equivalent to (but possibly more efficient than) (c take n, c drop n).

    n

    the position at which to split.

    returns

    a pair of lists consisting of the first n elements of this list, and the other elements.

    Definition Classes
    List → IterableOps
  108. def startsWith[B >: A](that: collection.Seq[B], offset: Int = 0): Boolean

    Tests whether this $coll contains the given sequence at a given index.

    Tests whether this $coll contains the given sequence at a given index.

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

    that

    the sequence to test

    offset

    the index where the sequence is searched.

    returns

    true if the sequence that is contained in this $coll at index offset, otherwise false.

    Definition Classes
    SeqOps
  109. def sum: A

    [use case] Sums up the elements of this collection.

    [use case]

    Sums up the elements of this collection.

    returns

    the sum of all elements in this list of numbers of type Int. Instead of Int, any other type T with an implicit Numeric[T] implementation can be used as element type of the list and as result type of sum. Examples of such types are: Long, Float, Double, BigInt.

    Definition Classes
    IterableOps
    Full Signature

    def sum[B >: A](implicit num: Numeric[B]): B

  110. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  111. def tail: List[A]

    The rest of the collection without its first element.

    The rest of the collection without its first element.

    Definition Classes
    :: → LinearSeqOps → IterableOps
  112. def take(n: Int): List[A]

    A collection containing the first n elements of this collection.

    A collection containing the first n elements of this collection.

    Definition Classes
    List → IterableOps
  113. def takeRight(n: Int): List[A]

    A collection containing the last n elements of this collection.

    A collection containing the last n elements of this collection.

    Definition Classes
    List → IterableOps
  114. final def takeWhile(p: (A) ⇒ Boolean): List[A]

    Takes longest prefix of elements that satisfy a predicate.

    Takes longest prefix of elements that satisfy a predicate.

    p

    The predicate used to test elements.

    returns

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

    Definition Classes
    List → IterableOps
    Annotations
    @inline()
  115. def to[C1](f: CanBuild[A, C1]): C1

    Given a collection factory fi, convert this collection to the appropriate representation for the current element type A.

    Given a collection factory fi, convert this collection to the appropriate representation for the current element type A. Example uses:

    xs.to(List) xs.to(ArrayBuffer) xs.to(BitSet) // for xs: Iterable[Int]

    Definition Classes
    IterableOps
  116. def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]

    Convert collection to array.

    Convert collection to array.

    Definition Classes
    IterableOps
  117. def toString(): String
    Definition Classes
    IterableOps → Any
  118. def unzip[A1, A2](implicit asPair: <:<[A, (A1, A2)]): (List[A1], List[A2])

    Converts this $coll of pairs into two collections of the first and second half of each pair.

    Converts this $coll of pairs into two collections of the first and second half of each pair.

    val xs = $Coll(
           (1, "one"),
           (2, "two"),
           (3, "three")).unzip
// xs == ($Coll(1, 2, 3),
//        $Coll(one, two, three))
    A1

    the type of the first half of the element pairs

    A2

    the type of the second half of the element pairs

    asPair

    an implicit conversion which asserts that the element type of this $coll is a pair.

    returns

    a pair of ${coll}s, containing the first, respectively second half of each element pair of this $coll.

    Definition Classes
    StrictOptimizedIterableOps → IterableOps
  119. def updated[B >: A](index: Int, elem: B): List[B]

    A copy of this $coll with one single replaced element.

    A copy of this $coll with one single replaced element.

    B

    the element type of the returned $coll.

    index

    the position of the replacement

    elem

    the replacing element

    returns

    a copy of this $coll with the element at position index replaced by elem.

    Definition Classes
    StrictOptimizedSeqOps → SeqOps
    Exceptions thrown

    IndexOutOfBoundsException if index does not satisfy 0 <= index < length. <invalid inheritdoc annotation>

  120. def view: View[A]

    A view representing the elements of this collection.

    A view representing the elements of this collection.

    Definition Classes
    IterableOps
  121. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  122. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  123. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  124. def withFilter(p: (A) ⇒ Boolean): WithFilter

    Creates a non-strict filter of this $coll.

    Creates a non-strict filter of this $coll.

    Note: the difference between c filter p and c withFilter p is that the former creates a new collection, whereas the latter only restricts the domain of subsequent map, flatMap, foreach, and withFilter operations. $orderDependent

    p

    the predicate used to test elements.

    returns

    an object of class WithFilter, which supports map, flatMap, foreach, and withFilter operations. All these operations apply to those elements of this $coll which satisfy the predicate p.

    Definition Classes
    IterableOps
  125. final def writeReplace(): AnyRef
    Attributes
    protected
    Definition Classes
    List
  126. val x: A
  127. def zip[B](xs: IterableOnce[B]): List[(A, B)]

    Returns a $coll formed from this $coll and another iterable collection by combining corresponding elements in pairs.

    Returns a $coll formed from this $coll and another iterable collection by combining corresponding elements in pairs. If one of the two collections is longer than the other, its remaining elements are ignored.

    B

    the type of the second half of the returned pairs

    xs

    The iterable providing the second half of each result pair

    returns

    a new collection of type That containing pairs consisting of corresponding elements of this $coll and that. The length of the returned collection is the minimum of the lengths of this $coll and that.

    Definition Classes
    IterableOps
  128. def zipWithIndex: List[(A, Int)]

    Zips this $coll with its indices.

    Zips this $coll with its indices.

    returns

    A new collection of type That containing pairs consisting of all elements of this $coll paired with their index. Indices start at 0.

    Definition Classes
    IterableOps
    Example:

    1. List("a", "b", "c").zipWithIndex == List(("a", 0), ("b", 1), ("c", 2))

Inherited from Product

Inherited from List[A]

Inherited from Serializable

Inherited from Serializable

Inherited from StrictOptimizedSeqOps[A, List, List[A]]

Inherited from StrictOptimizedIterableOps[A, List, List[A]]

Inherited from LinearSeq[A]

Inherited from LinearSeqOps[A, List, List[A]]

Inherited from collection.LinearSeq[A]

Inherited from collection.LinearSeqOps[A, List, List[A]]

Inherited from Seq[A]

Inherited from SeqOps[A, List, List[A]]

Inherited from collection.Seq[A]

Inherited from collection.SeqOps[A, List, List[A]]

Inherited from Equals

Inherited from ArrayLike[A]

Inherited from Iterable[A]

Inherited from collection.Iterable[A]

Inherited from IterableOps[A, List, List[A]]

Inherited from IterableOnce[A]

Inherited from AnyRef

Inherited from Any

Ungrouped