Commit | Line | Data |
---|---|---|
a6244ba2 SK |
1 | -module(hope_list). |
2 | ||
3 | -export_type( | |
4 | [ t/1 | |
5 | ]). | |
6 | ||
7 | -export( | |
8 | [ unique_preserve_order/1 | |
ff793acf | 9 | , map/2 |
781f182f | 10 | , map/3 % Tunable recursion limit |
c66ddf80 | 11 | , map_rev/2 |
2a81fbac | 12 | , map_slow/2 |
54ab0c82 | 13 | , map_result/2 % Not tail-recursive |
a626cf31 | 14 | , first_match/2 |
a6244ba2 SK |
15 | ]). |
16 | ||
17 | ||
781f182f | 18 | -define(DEFAULT_RECURSION_LIMIT, 1000). |
ff793acf SK |
19 | |
20 | ||
a6244ba2 SK |
21 | -type t(A) :: |
22 | [A]. | |
23 | ||
24 | ||
ff793acf SK |
25 | %% @doc Tail-recursive equivalent of lists:map/2 |
26 | %% @end | |
27 | -spec map([A], fun((A) -> (B))) -> | |
28 | [B]. | |
29 | map(Xs, F) -> | |
781f182f | 30 | map(Xs, F, ?DEFAULT_RECURSION_LIMIT). |
ff793acf | 31 | |
781f182f | 32 | -spec map([A], fun((A) -> (B)), RecursionLimit :: non_neg_integer()) -> |
ff793acf | 33 | [B]. |
781f182f SK |
34 | map(Xs, F, RecursionLimit) -> |
35 | map(Xs, F, RecursionLimit, 0). | |
36 | ||
37 | map([], _, _, _) -> | |
ff793acf | 38 | []; |
781f182f | 39 | map([X1], F, _, _) -> |
ff793acf SK |
40 | Y1 = F(X1), |
41 | [Y1]; | |
781f182f | 42 | map([X1, X2], F, _, _) -> |
ff793acf SK |
43 | Y1 = F(X1), |
44 | Y2 = F(X2), | |
45 | [Y1, Y2]; | |
781f182f | 46 | map([X1, X2, X3], F, _, _) -> |
ff793acf SK |
47 | Y1 = F(X1), |
48 | Y2 = F(X2), | |
49 | Y3 = F(X3), | |
50 | [Y1, Y2, Y3]; | |
781f182f | 51 | map([X1, X2, X3, X4], F, _, _) -> |
ff793acf SK |
52 | Y1 = F(X1), |
53 | Y2 = F(X2), | |
54 | Y3 = F(X3), | |
55 | Y4 = F(X4), | |
56 | [Y1, Y2, Y3, Y4]; | |
781f182f | 57 | map([X1, X2, X3, X4, X5 | Xs], F, RecursionLimit, RecursionCount) -> |
ff793acf SK |
58 | Y1 = F(X1), |
59 | Y2 = F(X2), | |
60 | Y3 = F(X3), | |
61 | Y4 = F(X4), | |
62 | Y5 = F(X5), | |
63 | Ys = | |
781f182f | 64 | case RecursionCount > RecursionLimit |
ff793acf | 65 | of true -> map_slow(Xs, F) |
781f182f | 66 | ; false -> map (Xs, F, RecursionLimit, RecursionCount + 1) |
ff793acf SK |
67 | end, |
68 | [Y1, Y2, Y3, Y4, Y5 | Ys]. | |
69 | ||
2a81fbac SK |
70 | %% @doc lists:reverse(map_rev(L, F)) |
71 | %% @end | |
72 | -spec map_slow([A], fun((A) -> (B))) -> | |
73 | [B]. | |
74 | map_slow(Xs, F) -> | |
75 | lists:reverse(map_rev(Xs, F)). | |
76 | ||
77 | ||
5e20a667 SK |
78 | %% @doc Tail-recursive alternative to lists:map/2, which accumulates and |
79 | %% returns list in reverse order. | |
c66ddf80 SK |
80 | %% @end |
81 | -spec map_rev([A], fun((A) -> (B))) -> | |
82 | [B]. | |
83 | map_rev(Xs, F) -> | |
84 | map_rev_acc(Xs, F, []). | |
85 | ||
86 | -spec map_rev_acc([A], fun((A) -> (B)), [B]) -> | |
87 | [B]. | |
88 | map_rev_acc([], _, Ys) -> | |
89 | Ys; | |
90 | map_rev_acc([X|Xs], F, Ys) -> | |
91 | Y = F(X), | |
92 | map_rev_acc(Xs, F, [Y|Ys]). | |
93 | ||
54ab0c82 SK |
94 | -spec map_result([A], fun((A) -> (hope_result:t(B, C)))) -> |
95 | hope_result:t([B], C). | |
96 | map_result([], _) -> | |
97 | {ok, []}; | |
98 | map_result([X | Xs], F) -> | |
99 | case F(X) | |
100 | of {ok, Y} -> | |
101 | case map_result(Xs, F) | |
102 | of {ok, Ys} -> | |
103 | {ok, [Y | Ys]} | |
104 | ; {error, _}=Error -> | |
105 | Error | |
106 | end | |
107 | ; {error, _}=Error -> | |
108 | Error | |
109 | end. | |
c66ddf80 | 110 | |
a6244ba2 SK |
111 | -spec unique_preserve_order(t(A)) -> |
112 | t(A). | |
113 | unique_preserve_order(L) -> | |
17b5d686 | 114 | PrependIfNew = |
a6244ba2 SK |
115 | fun (X, Xs) -> |
116 | case lists:member(X, Xs) | |
17b5d686 SK |
117 | of true -> Xs |
118 | ; false -> [X | Xs] | |
a6244ba2 SK |
119 | end |
120 | end, | |
17b5d686 | 121 | lists:reverse(lists:foldl(PrependIfNew, [], L)). |
a626cf31 SK |
122 | |
123 | -spec first_match([{Tag, fun((A) -> boolean())}], A) -> | |
124 | hope_option:t(Tag). | |
125 | first_match([], _) -> | |
126 | none; | |
127 | first_match([{Tag, F} | Tests], X) -> | |
128 | case F(X) | |
129 | of true -> {some, Tag} | |
130 | ; false -> first_match(Tests, X) | |
131 | end. |