Object None.None

case object None extends Option[Nothing]

This case object represents non-existent values.

Inherited classlikes

Source

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.

Inherited types

Source

type MirroredElemLabels = EmptyTuple

The names of the product elements

Source

type MirroredElemTypes = EmptyTuple

Source

type MirroredLabel <: String

The name of the type

Source

type MirroredMonoType = Singleton.this.type

The mirrored *-type

Source

type MirroredType = Singleton.this.type

Concrete methods

Source

def get: Nothing

Returns the option's value.

This is equivalent to:

option match {
 case Some(x) => x
 case None    => throw new Exception
}

Inherited methods

Source

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 and pf is defined for that value. Returns None otherwise.

// 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

final def contains[A1](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
}

// 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

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. Otherwise, returns false.

This is equivalent to:

option match {
 case Some(x) => p(x)
 case None    => false
}

Source

final def filter(p: Nothing => Boolean): Option[A]

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
}

Source

final def filterNot(p: Nothing => Boolean): Option[A]

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
}

Source

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 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
}

Source

def flatten[B](implicit ev: Nothing <:< Option[B]): Option[B]

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
}

Some(Some("something")).flatten

Source

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. 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

Source

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.

This is equivalent to:

option match {
 case Some(x) => p(x)
 case None    => true
}

Source

final def foreach[U](f: Nothing => 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    => ()
}

Source

def fromProduct(p: Product): MirroredMonoType

Create a new instance of type T with elements taken from product p.

Source

final def getOrElse[B](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
}

Source

final def isDefined: Boolean

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
}

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

def iterator: Iterator[A]

Returns a singleton iterator returning the scala.Option's value if it is nonempty, or an empty iterator if the option is empty.

Source

final override def knownSize: Int

Source

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. Otherwise return None.

This is equivalent to:

option match {
 case Some(x) => Some(f(x))
 case None    => None
}

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
}

Source

final def orElse[B](alternative: => Option[B]): Option[B]

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
}

Source

final def orNull[A1](implicit 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 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
}

val initialText: Option[String] = getInitialText
val textField = new JComponent(initialText.orNull,20)

Source

def productElementNames: Iterator[String]

An iterator over the names of all the elements of this product.

Source

def productIterator: Iterator[Any]

An iterator over all the elements of this product.

Source

def stepper[S <: Stepper[_]](implicit shape: StepperShape[Nothing, 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.

• For collections of Int, Short, Byte or Char, an scala.collection.IntStepper is returned

• For collections of Double or Float, 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.

Source

final def toLeft[X](right: => X): Either[A, 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.

This is equivalent to:

option match {
 case Some(x) => Left(x)
 case None    => Right(right)
}

Source

def toList: List[A]

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
}

Source

final def toRight[X](left: => X): Either[X, A]

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)
}

Source

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.

This is equivalent to:

option match {
  case Some((x, y)) => (Some(x), Some(y))
  case _            => (None,    None)
}

Source

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.

This is equivalent to:

option match {
  case Some((x, y, z)) => (Some(x), Some(y), Some(z))
  case _               => (None,    None,    None)
}

Source

final def withFilter(p: Nothing => Boolean): WithFilter

Necessary to keep scala.Option from being implicitly converted to scala.collection.Iterable in for comprehensions.

Source

final def zip[A1, 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. 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
}

// 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")