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.
Test two objects for inequality.
true
if !(this == that), false otherwise.
Equivalent to x.hashCode
except for boxed numeric types and null
. For numerics, it returns a hash value which is consistent with value equality: if two value type instances compare as true, then ## will produce the same hash value for each of them. For null
returns a hashcode where null.hashCode
throws a NullPointerException
.
a hash value consistent with ==
The expression x == that
is equivalent to if (x eq null) that eq null else x.equals(that)
.
true
if the receiver object is equivalent to the argument; false
otherwise.
Cast the receiver object to be of type T0
.
Note that the success of a cast at runtime is modulo Scala's erasure semantics. Therefore the expression 1.asInstanceOf[String]
will throw a ClassCastException
at runtime, while the expression List(1).asInstanceOf[List[String]]
will not. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the requested type.
the receiver object.
ClassCastException
if the receiver object is not an instance of the erasure of type T0
.
Create a copy of the receiver object.
The default implementation of the clone
method is platform dependent.
a copy of the receiver object.
Returns a scala.Some containing the result of applying pf
to this scala.Option's contained value, if this option is nonempty and pf
is defined for that value. Returns None
otherwise.
the partial function.
the result of applying pf
to this scala.Option's value (if possible), or None
.
// 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}
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 }
the element to test.
true
if the option has an element that is equal (as determined by ==
) to elem
, false
otherwise.
// 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"
Tests whether the argument (that
) is a reference to the receiver object (this
).
The eq
method implements an equivalence relation on non-null instances of AnyRef
, and has three additional properties:
x
and y
of type AnyRef
, multiple invocations of x.eq(y)
consistently returns true
or consistently returns false
.For any non-null instance x
of type AnyRef
, x.eq(null)
and null.eq(x)
returns false
.
null.eq(null)
returns true
. When overriding the equals
or hashCode
methods, it is important to ensure that their behavior is consistent with reference equality. Therefore, if two objects are references to each other (o1 eq o2
), they should be equal to each other (o1 == o2
) and they should hash to the same value (o1.hashCode == o2.hashCode
).
true
if the argument is a reference to the receiver object; false
otherwise.
The equality method for reference types. Default implementation delegates to eq
.
See also equals
in scala.Any.
true
if the receiver object is equivalent to the argument; false
otherwise.
Returns true if this option is nonempty and the predicate p
returns true when applied to this scala.Option's value. Otherwise, returns false.
This is equivalent to:
option match { case Some(x) => p(x) case None => false }
the predicate to test
Returns this scala.Option if it is nonempty and applying the predicate p
to this scala.Option's value returns true. Otherwise, return None
.
This is equivalent to:
option match { case Some(x) if p(x) => Some(x) case _ => None }
the predicate used for testing.
Returns this scala.Option if it is nonempty and applying the predicate p
to this scala.Option's value returns false. Otherwise, return None
.
This is equivalent to:
option match { case Some(x) if !p(x) => Some(x) case _ => None }
the predicate used for testing.
Called by the garbage collector on the receiver object when there are no more references to the object.
The details of when and if the finalize
method is invoked, as well as the interaction between finalize
and non-local returns and exceptions, are all platform dependent.
Returns the result of applying f
to this scala.Option's value if this scala.Option is nonempty. Returns None
if this scala.Option is empty. Slightly different from map
in that f
is expected to return an scala.Option (which could be None
).
This is equivalent to:
option match { case Some(x) => f(x) case None => None }
the function to apply
Returns the nested scala.Option value if it is nonempty. Otherwise, return None
.
This is equivalent to:
option match { case Some(Some(b)) => Some(b) case _ => None }
an implicit conversion that asserts that the value is also an scala.Option.
Some(Some("something")).flatten
flatMap
Returns the result of applying f
to this scala.Option's value if the scala.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
the expression to evaluate if empty.
the function to apply if nonempty.
Returns true if this option is empty or the predicate p
returns true when applied to this scala.Option's value.
This is equivalent to:
option match { case Some(x) => p(x) case None => true }
the predicate to test
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 => () }
the procedure to apply.
Returns the option's value.
This is equivalent to:
option match { case Some(x) => x case None => throw new Exception }
Returns the runtime class representation of the object.
a class object corresponding to the runtime type of the receiver.
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 }
the default expression.
Returns true if the option is an instance of scala.Some, false otherwise.
This is equivalent to:
option match { case Some(_) => true case None => false }
Returns true if the option is None
, false otherwise.
This is equivalent to:
option match { case Some(_) => false case None => true }
Test whether the dynamic type of the receiver object is T0
.
Note that the result of the test is modulo Scala's erasure semantics. Therefore the expression 1.isInstanceOf[String]
will return false
, while the expression List(1).isInstanceOf[List[String]]
will return true
. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the specified type.
true
if the receiver object is an instance of erasure of type T0
; false
otherwise.
Returns a singleton iterator returning the scala.Option's value if it is nonempty, or an empty iterator if the option is empty.
The number of elements in this option, if it can be cheaply computed, -1 otherwise. Cheaply usually means: Not requiring a collection traversal.
Returns a scala.Some containing the result of applying f
to this scala.Option's value if this scala.Option is nonempty. Otherwise return None
.
This is equivalent to:
option match { case Some(x) => Some(f(x)) case None => None }
the function to apply
This is similar to flatMap
except here, f
does not need to wrap its result in an scala.Option.
flatMap
foreach
Equivalent to !(this eq that)
.
true
if the argument is not a reference to the receiver object; false
otherwise.
Returns false if the option is None
, true otherwise.
This is equivalent to:
option match { case Some(_) => true case None => false }
Implemented here to avoid the implicit conversion to Iterable.
Wakes up a single thread that is waiting on the receiver object's monitor.
not specified by SLS as a member of AnyRef
Wakes up all threads that are waiting on the receiver object's monitor.
not specified by SLS as a member of AnyRef
Returns this scala.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 }
the alternative expression.
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 scala.Option must often interface with code that expects and returns nulls.
This is equivalent to:
option match { case Some(x) => x case None => null }
The name of the nth element of this product, 0-based. In the default implementation, an empty string.
the index of the element name to return
the name of the specified element
IndexOutOfBoundsException
if the n
is out of range(n < 0 || n >= productArity).
An iterator over the names of all the elements of this product.
Returns a 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 StepperShape parameter defines the resulting Stepper type according to the element type of this collection.
Int
, Short
, Byte
or Char
, an IntStepper is returnedFor collections of Double
or Float
, a DoubleStepper is returnedFor collections of Long
a LongStepper is returnedFor any other element type, an AnyStepper is returnedNote that this method is overridden in subclasses and the return type is refined to S with EfficientSplit
, for example 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.
Returns a scala.util.Right containing the given argument right
if this is empty, or a scala.util.Left containing this scala.Option's value if this scala.Option is nonempty.
This is equivalent to:
option match { case Some(x) => Left(x) case None => Right(right) }
the expression to evaluate and return if this is empty
Returns a singleton list containing the scala.Option's value if it is nonempty, or the empty list if the scala.Option is empty.
This is equivalent to:
option match { case Some(x) => List(x) case None => Nil }
Returns a scala.util.Left containing the given argument left
if this scala.Option is empty, or a scala.util.Right containing this scala.Option's value if this is nonempty.
This is equivalent to:
option match { case Some(x) => Right(x) case None => Left(left) }
the expression to evaluate and return if this is empty
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) }
the type of the first half of the element pair
the type of the second half of the element pair
an implicit conversion which asserts that the element type of this Option is a pair.
a pair of Options, containing, respectively, the first and second half of the element pair of this Option.
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) }
the type of the first of three elements in the triple
the type of the second of three elements in the triple
the type of the third of three elements in the triple
an implicit conversion which asserts that the element type of this Option is a triple.
a triple of Options, containing, respectively, the first, second, and third elements from the element triple of this Option.
Necessary to keep scala.Option from being implicitly converted to scala.collection.Iterable in for
comprehensions.
Returns a scala.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 }
the options which is going to be zipped
// 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")
© 2002-2019 EPFL, with contributions from Lightbend.
Licensed under the Apache License, Version 2.0.
https://www.scala-lang.org/api/2.13.0/scala/None$.html
This case object represents non-existent values.
1.0