anchor.diff:        (affirm (eq? (foldr + 0 '(1 2 3)) (+ (+ 1 2) (+ 3 0)))
                 (eq? (foldr append '() '((1 2) (3 4))) '(1 2 3 4))))
     (it "can be appended to another quoted list"
  -      (affirm (eq? (append '(1 2) '(3 4)) '(1 2 3 4))
  -              (eq? (# (append '(1 2) '(3 4))) (# '(1 2 3 4)))))
  +      (check [(list a) (list b)]
  +        (eq? (# (append a b)) (+ (# a) (# b)))
  +        (eq? (append a b) (reverse (append (reverse b) (reverse a))))))
     (it "can be mapped over"
  -      (affirm (eq? (map (cut + <> 1) '(0 1 2)) '(1 2 3))
  -              (eq? (map (const 1) '(1 2 3)) '(1 1 1))))
  -  (it "remains the same when mapped over with id"
  -      (affirm (eq? (map id '(1 2 3)) '(1 2 3))
  -              (eq? (traverse '(1 2 3) id) '(1 2 3))))
  +      (check [(list a)]
  +        (eq? (map id a) a)
  +        (eq? (# (map id a)) (# a))))
     (it "has two equivalent operations: map and traverse"
         (affirm (eq? (map (cut + <> 1) '(1 2 3))
                    (traverse '(1 2 3) (cut + <> 1)))))
  
positive.code:   (it "can be built using range"
        (affirm (eq? (range 1 3) '(1 2 3))))
    (it "has a cancellative operation reverse"
        (affirm (eq? (reverse (reverse '(1 2 3))) '(1 2 3))
                (eq? (reverse '(3 2 1)) '(1 2 3))))
    (it "can be tested for one element matching a predicate"
        (affirm (eq? true (any (cut = <> 1) (range 1 3)))
                (eq? false (any (cut = <> 6) (range 1 3)))))
  
negative.code:       (affirm (eq? (zip list '(1 foo "baz") '(2 bar "qux")) '((1 2) (foo bar) ("baz" "qux")))
                (eq? (zip + '(1 2 3) '(3 7 9)) '(4 9 12))))
    (it "exists"
        (check [(list a)] (exists? a)))
    (it "can be accumulated with a monoid"
        (affirm (eq? 10 (accumulate-with tonumber + 0 '(1 2 3 4)))))
    (it "can have an item mutated in-place"
        (affirm (eq? '(1 3) (with (l '(1 2)) (set-idx! l 2 3) l))))
  )
  