blob: 5058fae08698d6cab4c438411c6a0591ce1e9667 (
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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
|
(.module:
[library
[lux #*
["_" test (#+ Test)]
[abstract
[monad (#+ do)]
[equivalence (#+ Equivalence)]
["." enum]
[\\specification
["$." functor]
["$." comonad]]]
[data
["." text
["%" format (#+ format)]]
[collection
["." list ("#\." functor)]]]
[math
["." random]
[number
["n" nat]]]]]
[\\library
["." /]])
(implementation: (equivalence super)
(All [a] (-> (Equivalence a) (Equivalence (/.Sequence a))))
(def: (= reference subject)
(\ (list.equivalence super) =
(/.take 100 reference)
(/.take 100 subject))))
(def: #export test
Test
(<| (_.covering /._)
(_.for [/.Sequence])
(let [(^open "list\.") (list.equivalence n.equivalence)])
(do {! random.monad}
[repeated random.nat
index (\ ! map (n.% 100) random.nat)
size (\ ! map (|>> (n.% 10) inc) random.nat)
offset (\ ! map (n.% 100) random.nat)
cycle_start random.nat
cycle_next (random.list size random.nat)]
($_ _.and
(_.for [/.functor]
($functor.spec /.repeat ..equivalence /.functor))
(_.for [/.comonad]
($comonad.spec /.repeat ..equivalence /.comonad))
(_.cover [/.iterate /.nth]
(n.= (n.+ offset index)
(/.nth index (/.iterate inc offset))))
(_.cover [/.repeat]
(n.= repeated
(/.nth index (/.repeat repeated))))
(_.cover [/.take]
(list\= (enum.range n.enum offset (dec (n.+ size offset)))
(/.take size (/.iterate inc offset))))
(_.cover [/.drop]
(list\= (enum.range n.enum offset (dec (n.+ size offset)))
(/.take size (/.drop offset (/.iterate inc 0)))))
(_.cover [/.split]
(let [[drops takes] (/.split size (/.iterate inc 0))]
(and (list\= (enum.range n.enum 0 (dec size))
drops)
(list\= (enum.range n.enum size (dec (n.* 2 size)))
(/.take size takes)))))
(_.cover [/.take_while]
(list\= (enum.range n.enum 0 (dec size))
(/.take_while (n.< size) (/.iterate inc 0))))
(_.cover [/.drop_while]
(list\= (enum.range n.enum offset (dec (n.+ size offset)))
(/.take_while (n.< (n.+ size offset))
(/.drop_while (n.< offset) (/.iterate inc 0)))))
(_.cover [/.split_while]
(let [[drops takes] (/.split_while (n.< size) (/.iterate inc 0))]
(and (list\= (enum.range n.enum 0 (dec size))
drops)
(list\= (enum.range n.enum size (dec (n.* 2 size)))
(/.take_while (n.< (n.* 2 size)) takes)))))
(_.cover [/.head]
(n.= offset
(/.head (/.iterate inc offset))))
(_.cover [/.tail]
(list\= (enum.range n.enum (inc offset) (n.+ size offset))
(/.take size (/.tail (/.iterate inc offset)))))
(_.cover [/.only]
(list\= (list\map (n.* 2) (enum.range n.enum 0 (dec size)))
(/.take size (/.only n.even? (/.iterate inc 0)))))
(_.cover [/.partition]
(let [[evens odds] (/.partition n.even? (/.iterate inc 0))]
(and (n.= (n.* 2 offset)
(/.nth offset evens))
(n.= (inc (n.* 2 offset))
(/.nth offset odds)))))
(_.cover [/.unfold]
(let [(^open "/\.") /.functor
(^open "list\.") (list.equivalence text.equivalence)]
(list\= (/.take size
(/\map %.nat (/.iterate inc offset)))
(/.take size
(/.unfold (function (_ n) [(inc n) (%.nat n)])
offset)))))
(_.cover [/.cycle]
(let [cycle (list& cycle_start cycle_next)]
(list\= (list.concat (list.repeat size cycle))
(/.take (n.* size (list.size cycle))
(/.cycle [cycle_start cycle_next])))))
(_.cover [/.^sequence&]
(let [(/.^sequence& first second third next) (/.iterate inc offset)]
(and (n.= offset first)
(n.= (n.+ 1 offset) second)
(n.= (n.+ 2 offset) third))))
))))
|
