048control.test

(test "iflet works with :satisfies"
  :valueof (iflet x (+ 2 3) :satisfies odd?
             x+1)
  :should be 6)

(test "iflet works with multiple branches"
  :valueof (iflet x nil
                      x
                    (+ 2 3) :satisfies odd?
                      x+1)
  :should be 6)

(test "iflet works with multiple :satisfies"
  :valueof (iflet x nil :satisfies id
                      x
                    (+ 2 3) :satisfies odd?
                      x+1)
  :should be 6)

(test "aand works"
  :valueof (let x list.3
             (aand x (car.it < 4)))
  :should be_true)

(test "while works"
  :valueof (ret ans nil
             (let x 0
               (while (x < 3)
                 (ans <- (cons x ans))
                 (x <- x+1))))
  :should be '(2 1 0))

(test "whilet works"
  :valueof (ret ans nil
             (let x '(1 2 3)
               (whilet y (zap! cdr x)
                 (ans <- car.y))))
  :should be 3)

(test "whilet destructures like let"
  :valueof (ret ans nil
             (let x '(1 2 3)
               (whilet (y ... _) (zap! cdr x)
                 (ans <- y))))
  :should be 3)

(test "for works"
  :valueof (ret ans nil
             (for x 0 (x < 3) (x <- x+1)
               (ans <- (cons x ans))))
  :should be '(2 1 0))

mac (fooset x)
  `(,x <- 4)
(test "& works with macros"
  :valueof (ret x 3
             (fooset&fooset x))
  :should be 4)

(test "pipe operator works"
  :valueof (3 -> (fn(_) (_ * 2)))
  :should be 6)

(test "pipe operator chains"
  :valueof (list.1 -> cons? -> car)
  :should be 1)

(test "pipe turns exprs containing _ into fns"
  :valueof (3 -> _+1)
  :should be 4)

(test "transform is varargs pipe"
  :valueof (transform list.1 :thru cons? car)
  :should be 1)