case object None extends Option[Nothing] with Product with Serializable
This case object represents non-existent values.
- Annotations
- @SerialVersionUID()
- Source
- Option.scala
- Alphabetic
- By Inheritance
- None
- Option
- Serializable
- Product
- Equals
- IterableOnce
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Type Members
- class WithFilter extends AnyRef
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.
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.
- Definition Classes
- Option
Value Members
- final def collect[B](pf: PartialFunction[Nothing, B]): Option[B]
Returns a scala.Some containing the result of applying
pf
to this scala.Option's contained value, if this option is nonempty andpf
is defined for that value.Returns a scala.Some containing the result of applying
pf
to this scala.Option's contained value, if this option is nonempty andpf
is defined for that value. ReturnsNone
otherwise.- pf
the partial function.
- returns
the result of applying
pf
to this scala.Option's value (if possible), orNone
.
- Definition Classes
- Option
- Annotations
- @inline()
// 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}
Example: - final def contains[A1 >: Nothing](elem: A1): Boolean
Tests whether the option contains a given value as an element.
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 }
- elem
the element to test.
- returns
true
if the option has an element that is equal (as determined by==
) toelem
,false
otherwise.
- Definition Classes
- Option
// 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"
Example: - final def exists(p: (Nothing) => Boolean): Boolean
Returns true if this option is nonempty and the predicate
p
returns true when applied to this scala.Option's value.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 }
- p
the predicate to test
- final def filter(p: (Nothing) => Boolean): Option[Nothing]
Returns this scala.Option if it is nonempty and applying the predicate
p
to this scala.Option's value returns true.Returns this scala.Option if it is nonempty and applying the predicate
p
to this scala.Option's value returns true. Otherwise, returnNone
.This is equivalent to:
option match { case Some(x) if p(x) => Some(x) case _ => None }
- p
the predicate used for testing.
- final def filterNot(p: (Nothing) => Boolean): Option[Nothing]
Returns this scala.Option if it is nonempty and applying the predicate
p
to this scala.Option's value returns false.Returns this scala.Option if it is nonempty and applying the predicate
p
to this scala.Option's value returns false. Otherwise, returnNone
.This is equivalent to:
option match { case Some(x) if !p(x) => Some(x) case _ => None }
- p
the predicate used for testing.
- final def flatMap[B](f: (Nothing) => Option[B]): Option[B]
Returns the result of applying
f
to this scala.Option's value if this scala.Option is nonempty.Returns the result of applying
f
to this scala.Option's value if this scala.Option is nonempty. ReturnsNone
if this scala.Option is empty. Slightly different frommap
in thatf
is expected to return an scala.Option (which could beNone
).This is equivalent to:
option match { case Some(x) => f(x) case None => None }
- f
the function to apply
- def flatten[B](implicit ev: <:<[Nothing, Option[B]]): Option[B]
Returns the nested scala.Option value if it is nonempty.
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 }
- ev
an implicit conversion that asserts that the value is also an scala.Option.
- Definition Classes
- Option
Some(Some("something")).flatten
- See also
flatMap
Example: - final def fold[B](ifEmpty: => B)(f: (Nothing) => B): B
Returns the result of applying
f
to this scala.Option's value if the scala.Option is nonempty.Returns the result of applying
f
to this scala.Option's value if the scala.Option is nonempty. Otherwise, evaluates expressionifEmpty
.This is equivalent to:
option match { case Some(x) => f(x) case None => ifEmpty }
This is also equivalent to:
option map f getOrElse ifEmpty
- ifEmpty
the expression to evaluate if empty.
- f
the function to apply if nonempty.
- final def forall(p: (Nothing) => Boolean): Boolean
Returns true if this option is empty or the predicate
p
returns true when applied to this scala.Option's value.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 }
- p
the predicate to test
- final def foreach[U](f: (Nothing) => U): Unit
Apply the given procedure
f
to the option's value, if it is nonempty. - def get: Nothing
Returns the option's value.
Returns the option's value.
This is equivalent to:
option match { case Some(x) => x case None => throw new Exception }
- Definition Classes
- None → Option
- Exceptions thrown
NoSuchElementException
if the option is empty.- Note
The option must be nonempty.
- final def getOrElse[B >: Nothing](default: => B): B
Returns the option's value if the option is nonempty, otherwise return the result of evaluating
default
. - final def isDefined: Boolean
Returns true if the option is an instance of scala.Some, false otherwise.
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 }
- Definition Classes
- Option
- final def isEmpty: Boolean
Returns true if the option is
None
, false otherwise.Returns true if the option is
None
, false otherwise.This is equivalent to:
option match { case Some(_) => false case None => true }
- Definition Classes
- Option
- def iterator: Iterator[Nothing]
Returns a singleton iterator returning the scala.Option's value if it is nonempty, or an empty iterator if the option is empty.
Returns a singleton iterator returning the scala.Option's value if it is nonempty, or an empty iterator if the option is empty.
- Definition Classes
- Option → IterableOnce
- final def knownSize: Int
- returns
The number of elements in this option, if it can be cheaply computed, -1 otherwise. Cheaply usually means: Not requiring a collection traversal.
- Definition Classes
- Option → IterableOnce
- final def map[B](f: (Nothing) => B): Option[B]
Returns a scala.Some containing the result of applying
f
to this scala.Option's value if this scala.Option is nonempty.Returns a scala.Some containing the result of applying
f
to this scala.Option's value if this scala.Option is nonempty. Otherwise returnNone
.This is equivalent to:
option match { case Some(x) => Some(f(x)) case None => None }
- f
the function to apply
- Definition Classes
- Option
- Annotations
- @inline()
- Note
This is similar to
flatMap
except here,f
does not need to wrap its result in an scala.Option.- See also
flatMap
foreach
- final def nonEmpty: Boolean
Returns false if the option is
None
, true otherwise.Returns false if the option is
None
, true otherwise.This is equivalent to:
option match { case Some(_) => true case None => false }
- Definition Classes
- Option
- Note
Implemented here to avoid the implicit conversion to Iterable.
- final def orElse[B >: Nothing](alternative: => Option[B]): Option[B]
Returns this scala.Option if it is nonempty, otherwise return the result of evaluating
alternative
.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 }
- alternative
the alternative expression.
- final def orNull[A1 >: Nothing](implicit ev: <:<[Null, A1]): A1
Returns the option's value if it is nonempty, or
null
if it is empty.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 }
- def productElementName(n: Int): String
The name of the nth element of this product, 0-based.
The name of the nth element of this product, 0-based. In the default implementation, an empty string.
- n
the index of the element name to return
- returns
the name of the specified element
- Definition Classes
- Product
- Exceptions thrown
IndexOutOfBoundsException
if then
is out of range(n < 0 || n >= productArity).
- def productElementNames: Iterator[String]
An iterator over the names of all the elements of this product.
An iterator over the names of all the elements of this product.
- Definition Classes
- Product
- def stepper[S <: Stepper[_]](implicit shape: StepperShape[Nothing, S]): S
Returns a scala.collection.Stepper for the elements of this collection.
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.
- For collections of
Int
,Short
,Byte
orChar
, an scala.collection.IntStepper is returned - For collections of
Double
orFloat
, a scala.collection.DoubleStepper is returned - For collections of
Long
a scala.collection.LongStepper is returned - For any other element type, an scala.collection.AnyStepper is returned
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.- Definition Classes
- IterableOnce
- For collections of
- final def toLeft[X](right: => X): Either[Nothing, X]
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.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) }
- right
the expression to evaluate and return if this is empty
- def toList: List[Nothing]
Returns a singleton list containing the scala.Option's value if it is nonempty, or the empty list if the scala.Option 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 }
- Definition Classes
- Option
- final def toRight[X](left: => X): Either[X, Nothing]
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.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) }
- left
the expression to evaluate and return if this is empty
- final def unzip[A1, A2](implicit asPair: <:<[Nothing, (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.
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) }
- A1
the type of the first half of the element pair
- A2
the type of the second half of the element pair
- 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.
- Definition Classes
- Option
- final def unzip3[A1, A2, A3](implicit asTriple: <:<[Nothing, (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.
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) }
- 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
- 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.
- Definition Classes
- Option
- final def withFilter(p: (Nothing) => Boolean): WithFilter
Necessary to keep scala.Option from being implicitly converted to scala.collection.Iterable in
for
comprehensions.Necessary to keep scala.Option from being implicitly converted to scala.collection.Iterable in
for
comprehensions. - final def zip[A1 >: Nothing, B](that: Option[B]): Option[(A1, B)]
Returns a scala.Some formed from this option and another option by combining the corresponding elements in a pair.
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 }
- that
the options which is going to be zipped
- Definition Classes
- Option
// 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")
Example:
This is the documentation for the Scala standard library.
Package structure
The scala package contains core types like
Int
,Float
,Array
orOption
which are accessible in all Scala compilation units without explicit qualification or imports.Notable packages include:
scala.collection
and its sub-packages contain Scala's collections frameworkscala.collection.immutable
- Immutable, sequential data-structures such asVector
,List
,Range
,HashMap
orHashSet
scala.collection.mutable
- Mutable, sequential data-structures such asArrayBuffer
,StringBuilder
,HashMap
orHashSet
scala.collection.concurrent
- Mutable, concurrent data-structures such asTrieMap
scala.concurrent
- Primitives for concurrent programming such asFutures
andPromises
scala.io
- Input and output operationsscala.math
- Basic math functions and additional numeric types likeBigInt
andBigDecimal
scala.sys
- Interaction with other processes and the operating systemscala.util.matching
- Regular expressionsOther packages exist. See the complete list on the right.
Additional parts of the standard library are shipped as separate libraries. These include:
scala.reflect
- Scala's reflection API (scala-reflect.jar)scala.xml
- XML parsing, manipulation, and serialization (scala-xml.jar)scala.collection.parallel
- Parallel collections (scala-parallel-collections.jar)scala.util.parsing
- Parser combinators (scala-parser-combinators.jar)scala.swing
- A convenient wrapper around Java's GUI framework called Swing (scala-swing.jar)Automatic imports
Identifiers in the scala package and the
scala.Predef
object are always in scope by default.Some of these identifiers are type aliases provided as shortcuts to commonly used classes. For example,
List
is an alias forscala.collection.immutable.List
.Other aliases refer to classes provided by the underlying platform. For example, on the JVM,
String
is an alias forjava.lang.String
.