stdlib/source/test/lux/control/pipe.lux


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

(.module:
  [lux #*
   ["_" test (#+ Test)]
   [abstract
    [monad (#+ do)]]
   [data
    ["." identity]
    ["." name]
    [number
     ["n" nat]]
    ["." text ("#@." equivalence)
     ["%" format (#+ format)]]]
   [math
    ["r" random]]]
  {1
   ["." / #*]})

(def: #export test
  Test
  (<| (_.context (name.module (name-of /._)))
      (do r.monad
        [sample r.nat]
        ($_ _.and
            (do @
              [another r.nat]
              (_.test "Can dismiss previous pipeline results and begin a new one."
                      (n.= (inc another)
                           (|> sample
                               (n.* 3)
                               (n.+ 4)
                               (new> another [inc])))))
            (_.test "Let-binding"
                    (n.= (n.+ sample sample)
                         (|> sample
                             (let> x [(n.+ x x)]))))
            (_.test "'Conditional' branching."
                    (text@= (cond (n.= 0 sample) "zero"
                                  (n.even? sample) "even"
                                  "odd")
                            (|> sample
                                (cond> [(n.= 0)] [(new> "zero" [])]
                                       [n.even?] [(new> "even" [])]
                                       [(new> "odd" [])]))))
            (_.test "'If' branching."
                    (text@= (if (n.even? sample)
                              "even"
                              "odd")
                            (|> sample
                                (if> [n.even?]
                                     [(new> "even" [])]
                                     [(new> "odd" [])]))))
            (_.test "'When' branching."
                    (n.= (if (n.even? sample)
                           (n.* 2 sample)
                           sample)
                         (|> sample
                             (when> [n.even?]
                                    [(n.* 2)]))))
            (_.test "Can loop."
                    (n.= (n.* 10 sample)
                         (|> sample
                             (loop> [(n.= (n.* 10 sample)) not]
                                    [(n.+ sample)]))))
            (_.test "Monads."
                    (n.= (inc (n.+ 4 (n.* 3 sample)))
                         (|> sample
                             (do> identity.monad
                                  [(n.* 3)]
                                  [(n.+ 4)]
                                  [inc]))))
            (_.test "Execution."
                    (n.= (n.* 10 sample)
                         (|> sample
                             (exec> [%.nat (format "sample = ") log!])
                             (n.* 10))))
            (_.test "Tuple."
                    (let [[left middle right] (|> sample
                                                  (tuple> [inc]
                                                          [dec]
                                                          [%.nat]))]
                      (and (n.= (inc sample) left)
                           (n.= (dec sample) middle)
                           (text@= (%.nat sample) right))))
            (_.test "Pattern-matching."
                    (text@= (case (n.% 10 sample)
                              0 "zero"
                              1 "one"
                              2 "two"
                              3 "three"
                              4 "four"
                              5 "five"
                              6 "six"
                              7 "seven"
                              8 "eight"
                              9 "nine"
                              _ "???")
                            (|> sample
                                (n.% 10)
                                (case> 0 "zero"
                                       1 "one"
                                       2 "two"
                                       3 "three"
                                       4 "four"
                                       5 "five"
                                       6 "six"
                                       7 "seven"
                                       8 "eight"
                                       9 "nine"
                                       _ "???"))))
            ))))