anchor.diff:         (for ,ctr' 1 (# ,lst') 1 (with (,var (get-idx ,lst' ,ctr')) ,@body)))))
   
   (defun append (xs ys)
  +  "Concatenate XS and YS."
     (cond
       [(nil? xs) ys]
       [true (cons (car xs) (append (cdr xs) ys))]))
   
   (defun flatten (xss)
  +  "Concatenate all the lists in XSS. XSS must not contain elements which are not lists."
     (foldr append '() xss)) 
   
   (defun range (start end acc)
  +  "Build a list from START to END. This function is tail recursive, and uses the parameter ACC as an accumulator."
     (cond
       [(! (exists? acc)) (range start end '())]
       [(>= start end) (reverse (cons start acc))]
       [true (range (+ 1 start) end (cons start acc))]))
   
   (defun reverse (xs acc)
  +  "Reverse the list XS, using the accumulator ACC."
     (cond
       [(! (exists? acc)) (reverse xs '())]
       [(nil? xs) acc]
  
positive.code:     [(nil? xs) (reverse acc)]
      [true (map f (cdr xs) (cons (f (car xs)) acc))]))
  
  (defun filter (p xs)
    (assert-type! p function)
    (assert-type! xs list)
    (cond
      [(nil? xs) xs]
      [true (let* [(head (car xs))
                   (tail (cdr xs))]
              (if (p head)
                (cons head (filter p tail))
                (filter p tail)))]))
  
  (defun any (p xs)
    (assert-type! p function)
    (assert-type! xs list)
    (foldr (lambda (x y) (or x y)) false (map p xs)))
  
  (defun all (p xs)
    (assert-type! p function)
    (assert-type! xs list)
    (foldr (lambda (x y) (and x y)) true (map p xs)))
  
  (defun elem? (x xs)
    (assert-type! xs list)
    (any (lambda (y) (= x y)) xs))
  
  (defun prune (xs)
    (assert-type! xs list)
    (filter (lambda (x) (! (nil? x))) xs))
  
  (defun traverse (xs f) (map f xs))
  (defun last (xs)
    (assert-type! xs list)
    (get-idx xs (# xs)))
  
  (define nth get-idx)
  
  (defun push-cdr! (xs val)
    (assert-type! xs list)
    (let* [(len (+ (# xs) 1))]
      (set-idx! xs "n" len)
  
negative.code:             (f head (foldr f z tail)))]))
  
  (defun map (f xs acc)
    "Map over the list XS using the unary function F. The parameter ACC is for internal use only."
    (assert-type! f function)
    (assert-type! xs list)
    (cond
  