tsml/Option.roc at main · austindd/tsml · GitHub

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
129
module [
    Option,
    Some,
    None,
    is_some,
    is_none,
    map,
    map2,
    map3,
    join_map,
    unsafe_get,
    combine2,
    combine3,
    gather,
    compact,
]

Option a : [Some a, None]

Some a : [Some a]

None : [None]

is_some : Option a -> Bool
is_some = |option|
    when option is
        Some(_) -> Bool.true
        None -> Bool.false

is_none : Option a -> Bool
is_none = |option|
    when option is
        Some(_) -> Bool.false
        None -> Bool.true

map : Option a, (a -> b) -> Option b
map = |option, f|
    when option is
        Some(x) -> Some(f(x))
        None -> None

map2 : Option a, Option b, (a, b -> c) -> Option c
map2 = |option_a, option_b, f|
    when (option_a, option_b) is
        (Some(a), Some(b)) -> Some(f(a, b))
        (None, _) -> None
        (_, None) -> None

map3 : Option a, Option b, Option c, (a, b, c -> d) -> Option d
map3 = |option_a, option_b, option_c, f|
    when (option_a, option_b, option_c) is
        (Some(a), Some(b), Some(c)) -> Some(f(a, b, c))
        (None, _, _) -> None
        (_, None, _) -> None
        (_, _, None) -> None

join_map : Option a, (a -> Option b) -> Option b
join_map = |option, f|
    when option is
        Some(x) -> f(x)
        None -> None

unsafe_get : Option a -> a
unsafe_get = |option|
    when option is
        Some(x) -> x
        None -> crash("Option.unsafeGet: called on None")

combine2 : Option a, Option b -> Option (a, b)
combine2 = |option_a, option_b|
    when option_a is
        Some(a) ->
            when option_b is
                Some(b) -> Some((a, b))
                None -> None

        None -> None

combine3 : Option a, Option b, Option c -> Option (a, b, c)
combine3 = |option_a, option_b, option_c|
    when option_a is
        Some(a) ->
            when option_b is
                Some(b) ->
                    when option_c is
                        Some(c) -> Some((a, b, c))
                        None -> None

                None -> None

        None -> None

gather : List (Option a) -> Option (List a)
gather = |options|
    List.walk_until(
        options,
        Some([]),
        |state, option|
            when state is
                Some(list) ->
                    when option is
                        Some(x) -> Continue(Some(List.concat(list, [x])))
                        None -> Break(None)

                None -> Break(None),
    )

compact : List (Option a) -> List a
compact = |options|
    List.walk(
        options,
        List.with_capacity(List.len(options)),
        |state, option|
            when option is
                Some(x) -> List.concat(state, [x])
                None -> state,
    )

from_result : Result a b -> Option a
from_result = |result|
    when result is
        Ok(value) -> Some(value)
        Err(_) -> None

to_result : Option a -> Result a {}
to_result = |option|
    when option is
        Some(value) -> Ok(value)
        None -> Err({})