Scala Standard Library 2.13.1 - scala.Some (original) (raw)

final case class Some[+A](value: A) extends Option[A] with Product with Serializable

 

Ordering

1. Alphabetic
2. By Inheritance

Inherited

1. Some
2. Option
3. Serializable
4. Product
5. Equals
6. IterableOnce
7. AnyRef
8. Any

Implicitly

1. by option2Iterable

2. by iterableOnceExtensionMethods

3. by any2stringadd

4. by StringFormat

5. by Ensuring

6. by ArrowAssoc

7. Hide All

8. Show All

Visibility

1. Public
2. Protected

Instance Constructors

1.  new Some(value: A)

Value Members

1.  final def !=(arg0: Any): Boolean
2.  final def ##(): Int
3.  def +(other: String): String
4.  final def ++[B >: A](suffix: collection.IterableOnce[B]): collection.Iterable[B]
5.  def ->[B](y: B): (Some[A], B)
6.  final def ==(arg0: Any): Boolean
7.  final def addString(b: collection.mutable.StringBuilder): collection.mutable.StringBuilder
8.  final def addString(b: collection.mutable.StringBuilder, sep: String): collection.mutable.StringBuilder
9.  def addString(b: collection.mutable.StringBuilder, start: String, sep: String, end: String): collection.mutable.StringBuilder
10.  final def asInstanceOf[T0]: T0
11.  def clone(): AnyRef
12.  final def collect[B](pf: PartialFunction[A, B]): Option[B]
13.  def collectFirst[B](pf: PartialFunction[A, B]): Option[B]
14.  def concat[B >: A](suffix: collection.IterableOnce[B]): collection.Iterable[B]
15.  final def contains[A1 >: A](elem: A1): Boolean
16.  def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Int
17.  def copyToArray[B >: A](xs: Array[B], start: Int): Int
18.  def copyToArray[B >: A](xs: Array[B]): Int
19.  def corresponds[B](that: collection.IterableOnce[B])(p: (A, B) => Boolean): Boolean
20.  def drop(n: Int): collection.Iterable[A]
21.  def dropRight(n: Int): collection.Iterable[A]
22.  def dropWhile(p: (A) => Boolean): collection.Iterable[A]
23.  def empty: collection.Iterable[A]
24.  def ensuring(cond: (Some[A]) => Boolean, msg: => Any): Some[A]
25.  def ensuring(cond: (Some[A]) => Boolean): Some[A]
26.  def ensuring(cond: Boolean, msg: => Any): Some[A]
27.  def ensuring(cond: Boolean): Some[A]
28.  final def eq(arg0: AnyRef): Boolean
29.  final def exists(p: (A) => Boolean): Boolean
30.  final def filter(p: (A) => Boolean): Option[A]
31.  final def filterNot(p: (A) => Boolean): Option[A]
32.  def finalize(): Unit
33.  final def flatMap[B](f: (A) => Option[B]): Option[B]
34.  def flatten[B](implicit ev: <:<[A, Option[B]]): Option[B]
35.  final def fold[B](ifEmpty: => B)(f: (A) => B): B
36.  def foldLeft[B](z: B)(op: (B, A) => B): B
37.  def foldRight[B](z: B)(op: (A, B) => B): B
38.  final def forall(p: (A) => Boolean): Boolean
39.  final def foreach[U](f: (A) => U): Unit
40.  def formatted(fmtstr: String): String
41.  def get: A
42.  final def getClass(): Class[_ <: AnyRef]
43.  final def getOrElse[B >: A](default: => B): B
44.  def groupBy[K](f: (A) => K): Map[K, collection.Iterable[A]]
45.  def groupMap[K, B](key: (A) => K)(f: (A) => B): Map[K, collection.Iterable[B]]
46.  def groupMapReduce[K, B](key: (A) => K)(f: (A) => B)(reduce: (B, B) => B): Map[K, B]
47.  def grouped(size: Int): collection.Iterator[collection.Iterable[A]]
48.  def head: A
49.  def headOption: Option[A]
50.  def init: collection.Iterable[A]
51.  def inits: collection.Iterator[collection.Iterable[A]]
52.  final def isDefined: Boolean
53.  final def isEmpty: Boolean
54.  final def isInstanceOf[T0]: Boolean
55.  def isTraversableAgain: Boolean
56.  def iterableFactory: IterableFactory[collection.Iterable]
57.  def iterator: Iterator[A]
58.  final def knownSize: Int
59.  def last: A
60.  def lastOption: Option[A]
61.  def lazyZip[B]: ([B](that: Iterable[B])scala.collection.LazyZip2[A,B,_1.type]) forSome {val _1: collection.Iterable[A]}
62.  final def map[B](f: (A) => B): Option[B]
63.  def max[B >: A](implicit ord: math.Ordering[B]): A
64.  def maxBy[B](f: (A) => B)(implicit cmp: math.Ordering[B]): A
65.  def maxByOption[B](f: (A) => B)(implicit cmp: math.Ordering[B]): Option[A]
66.  def maxOption[B >: A](implicit ord: math.Ordering[B]): Option[A]
67.  def min[B >: A](implicit ord: math.Ordering[B]): A
68.  def minBy[B](f: (A) => B)(implicit cmp: math.Ordering[B]): A
69.  def minByOption[B](f: (A) => B)(implicit cmp: math.Ordering[B]): Option[A]
70.  def minOption[B >: A](implicit ord: math.Ordering[B]): Option[A]
71.  final def ne(arg0: AnyRef): Boolean
72.  final def nonEmpty: Boolean
73.  final def notify(): Unit
74.  final def notifyAll(): Unit
75.  final def orElse[B >: A](alternative: => Option[B]): Option[B]
76.  final def orNull[A1 >: A](implicit ev: <:<[Null, A1]): A1
77.  def partition(p: (A) => Boolean): (collection.Iterable[A], collection.Iterable[A])
78.  def partitionMap[A1, A2](f: (A) => Either[A1, A2]): (collection.Iterable[A1], collection.Iterable[A2])
79.  def product[B >: A](implicit num: math.Numeric[B]): B
80.  def productElementNames: Iterator[String]
81.  def reduce[B >: A](op: (B, B) => B): B
82.  def reduceLeft[B >: A](op: (B, A) => B): B
83.  def reduceLeftOption[B >: A](op: (B, A) => B): Option[B]
84.  def reduceOption[B >: A](op: (B, B) => B): Option[B]
85.  def reduceRight[B >: A](op: (A, B) => B): B
86.  def reduceRightOption[B >: A](op: (A, B) => B): Option[B]
87.  def scan[B >: A](z: B)(op: (B, B) => B): collection.Iterable[B]
88.  def scanLeft[B](z: B)(op: (B, A) => B): collection.Iterable[B]
89.  def scanRight[B](z: B)(op: (A, B) => B): collection.Iterable[B]
90.  def sizeCompare(that: collection.Iterable[_]): Int
91.  def sizeCompare(otherSize: Int): Int
92.  final def sizeIs: SizeCompareOps
93.  def slice(from: Int, until: Int): collection.Iterable[A]
94.  def sliding(size: Int, step: Int): collection.Iterator[collection.Iterable[A]]
95.  def sliding(size: Int): collection.Iterator[collection.Iterable[A]]
96.  def span(p: (A) => Boolean): (collection.Iterable[A], collection.Iterable[A])
97.  def splitAt(n: Int): (collection.Iterable[A], collection.Iterable[A])
98.  def stepper[S <: Stepper[_]](implicit shape: StepperShape[A, S]): S
99.  def sum[B >: A](implicit num: math.Numeric[B]): B
100.  final def synchronized[T0](arg0: => T0): T0
101.  def tail: collection.Iterable[A]
102.  def tails: collection.Iterator[collection.Iterable[A]]
103.  def take(n: Int): collection.Iterable[A]
104.  def takeRight(n: Int): collection.Iterable[A]
105.  def takeWhile(p: (A) => Boolean): collection.Iterable[A]
106.  def tapEach[U](f: (A) => U): collection.Iterable[A]
107.  def to[C1](factory: Factory[A, C1]): C1
108.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
109.  final def toLeft[X](right: => X): Either[A, X]
110.  def toList: List[A]
111.  def toMap[K, V](implicit ev: <:<[A, (K, V)]): Map[K, V]
112.  final def toRight[X](left: => X): Either[X, A]
113.  def toString(): String
114.  def transpose[B](implicit asIterable: (A) => collection.Iterable[B]): collection.Iterable[collection.Iterable[B]]
115.  final def unzip[A1, A2](implicit asPair: <:<[A, (A1, A2)]): (Option[A1], Option[A2])
116.  final def unzip3[A1, A2, A3](implicit asTriple: <:<[A, (A1, A2, A3)]): (Option[A1], Option[A2], Option[A3])
117.  val value: A
118.  def view: View[A]
119.  final def wait(): Unit
120.  final def wait(arg0: Long, arg1: Int): Unit
121.  final def wait(arg0: Long): Unit
122.  final def withFilter(p: (A) => Boolean): WithFilter
123.  final def zip[A1 >: A, B](that: Option[B]): Option[(A1, B)]
124.  def zipAll[A1 >: A, B](that: collection.Iterable[B], thisElem: A1, thatElem: B): collection.Iterable[(A1, B)]
125.  def zipWithIndex: collection.Iterable[(A, Int)]

Shadowed Implicit Value Members

1.  def collect[B](pf: PartialFunction[A, B]): collection.Iterable[B]
2.  def count(p: (A) => Boolean): Int
3.  def exists(p: (A) => Boolean): Boolean
4.  def filter(pred: (A) => Boolean): collection.Iterable[A]
5.  def filterNot(pred: (A) => Boolean): collection.Iterable[A]
6.  def find(p: (A) => Boolean): Option[A]
7.  def flatMap[B](f: (A) => collection.IterableOnce[B]): collection.Iterable[B]
8.  def flatten[B](implicit asIterable: (A) => collection.IterableOnce[B]): collection.Iterable[B]
9.  def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1
10.  def forall(p: (A) => Boolean): Boolean
11.  def foreach[U](f: (A) => U): Unit
12.  def isEmpty: Boolean
13.  def iterator: collection.Iterator[A]
14.  def knownSize: Int
15.  def map[B](f: (A) => B): collection.Iterable[B]
16.  final def mkString: String
17.  final def mkString(sep: String): String
18.  final def mkString(start: String, sep: String, end: String): String
19.  def nonEmpty: Boolean
20.  def size: Int
21.  def stepper[S <: Stepper[_]](implicit shape: StepperShape[A, S]): S
22.  final def toBuffer[B >: A]: Buffer[B]
23.  def toIndexedSeq: collection.immutable.IndexedSeq[A]
24.  final def toIterable: collection.Iterable[A]
25.  def toList: collection.immutable.List[A]
26.  def toSeq: collection.immutable.Seq[A]
27.  def toSet[B >: A]: Set[B]
28.  def toVector: collection.immutable.Vector[A]
29.  def unzip[A1, A2](implicit asPair: (A) => (A1, A2)): (collection.Iterable[A1], collection.Iterable[A2])
30.  def unzip3[A1, A2, A3](implicit asTriple: (A) => (A1, A2, A3)): (collection.Iterable[A1], collection.Iterable[A2], collection.Iterable[A3])
31.  def withFilter(p: (A) => Boolean): collection.WithFilter[A, collection.Iterable]
32.  def zip[B](that: collection.IterableOnce[B]): collection.Iterable[(A, B)]

Deprecated Value Members

1.  def ++:[B >: A](that: collection.IterableOnce[B]): collection.Iterable[B]
2.  final def /:[B](z: B)(op: (B, A) => B): B
3.  def /:[B](z: B)(op: (B, A) => B): B
4.  final def :\[B](z: B)(op: (A, B) => B): B
5.  def :\[B](z: B)(op: (A, B) => B): B
6.  def aggregate[B](z: => B)(seqop: (B, A) => B, combop: (B, B) => B): B
7.  def collectFirst[B](f: PartialFunction[A, B]): Option[B]
8.  def companion: IterableFactory[collection.Iterable]
9.  final def copyToBuffer[B >: A](dest: Buffer[B]): Unit
10.  def copyToBuffer(dest: Buffer[A]): Unit
11.  def count(f: (A) => Boolean): Int
12.  def exists(f: (A) => Boolean): Boolean
13.  def filter(f: (A) => Boolean): collection.Iterator[A]
14.  def find(p: (A) => Boolean): Option[A]
15.  def flatMap[B](f: (A) => collection.IterableOnce[B]): collection.IterableOnce[B]
16.  def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1
17.  def foldLeft[B](z: B)(op: (B, A) => B): B
18.  def foldRight[B](z: B)(op: (A, B) => B): B
19.  def forall(f: (A) => Boolean): Boolean
20.  def foreach[U](f: (A) => U): Unit
21.  def hasDefiniteSize: Boolean
22.  def isEmpty: Boolean
23.  def map[B](f: (A) => B): collection.IterableOnce[B]
24.  def max(implicit ord: math.Ordering[A]): A
25.  def maxBy[B](f: (A) => B)(implicit cmp: math.Ordering[B]): A
26.  def min(implicit ord: math.Ordering[A]): A
27.  def minBy[B](f: (A) => B)(implicit cmp: math.Ordering[B]): A
28.  def mkString: String
29.  def mkString(sep: String): String
30.  def mkString(start: String, sep: String, end: String): String
31.  def nonEmpty: Boolean
32.  def product(implicit num: math.Numeric[A]): A
33.  def reduce(f: (A, A) => A): A
34.  def reduceLeft(f: (A, A) => A): A
35.  def reduceLeftOption(f: (A, A) => A): Option[A]
36.  def reduceOption(f: (A, A) => A): Option[A]
37.  def reduceRight(f: (A, A) => A): A
38.  def reduceRightOption(f: (A, A) => A): Option[A]
39.  final def repr: collection.Iterable[A]
40.  def sameElements[B >: A](that: collection.IterableOnce[B]): Boolean
41.  def seq: collection.Iterable[A]
42.  def size: Int
43.  def sum(implicit num: math.Numeric[A]): A
44.  def to[C1](factory: Factory[A, C1]): C1
45.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
46.  def toBuffer[B >: A]: Buffer[B]
47.  def toIndexedSeq: collection.IndexedSeq[A]
48.  final def toIterable: collection.Iterable[A]
49.  final def toIterator: collection.Iterator[A]
50.  def toIterator: collection.Iterator[A]
51.  def toList: collection.immutable.List[A]
52.  def toMap[K, V](implicit ev: <:<[A, (K, V)]): Map[K, V]
53.  def toSeq: collection.immutable.Seq[A]
54.  def toSet[B >: A]: Set[B]
55.  final def toStream: collection.immutable.Stream[A]
56.  def toStream: collection.immutable.Stream[A]
57.  final def toTraversable: collection.Traversable[A]
58.  final def toTraversable: collection.Traversable[A]
59.  def toVector: collection.immutable.Vector[A]
60.  def view(from: Int, until: Int): View[A]
61.  def withFilter(f: (A) => Boolean): collection.Iterator[A]
62.  def →[B](y: B): (Some[A], B)

Ungrouped