stdlib/source/test/lux/abstract/enum.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

(.module:
  [lux #*
   ["_" test (#+ Test)]
   [abstract
    [monad (#+ do)]]
   [data
    ["." product]
    ["." maybe ("#@." functor)]
    [number
     ["n" nat]]
    [collection
     ["." list ("#@." fold)]]]
   [math
    ["." random (#+ Random)]]]
  {1
   ["." /]})

(def: #export test
  Test
  (let [limit (: (Random Nat)
                 (:: random.monad map (n.% 20) random.nat))]
    (do random.monad
      [start limit
       end limit
       #let [[start end] (if (n.< end start)
                           [start end]
                           [end start])
             range (/.range n.enum start end)]]
      (<| (_.covering /._)
          ($_ _.and
              (_.cover [/.range]
                       (let [expected-size (|> end (n.- start) inc)
                             expected-start? (|> range list.head (maybe@map (n.= start)) (maybe.default false))
                             expected-end? (|> range list.last (maybe@map (n.= end)) (maybe.default false))
                             every-element-is-a-successor? (case range
                                                             (#.Cons head tail)
                                                             (|> (list@fold (function (_ next [verdict prev])
                                                                              [(and verdict
                                                                                    (n.= next (:: n.enum succ prev)))
                                                                               next])
                                                                            [true head]
                                                                            tail)
                                                                 product.left)
                                                             
                                                             #.Nil
                                                             false)]
                         (and (n.= expected-size (list.size range))
                              expected-start?
                              expected-end?
                              every-element-is-a-successor?)))
              )))))