Option

@SerialVersionUID(-114498752079829388L) sealed abstract class Option[+A] extends IterableOnce[A] with Product with Serializable
Represents optional values. Instances of Option are either an instance of Some or the object None.
The most idiomatic way to use an Option instance is to treat it as a collection or monad and use map,flatMap, filter, or foreach:
val name: Option[String] = request getParameter "name"
val upper = name map { _.trim } filter { _.length != 0 } map { _.toUpperCase }
println(upper getOrElse "")
Note that this is equivalent to
val upper = for {
  name <- request getParameter "name"
  trimmed <- Some(name.trim)
  upper <- Some(trimmed.toUpperCase) if trimmed.length != 0
} yield upper
println(upper getOrElse "")
Because of how for comprehension works, if None is returned from request.getParameter, the entire expression results in None
This allows for sophisticated chaining of Option values without having to check for the existence of a value.
These are useful methods that exist for both Some and None. - isDefined — True if not empty - isEmpty — True if empty - nonEmpty — True if not empty - orElse — Evaluate and return alternate optional value if empty - getOrElse — Evaluate and return alternate value if empty - get — Return value, throw exception if empty - fold — Apply function on optional value, return default if empty - map — Apply a function on the optional value - flatMap — Same as map but function must return an optional value - foreach — Apply a procedure on option value - collect — Apply partial pattern match on optional value - filter — An optional value satisfies predicate - filterNot — An optional value doesn't satisfy predicate - exists — Apply predicate on optional value, or false if empty - forall — Apply predicate on optional value, or true if empty - contains — Checks if value equals optional value, or false if empty - zip — Combine two optional values to make a paired optional value - unzip — Split an optional pair to two optional values - unzip3 — Split an optional triple to three optional values - toList — Unary list of optional value, otherwise the empty list
A less-idiomatic way to use Option values is via pattern matching:
val nameMaybe = request getParameter "name"
nameMaybe match {
  case Some(name) =>
    println(name.trim.toUppercase)
  case None =>
    println("No name value")
}
Interacting with code that can occasionally return null can be safely wrapped in Option to become None and Some otherwise.
val abc = new java.util.HashMap[Int, String]
abc.put(1, "A")
bMaybe = Option(abc.get(2))
bMaybe match {
 case Some(b) =>
   println(s"Found $b")
 case None =>
   println("Not found")
}
Note
Many of the methods in here are duplicative with those in the Traversable hierarchy, but they are duplicated for a reason: the implicit conversion tends to leave one with an Iterable in situations where one could have retained an Option.
Companion
object
Source
(source)
trait Product
trait Equals
class Object
trait Matchable
class Any
object None
class Some[A]

Type members

Classlikes

class WithFilter(p: A => Boolean)
We need a whole WithFilter class to honor the "doesn't create a new collection" contract even though it seems unlikely to matter much in a collection with max size 1.
Source
(source)

Value members

Methods

final def toIterable: Iterable[A]
Implicitly added by option2Iterable
Source
(source)
Implicitly added by option2Iterable
Source
(source)
@deprecated("Iterable.seq always returns the iterable itself", "2.13.0")
def seq: Iterable[A]
Implicitly added by option2Iterable
Source
(source)
def lazyZip[B](that: Iterable[B]): LazyZip2[A, B, Iterable[A]]
Implicitly added by option2Iterable
Analogous to zip except that the elements in each collection are not consumed until a strict operation is invoked on the returned LazyZip2 decorator.
Calls to lazyZip can be chained to support higher arities (up to 4) without incurring the expense of constructing and deconstructing intermediary tuples.
val xs = List(1, 2, 3)
val res = (xs lazyZip xs lazyZip xs lazyZip xs).map((a, b, c, d) => a + b + c + d)
// res == List(4, 8, 12)
Type Params
B
the type of the second element in each eventual pair
Value Params
that
the iterable providing the second element of each eventual pair
Returns
a decorator LazyZip2 that allows strict operations to be performed on the lazily evaluated pairs or chained calls to lazyZip. Implicit conversion to Iterable[(A, B)] is also supported.
Source
(source)
final def isEmpty: Boolean
Returns true if the option is None, false otherwise.
This is equivalent to:
option match {
 case Some(_) => false
 case None    => true
}
Source
(source)
final def isDefined: Boolean
Returns true if the option is an instance of Some, false otherwise.
This is equivalent to:
option match {
 case Some(_) => true
 case None    => false
}
Source
(source)
final override def knownSize: Int
Definition Classes
Source
(source)
def get: A
Returns the option's value.
This is equivalent to:
option match {
 case Some(x) => x
 case None    => throw new Exception
}
Throws
NoSuchElementException
NoSuchElementException
Note
The option must be nonempty.
Source
(source)
final def getOrElse[B >: A](default: => B): B
Returns the option's value if the option is nonempty, otherwise return the result of evaluating default.
This is equivalent to:
option match {
 case Some(x) => x
 case None    => default
}
Value Params
default
the default expression.
Source
(source)
final def orNull[A1 >: A](ev: Null <:< A1): A1
Returns the option's value if it is nonempty, or null if it is empty.
Although the use of null is discouraged, code written to use Option must often interface with code that expects and returns nulls.
This is equivalent to:
option match {
 case Some(x) => x
 case None    => null
}
Example
val initialText: Option[String] = getInitialText
val textField = new JComponent(initialText.orNull,20)
Source
(source)
final def map[B](f: A => B): Option[B]
Returns a Some containing the result of applying f to this Option's value if this Option is nonempty. Otherwise return None.
This is equivalent to:
option match {
 case Some(x) => Some(f(x))
 case None    => None
}
Value Params
f
the function to apply
See also
flatMap
foreach
Note
This is similar to flatMap except here, f does not need to wrap its result in an Option.
Source
(source)
final def fold[B](ifEmpty: => B)(f: A => B): B
Returns the result of applying f to this Option's value if the Option is nonempty. Otherwise, evaluates expression ifEmpty.
This is equivalent to:
option match {
 case Some(x) => f(x)
 case None    => ifEmpty
}
This is also equivalent to:
option map f getOrElse ifEmpty
Value Params
f
the function to apply if nonempty.
ifEmpty
the expression to evaluate if empty.
Source
(source)
final def flatMap[B](f: A => Option[B]): Option[B]
Returns the result of applying f to this Option's value if this Option is nonempty. Returns None if this Option is empty. Slightly different from map in that f is expected to return an Option (which could be None).
This is equivalent to:
option match {
 case Some(x) => f(x)
 case None    => None
}
Value Params
f
the function to apply
See also
map
foreach
Source
(source)
def flatten[B](ev: A <:< Option[B]): Option[B]
Returns the nested Option value if it is nonempty. Otherwise, return None.
This is equivalent to:
option match {
 case Some(Some(b)) => Some(b)
 case _             => None
}
Value Params
ev
an implicit conversion that asserts that the value is also an Option.
See also
flatMap
Example
Some(Some("something")).flatten
Source
(source)
final def filter(p: A => Boolean): Option[A]
Returns this Option if it is nonempty and applying the predicate p to this Option's value returns true. Otherwise, return None.
This is equivalent to:
option match {
 case Some(x) if p(x) => Some(x)
 case _               => None
}
Value Params
p
the predicate used for testing.
Source
(source)
final def filterNot(p: A => Boolean): Option[A]
Returns this Option if it is nonempty and applying the predicate p to this Option's value returns false. Otherwise, return None.
This is equivalent to:
option match {
 case Some(x) if !p(x) => Some(x)
 case _                => None
}
Value Params
p
the predicate used for testing.
Source
(source)
final def nonEmpty: Boolean
Returns false if the option is None, true otherwise.
This is equivalent to:
option match {
 case Some(_) => true
 case None    => false
}
Note
Implemented here to avoid the implicit conversion to Iterable.
Source
(source)
final def withFilter(p: A => Boolean): WithFilter
Necessary to keep Option from being implicitly converted to collection.Iterable in for comprehensions.
Source
(source)
final def contains[A1 >: A](elem: A1): Boolean
Tests whether the option contains a given value as an element.
This is equivalent to:
option match {
 case Some(x) => x == elem
 case None    => false
}
Value Params
elem
the element to test.
Returns
true if the option has an element that is equal (as determined by ==) to elem, false otherwise.
Example
// Returns true because Some instance contains string "something" which equals "something".
Some("something") contains "something"
// Returns false because "something" != "anything".
Some("something") contains "anything"
// Returns false when method called on None.
None contains "anything"
Source
(source)
final def exists(p: A => Boolean): Boolean
Returns true if this option is nonempty and the predicate p returns true when applied to this Option's value. Otherwise, returns false.
This is equivalent to:
option match {
 case Some(x) => p(x)
 case None    => false
}
Value Params
p
the predicate to test
Source
(source)
final def forall(p: A => Boolean): Boolean
Returns true if this option is empty or the predicate p returns true when applied to this Option's value.
This is equivalent to:
option match {
 case Some(x) => p(x)
 case None    => true
}
Value Params
p
the predicate to test
Source
(source)
final def foreach[U](f: A => U): Unit
Apply the given procedure f to the option's value, if it is nonempty. Otherwise, do nothing.
This is equivalent to:
option match {
 case Some(x) => f(x)
 case None    => ()
}
Value Params
f
the procedure to apply.
See also
map
flatMap
Source
(source)
final def collect[B](pf: PartialFunction[A, B]): Option[B]
Returns a Some containing the result of applying pf to this Option's contained value, if this option is nonempty and pf is defined for that value. Returns None otherwise.
Value Params
pf
the partial function.
Returns
the result of applying pf to this Option's value (if possible), or None.
Example
// Returns Some(HTTP) because the partial function covers the case.
Some("http") collect {case "http" => "HTTP"}
// Returns None because the partial function doesn't cover the case.
Some("ftp") collect {case "http" => "HTTP"}
// Returns None because the option is empty. There is no value to pass to the partial function.
None collect {case value => value}
Source
(source)
final def orElse[B >: A](alternative: => Option[B]): Option[B]
Returns this Option if it is nonempty, otherwise return the result of evaluating alternative.
This is equivalent to:
option match {
 case Some(x) => Some(x)
 case None    => alternative
}
Value Params
alternative
the alternative expression.
Source
(source)
final def zip[A1 >: A, B](that: Option[B]): Option[(A1, B)]
Returns a Some formed from this option and another option by combining the corresponding elements in a pair. If either of the two options is empty, None is returned.
This is equivalent to:
(option1, option2) match {
  case (Some(x), Some(y)) => Some((x, y))
  case _                  => None
}
Value Params
that
the options which is going to be zipped
Example
// Returns Some(("foo", "bar")) because both options are nonempty.
Some("foo") zip Some("bar")
// Returns None because `that` option is empty.
Some("foo") zip None
// Returns None because `this` option is empty.
None zip Some("bar")
Source
(source)
final def unzip[A1, A2](asPair: A <:< (A1, A2)): (Option[A1], Option[A2])
Converts an Option of a pair into an Option of the first element and an Option of the second element.
This is equivalent to:
option match {
  case Some((x, y)) => (Some(x), Some(y))
  case _            => (None,    None)
}
Type Params
A1
the type of the first half of the element pair
A2
the type of the second half of the element pair
Value Params
asPair
an implicit conversion which asserts that the element type of this Option is a pair.
Returns
a pair of Options, containing, respectively, the first and second half of the element pair of this Option.
Source
(source)
final def unzip3[A1, A2, A3](asTriple: A <:< (A1, A2, A3)): (Option[A1], Option[A2], Option[A3])
Converts an Option of a triple into three Options, one containing the element from each position of the triple.
This is equivalent to:
option match {
  case Some((x, y, z)) => (Some(x), Some(y), Some(z))
  case _               => (None,    None,    None)
}
Type Params
A1
the type of the first of three elements in the triple
A2
the type of the second of three elements in the triple
A3
the type of the third of three elements in the triple
Value Params
asTriple
an implicit conversion which asserts that the element type of this Option is a triple.
Returns
a triple of Options, containing, respectively, the first, second, and third elements from the element triple of this Option.
Source
(source)
Returns a singleton iterator returning the Option's value if it is nonempty, or an empty iterator if the option is empty.
Source
(source)
def toList: List[A]
Returns a singleton list containing the Option's value if it is nonempty, or the empty list if the Option is empty.
This is equivalent to:
option match {
 case Some(x) => List(x)
 case None    => Nil
}
Source
(source)
final def toRight[X](left: => X): Either[X, A]
Returns a util.Left containing the given argument left if this Option is empty, or a util.Right containing this Option's value if this is nonempty.
This is equivalent to:
option match {
 case Some(x) => Right(x)
 case None    => Left(left)
}
Value Params
left
the expression to evaluate and return if this is empty
See also
toLeft
Source
(source)
final def toLeft[X](right: => X): Either[A, X]
Returns a util.Right containing the given argument right if this is empty, or a util.Left containing this Option's value if this Option is nonempty.
This is equivalent to:
option match {
 case Some(x) => Left(x)
 case None    => Right(right)
}
Value Params
right
the expression to evaluate and return if this is empty
See also
toRight
Source
(source)

Inherited methods

def filter(pred: A => Boolean): Iterable[A]
Implicitly added by option2Iterable
Inhertied from
IterableOps
Source
(source)
def to[C1](factory: Factory[A, C1]): C1
Implicitly added by option2Iterable
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]
Inhertied from
IterableOnceOps
Source
(source)
def dropRight(n: Int): Iterable[A]
Implicitly added by option2Iterable
Selects all elements except last n ones.
Note: might return different results for different runs, unless the underlying collection type is ordered.
Value Params
n
the number of elements to drop from this iterable collection.
Returns
a iterable collection consisting of all elements of this iterable collection except the last n ones, or else the empty iterable collection, if this iterable collection has less than n elements. If n is negative, don't drop any elements.
Inhertied from
IterableOps
Source
(source)
def reduceRightOption[B >: A](op: (A, B) => B): Option[B]
Implicitly added by option2Iterable
Optionally applies a binary operator to all elements of this collection, going right to left.
Note: will not terminate for infinite-sized collections.
Note: might return different results for different runs, unless the underlying collection type is ordered or the operator is associative and commutative.
Type Params
B
the result type of the binary operator.
Value Params
op
the binary operator.
Returns
an option value containing the result of reduceRight(op) if this collection is nonempty, None otherwise.
Inhertied from
IterableOnceOps
Source
(source)
def last: A
Implicitly added by option2Iterable
Selects the last element.
Note: might return different results for different runs, unless the underlying collection type is ordered.
Returns
The last element of this iterable collection.
Throws
NoSuchElementException
NoSuchElementException
Inhertied from
IterableOps
Source
(source)
def collect[B](pf: PartialFunction[A, B]): Iterable[B]
Implicitly added by option2Iterable
Inhertied from
IterableOps
Source
(source)
@deprecated("Use foldLeft instead of /:", "2.13.0") @inline
final def /:[B](z: B)(op: (B, A) => B): B
Implicitly added by option2Iterable
Inhertied from
IterableOnceOps
Source
(source)
def collectFirst[B](pf: PartialFunction[A, B]): Option[B]
Implicitly added by option2Iterable
Finds the first element of the collection for which the given partial function is defined, and applies the partial function to it.
Note: may not terminate for infinite-sized collections.
Note: might return different results for different runs, unless the underlying collection type is ordered.
Value Params
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.
Example
Seq("a", 1, 5L).collectFirst({ case x: Int => x*10 }) = Some(10)
Inhertied from
IterableOnceOps
Source
(source)
def groupMap[K, B](key: A => K)(f: A => B): Map[K, Iterable[B]]
Implicitly added by option2Iterable
Partitions this iterable collection into a map of iterable collections 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)
Note: Even when applied to a view or a lazy collection it will always force the elements.
Type Params
B
the type of values returned by the transformation function
K
the type of keys returned by the discriminator function
Value Params
f
the element transformation function
key
the discriminator function
Inhertied from
IterableOps
Source
(source)
def zip[B](that: IterableOnce[B]): Iterable[(A, B)]
Implicitly added by option2Iterable
Returns a iterable collection formed from this iterable collection 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.
Type Params
B
the type of the second half of the returned pairs
Value Params
that
The iterable providing the second half of each result pair
Returns
a new iterable collection containing pairs consisting of corresponding elements of this iterable collection and that. The length of the returned collection is the minimum of the lengths of this iterable collection and that.
Inhertied from
IterableOps
Source
(source)
def drop(n: Int): Iterable[A]
Implicitly added by option2Iterable
Inhertied from
IterableOps
Source
(source)
Implicitly added by option2Iterable
Inhertied from
IterableOnceOps
Source
(source)
def partitionMap[A1, A2](f: A => Either[A1, A2]): (Iterable[A1], Iterable[A2])
Implicitly added by option2Iterable
Applies a function f to each element of the iterable collection and returns a pair of iterable collections: the first one made of those values returned by f that were wrapped in scala.util.Left, and the second one made of those wrapped in scala.util.Right.
Example:
val xs = Iterable(1, "one", 2, "two", 3, "three") partitionMap {
 case i: Int => Left(i)
 case s: String => Right(s)
}
// xs == (Iterable(1, 2, 3),
//        Iterable(one, two, three))
Type Params
A1
the element type of the first resulting collection
A2
the element type of the second resulting collection
Value Params
f
the 'split function' mapping the elements of this iterable collection to an scala.util.Either
Returns
a pair of iterable collections: the first one made of those values returned by f that were wrapped in scala.util.Left, and the second one made of those wrapped in scala.util.Right.
Inhertied from
IterableOps
Source
(source)
@deprecated("Use .to(LazyList) instead of .toStream", "2.13.0") @inline
final def toStream: Stream[A]
Implicitly added by option2Iterable
Inhertied from
IterableOnceOps
Source
(source)
def foreach[U](f: A => U): Unit
Implicitly added by option2Iterable
Apply f to each element for its side effects Note: [U] parameter needed to help scalac's type inference.
Inhertied from
IterableOnceOps
Source
(source)
def sum[B >: A](num: Numeric[B]): B
Implicitly added by option2Iterable
Sums up the elements of this collection.
Note: will not terminate for infinite-sized collections.
Type Params
B
the result type of the + operator.
Value Params
num
an implicit parameter defining a set of numeric operations which includes the + operator to be used in forming the sum.
Returns
the sum of all elements of this collection with respect to the + operator in num.
Inhertied from
IterableOnceOps
Source
(source)
def span(p: A => Boolean): (Iterable[A], Iterable[A])
Implicitly added by option2Iterable
Inhertied from
IterableOps
Source
(source)
def flatMap[B](f: A => IterableOnce[B]): Iterable[B]
Implicitly added by option2Iterable
Inhertied from
IterableOps
Source
(source)
def filterNot(pred: A => Boolean): Iterable[A]
Implicitly added by option2Iterable
Inhertied from
IterableOps
Source
(source)
def scanRight[B](z: B)(op: (A, B) => B): Iterable[B]
Implicitly added by option2Iterable
Produces a collection containing cumulative results of applying the operator going right to left. The head of the collection is the last cumulative result.
Note: will not terminate for infinite-sized collections.
Note: might return different results for different runs, unless the underlying collection type is ordered.
Note: Even when applied to a view or a lazy collection it will always force the elements.
Example:
List(1, 2, 3, 4).scanRight(0)(_ + _) == List(10, 9, 7, 4, 0)
Type Params
B
the type of the elements in the resulting collection
Value Params
op
the binary operator applied to the intermediate result and the element
z
the initial value
Returns
collection with intermediate results
Inhertied from
IterableOps
Source
(source)
def corresponds[B](that: IterableOnce[B])(p: (A, B) => Boolean): Boolean
Implicitly added by option2Iterable
Tests whether every element of this collection's iterator relates to the corresponding element of another collection by satisfying a test predicate.
Note: will not terminate for infinite-sized collections.
Type Params
B
the type of the elements of that
Value Params
p
the test predicate, which relates elements from both collections
that
the other collection
Returns
true if both collections have the same length and p(x, y) is true for all corresponding elements x of this iterator and y of that, otherwise false
Inhertied from
IterableOnceOps
Source
(source)
def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1
Implicitly added by option2Iterable
Folds the elements of this collection using the specified associative binary operator. The default implementation in IterableOnce is equivalent to foldLeft but may be overridden for more efficient traversal orders.
The order in which operations are performed on elements is unspecified and may be nondeterministic.
Note: will not terminate for infinite-sized collections.
Type Params
A1
a type parameter for the binary operator, a supertype of A.
Value Params
op
a binary operator that must be associative.
z
a neutral element for the fold operation; may be added to the result an arbitrary number of times, and must not change the result (e.g., Nil for list concatenation, 0 for addition, or 1 for multiplication).
Returns
the result of applying the fold operator op between all the elements and z, or z if this collection is empty.
Inhertied from
IterableOnceOps
Source
(source)
def minByOption[B](f: A => B)(cmp: Ordering[B]): Option[A]
Implicitly added by option2Iterable
Finds the first element which yields the smallest value measured by function f.
Note: will not terminate for infinite-sized collections.
Type Params
B
The result type of the function f.
Value Params
cmp
An ordering to be used for comparing elements.
f
The measuring function.
Returns
an option value containing the first element of this collection with the smallest value measured by function f with respect to the ordering cmp.
Inhertied from
IterableOnceOps
Source
(source)
def toArray[B >: A](evidence$1: ClassTag[B]): Array[B]
Implicitly added by option2Iterable
Convert collection to array.
Implementation note: DO NOT call Array.from from this method.
Inhertied from
IterableOnceOps
Source
(source)
Implicitly added by option2Iterable
Iterates over the inits of this iterable collection. The first value will be this iterable collection and the final one will be an empty iterable collection, with the intervening values the results of successive applications of init.
Note: Even when applied to a view or a lazy collection it will always force the elements.
Returns
an iterator over all the inits of this iterable collection
Example
List(1,2,3).inits = Iterator(List(1,2,3), List(1,2), List(1), Nil)
Inhertied from
IterableOps
Source
(source)
def sliding(size: Int, step: Int): Iterator[Iterable[A]]
Implicitly added by option2Iterable
Groups elements in fixed size blocks by passing a "sliding window" over them (as opposed to partitioning them, as is done in grouped.)
The returned iterator will be empty when called on an empty collection. The last element the iterator produces may be smaller than the window size when the original collection isn't exhausted by the window before it and its last element isn't skipped by the step before it.
Value Params
size
the number of elements per group
step
the distance between the first elements of successive groups
Returns
An iterator producing iterable collections of size size, except the last element (which may be the only element) will be smaller if there are fewer than size elements remaining to be grouped.
See also
Example
List(1, 2, 3, 4, 5).sliding(2, 2) = Iterator(List(1, 2), List(3, 4), List(5))
List(1, 2, 3, 4, 5, 6).sliding(2, 3) = Iterator(List(1, 2), List(4, 5))
Inhertied from
IterableOps
Source
(source)
def sliding(size: Int): Iterator[Iterable[A]]
Implicitly added by option2Iterable
Groups elements in fixed size blocks by passing a "sliding window" over them (as opposed to partitioning them, as is done in grouped.)
An empty collection returns an empty iterator, and a non-empty collection containing fewer elements than the window size returns an iterator that will produce the original collection as its only element.
Value Params
size
the number of elements per group
Returns
An iterator producing iterable collections of size size, except for a non-empty collection with less than size elements, which returns an iterator that produces the source collection itself as its only element.
See also
Example
List().sliding(2) = empty iterator
List(1).sliding(2) = Iterator(List(1))
List(1, 2).sliding(2) = Iterator(List(1, 2))
List(1, 2, 3).sliding(2) = Iterator(List(1, 2), List(2, 3))
Inhertied from
IterableOps
Source
(source)
def tail: Iterable[A]
Implicitly added by option2Iterable
The rest of the collection without its first element.
Inhertied from
IterableOps
Source
(source)
@deprecated("`aggregate` is not relevant for sequential collections. Use `foldLeft(z)(seqop)` instead.", "2.13.0")
def aggregate[B](z: => B)(seqop: (B, A) => B, combop: (B, B) => B): B
Implicitly added by option2Iterable
Inhertied from
IterableOnceOps
Source
(source)
def transpose[B](asIterable: A => Iterable[B]): Iterable[Iterable[B]]
Implicitly added by option2Iterable
Transposes this iterable collection of iterable collections into a iterable collection of iterable collections.
The resulting collection's type will be guided by the static type of iterable collection. For example:
val xs = List(
           Set(1, 2, 3),
           Set(4, 5, 6)).transpose
// xs == List(
//         List(1, 4),
//         List(2, 5),
//         List(3, 6))

val ys = Vector(
           List(1, 2, 3),
           List(4, 5, 6)).transpose
// ys == Vector(
//         Vector(1, 4),
//         Vector(2, 5),
//         Vector(3, 6))
Note: Even when applied to a view or a lazy collection it will always force the elements.
Type Params
B
the type of the elements of each iterable collection.
Value Params
asIterable
an implicit conversion which asserts that the element type of this iterable collection is an Iterable.
Returns
a two-dimensional iterable collection of iterable collections which has as nth row the nth column of this iterable collection.
Throws
IllegalArgumentException
IllegalArgumentException
Inhertied from
IterableOps
Source
(source)
def foldLeft[B](z: B)(op: (B, A) => B): B
Implicitly added by option2Iterable
Applies a binary operator to a start value and all elements of this collection, going left to right.
Note: will not terminate for infinite-sized collections.
Note: might return different results for different runs, unless the underlying collection type is ordered or the operator is associative and commutative.
Type Params
B
the result type of the binary operator.
Value Params
op
the binary operator.
z
the start value.
Returns
the result of inserting op between consecutive elements of this collection, going left to right with the start value z on the left: op(...op(z, x1), x2, ..., xn) where x1, ..., xn are the elements of this collection. Returns z if this collection is empty.
Inhertied from
IterableOnceOps
Source
(source)
def withFilter(p: A => Boolean): WithFilter[A, [A] =>> Iterable[A]]
Implicitly added by option2Iterable
Creates a non-strict filter of this iterable collection.
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.
Note: might return different results for different runs, unless the underlying collection type is ordered.
Value Params
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 iterable collection which satisfy the predicate p.
Inhertied from
IterableOps
Source
(source)
Implicitly added by option2Iterable
Appends all elements of this collection to a string builder. The written text consists of the string representations (w.r.t. the method toString) of all elements of this collection without any separator string.
Example:
scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> val h = a.addString(b)
h: StringBuilder = 1234
Value Params
b
the string builder to which elements are appended.
Returns
the string builder b to which elements were appended.
Inhertied from
IterableOnceOps
Source
(source)
Implicitly added by option2Iterable
Appends all elements of this collection to a string builder using a separator string. The written text consists of the string representations (w.r.t. the method toString) of all elements of this collection, separated by the string sep.
Example:
scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> a.addString(b, ", ")
res0: StringBuilder = 1, 2, 3, 4
Value Params
b
the string builder to which elements are appended.
sep
the separator string.
Returns
the string builder b to which elements were appended.
Inhertied from
IterableOnceOps
Source
(source)
Implicitly added by option2Iterable
Appends all elements of this collection to a string builder using start, end, and separator strings. The written text begins with the string start and ends with the string end. Inside, the string representations (w.r.t. the method toString) of all elements of this collection are separated by the string sep.
Example:
scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> a.addString(b , "List(" , ", " , ")")
res5: StringBuilder = List(1, 2, 3, 4)
Value Params
b
the string builder to which elements are appended.
end
the ending string.
sep
the separator string.
start
the starting string.
Returns
the string builder b to which elements were appended.
Inhertied from
IterableOnceOps
Source
(source)
def toList: List[A]
Implicitly added by option2Iterable
Inhertied from
IterableOnceOps
Source
(source)
def size: Int
Implicitly added by option2Iterable
The size of this collection.
Note: will not terminate for infinite-sized collections.
Returns
the number of elements in this collection.
Inhertied from
IterableOnceOps
Source
(source)
@deprecated("Use toIterable instead", "2.13.0")
Implicitly added by option2Iterable
Converts this iterable collection to an unspecified Iterable. Will return the same collection if this instance is already Iterable.
Returns
An Iterable containing all elements of this iterable collection.
Inhertied from
IterableOps
Source
(source)
def foldRight[B](z: B)(op: (A, B) => B): B
Implicitly added by option2Iterable
Applies a binary operator to all elements of this collection and a start value, going right to left.
Note: will not terminate for infinite-sized collections.
Note: might return different results for different runs, unless the underlying collection type is ordered or the operator is associative and commutative.
Type Params
B
the result type of the binary operator.
Value Params
op
the binary operator.
z
the start value.
Returns
the result of inserting op between consecutive elements of this collection, going right to left with the start value z on the right: op(x1, op(x2, ... op(xn, z)...)) where x1, ..., xn are the elements of this collection. Returns z if this collection is empty.
Inhertied from
IterableOnceOps
Source
(source)
def map[B](f: A => B): Iterable[B]
Implicitly added by option2Iterable
Inhertied from
IterableOps
Source
(source)
def toSeq: Seq[A]
Implicitly added by option2Iterable
Returns
This collection as a Seq[A]. This is equivalent to to(Seq) but might be faster.
Inhertied from
IterableOnceOps
Source
(source)
def minBy[B](f: A => B)(cmp: Ordering[B]): A
Implicitly added by option2Iterable
Finds the first element which yields the smallest value measured by function f.
Note: will not terminate for infinite-sized collections.
Type Params
B
The result type of the function f.
Value Params
cmp
An ordering to be used for comparing elements.
f
The measuring function.
Returns
the first element of this collection with the smallest value measured by function f with respect to the ordering cmp.
Throws
UnsupportedOperationException
UnsupportedOperationException
Inhertied from
IterableOnceOps
Source
(source)
@deprecatedOverriding("nonEmpty is defined as !isEmpty; override isEmpty instead", "2.13.0")
Implicitly added by option2Iterable
Tests whether the collection is not empty.
Returns
true if the collection contains at least one element, false otherwise.
Inhertied from
IterableOnceOps
Source
(source)
@deprecated("Check .knownSize instead of .hasDefiniteSize for more actionable information (see scaladoc for details)", "2.13.0")
Implicitly added by option2Iterable
Tests whether this collection is known to have a finite size. All strict collections are known to have finite size. For a non-strict collection such as Stream, the predicate returns true if all elements have been computed. It returns false if the stream is not yet evaluated to the end. Non-empty Iterators usually return false even if they were created from a collection with a known finite size.
Note: many collection methods will not work on collections of infinite sizes. The typical failure mode is an infinite loop. These methods always attempt a traversal without checking first that hasDefiniteSize returns true. However, checking hasDefiniteSize can provide an assurance that size is well-defined and non-termination is not a concern.
Returns
true if this collection is known to have finite size, false otherwise.
See also
method knownSize for a more useful alternative
Inhertied from
IterableOnceOps
Source
(source)
def partition(p: A => Boolean): (Iterable[A], Iterable[A])
Implicitly added by option2Iterable
A pair of, first, all elements that satisfy predicate p and, second, all elements that do not. Interesting because it splits a collection in two.
The default implementation provided here needs to traverse the collection twice. Strict collections have an overridden version of partition in StrictOptimizedIterableOps, which requires only a single traversal.
Inhertied from
IterableOps
Source
(source)
def sizeCompare(that: Iterable[]): Int
Implicitly added by option2Iterable
Compares the size of this iterable collection to the size of another Iterable.
Value Params
that
the Iterable whose size is compared with this iterable collection's size.
Returns
A value x where
x <  0       if this.size <  that.size
x == 0       if this.size == that.size
x >  0       if this.size >  that.size
The method as implemented here does not call size directly; its running time is O(this.size min that.size) instead of O(this.size + that.size). The method should be overridden if computing size is cheap and knownSize returns -1.
Inhertied from
IterableOps
Source
(source)
def sizeCompare(otherSize: Int): Int
Implicitly added by option2Iterable
Compares the size of this iterable collection to a test value.
Value Params
otherSize
the test value that gets compared with the size.
Returns
A value x where
x <  0       if this.size <  otherSize
x == 0       if this.size == otherSize
x >  0       if this.size >  otherSize
The method as implemented here does not call size directly; its running time is O(size min otherSize) instead of O(size). The method should be overridden if computing size is cheap and knownSize returns -1.
See also
Inhertied from
IterableOps
Source
(source)
protected def reversed: Iterable[A]
Implicitly added by option2Iterable
Inhertied from
IterableOnceOps
Source
(source)
def reduceRight[B >: A](op: (A, B) => B): B
Implicitly added by option2Iterable
Applies a binary operator to all elements of this collection, going right to left.
Note: will not terminate for infinite-sized collections.
Note: might return different results for different runs, unless the underlying collection type is ordered or the operator is associative and commutative.
Type Params
B
the result type of the binary operator.
Value Params
op
the binary operator.
Returns
the result of inserting op between consecutive elements of this collection, going right to left: op(x1, op(x2, ..., op(xn-1, xn)...)) where x1, ..., xn are the elements of this collection.
Throws
UnsupportedOperationException
UnsupportedOperationException
Inhertied from
IterableOnceOps
Source
(source)
def min[B >: A](ord: Ordering[B]): A
Implicitly added by option2Iterable
Finds the smallest element.
Note: will not terminate for infinite-sized collections.
Type Params
B
The type over which the ordering is defined.
Value Params
ord
An ordering to be used for comparing elements.
Returns
the smallest element of this collection with respect to the ordering ord.
Throws
UnsupportedOperationException
UnsupportedOperationException
Inhertied from
IterableOnceOps
Source
(source)
@deprecated("Use `dest ++= coll` instead", "2.13.0") @inline
final def copyToBuffer[B >: A](dest: Buffer[B]): Unit
Implicitly added by option2Iterable
Inhertied from
IterableOnceOps
Source
(source)
Implicitly added by option2Iterable
Tests whether the collection is empty.
Note: Implementations in subclasses that are not repeatedly traversable must take care not to consume any elements when isEmpty is called.
Returns
true if the collection contains no elements, false otherwise.
Inhertied from
IterableOnceOps
Source
(source)
Implicitly added by option2Iterable
Returns
The number of elements in this collection, if it can be cheaply computed, -1 otherwise. Cheaply usually means: Not requiring a collection traversal.
Inhertied from
IterableOnce
Source
(source)
def toMap[K, V](ev: A <:< (K, V)): Map[K, V]
Implicitly added by option2Iterable
Inhertied from
IterableOnceOps
Source
(source)
def maxByOption[B](f: A => B)(cmp: Ordering[B]): Option[A]
Implicitly added by option2Iterable
Finds the first element which yields the largest value measured by function f.
Note: will not terminate for infinite-sized collections.
Type Params
B
The result type of the function f.
Value Params
cmp
An ordering to be used for comparing elements.
f
The measuring function.
Returns
an option value containing the first element of this collection with the largest value measured by function f with respect to the ordering cmp.
Inhertied from
IterableOnceOps
Source
(source)
def groupBy[K](f: A => K): Map[K, Iterable[A]]
Implicitly added by option2Iterable
Partitions this iterable collection into a map of iterable collections according to some discriminator function.
Note: Even when applied to a view or a lazy collection it will always force the elements.
Type Params
K
the type of keys returned by the discriminator function.
Value Params
f
the discriminator function.
Returns
A map from keys to iterable collections 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 iterable collection of those elements x for which f(x) equals k.
Inhertied from
IterableOps
Source
(source)
@deprecated("Use .iterator instead of .toIterator", "2.13.0") @inline
final def toIterator: Iterator[A]
Implicitly added by option2Iterable
Inhertied from
IterableOnceOps
Source
(source)
def find(p: A => Boolean): Option[A]
Implicitly added by option2Iterable
Finds the first element of the collection satisfying a predicate, if any.
Note: may not terminate for infinite-sized collections.
Note: might return different results for different runs, unless the underlying collection type is ordered.
Value Params
p
the predicate used to test elements.
Returns
an option value containing the first element in the collection that satisfies p, or None if none exists.
Inhertied from
IterableOnceOps
Source
(source)
def dropWhile(p: A => Boolean): Iterable[A]
Implicitly added by option2Iterable
Inhertied from
IterableOps
Source
(source)
@deprecated("Use iterableFactory instead", "2.13.0") @deprecatedOverriding("Use iterableFactory instead", "2.13.0") @inline
Implicitly added by option2Iterable
Inhertied from
IterableOps
Source
(source)
def maxBy[B](f: A => B)(cmp: Ordering[B]): A
Implicitly added by option2Iterable
Finds the first element which yields the largest value measured by function f.
Note: will not terminate for infinite-sized collections.
Type Params
B
The result type of the function f.
Value Params
cmp
An ordering to be used for comparing elements.
f
The measuring function.
Returns
the first element of this collection with the largest value measured by function f with respect to the ordering cmp.
Throws
UnsupportedOperationException
UnsupportedOperationException
Inhertied from
IterableOnceOps
Source
(source)
def takeRight(n: Int): Iterable[A]
Implicitly added by option2Iterable
Selects the last n elements.
Note: might return different results for different runs, unless the underlying collection type is ordered.
Value Params
n
the number of elements to take from this iterable collection.
Returns
a iterable collection consisting only of the last n elements of this iterable collection, or else the whole iterable collection, if it has less than n elements. If n is negative, returns an empty iterable collection.
Inhertied from
IterableOps
Source
(source)
def scanLeft[B](z: B)(op: (B, A) => B): Iterable[B]
Implicitly added by option2Iterable
Inhertied from
IterableOps
Source
(source)
def slice(from: Int, until: Int): Iterable[A]
Implicitly added by option2Iterable
Inhertied from
IterableOps
Source
(source)
def unzip[A1, A2](asPair: A => (A1, A2)): (Iterable[A1], Iterable[A2])
Implicitly added by option2Iterable
Converts this iterable collection of pairs into two collections of the first and second half of each pair.
val xs = Iterable(
           (1, "one"),
           (2, "two"),
           (3, "three")).unzip
// xs == (Iterable(1, 2, 3),
//        Iterable(one, two, three))
Type Params
A1
the type of the first half of the element pairs
A2
the type of the second half of the element pairs
Value Params
asPair
an implicit conversion which asserts that the element type of this iterable collection is a pair.
Returns
a pair of iterable collections, containing the first, respectively second half of each element pair of this iterable collection.
Inhertied from
IterableOps
Source
(source)
def grouped(size: Int): Iterator[Iterable[A]]
Implicitly added by option2Iterable
Partitions elements in fixed size iterable collections.
Value Params
size
the number of elements per group
Returns
An iterator producing iterable collections of size size, except the last will be less than size size if the elements don't divide evenly.
See also
Inhertied from
IterableOps
Source
(source)
Implicitly added by option2Iterable
Inhertied from
IterableOnceOps
Source
(source)
def maxOption[B >: A](ord: Ordering[B]): Option[A]
Implicitly added by option2Iterable
Finds the largest element.
Note: will not terminate for infinite-sized collections.
Type Params
B
The type over which the ordering is defined.
Value Params
ord
An ordering to be used for comparing elements.
Returns
an option value containing the largest element of this collection with respect to the ordering ord.
Inhertied from
IterableOnceOps
Source
(source)
def product[B >: A](num: Numeric[B]): B
Implicitly added by option2Iterable
Multiplies up the elements of this collection.
Note: will not terminate for infinite-sized collections.
Type Params
B
the result type of the * operator.
Value Params
num
an implicit parameter defining a set of numeric operations which includes the * operator to be used in forming the product.
Returns
the product of all elements of this collection with respect to the * operator in num.
Inhertied from
IterableOnceOps
Source
(source)
@deprecated("Use foldRight instead of :\\", "2.13.0") @inline
final def :\[B](z: B)(op: (A, B) => B): B
Implicitly added by option2Iterable
Inhertied from
IterableOnceOps
Source
(source)
Implicitly added by option2Iterable
Inhertied from
IterableOps
Source
(source)
def scan[B >: A](z: B)(op: (B, B) => B): Iterable[B]
Implicitly added by option2Iterable
Computes a prefix scan of the elements of the collection.
Note: The neutral element z may be applied more than once.
Type Params
B
element type of the resulting collection
Value Params
op
the associative operator for the scan
z
neutral element for the operator op
Returns
a new iterable collection containing the prefix scan of the elements in this iterable collection
Inhertied from
IterableOps
Source
(source)
Implicitly added by option2Iterable
Optionally selects the first element.
Note: might return different results for different runs, unless the underlying collection type is ordered.
Returns
the first element of this iterable collection if it is nonempty, None if it is empty.
Inhertied from
IterableOps
Source
(source)
def forall(p: A => Boolean): Boolean
Implicitly added by option2Iterable
Tests whether a predicate holds for all elements of this collection.
Note: may not terminate for infinite-sized collections.
Value Params
p
the predicate used to test elements.
Returns
true if this collection is empty or the given predicate p holds for all elements of this collection, otherwise false.
Inhertied from
IterableOnceOps
Source
(source)
final def ++[B >: A](suffix: IterableOnce[B]): Iterable[B]
Implicitly added by option2Iterable
Alias for concat
Inhertied from
IterableOps
Source
(source)
Implicitly added by option2Iterable
Iterator can be used only once
Inhertied from
IterableOnce
Source
(source)
def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Int
Implicitly added by option2Iterable
Copy elements to an array, returning the number of elements written.
Fills the given array xs starting at index start with at most len elements of this collection.
Copying will stop once either all the elements of this collection have been copied, or the end of the array is reached, or len elements have been copied.
Type Params
B
the type of the elements of the array.
Value Params
len
the maximal number of elements to copy.
start
the starting index of xs.
xs
the array to fill.
Returns
the number of elements written to the array
Note
Reuse: After calling this method, one should discard the iterator it was called on. Using it is undefined and subject to change.
Inhertied from
IterableOnceOps
Source
(source)
@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")
def copyToArray[B >: A](xs: Array[B], start: Int): Int
Implicitly added by option2Iterable
Copy elements to an array, returning the number of elements written.
Fills the given array xs starting at index start with values of this collection.
Copying will stop once either all the elements of this collection have been copied, or the end of the array is reached.
Type Params
B
the type of the elements of the array.
Value Params
start
the starting index of xs.
xs
the array to fill.
Returns
the number of elements written to the array
Note
Reuse: After calling this method, one should discard the iterator it was called on. Using it is undefined and subject to change.
Inhertied from
IterableOnceOps
Source
(source)
@deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")
def copyToArray[B >: A](xs: Array[B]): Int
Implicitly added by option2Iterable
Copy elements to an array, returning the number of elements written.
Fills the given array xs starting at index start with values of this collection.
Copying will stop once either all the elements of this collection have been copied, or the end of the array is reached.
Type Params
B
the type of the elements of the array.
Value Params
xs
the array to fill.
Returns
the number of elements written to the array
Note
Reuse: After calling this method, one should discard the iterator it was called on. Using it is undefined and subject to change.
Inhertied from
IterableOnceOps
Source
(source)
def minOption[B >: A](ord: Ordering[B]): Option[A]
Implicitly added by option2Iterable
Finds the smallest element.
Note: will not terminate for infinite-sized collections.
Type Params
B
The type over which the ordering is defined.
Value Params
ord
An ordering to be used for comparing elements.
Returns
an option value containing the smallest element of this collection with respect to the ordering ord.
Inhertied from
IterableOnceOps
Source
(source)
final def mkString: String
Implicitly added by option2Iterable
Displays all elements of this collection in a string.
Delegates to addString, which can be overridden.
Returns
a string representation of this collection. In the resulting string the string representations (w.r.t. the method toString) of all elements of this collection follow each other without any separator string.
Inhertied from
IterableOnceOps
Source
(source)
final def mkString(sep: String): String
Implicitly added by option2Iterable
Displays all elements of this collection in a string using a separator string.
Delegates to addString, which can be overridden.
Value Params
sep
the separator string.
Returns
a string representation of this collection. In the resulting string the string representations (w.r.t. the method toString) of all elements of this collection are separated by the string sep.
Example
List(1, 2, 3).mkString("|") = "1|2|3"
Inhertied from
IterableOnceOps
Source
(source)
final def mkString(start: String, sep: String, end: String): String
Implicitly added by option2Iterable
Displays all elements of this collection in a string using start, end, and separator strings.
Delegates to addString, which can be overridden.
Value Params
end
the ending string.
sep
the separator string.
start
the starting string.
Returns
a string representation of this collection. The resulting string begins with the string start and ends with the string end. Inside, the string representations (w.r.t. the method toString) of all elements of this collection are separated by the string sep.
Example
List(1, 2, 3).mkString("(", "; ", ")") = "(1; 2; 3)"
Inhertied from
IterableOnceOps
Source
(source)
def stepper[S <: Stepper[]](shape: StepperShape[A, S]): S
Implicitly added by option2Iterable
Returns a scala.collection.Stepper for the elements of this collection.
The Stepper enables creating a Java stream to operate on the collection, see scala.jdk.StreamConverters. For collections holding primitive values, the Stepper can be used as an iterator which doesn't box the elements.
The implicit scala.collection.StepperShape parameter defines the resulting Stepper type according to the element type of this collection.
Note that this method is overridden in subclasses and the return type is refined to S with EfficientSplit, for example scala.collection.IndexedSeqOps.stepper. For Steppers marked with scala.collection.Stepper.EfficientSplit, the converters in scala.jdk.StreamConverters allow creating parallel streams, whereas bare Steppers can be converted only to sequential streams.
Inhertied from
IterableOnce
Source
(source)
def reduceOption[B >: A](op: (B, B) => B): Option[B]
Implicitly added by option2Iterable
Reduces the elements of this collection, if any, using the specified associative binary operator.
The order in which operations are performed on elements is unspecified and may be nondeterministic.
Type Params
B
A type parameter for the binary operator, a supertype of A.
Value Params
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.
Inhertied from
IterableOnceOps
Source
(source)
protected def fromSpecific(coll: IterableOnce[A]): Iterable[A]
Implicitly added by option2Iterable
def groupMapReduce[K, B](key: A => K)(f: A => B)(reduce: (B, B) => B): Map[K, B]
Implicitly added by option2Iterable
Partitions this iterable collection into a map according to a discriminator function key. All the values that have the same discriminator are then transformed by the f 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)(_ + _)
Note: Even when applied to a view or a lazy collection it will always force the elements.
Inhertied from
IterableOps
Source
(source)
def count(p: A => Boolean): Int
Implicitly added by option2Iterable
Counts the number of elements in the collection which satisfy a predicate.
Note: will not terminate for infinite-sized collections.
Value Params
p
the predicate used to test elements.
Returns
the number of elements satisfying the predicate p.
Inhertied from
IterableOnceOps
Source
(source)
def concat[B >: A](suffix: IterableOnce[B]): Iterable[B]
Implicitly added by option2Iterable
Returns a new iterable collection containing the elements from the left hand operand followed by the elements from the right hand operand. The element type of the iterable collection is the most specific superclass encompassing the element types of the two operands.
Type Params
B
the element type of the returned collection.
Value Params
suffix
the traversable to append.
Returns
a new iterable collection which contains all elements of this iterable collection followed by all elements of suffix.
Inhertied from
IterableOps
Source
(source)
def init: Iterable[A]
Implicitly added by option2Iterable
The initial part of the collection without its last element.
Note: Even when applied to a view or a lazy collection it will always force the elements.
Inhertied from
IterableOps
Source
(source)
Implicitly added by option2Iterable
Returns a value class containing operations for comparing the size of this iterable collection to a test value.
These operations are implemented in terms of sizeCompare(Int), and allow the following more readable usages:
this.sizeIs < size     // this.sizeCompare(size) < 0
this.sizeIs <= size    // this.sizeCompare(size) <= 0
this.sizeIs == size    // this.sizeCompare(size) == 0
this.sizeIs != size    // this.sizeCompare(size) != 0
this.sizeIs >= size    // this.sizeCompare(size) >= 0
this.sizeIs > size     // this.sizeCompare(size) > 0
Inhertied from
IterableOps
Source
(source)
@deprecated("Use coll instead of repr in a collection implementation, use the collection value itself from the outside", "2.13.0")
final def repr: Iterable[A]
Implicitly added by option2Iterable
Inhertied from
IterableOps
Source
(source)
def reduceLeft[B >: A](op: (B, A) => B): B
Implicitly added by option2Iterable
Applies a binary operator to all elements of this collection, going left to right.
Note: will not terminate for infinite-sized collections.
Note: might return different results for different runs, unless the underlying collection type is ordered or the operator is associative and commutative.
Type Params
B
the result type of the binary operator.
Value Params
op
the binary operator.
Returns
the result of inserting op between consecutive elements of this collection, going left to right: op( op( ... op(x1, x2) ..., xn-1), xn) where x1, ..., xn are the elements of this collection.
Throws
UnsupportedOperationException
UnsupportedOperationException
Inhertied from
IterableOnceOps
Source
(source)
def toSet[B >: A]: Set[B]
Implicitly added by option2Iterable
Inhertied from
IterableOnceOps
Source
(source)
Implicitly added by option2Iterable
def exists(p: A => Boolean): Boolean
Implicitly added by option2Iterable
Tests whether a predicate holds for at least one element of this collection.
Note: may not terminate for infinite-sized collections.
Value Params
p
the predicate used to test elements.
Returns
true if the given predicate p is satisfied by at least one element of this collection, otherwise false
Inhertied from
IterableOnceOps
Source
(source)
final def toBuffer[B >: A]: Buffer[B]
Implicitly added by option2Iterable
Inhertied from
IterableOnceOps
Source
(source)
def takeWhile(p: A => Boolean): Iterable[A]
Implicitly added by option2Iterable
Takes longest prefix of elements that satisfy a predicate.
Note: might return different results for different runs, unless the underlying collection type is ordered.
Value Params
p
The predicate used to test elements.
Returns
the longest prefix of this iterable collection whose elements all satisfy the predicate p.
Inhertied from
IterableOps
Source
(source)
def take(n: Int): Iterable[A]
Implicitly added by option2Iterable
Inhertied from
IterableOps
Source
(source)
def unzip3[A1, A2, A3](asTriple: A => (A1, A2, A3)): (Iterable[A1], Iterable[A2], Iterable[A3])
Implicitly added by option2Iterable
Converts this iterable collection of triples into three collections of the first, second, and third element of each triple.
val xs = Iterable(
           (1, "one", '1'),
           (2, "two", '2'),
           (3, "three", '3')).unzip3
// xs == (Iterable(1, 2, 3),
//        Iterable(one, two, three),
//        Iterable(1, 2, 3))
Type Params
A1
the type of the first member of the element triples
A2
the type of the second member of the element triples
A3
the type of the third member of the element triples
Value Params
asTriple
an implicit conversion which asserts that the element type of this iterable collection is a triple.
Returns
a triple of iterable collections, containing the first, second, respectively third member of each element triple of this iterable collection.
Inhertied from
IterableOps
Source
(source)
def zipAll[A1 >: A, B](that: Iterable[B], thisElem: A1, thatElem: B): Iterable[(A1, B)]
Implicitly added by option2Iterable
Returns a iterable collection formed from this iterable collection and another iterable collection by combining corresponding elements in pairs. If one of the two collections is shorter than the other, placeholder elements are used to extend the shorter collection to the length of the longer.
Value Params
that
the iterable providing the second half of each result pair
thatElem
the element to be used to fill up the result if that is shorter than this iterable collection.
thisElem
the element to be used to fill up the result if this iterable collection is shorter than that.
Returns
a new collection of type That containing pairs consisting of corresponding elements of this iterable collection and that. The length of the returned collection is the maximum of the lengths of this iterable collection and that. If this iterable collection is shorter than that, thisElem values are used to pad the result. If that is shorter than this iterable collection, thatElem values are used to pad the result.
Inhertied from
IterableOps
Source
(source)
def max[B >: A](ord: Ordering[B]): A
Implicitly added by option2Iterable
Finds the largest element.
Note: will not terminate for infinite-sized collections.
Type Params
B
The type over which the ordering is defined.
Value Params
ord
An ordering to be used for comparing elements.
Returns
the largest element of this collection with respect to the ordering ord.
Throws
UnsupportedOperationException
UnsupportedOperationException
Inhertied from
IterableOnceOps
Source
(source)
def flatten[B](asIterable: A => IterableOnce[B]): Iterable[B]
Implicitly added by option2Iterable
Inhertied from
IterableOps
Source
(source)
@deprecated("Use ++ instead of ++: for collections of type Iterable", "2.13.0")
def ++:[B >: A](that: IterableOnce[B]): Iterable[B]
Implicitly added by option2Iterable
Inhertied from
IterableOps
Source
(source)
@deprecated("Use .view.slice(from, until) instead of .view(from, until)", "2.13.0")
def view(from: Int, until: Int): View[A]
Implicitly added by option2Iterable
A view over a slice of the elements of this collection.
Inhertied from
IterableOps
Source
(source)
def view: View[A]
Implicitly added by option2Iterable
A view over the elements of this collection.
Inhertied from
IterableOps
Source
(source)
def reduceLeftOption[B >: A](op: (B, A) => B): Option[B]
Implicitly added by option2Iterable
Optionally applies a binary operator to all elements of this collection, going left to right.
Note: will not terminate for infinite-sized collections.
Note: might return different results for different runs, unless the underlying collection type is ordered or the operator is associative and commutative.
Type Params
B
the result type of the binary operator.
Value Params
op
the binary operator.
Returns
an option value containing the result of reduceLeft(op) if this collection is nonempty, None otherwise.
Inhertied from
IterableOnceOps
Source
(source)
Implicitly added by option2Iterable
Iterates over the tails of this iterable collection. The first value will be this iterable collection and the final one will be an empty iterable collection, with the intervening values the results of successive applications of tail.
Returns
an iterator over all the tails of this iterable collection
Example
List(1,2,3).tails = Iterator(List(1,2,3), List(2,3), List(3), Nil)
Inhertied from
IterableOps
Source
(source)
def reduce[B >: A](op: (B, B) => B): B
Implicitly added by option2Iterable
Reduces the elements of this collection using the specified associative binary operator.
The order in which operations are performed on elements is unspecified and may be nondeterministic.
Type Params
B
A type parameter for the binary operator, a supertype of A.
Value Params
op
A binary operator that must be associative.
Returns
The result of applying reduce operator op between all the elements if the collection is nonempty.
Throws
UnsupportedOperationException
UnsupportedOperationException
Inhertied from
IterableOnceOps
Source
(source)
Implicitly added by option2Iterable
Optionally selects the last element.
Note: might return different results for different runs, unless the underlying collection type is ordered.
Returns
the last element of this iterable collection$ if it is nonempty, None if it is empty.
Inhertied from
IterableOps
Source
(source)
A string used in the toString methods of derived classes. Implementations may override this method to prepend a string prefix to the result of toString methods.
Returns
in the default implementation, the empty string
Inhertied from
Product
Source
(source)
An iterator over all the elements of this product.
Returns
in the default implementation, an Iterator[Any]
Inhertied from
Product
Source
(source)
An iterator over the names of all the elements of this product.
Inhertied from
Product
Source
(source)
The size of this product.
Returns
for a product A(x1, ..., xk), returns k
Inhertied from
Product
Source
(source)
def stepper[S <: Stepper[]](shape: StepperShape[A, S]): S
Returns a scala.collection.Stepper for the elements of this collection.
The Stepper enables creating a Java stream to operate on the collection, see scala.jdk.StreamConverters. For collections holding primitive values, the Stepper can be used as an iterator which doesn't box the elements.
The implicit scala.collection.StepperShape parameter defines the resulting Stepper type according to the element type of this collection.
Note that this method is overridden in subclasses and the return type is refined to S with EfficientSplit, for example scala.collection.IndexedSeqOps.stepper. For Steppers marked with scala.collection.Stepper.EfficientSplit, the converters in scala.jdk.StreamConverters allow creating parallel streams, whereas bare Steppers can be converted only to sequential streams.
Inhertied from
IterableOnce
Source
(source)
def canEqual(that: Any): Boolean
A method that should be called from every well-designed equals method that is open to be overridden in a subclass. See Programming in Scala, Chapter 28 for discussion and design.
Value Params
that
the value being probed for possible equality
Returns
true if this instance can possibly equal that, otherwise false
Inhertied from
Equals
Source
(source)
def productElement(n: Int): Any
The nth element of this product, 0-based. In other words, for a product A(x1, ..., xk), returns x(n+1) where 0 <= n < k.
Value Params
n
the index of the element to return
Returns
the element n elements after the first element
Throws
IndexOutOfBoundsException
IndexOutOfBoundsException
Inhertied from
Product
Source
(source)
The name of the nth element of this product, 0-based. In the default implementation, an empty string.
Value Params
n
the index of the element name to return
Returns
the name of the specified element
Throws
IndexOutOfBoundsException
IndexOutOfBoundsException
Inhertied from
Product
Source
(source)