Debian Codegraph @

test/loops.fnl

raw
1 (local t (require :test.faith))
2 (local fennel (require :fennel))
3
4 (macro == [form expected ?opts]
5 `(let [(ok# val#) (pcall fennel.eval ,(view form) ,?opts)]
6 (t.is ok# val#)
7 (t.= val# ,expected)))
8
9 (fn test-each []
10 (== (each [x (pairs [])] nil) nil)
11 (== (let [t {:a 1 :b 2} t2 {}]
12 (each [k v (pairs t)]
13 (tset t2 k v))
14 (+ t2.a t2.b)) 3)
15 (== (do (var t 0) (local (f s v) (pairs [1 2 3]))
16 (each [_ x (values f (doto s (table.remove 1)))] (set t (+ t x))) t) 5)
17 (== (do (var t 0) (local (f s v) (pairs [1 2 3]))
18 (each [_ x (values f s v)] (set t (+ t x))) t) 6)
19 (== (do (var x 0) (while (< x 7) (set x (+ x 1))) x) 7)
20 (== (let [x [] y [1 2 3]]
21 (each [(i n) (ipairs y)]
22 (table.insert x (+ i n)))
23 x) [2 4 6]))
24
25 (fn test-for []
26 (== (for [y 0 2] nil) nil)
27 (== (do (var x 0) (for [y 1 20 2] (set x (+ x 1))) x) 10)
28 (== (do (var x 0) (for [y 1 5] (set x (+ x 1))) x) 5))
29
30 (fn test-comprehensions []
31 (== (collect [k v (pairs {:a 1 :b 2 :c 3})] v k)
32 [:a :b :c])
33 (== (collect [k v (pairs {:apple :red :orange :orange})]
34 (values (.. :color- v) (.. :fruit- k)))
35 {:color-red :fruit-apple :color-orange :fruit-orange})
36 (== (collect [k v (pairs {:foo 3 :bar 4 :baz 5 :qux 6})]
37 (if (> v 4) (values k (+ v 1))))
38 {:baz 6 :qux 7})
39 (== (collect [k v (pairs {:neon :lights}) &into {:shimmering-neon :lights}]
40 (values k (v:upper)))
41 {:neon "LIGHTS" :shimmering-neon "lights"})
42 (== (icollect [_ v (ipairs [1 2 3 4 5 6])]
43 (if (= 0 (% v 2)) (* v v)))
44 [4 16 36])
45 (== (icollect [num (string.gmatch "24,58,1999" "%d+")]
46 (tonumber num))
47 [24 58 1999])
48 (== (icollect [_ x (ipairs [2 3]) &into [11]] (* x 11))
49 [11 22 33])
50 (== (let [xs [11]] (icollect [_ x (ipairs [2 3]) &into xs] (* x 11)))
51 [11 22 33])
52 (let [code "(icollect [_ x (ipairs [2 3]) &into \"oops\"] x)"
53 (ok? msg) (pcall fennel.compileString code)]
54 (t.is (not ok?))
55 (t.match "&into clause" msg))
56 (let [code "(icollect [_ x (ipairs [2 3]) &into 2] x)"
57 (ok? msg) (pcall fennel.compileString code)]
58 (t.is (not ok?))
59 (t.match "&into clause" msg))
60 (== (do (macro twice [expr] `(do ,expr ,expr))
61 (twice (icollect [i v (ipairs [:a :b :c])] v)))
62 [:a :b :c])
63 (== (let [result [0]]
64 (icollect [_ v (ipairs [1 2 [3 4 5] 6 7]) &into result]
65 (case (type v)
66 :table (do
67 (icollect [_ e (ipairs v) &into result] e)
68 nil)
69 _ v)))
70 [0 1 2 3 4 5 6 7])
71 (== (fcollect [i 1 4] i)
72 [1 2 3 4])
73 (== (fcollect [i 1 4 2] i)
74 [1 3])
75 (== (fcollect [i 1 10 2 &until (> i 5)] i)
76 [1 3 5])
77 (== (fcollect [i 1 10 2 :until (> i 5)] i)
78 [1 3 5])
79 (== (fcollect [i 1 4 &into [0]] i)
80 [0 1 2 3 4])
81 (== (fcollect [i 1 4 :into [0]] i)
82 [0 1 2 3 4])
83 (== (fcollect [i 1 4 2 &into [0]] i)
84 [0 1 3])
85 (== (fcollect [i 1 10 2
86 &into [0]
87 &until (> i 5)]
88 (when (not= i 3) i))
89 [0 1 5]))
90
91 (fn test-accumulate []
92 (== (do (var x true)
93 (let [y (accumulate [state :init
94 _ _ (pairs {})]
95 (do (set x false)
96 :update))]
97 [x y]))
98 [true :init])
99 (== (accumulate [s :fen
100 _ c (ipairs [:n :e :l :o]) &until (>= c :o)]
101 (.. s c))
102 "fennel")
103 (== (accumulate [n 0 _ _ (pairs {:one 1 :two nil :three 3})]
104 (+ n 1))
105 2)
106 (== (accumulate [yes? true
107 _ s (ipairs [:yes :no :yes])]
108 (and yes? (string.match s :yes)))
109 nil)
110 (== (let [(a b) (accumulate [(x y) (values 8 2) _ (ipairs [1])] (values y x))]
111 (+ a b)) 10)
112 (== (do (macro twice [expr] `(do ,expr ,expr))
113 (twice (accumulate [s "" _ v (ipairs [:a :b])] (.. s v))))
114 :ab))
115
116 (fn test-faccumulate []
117 (== 15 (faccumulate [sum 0 i 1 5] (+ sum i)))
118 (== 6 (faccumulate [sum 0 i 1 5 &until (= i 4)] (+ sum i)))
119 (== "EDCBA" (faccumulate [alphabet "" i 4 0 -1]
120 (.. alphabet (string.char (+ i 65))))))
121
122 (fn test-conditions []
123 (== (do (var x 0) (for [i 1 10 &until (= i 5)] (set x i)) x) 4)
124 (== (do (var x 0) (each [_ i (ipairs [1 2 3]) &until (< 2 x)] (set x i)) x) 3)
125 (== (icollect [_ i (ipairs [4 5 6]) &until (= i 5)] i) [4])
126 (== (collect [i x (pairs [4 5 6]) &until (= x 6)] (values i x)) [4 5])
127 (== (icollect [i x (pairs [4 5 6]) &into [3] &until (= x 6)] x) [3 4 5]))
128
129 {: test-each
130 : test-for
131 : test-comprehensions
132 : test-accumulate
133 : test-faccumulate
134 : test-conditions}