anchor.diff:    "Iterate over all the successive cars of XSS, producing a single list
      by applying FN to all of them. For example:
   
  +   Example:
      ```
      > (zip list '(1 2 3) '(4 5 6) '(7 8 9))
      '((1 4 7) (2 5 8) (3 6 9))
  
positive.code:     [true (map f (cdr xs) (cons (f (car xs)) acc))]))
  
  (defun filter (p xs acc)
    "Filter the list XS using the predicate P. The parameter ACC is for internal use only."
    (assert-type! p function)
    (assert-type! xs list)
    (cond
  
negative.code:             (filter p (cdr xs) acc))]))
  
  (defun any (p xs)
    "Check for the existence of an element in XS that matches the
     predicate P.
     
     Example:
     ```
     > (any exists? '(nil 1 \"foo\"))
     true
     ```"
    (assert-type! p function)
    (assert-type! xs list)
    (accumulate-with p -or false xs))
  
  (defun all (p xs)
    "Test if all elements of XS match the predicate P.
    
     Example:
     ```
     > (all symbol? '(foo bar baz))
     true
     > (all number? '(1 2 foo))
     false
     ```"
    (assert-type! p function)
    (assert-type! xs list)
    (accumulate-with p -and true xs))
  
  (defun elem? (x xs)
    "Test if X is present in the list XS.
    
     Example:
     ```
     > (elem? 1 '(1 2 3))
     true
     > (elem? 'foo '(1 2 3))
     false
     ```"
    (assert-type! xs list)
    (any (lambda (y) (= x y)) xs))
  
  (defun prune (xs)
    "Remove values matching the predicate [[nil?]] from the list XS.
  
     Example:
     ```
     > (prune '(() 1 () 2))
     '(1 2)
     ```"
    (assert-type! xs list)
    (filter (lambda (x) (! (nil? x))) xs))
  
  (defun traverse (xs f)
    "An alias for [[map]] with the arguments XS and F flipped.
  
     Example:
     ```
     > (traverse '(1 2 3) succ)
     '(2 3 4)
     ```"
    (map f xs))
  
  (defun last (xs)
    "Return the last element of the list XS.
     Counterintutively, this function runs in constant time.
  
     Example:
     ```
     > (last (range 1 100))
     100
     ```"
    (assert-type! xs list)
    (get-idx xs (# xs)))
  
  (defun nth (xs idx)
    "Get the IDX th element in the list XS. The first element is 1.
     This function runs in constant time.
  
     Example:
     ```
     > (nth (range 1 100) 10)
     10
     ```"
    (get-idx xs idx))
  
  (defun push-cdr! (xs val)
    "Mutate the list XS, adding VAL to its end.
  
     Example:
     ```
     > (define list '(1 2 3))
     > (push-cdr! list 4)
     '(1 2 3 4)
     > list
     '(1 2 3 4)
     ```"
    (assert-type! xs list)
    (let* [(len (+ (# xs) 1))]
      (set-idx! xs "n" len)
  