test.zp

(load "transducers")
(load "minitest/minitest")
(define transducers:transduce (import "transducers:transduce"))
(define transducers:map (import "transducers:map"))
(define transducers:take (import "transducers:take"))
(define transducers:filter (import "transducers:filter"))
(define transducers:partition-by (import "transducers:partition-by"))
(define transducers:compose (import "transducers:compose"))
(define transducers:into (import "transducers:into"))
(define transducers:cat (import "transducers:cat"))
(define transducers:mapcat (import "transducers:mapcat"))
(define minitest:assert-equal (import "minitest:assert-equal"))
((import "minitest:colorize") #t)
((import "minitest:verbose") #t)

(minitest:assert-equal
  9
  (transducers:transduce (transducers:map add1) + 0 [1 2 3])
  "test that we can map and reduce with a transducer")

(minitest:assert-equal
  9
  (transducers:transduce (transducers:map add1) + 0 {1 2 3} vector:reduce)
  "test that we can transduce other collections")

(minitest:assert-equal
  1
  (transducers:transduce (transducers:take 1) + 0 [1 2 3])
  "test that we can take and reduce with a transducer")

(minitest:assert-equal
  [(1 1 1) (2 2 2) (1)]
  (transducers:transduce (transducers:partition-by id) += [] [1 1 1 2 2 2 1])
  "test that we can take and reduce with a transducer")

(minitest:assert-equal
  [1 1]
  (transducers:transduce (transducers:filter (curry eq? 1)) += [] [1 2 3 1])
  "test that we can filter with a transducer")

(minitest:assert-equal
  [2 3]
  (transducers:transduce
    (transducers:compose
      (transducers:map add1)
      (transducers:filter (lambda (x) (not (eq? 4 x)))))
    +=
    []
    [1 2 3])
  "test that we can compose transducers")

(minitest:assert-equal
  [2]
  (transducers:transduce
    (transducers:compose
      (transducers:map add1)
      (transducers:filter (lambda (x) (not (eq? 3 x))))
      (transducers:compose
        (transducers:filter (lambda (x) (not (eq? 4 x))))))
    +=
    []
    [1 2 3])
  "test that we can nest compositions")

(minitest:assert-equal
  {1 2 3 4}
  (transducers:into {} (transducers:map sub1) [2 3 4 5])
  "test that we can transduce into new collection")

(minitest:assert-equal
  [1 2 3 4]
  (transducers:into [] transducers:cat [(1 2) (3 4)])
  "test that we can cat collections (list)")

(minitest:assert-equal
  [1 2 3 4]
  (transducers:into [] transducers:cat {(1 2) (3 4)})
  "test that we can cat collections (vector)")

(minitest:assert-equal
  [0 1 2 3 4 5 6 7 8 9]
  (transducers:into [] (transducers:mapcat reverse) [(3 2 1 0) (6 5 4) (9 8 7)])
  "test that we can mapcat collections")

((import "minitest:results"))