tsml/SymTbl.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
module [
    SymTbl,
    SymTblId,
    get,
    insert,
    set,
    update,
    map,
    update_all,
    from_list,
    update_all_with_key,
]

import ResultUtils

SymTbl a := List (Result a {}) implements [
        Eq,
        Hash,
    ]
SymTblId := U64 implements [
        Eq,
        Hash,
    ]

get : SymTbl a, SymTblId -> Result a {}
get = |@SymTbl(list), @SymTblId(key)|
    when List.get(list, key) is
        Ok(item) -> item
        Err(_) -> Err({})

expect (@SymTbl([Ok(1), Ok(2), Ok(3), Ok(4)]) |> get(@SymTblId(3))) == Ok(4)
expect (@SymTbl([Err({}), Ok(2), Ok(3), Ok(4)]) |> get(@SymTblId(0))) == Err({})

insert : SymTbl a, a -> (SymTbl a, SymTblId)
insert = |@SymTbl(list), value|
    new_key = List.len(list)
    new_list = List.append(list, Ok(value))
    (@SymTbl(new_list), @SymTblId(new_key))

expect
    (
        @SymTbl([Ok(1), Ok(2), Ok(3), Ok(4)])
        |> insert(42)
    )
    == (@SymTbl([Ok(1), Ok(2), Ok(3), Ok(4), Ok(42)]), @SymTblId(4))

set : SymTbl a, SymTblId, a -> SymTbl a
set = |@SymTbl(list), @SymTblId key, value|
    new_list = List.set(list, key, Ok(value))
    @SymTbl(new_list)

expect
    (
        @SymTbl([Ok(1), Ok(2), Ok(3), Ok(4)])
        |> set(@SymTblId(1), 42)
    )
    == @SymTbl([Ok(1), Ok(42), Ok(3), Ok(4)])

expect
    (
        @SymTbl([Ok(1), Ok(2), Ok(3), Ok(4)])
        |> set(@SymTblId(5), 42)
    )
    == @SymTbl([Ok(1), Ok(2), Ok(3), Ok(4)])

update : SymTbl a, SymTblId, (Result a {} -> Result a {}) -> SymTbl a
update = |@SymTbl(list), @SymTblId key, modify_value|
    new_item =
        when List.get(list, key) is
            Ok(item) -> modify_value(item)
            Err(_) -> modify_value(Err({}))
    new_list = List.set(list, key, new_item)
    @SymTbl(new_list)

expect
    (
        @SymTbl([Ok(1), Ok(2), Ok(3), Ok(4)])
        |> update(@SymTblId(0), |_| Ok(42))
    )
    == @SymTbl([Ok(42), Ok(2), Ok(3), Ok(4)])

expect
    (
        @SymTbl([Ok(1), Ok(2), Ok(3), Ok(4)])
        |> update(@SymTblId(0), |_| Err({}))
    )
    == @SymTbl([Err({}), Ok(2), Ok(3), Ok(4)])

expect
    (
        @SymTbl([Ok(1), Ok(2), Ok(3), Ok(4)])
        |> update(@SymTblId(5), |_| Ok(42))
    )
    == @SymTbl([Ok(1), Ok(2), Ok(3), Ok(4)])

map : SymTbl a, (a -> b) -> SymTbl b
map = |@SymTbl(list), fn|
    list
    |> List.map(|maybe_value| Result.map_ok(maybe_value, fn))
    |> @SymTbl

expect
    (
        @SymTbl([Ok(1), Ok(2), Ok(3), Ok(4)])
        |> map(|value| value + 1)
    )
    == @SymTbl([Ok(2), Ok(3), Ok(4), Ok(5)])

expect
    (
        @SymTbl([Ok(1), Err({}), Ok(3), Ok(4)])
        |> map(|value| value + 1)
    )
    == @SymTbl([Ok(2), Err({}), Ok(4), Ok(5)])

update_all : SymTbl a, (Result a {} -> Result b {}) -> SymTbl b
update_all = |@SymTbl(list), fn|
    List.map(list, fn) |> @SymTbl

update_all_with_key : SymTbl a, (Result a {}, SymTblId -> Result b {}) -> SymTbl b
update_all_with_key = |@SymTbl(list), fn|
    List.map_with_index(list, |maybe_value, idx| fn(maybe_value, @SymTblId(idx))) |> @SymTbl

from_list : List a -> (SymTbl a, List SymTblId)
from_list = |list|
    sym_tbl = List.map(list, |value| Ok(value)) |> @SymTbl
    sym_key_list = List.map_with_index(list, |_, idx| @SymTblId(idx))
    (sym_tbl, sym_key_list)