object Nil extends List[Nothing] with Product with Serializable

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

Type Members

  1. class WithFilter extends collection.WithFilter[A, CC]

    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 >: Nothing](suffix: collection.Iterable[B]): List[B]

    Alias for concat

    Alias for concat

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

    Alias for prependedAll

    Alias for prependedAll

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

    Alias for prepended.

    Alias for prepended.

    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 >: Nothing](elem: B): List[B]

    Alias for appended

    Alias for appended

    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. final def :++[B >: Nothing](suffix: collection.Iterable[B]): List[B]

    Alias for appendedAll

    Alias for appendedAll

    Definition Classes
    SeqOps
    Annotations
    @inline()
  8. def ::(elem: Nothing): List[Nothing]

    [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 >: Nothing](elem: B): List[B]

  9. def :::[B >: Nothing](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
  10. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  11. def appended[B >: Nothing](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
  12. def appendedAll[B >: Nothing](suffix: collection.Iterable[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 iterable 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 → SeqOps
  13. def apply(n: Int): Nothing

    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( ... )
  14. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  15. 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
  16. 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
  17. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  18. final def coll: Nil.this.type

    returns

    This collection as a C.

    Attributes
    protected[this]
    Definition Classes
    Seq → IterableOps
  19. final def collect[B](pf: PartialFunction[Nothing, B]): List[B]
    Definition Classes
    List → IterableOps
  20. def collectFirst[B](pf: PartialFunction[Nothing, B]): Option[B]

    Finds the first element of the $coll for which the given partial function is defined, and applies the partial function to it.

    Finds the first element of the $coll for which the given partial function is defined, and applies the partial function to it.

    $mayNotTerminateInf $orderDependent

    pf

    the partial function

    returns

    an option value containing pf applied to the first value for which it is defined, or None if none exists.

    Definition Classes
    IterableOps
    Example:

    1. Seq("a", 1, 5L).collectFirst({ case x: Int => x*10 }) = Some(10)

  21. def combinations(n: Int): Iterator[List[Nothing]]

    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)

  22. final def concat[B >: Nothing](suffix: collection.Iterable[B]): List[B]
    Definition Classes
    IterableOps
    Annotations
    @inline()
  23. def contains[A1 >: Nothing](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
  24. 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
  25. def copyToArray[B >: Nothing](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
  26. def count(p: (Nothing) ⇒ 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
  27. def distinct: List[Nothing]

    Selects all the elements of this $coll ignoring the duplicates.

    Selects all the elements of this $coll ignoring the duplicates.

    returns

    a new $coll consisting of all the elements of this $coll without duplicates.

    Definition Classes
    SeqOps
  28. def distinctBy[B](f: (Nothing) ⇒ B): List[Nothing]

    Selects all the elements of this $coll ignoring the duplicates as determined by == after applying the transforming function f.

    Selects all the elements of this $coll ignoring the duplicates as determined by == after applying the transforming function f.

    B

    the type of the elements after being transformed by f

    f

    The transforming function whose result is used to determine the uniqueness of each element

    returns

    a new $coll consisting of all the elements of this $coll without duplicates.

    Definition Classes
    StrictOptimizedSeqOps → SeqOps
  29. def drop(n: Int): List[Nothing]

    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
  30. def dropRight(n: Int): List[Nothing]

    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
  31. final def dropWhile(p: (Nothing) ⇒ Boolean): List[Nothing]

    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

  32. def endsWith[B >: Nothing](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
  33. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  34. def equals(o: Any): Boolean
    Definition Classes
    SeqOps → Equals → Any
  35. def exists(p: (Nothing) ⇒ 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
  36. def filter(pred: (Nothing) ⇒ Boolean): List[Nothing]

    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
  37. def filterNot(pred: (Nothing) ⇒ Boolean): List[Nothing]

    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
  38. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  39. def find(p: (Nothing) ⇒ Boolean): Option[Nothing]

    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
  40. final def flatMap[B](f: (Nothing) ⇒ IterableOnce[B]): List[B]

    Flatmap

    Flatmap

    Definition Classes
    List → IterableOps
  41. def flatten[B](implicit ev: (Nothing) ⇒ IterableOnce[B]): List[B]
    Definition Classes
    IterableOps
  42. def foldLeft[B](z: B)(op: (B, Nothing) ⇒ B): B

    Fold left

    Fold left

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

    Fold right

    Fold right

    Definition Classes
    List → IterableOps
  44. def forall(p: (Nothing) ⇒ 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
  45. final def foreach[U](f: (Nothing) ⇒ 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()
  46. def fromIterable[E](it: collection.Iterable[E]): List[E]
    Attributes
    protected[this]
    Definition Classes
    IterableOps
  47. def fromSpecificIterable(coll: collection.Iterable[Nothing]): List[Nothing]
    Attributes
    protected[this]
    Definition Classes
    List → IterableOps
  48. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
  49. def groupBy[K](f: (Nothing) ⇒ K): Map[K, List[Nothing]]

    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
  50. def groupMap[K, B](key: (Nothing) ⇒ K)(f: (Nothing) ⇒ B): Map[K, List[B]]

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

    Partitions this $coll into a map of ${coll}s according to a discriminator function key. Each element in a group is transformed into a value of type B using the value function.

    It is equivalent to groupBy(key).mapValues(_.map(f)), but more efficient.

    case class User(name: String, age: Int)

def namesByAge(users: Seq[User]): Map[Int, Seq[String]] =
  users.groupMap(_.age)(_.name)
    K

    the type of keys returned by the discriminator function

    B

    the type of values returned by the transformation function

    key

    the discriminator function

    f

    the element transformation function

    Definition Classes
    IterableOps
  51. def groupMapReduce[K, B](key: (Nothing) ⇒ K)(f: (Nothing) ⇒ B)(reduce: (B, B) ⇒ B): Map[K, B]

    Partitions this $coll into a map according to a discriminator function key.

    Partitions this $coll into a map according to a discriminator function key. All the values that have the same discriminator are then transformed by the value function and then reduced into a single value with the reduce function.

    It is equivalent to groupBy(key).mapValues(_.map(f).reduce(reduce)), but more efficient.

    def occurrences[A](as: Seq[A]): Map[A, Int] =
  as.groupMapReduce(identity)(_ => 1)(_ + _)
    Definition Classes
    IterableOps
  52. def grouped(size: Int): Iterator[List[Nothing]]

    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

  53. def hashCode(): Int
    Definition Classes
    SeqOps → Any
  54. def head: Nothing

    The first element of the collection.

    The first element of the collection.

    Definition Classes
    Nil → LinearSeqOps → IterableOps
  55. def indexOf[B >: Nothing](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
  56. def indexOfSlice[B >: Nothing](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
  57. def indexWhere(p: (Nothing) ⇒ 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
  58. 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
  59. def init: Nothing

    The initial part of the collection without its last element.

    The initial part of the collection without its last element.

    Definition Classes
    Nil → IterableOps
  60. def isEmpty: Boolean

    To be overridden in implementations:

    To be overridden in implementations:

    Definition Classes
    Nil → LinearSeqOps → IterableOps
  61. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  62. def iterableFactory: SeqFactory[List]
    Definition Classes
    List → Seq → IterableOps
  63. def iterator(): Iterator[Nothing]

    iterator is implemented in terms of head and tail

    iterator is implemented in terms of head and tail

    Definition Classes
    LinearSeqOps
  64. 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
  65. def last: Nothing

    Selects the last element.

    Selects the last element.

    returns

    The last element of this list.

    Definition Classes
    Nil → IterableOps
    Exceptions thrown

    NoSuchElementException If the list is empty.

  66. def lastIndexOf[B >: Nothing](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
  67. def lastIndexOfSlice[B >: Nothing](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
  68. def lastIndexWhere(p: (Nothing) ⇒ 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
  69. def lastOption: Option[Nothing]

    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
  70. final def length: Int
    Definition Classes
    LinearSeqOps → ArrayLike
  71. final def map[B](f: (Nothing) ⇒ 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
  72. def max: Nothing

    [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 >: Nothing](implicit ord: Ordering[B]): Nothing

  73. def maxBy[B](f: (Nothing) ⇒ B): Nothing

    [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: (Nothing) ⇒ B)(implicit cmp: Ordering[B]): Nothing

  74. def min: Nothing

    [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 >: Nothing](implicit ord: Ordering[B]): Nothing

  75. def minBy[B](f: (Nothing) ⇒ B): Nothing

    [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: (Nothing) ⇒ B)(implicit cmp: Ordering[B]): Nothing

  76. def mkString: String
    Definition Classes
    IterableOps
  77. def mkString(sep: String): String
    Definition Classes
    IterableOps
  78. 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
  79. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  80. def newSpecificBuilder(): Builder[Nothing, List[Nothing]]

    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
  81. def nonEmpty: Boolean

    Is the collection not empty?

    Is the collection not empty?

    Definition Classes
    Nil → IterableOps
  82. final def notify(): Unit
    Definition Classes
    AnyRef
  83. final def notifyAll(): Unit
    Definition Classes
    AnyRef
  84. def padTo[B >: Nothing](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
  85. def partition(p: (Nothing) ⇒ Boolean): (List[Nothing], List[Nothing])

    Optimized, push-based version of partition.

    Optimized, push-based version of partition.

    Definition Classes
    StrictOptimizedIterableOps → IterableOps
  86. def patch[B >: Nothing](from: Int, other: IterableOnce[B], replaced: Int): List[B]

    Produces a new $coll where a slice of elements in this $coll is replaced by another sequence.

    Produces a new $coll where a slice of elements in this $coll is replaced by another sequence.

    Patching at negative indices is the same as patching starting at 0. Patching at indices at or larger than the length of the original $coll appends the patch to the end. If more values are replaced than actually exist, the excess is ignored.

    B

    the element type of the returned $coll.

    from

    the index of the first replaced element

    other

    the replacement sequence

    replaced

    the number of elements to drop in the original $coll

    returns

    a new $coll consisting of all elements of this $coll except that replaced elements starting from from are replaced by all the elements of other.

    Definition Classes
    StrictOptimizedSeqOps → SeqOps
  87. def permutations: Iterator[List[Nothing]]

    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)

  88. def prependAll[B](that: collection.Iterable[B]): <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 → SeqOps
    Full Signature

    def prependedAll[B >: Nothing](prefix: collection.Iterable[B]): List[B]

  89. def prepended[B >: Nothing](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
  90. def product: Nothing

    [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 >: Nothing](implicit num: Numeric[B]): B

  91. def reduce[B >: Nothing](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.

  92. def reduceLeft[B >: Nothing](op: (B, Nothing) ⇒ 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.

  93. def reduceLeftOption[B >: Nothing](op: (B, Nothing) ⇒ 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
  94. def reduceOption[B >: Nothing](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
  95. def reduceRight[B >: Nothing](op: (Nothing, 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.

  96. def reduceRightOption[B >: Nothing](op: (Nothing, 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
  97. def reverse: List[Nothing]

    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
  98. def reverseIterator(): Iterator[Nothing]

    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
  99. def reverse_:::[B >: Nothing](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
  100. def reversed: collection.Iterable[Nothing]
    Attributes
    protected[this]
    Definition Classes
    IterableOps
  101. def sameElements[B >: Nothing](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
  102. def scan[B >: Nothing](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
  103. def scanLeft[B](z: B)(op: (B, Nothing) ⇒ 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
  104. def scanRight[B](z: B)(op: (Nothing, 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
  105. 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
  106. def slice(from: Int, until: Int): List[Nothing]

    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')
  107. def sliding(size: Int, step: Int): Iterator[List[Nothing]]

    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

  108. def sliding(size: Int): Iterator[List[Nothing]]

    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

  109. def sortBy[B](f: (Nothing) ⇒ B)(implicit ord: Ordering[B]): List[Nothing]

    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

  110. def sortWith(lt: (Nothing, Nothing) ⇒ Boolean): List[Nothing]

    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")
  111. def sorted[B >: Nothing](implicit ord: Ordering[B]): List[Nothing]

    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

  112. final def span(p: (Nothing) ⇒ Boolean): (List[Nothing], List[Nothing])

    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()
  113. def splitAt(n: Int): (List[Nothing], List[Nothing])

    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
  114. def startsWith[B >: Nothing](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
  115. def sum: Nothing

    [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 >: Nothing](implicit num: Numeric[B]): B

  116. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  117. def tail: Nothing

    The rest of the collection without its first element.

    The rest of the collection without its first element.

    Definition Classes
    Nil → LinearSeqOps → IterableOps
  118. def take(n: Int): List[Nothing]

    A collection containing the first n elements of this collection.

    A collection containing the first n elements of this collection.

    Definition Classes
    List → IterableOps
  119. def takeRight(n: Int): List[Nothing]

    A collection containing the last n elements of this collection.

    A collection containing the last n elements of this collection.

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

    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()
  121. def to[C1](factory: Factory[Nothing, C1]): C1

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

    Given a collection factory factory, 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
  122. def toArray[B >: Nothing](implicit arg0: ClassTag[B]): Array[B]

    Convert collection to array.

    Convert collection to array.

    Definition Classes
    IterableOps
  123. final def toIterable: Nil.this.type

    The collection itself

    The collection itself

    returns

    This collection as an Iterable[A]. No new collection will be built if this is already an Iterable[A].

    Definition Classes
    Iterable → IterableOps
  124. final def toSeq: Nil.this.type

    returns

    This collection as a Seq[A]. This is equivalent to to(Seq) but might be faster.

    Definition Classes
    Seq → SeqOps
  125. def toString(): String
    Definition Classes
    IterableOps → Any
  126. def unzip[A1, A2](implicit asPair: <:<[Nothing, (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
  127. def updated[B >: Nothing](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>

  128. def view: View[Nothing]

    A view representing the elements of this collection.

    A view representing the elements of this collection.

    Definition Classes
    IterableOps
  129. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  130. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  131. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  132. def withFilter(p: (Nothing) ⇒ Boolean): collection.WithFilter[Nothing, List]

    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
  133. final def writeReplace(): AnyRef
    Attributes
    protected
    Definition Classes
    List
  134. def zip[B](xs: collection.Iterable[B]): List[(Nothing, 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
  135. def zipWithIndex: List[(Nothing, 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[Nothing]

Inherited from Serializable

Inherited from Serializable

Inherited from StrictOptimizedSeqOps[Nothing, List, List[Nothing]]

Inherited from collection.StrictOptimizedSeqOps[Nothing, List, List[Nothing]]

Inherited from StrictOptimizedIterableOps[Nothing, List, List[Nothing]]

Inherited from LinearSeq[Nothing]

Inherited from LinearSeqOps[Nothing, List, List[Nothing]]

Inherited from collection.LinearSeq[Nothing]

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

Inherited from Seq[Nothing]

Inherited from SeqOps[Nothing, List, List[Nothing]]

Inherited from collection.Seq[Nothing]

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

Inherited from Equals

Inherited from ArrayLike[Nothing]

Inherited from Iterable[Nothing]

Inherited from collection.Iterable[Nothing]

Inherited from IterableOps[Nothing, List, List[Nothing]]

Inherited from IterableOnce[Nothing]

Inherited from AnyRef

Inherited from Any

Ungrouped