blob: fe2a71c88d5e6dbaeb2ef11d5e11469a45e21606 (
plain) (
blame)
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
|
(import-macros {: fn*} :macros.fn)
(import-macros {: into} :macros.core)
(import-macros {: assert-eq : assert-ne : assert* : test} :test)
(local {: seq
: mapv
: filter
: reduce
: reduce-kv
: conj
: cons
: first
: rest
: eq?
: identity
: comp
: every?
: some
: not-any?
: range
: even?
: odd?}
(require :core))
(test equality-test
;; comparing basetypes
(assert-eq 1 1)
(assert-ne 1 2)
(assert* (eq? 1 1 1 1 1))
(assert-eq 1.0 1.0)
(assert* (eq? 1.0 1.0 1.0))
(assert* (eq? 1.0 1.0 1.0))
(assert* (eq? "1" "1" "1" "1" "1"))
;; deep comparison
(assert* (eq? []))
(assert-eq [] [])
(assert-eq [] {})
(assert-eq [1 2] [1 2])
(assert-ne [1] [1 2])
(assert-ne [1 2] [1])
(assert* (eq? [1 [2]] [1 [2]] [1 [2]]))
(assert* (eq? [1 [2]] [1 [2]] [1 [2]]))
(assert* (not (eq? [1 [2]] [1 [2]] [1 [2 [3]]])))
(assert-eq (range 10) [0 1 2 3 4 5 6 7 8 9])
(assert-eq (range -5 5) [-5 -4 -3 -2 -1 0 1 2 3 4])
(assert-eq [0 0.2 0.4 0.6 0.8] [0 0.2 0.4 0.6 0.8])
(assert-eq (range 0 1 0.2) (range 0 1 0.2))
(let [a {:a 1 :b 2}
b {:a 1 :b 2}]
(table.insert b 10)
(assert-ne a b))
(let [a [1 2 3]
b [1 2 3]]
(tset b :a 10)
(assert-ne a b))
(assert-eq [1 2 3] {1 1 2 2 3 3})
;; TODO: decide if this is right or not. Looking from `seq'
;; perspective, it is correct, as `(seq {4 1})' and `(seq [nil nil
;; nil 1])' both yield `{4 1}'. From Lua's point this is not the
;; same thing, for example because the sizes of these tables are
;; different.
(assert-eq {4 1} [nil nil nil 1]))
(test mapv-test
(assert-eq (mapv #(* $ $) [1 2 3 4]) [1 4 9 16])
(assert-eq (into {} (mapv (fn [[k v]] [k (* v v)]) {:a 1 :b 2 :c 3}))
(into {} [[:a 1] [:b 4] [:c 9]]))
(assert-eq (into {} (mapv (fn [[k1 v1] [k2 v2]] [k1 (* v1 v2)])
{:a 1 :b 2 :c 3}
{:a -1 :b 0 :c 2}))
{:a -1 :b 0 :c 6})
(assert-eq (mapv string.upper ["a" "b" "c"]) ["A" "B" "C"])
(assert-eq (mapv #(+ $1 $2 $3 $4) [1 -1] [2 -2] [3 -3] [4 -4]) [(+ 1 2 3 4) (+ -1 -2 -3 -4)])
(assert-eq (mapv (fn [f-name s-name company position]
(.. f-name " " s-name " works as " position " at " company))
["Bob" "Alice"]
["Smith" "Watson"]
["Happy Days co." "Coffee With You"]
["secretary" "chief officer"])
["Bob Smith works as secretary at Happy Days co."
"Alice Watson works as chief officer at Coffee With You"]))
(test reduce-test
(fn* ++
([] 0)
([a] a)
([a b] (+ a b))
([a b & c]
(var res (+ a b))
(each [_ v (ipairs c)]
(set res (+ res v)))
res))
(assert-eq (reduce ++ (range 10)) 45)
(assert-eq (reduce ++ -3 (range 10)) 42)
(assert-eq (reduce ++ 10 nil) 10)
(fn mapping [f]
(fn [reducing]
(fn [result input]
(reducing result (f input)))))
(fn reduce- [f init tbl]
(if (and tbl (> (length tbl) 0))
(reduce f (f init (first tbl)) (rest tbl))
init))
(assert-eq (reduce ++ (range 10)) (reduce- ++ 0 (range 10))))
(test filter-test
(assert-eq (filter even? (range 10)) [0 2 4 6 8])
(assert-eq (filter odd? (range 10)) [1 3 5 7 9]))
|