anchor.diff:        (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"
  -      (affirm (eq? true (exists? '(1 2 3)))
  -              (eq? true (exists? (range 1 3)))
  -              (eq? true (exists? (cons 1 '())))))
  +      (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))))
  +      (affirm (eq? '(1 3) (with (l '(1 2)) (set-idx! l 2 3) l))))
   )
  
positive.code:               (eq? (# '(foo "foo" 2)) 3)
                (eq? (cadr '(foo "foo")) "foo")))
    (it "compares equal to itself"
        (affirm (eq? '(1 2 3) '(1 2 3))
                (eq? '(1 2) '(1 2))))
    (it "has a congruent operation cdr"
        (affirm (eq? '(b c d) (cdr '(a b c d)))
                (eq? (cdr '(a b c)) (cdr '(a b c)))))
    (it "has a congruent operation car"
        (affirm (eq? 'a (car '(a)))
                (eq? (cdr '(1 2 3)) (cdr '(1 2 3)))))
    (it "can be extended by cons"
        (affirm (eq? (cons 1 '(2 3)) '(1 2 3))
                (eq? (cons "foo" '(bar baz)) '("foo" bar baz))
                (eq? (cons "foo" (list 1 nil 2)) (list "foo" 1 nil 2))))
    (it "can be extended by snoc"
        (affirm (eq? (snoc '(1 2) 3) '(1 2 3))
                (eq? (snoc '(bar baz) "foo") '(bar baz "foo"))
  
negative.code:       (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"
        (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"
        (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)))))
  