1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2002-2006, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
// $Id$
package scala;
import Predef._
object Option {
/** An implicit conversion that converts an option to an iterable value
*/
implicit def option2Iterable[a](xo: Option[a]): Iterable[a] = xo.toList
}
/** This class represents optional values. Instances of <code>Option</code>
* are either instances of case class <code>Some</code> or it is case
* object <code>None</code>.
*
* @author Martin Odersky
* @author Matthias Zenger
* @version 1.1, 16/01/2007
*/
sealed abstract class Option[+A] extends Product {
/** True if the option is the <code>None</value>, false otherwise.
*/
def isEmpty: Boolean
/** get the value of this option.
* @requires that the option is nonEmpty.
* @throws Predef.NoSuchElementException if the option is empty.
*/
def get: A
/** @deprecated; use getOrElse instead */
[deprecated] def get[B >: A](default: B): B = this match {
case None => default
case Some(x) => x
}
/** If the option is nonempty return its value,
* otherwise return the result of evaluating a default expression.
* @param default the default expression.
*/
def getOrElse[B >: A](default: => B): B =
if (isEmpty) default else this.get
/** If the option is nonempty, return a function applied to its value,
* wrapped in a Some i.e. <code>Some(f(this.get))</code>.
* Otherwise return None.
* @param f the function to apply
*/
def map[B](f: A => B): Option[B] =
if (isEmpty) None else Some(f(this.get))
/** If the option is nonempty, return a function applied to its value.
* Otherwise return None.
* @param f the function to apply
*/
def flatMap[B](f: A => Option[B]): Option[B] =
if (isEmpty) None else f(this.get)
/** If the option is nonempty and the given predicate <code>p</code>
* yields <code>false</code> on its value, return <code>None</code>.
* Otherwise return the option value itself.
* @param p the predicate used for testing.
*/
def filter(p: A => Boolean): Option[A] =
if (isEmpty || p(this.get)) this else None
/** Apply the given procedure <code>f</code> to the option's value,
* if it is nonempty. Do nothing if it is empty.
* @param f the procedure to apply.
*/
def foreach(f: A => Unit) {
if (!isEmpty) f(this.get)
}
/** If the option is nonempty return it,
* otherwise return the result of evaluating an alternative expression.
* @param alternative the alternative expression.
*/
def orElse[B >: A](alternative: => Option[B]): Option[B] =
if (isEmpty) alternative else this
/** An singleton iterator returning the option's value if it is nonempty
* or the empty iterator if the option is empty.
*/
def elements: Iterator[A] =
if (isEmpty) Iterator.empty else Iterator.fromValues(this.get)
/** A singleton list containing the option's value if it is nonempty
* or the empty list if the option is empty.
*/
def toList: List[A] =
if (isEmpty) List() else List(this.get)
}
/** Class <code>Some[A]</code> represents existing values of type
* <code>A</code>.
*
* @author Martin Odersky
* @version 1.0, 16/07/2003
*/
final case class Some[+A](x: A) extends Option[A] {
def isEmpty = false
def get = x
}
/** This case object represents non-existent values.
*
* @author Martin Odersky
* @version 1.0, 16/07/2003
*/
case object None extends Option[Nothing] {
def isEmpty = true
def get = throw new NoSuchElementException("None.get")
}
|
