anchor.diff:    (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))))
  +      (check [(list a)]
  +        (eq? (reverse (reverse a)) a)))
     (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)))))
  
positive.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"
        (affirm (eq? (append '(1 2) '(3 4)) '(1 2 3 4))
                (eq? (# (append '(1 2) '(3 4))) (# '(1 2 3 4)))))
    (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))))
    (it "has two equivalent operations: map and traverse"
        (affirm (eq? (map (cut + <> 1) '(1 2 3))
                   (traverse '(1 2 3) (cut + <> 1)))))
  
negative.code:               (eq? (# '(foo "foo" 2)) 3)
                (eq? (cadr '(foo "foo")) "foo")))
    (it "compares equal to itself"
        (check [(list a)]
          (eq? a a)))
    (it "has a congruent operation cdr"
        (check [(list a)]
          (eq? (drop a 1) (cdr a))))
    (it "has a congruent operation car"
        (check [(list a)]
          (eq? (car a) (nth a 1))))
    (it "can be extended by cons"
        (check [(list a) (any b)]
          (eq? (cons b a) `(,b ,@a))))
    (it "can be extended by snoc"
        (affirm (eq? (snoc '(1 2) 3) '(1 2 3))
                (eq? (snoc '(bar baz) "foo") '(bar baz "foo"))
  