blob: aaaf82eb7cd3981ed305321f56f666557e3006ef (
plain)
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
|
/*
Module: option
Represents the presence or absence of a value.
Every option<T> value can either be some(T) or none. Where in other languages
you might use a nullable type, in Rust you would use an option type.
*/
/*
Tag: t
The option type
*/
tag t<T> {
/* Variant: none */
none;
/* Variant: some */
some(T);
}
/* Section: Operations */
/*
Function: get
Gets the value out of an option
Failure:
Fails if the value equals `none`.
*/
pure fn get<copy T>(opt: t<T>) -> T {
alt opt { some(x) { ret x; } none. { fail "option none"; } }
}
/*
*/
fn map<T, U>(opt: t<T>, f: block(T) -> U) -> t<U> {
alt opt { some(x) { some(f(x)) } none. { none } }
}
/*
Function: is_none
Returns true if the option equals none
*/
pure fn is_none<T>(opt: t<T>) -> bool {
alt opt { none. { true } some(_) { false } }
}
/*
Function: is_some
Returns true if the option contains some value
*/
pure fn is_some<T>(opt: t<T>) -> bool { !is_none(opt) }
/*
Function: from_maybe
Returns the contained value or a default
*/
pure fn from_maybe<T>(def: T, opt: t<T>) -> T {
alt opt { some(x) { x } none. { def } }
}
/*
Function: maybe
Applies a function to the contained value or returns a default
*/
fn maybe<T, U>(def: U, opt: t<T>, f: block(T) -> U) -> U {
alt opt { none. { def } some(t) { f(t) } }
}
// FIXME: Can be defined in terms of the above when/if we have const bind.
/*
Function: may
Performs an operation on the contained value or does nothing
*/
fn may<T>(opt: t<T>, f: block(T)) {
alt opt { none. {/* nothing */ } some(t) { f(t); } }
}
// Local Variables:
// mode: rust;
// fill-column: 78;
// indent-tabs-mode: nil
// c-basic-offset: 4
// buffer-file-coding-system: utf-8-unix
// End:
|
