-
-
Notifications
You must be signed in to change notification settings - Fork 119
/
suite.coco
357 lines (355 loc) · 13.6 KB
/
suite.coco
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
from .util import *
def suite_test():
"""Executes the main test suite."""
assert 1 `plus` 1 == 2 == 1 `(+)` 1
assert "1" `plus` "1" == "11" == "1" `(+)` "1"
assert 3 `mod` 6 == 3 == 3 `(%)` 6
assert 5 `mod` 4 == 1 == 5 `mod_` 4
assert 5 `mod` 2 `plus` 2 == 1 == 5 `(%)` 2 `(+)` 2
assert "11" `base` 2 == 3
assert "10A" `int` 12 == 154
assert ["1", "2"] `join_with` ", " == "1, 2"
assert ["a","b","c"] `join_with` == "abc"
assert {"a", 5} |> len == 2
assert 5 |> swap2((-))$(2) |> (*)$(2) == 6 == 5 |> swap2_((-))$(2) |> (*)$(2)
assert all(same((1, 2, 3), [1, 2, 3]))
assert chain2((|1, 2|), (|3, 4|)) |> list == [1, 2, 3, 4]
assert threeple$(1, 2)(3) == (1, 2, 3)
assert 1 `range` 5 |> product == 24
assert plus1(4) == 5 == plus1_(4)
assert 2 `plus1` == 3 == plus1(2)
assert plus1(plus1(5)) == 7 == (plus1..plus1)(5)
assert `sqrt` 16 == 4 == `sqrt_` 16
assert `square` 3 == 9
assert sqplus1(3) == 10 == (plus1..square)(3)
assert parallel_map(sqplus1, range(3)) |> tuple == (1, 2, 5)
assert 3 `plus1sq` == 16 == 3 `plus1sq_`
assert 3 `sqplus1` == 10 == 3 `sqplus1_`
assert 3 |> plus1 |> square == 16 == 3 |> plus1_ |> square
assert reduce((|>), [3, plus1, square]) == 16 == pipe(pipe(3, plus1), square)
assert reduce((..), [sqrt, square, plus1])(3) == 4 == compose(compose(sqrt, square), plus1)(3)
assert sum_([1,7,3,5]) == 16
assert (add([1,2,3], [10,20,30]) |> list
== [11,22,33]
== zipsum([1,2,3], [10,20,30]) |> list
)
assert clean(" ab cd ef ") == "ab cd ef" == " ab cd ef " |> clean
assert add2 <| 2 <| 3 == 5
for qsort in [qsort1, qsort2, qsort3, qsort4, qsort5]:
to_sort = rand_list(10)
assert to_sort |> qsort |> tuple == to_sort |> sorted |> tuple
assert repeat(3)$[2] == 3 == repeat_(3)$[2]
assert sum_(repeat(1)$[:5]) == 5 == sum_(repeat_(1)$[:5])
assert (sum_(takewhile((x)-> x<5, N()))
== 10
== dropwhile((>)$(0), (range(-10, 0) :: N()))$[:5] |> sum
)
assert "ABCDEFG" |> ((s) -> map(s[], (1, 3, 5))) |> sum_ == "BDF"
assert N()$[10:15] |> list == [10,11,12,13,14] == N_()$[10:15] |> list
assert (N() |> takewhile$((>)$(5)) |> list
== [0,1,2,3,4]
== range(0,10)$[:5:] |> list
)
assert (range(-10, 0) :: N())$[5:15] |> sum == -5 == chain(range(-10, 0), N())$[5:15] |> sum
assert add(repeat(1), N())$[:5] |> list == [1,2,3,4,5] == add(repeat(1), N_())$[:5] |> list
assert sum(N()$[5:]$[:5]) == 35 == sum(N_()$[5:]$[:5])
assert N()$[](slice(5, 10)) |> list == [5,6,7,8,9] == list(range(0, 15))[](slice(5, 10))
assert N()$[slice(5, 10)] |> list == [5,6,7,8,9] == list(range(0, 15))[slice(5, 10)]
assert preN(range(-5, 0))$[1:10] |> list == [-4,-3,-2,-1,0,1,2,3,4]
assert map_iter((*)$(2), N())$[:5] |> list == [0,2,4,6,8]
assert N()$[:100] |> tuple == N_()$[:100] |> tuple == N__()$[:100] |> tuple
assert 12 |> next_mul_of $(5) == 15
assert collatz(27)
assert preop(1, 2).add() == 3
assert vector(3, 4) |> abs == 5 == vector_with_id(3, 4, 1) |> abs
assert vector(1, 2) |> ((v) -> map(v., ("x", "y"))) |> tuple == (1, 2)
assert vector(3, 1) |> vector(1, 2).transform |> ((v) -> map(v[], (0, 1))) |> tuple == (4, 3)
assert vector(1, 2) |> vector(1, 2).__eq__
assert not vector(1, 2) |> vector(3, 4).__eq__
assert not (1, 2) |> vector(1, 2).__eq__
assert vector(vector(4, 3)) == vector(4, 3)
assert not vector(4, 3) != vector(4, 3)
assert not vector(1, 2) == (1, 2)
assert not vector(2, 3) != vector(2, 3)
assert vector(1, 2) != (1, 2)
assert triangle(3, 4, 5).is_right()
assert (.)(triangle(3, 4, 5), "is_right")
assert triangle(3, 4, 5) |> .is_right()
assert factorial1(3) == 6
assert factorial2(3) == 6
assert factorial4(3) == 6
assert factorial5(3) == 6
assert fact(3) == 6 == fact_(3)
assert factorial(3) == 6
assert factorial1(-1) is None
assert factorial2(-1) is None
assert factorial4(-1) is None
assert factorial5(-1) is None
assert factorial3([2,3]) == [2,6] == factorial3((2,3))
assert classify(()) == "empty tuple"
assert classify([]) == "empty list"
assert classify((1,)) == "singleton tuple"
assert classify([1,1]) == "duplicate pair list of 1"
assert classify((1,2)) == "pair tuple"
assert classify([1,2,3]) == "list"
assert classify((1,1,1)) == "tuple"
assert classify({}) == "empty dict"
assert classify({"a":1}) == "dict"
assert classify({0}) == "set of 0" == classify(f{0})
assert classify({0,1}) == "set" == classify(f{1})
assert classify(s{}) == "empty set" == classify(f{})
assert classify_sequence(()) == "empty"
assert classify_sequence((1,)) == "singleton"
assert classify_sequence((1, 1)) == "duplicate pair of 1"
assert classify_sequence((1, 2)) == "pair"
assert classify_sequence((1, 2, 3)) == "few"
assert dictpoint({"x":1, "y":2}) == (1,2)
assert dictpoint_({"x":1, "y":2}) == (1,2) == dictpoint__({"x":1, "y":2})
assert map_((+)$(1), []) == []
assert map_((+)$(1), ()) == ()
assert map_((+)$(1), [0,1,2,3]) == [1,2,3,4]
assert map_((+)$(1), (0,1,2,3)) == (1,2,3,4)
assert duplicate_first1([1,2,3]) == [1,1,2,3]
assert duplicate_first2([1,2,3]) |> list == [1,1,2,3] == duplicate_first3([1,2,3]) |> list
assert one_to_five([1,2,3,4,5]) == [2,3,4]
assert not one_to_five([0,1,2,3,4,5])
assert one_to_five([1,5]) == []
assert -4 == neg_square_u(2) ≠ 4 ∧ 0 ≤ neg_square_u(0) ≤ 0
assert is_null(null1())
assert is_null(null2())
assert empty() |> depth == 0
assert leaf(5) |> depth == 1
assert node(leaf(2), node(empty(), leaf(3))) |> depth == 3
assert maybes(5, square, plus1) == 26
assert maybes(None, square, plus1) is None
assert square <| 2 == 4
assert (5, 3) |*> mod == 2 == mod <*| (5, 3)
assert Just(5) <| square <| plus1 == Just(26)
assert Nothing() <| square <| plus1 == Nothing()
assert not Nothing() == ()
assert not Nothing() != Nothing()
assert Nothing() != ()
assert not Just(1) == (1,)
assert not Just(1) != Just(1)
assert Just(1) != (1,)
assert head_tail([1,2,3]) == (1, [2,3])
assert init_last([1,2,3]) == ([1,2], 3)
assert last_two([1,2,3]) == (2, 3) == last_two_([1,2,3])
assert expl_ident(5) == 5
assert mod$ <| 5 <| 3 == 2 == (%)$ <| 5 <| 3
assert 5 |> dectest == 5
try:
raise ValueError()
except TypeError, ValueError as err:
assert err
else:
assert False
assert delist2([1, 2]) == (1, 2) == delist2_([1, 2])
assert tuple1(1) == (1,) == tuple1_(1)
assert tuple2(1, 2) == (1, 2) == tuple2_(1, 2)
assert htsplit([1,2,3]) == [1,[2,3]] == htsplit_([1,2,3])
assert iadd(1, 2) == 3 == iadd_(1, 2)
assert strmul("a", 3) == "aaa" == strmul_("a", 3)
try:
strmul("a", "b")
except MatchError as err:
assert err.pattern == "match def strmul(a is str, x is int):"
assert err.value == ("a", "b")
else:
assert False
laz = lazy()
assert not laz.done
lazl = laz.list()
assert lazl$[:3] |> list == [1, 2, 3]
assert not laz.done
assert lazl |> list == [None]
assert laz.done
assert is_empty(iter(()))
assert is_empty(())
assert not is_empty([1])
assert is_one(iter([1]))
assert not is_one(iter(()))
assert not is_one([])
assert is_one([1])
assert trilen(3, 4).h == 5 == datamaker(trilen)(5).h
assert A().true()
assert B().true()
assert pt.__doc__
out0 = grid() |> grid_trim$(xmax=5, ymax=5)
assert out0 == [
[pt(x=0, y=0), pt(x=0, y=1), pt(x=0, y=2), pt(x=0, y=3), pt(x=0, y=4)],
[pt(x=1, y=0), pt(x=1, y=1), pt(x=1, y=2), pt(x=1, y=3), pt(x=1, y=4)],
[pt(x=2, y=0), pt(x=2, y=1), pt(x=2, y=2), pt(x=2, y=3), pt(x=2, y=4)],
[pt(x=3, y=0), pt(x=3, y=1), pt(x=3, y=2), pt(x=3, y=3), pt(x=3, y=4)],
[pt(x=4, y=0), pt(x=4, y=1), pt(x=4, y=2), pt(x=4, y=3), pt(x=4, y=4)]
]
out1 = grid() |> grid_map$(abs) |> grid_trim$(xmax=5, ymax=5)
out1_ = grid() |> grid_trim$(xmax=5, ymax=5) |> parallel_grid_map$(abs) |> map$(list) |> list
assert out1[0] == [0.0, 1.0, 2.0, 3.0, 4.0] == out1_[0]
assert out1[1][0] == 1.0 == out1_[1][0]
assert out1[2][0] == 2.0 == out1_[2][0]
assert out1[3][0] == 3.0 == out1_[3][0]
assert out1[3][4] == 5.0 == out1_[3][4]
assert out1[4][0] == 4.0 == out1_[4][0]
assert out1[4][3] == 5.0 == out1_[4][3]
x = 5
x |>= square
y = square
y <|= 5
assert x == 25 == y
x = (5, 3)
x |*>= mod
y = mod
y <*|= (5, 3)
assert x == 2 == y
x = square
x ..= (+)$(1)
x <|= 4
assert x == 25
v = vector(1, 2)
try:
v.x = 3
except AttributeError as err:
assert err
else:
assert False
try:
v.new_attr = True
except AttributeError as err:
assert err
else:
assert False
assert SHOPeriodTerminate([-1, 0], 0, {"epsilon": 1})
assert add_int_or_str_1(2) == 3 == coercive_add(2, "1")
assert add_int_or_str_1("2") == "21" == coercive_add("2", 1)
assert still_ident(3) == 3
assert not_ident(3) == "bar"
assert pattern_abs(4) == 4 == pattern_abs_(4)
assert pattern_abs(0) == 0 == pattern_abs_(0)
assert pattern_abs(-4) == 4 == pattern_abs_(-4)
assert vector(1, 2) |> (==)$(vector(1, 2))
assert vector(1, 2) |> .__eq__(other=vector(1, 2))
assert fib()$[1:4] |> tuple == (1, 2, 3)
assert fib() |> takewhile$((i) -> i < 4000000 ) |> filter$((i) -> i % 2 == 0 ) |> sum == 4613732
assert loop([1,2])$[:4] |> list == [1, 2] * 2
assert (def -> mod)()(5, 3) == 2
assert sieve((2, 3, 4, 5)) |> list == [2, 3, 5]
assert 11 == double_plus_one(5)
assert 15 == assign_func_1((*), 3, 5)
assert 15 == assign_func_2((*), 3, 5)
assert 20 == (..)(minus$(2), mul$(2), plus$(1))(10)
assert 20 == (minus$(2) .. mul$(2) .. plus$(1))(10)
assert does_raise_exc(raise_exc)
assert ret_none(10) is None
assert (2, 3, 5) |*> ret_args_kwargs$(1, ?, ?, 4, ?, *(6, 7), a="k") == ((1, 2, 3, 4, 5, 6, 7), {"a": "k"})
assert anything_func() is None
assert args_kwargs_func() is None
assert x_is_int(4) == 4 == x_is_int(x=4)
try:
x_is_int(x="herp")
except MatchError:
pass
else:
assert False
try:
x_is_int()
except MatchError:
pass
else:
assert False
assert x_as_y(x=2) == (2, 2) == x_as_y(y=2)
assert x_y_are_int_gt_0(1, 2) == (1, 2) == x_y_are_int_gt_0(x=1, y=2)
try:
x_y_are_int_gt_0(1, y=0)
except MatchError:
pass
else:
assert False
assert x_is_int_def_0() == 0 == x_is_int_def_0(x=0)
try:
x_is_int_def_0("derp")
except MatchError:
pass
else:
assert False
assert head_tail_def_none() == (None, []) == head_tail_def_none([None])
assert kwd_only_x_is_int_def_0() == 0 == kwd_only_x_is_int_def_0(x=0)
try:
kwd_only_x_is_int_def_0(1)
except MatchError:
pass
else:
assert False
assert no_args_kwargs()
try:
no_args_kwargs(1)
except MatchError:
pass
else:
assert False
try:
no_args_kwargs(a=1)
except MatchError:
pass
else:
assert False
a = altclass()
assert a.func(1) == 1
assert a.zero(10) == 0
with Vars.using(globals()):
assert var_one == 1
try:
var_one
except NameError:
assert True
else:
assert False
assert Just(3) |> map$(-> _*2) |*> Just == Just(6) == Just(3) |> fmap$(-> _*2)
assert Nothing() |> map$(-> _*2) |*> Nothing == Nothing() == Nothing() |> fmap$(-> _*2)
assert Elems(1, 2, 3) != Elems(1, 2)
assert map(plus1, (1, 2, 3)) |> fmap$(times2) |> repr == map(times2..plus1, (1, 2, 3)) |> repr
assert reversed((1, 2, 3)) |> fmap$(plus1) |> repr == map(plus1, (1, 2, 3)) |> reversed |> repr
assert ident[1:2, 2:3] == (slice(1, 2), slice(2, 3)) == ident |> .[1:2, 2:3]
assert ident.method(*(1,), **{"a": 2}) == ((1,), {"a": 2}) == ident |> .method(*(1,), **{"a": 2})
assert container(1) == container(1)
assert not container(1) != container(1)
assert container(1) != container(2)
assert not container(1) == container(2)
assert container_(1) == container_(1)
assert not container_(1) != container_(1)
assert container_(1) != container_(2)
assert not container_(1) == container_(2)
t = Tuple(1, 2)
assert repr(t) == "Tuple(*elems=(1, 2))"
assert t.elems == (1, 2)
assert isinstance(t.elems, tuple)
assert t |> fmap$(-> _+1) == Tuple(2, 3)
Tuple(x, y) = t
assert x == 1 and y == 2
p = Pred("name", 1, 2)
assert repr(p) in ("Pred(name='name', *args=(1, 2))", "Pred(name=u'name', *args=(1, 2))")
assert p.name == "name"
assert p.args == (1, 2)
assert isinstance(p.args, tuple)
Pred(name, *args) = p
assert name == "name"
assert args == (1, 2)
q = Quant("name", "var", 1, 2)
assert repr(q) in ("Quant(name='name', var='var', *args=(1, 2))", "Quant(name=u'name', var=u'var', *args=(1, 2))")
assert q.name == "name"
assert q.var == "var"
assert q.args == (1, 2)
assert isinstance(q.args, tuple)
Quant(name, var, *args) = q
assert name == "name"
assert var == "var"
assert args == (1, 2)
assert Pred(0, 1, 2) |> fmap$(-> _+1) == Pred(1, 2, 3)
assert Quant(0, 1, 2) |> fmap$(-> _+1) == Quant(1, 2, 3)
return True
def tco_test():
"""Exectues suite tests that rely on TCO."""
assert recurse_n_times(10000)
assert is_even(5000) and is_odd(5001)
assert is_even_(5000) and is_odd_(5001)
return True