anchor.diff:  
   
   ;;; The following functions are analogous to MAPC/MAPCAR/MAPCAN
  -;;; and MAPL/MAPLIST/MAPCON, but for alists and plists.
  +;;; and MAPL/MAPLIST/MAPCON, but for alists, plists and vectors.
  +;;;
  +;;; Also, with slightly different semantics,
  +;;; the MAPT* family of functions for mapping over integers.
   ;;;
   ;;; ┌───┬────────────────────────────┬────────┬───────────┬──────────┐
  -;;; │PKG│         Result acc. method │ nil    │ list      │ nconc    │
  +;;; │PKG│ Result accumulation method │ nil    │ list      │ nconc    │
   ;;; ├───┼────────────────────────────┼────────┼───────────┼──────────┤
  -;;; │   │      Structure mapped over │        │           │          │
  -;;; │   │                            │        │           │          │
  +;;; │   │         Values mapped over │        │           │          │
  +;;; │   ├----------------------------┤        │           │          │
   ;;; │CL │         elements of a list │ MAPC   │ MAPCAR    │ MAPCAN   │
   ;;; │CL │           conses of a list │ MAPL   │ MAPLIST   │ MAPCON   │
   ;;; │   │                            │        │           │          │
   ;;; │LL │ (key . value)s of an alist │ MAPAL  │ MAPALIST  │ MAPACON  │
   ;;; │LL │   (key value)s of an alist │ MAPAL* │ MAPALIST* │ MAPACON* │
   ;;; │LL │    (key value)s of a plist │ MAPPL  │ MAPPLIST  │ MAPPCON  │
  +;;; │LL │       elements of a vector │ MAPV   │ MAPVECTOR │ MAPVCON  │
  +;;; │   │                            │        │           │          │
  +;;; │LL │  integers from 0 below max │ MAPT   │ MAPTIMES  │ MAPTCON  │
  +;;; │LL │  As above, but no iter var │ MAPT*  │ MAPTIMES* │ MAPTCON* │
   ;;; └───┴────────────────────────────┴────────┴───────────┴──────────┘
   ;;;
   ;;; Note that the names of the new functions
  
positive.code: arguments for each alist entry: the key and value. MAPACON returns a
  list composed of the concatenation of each list returned by FUNCTION."
    (if more-alists
        (error "mapacan only supports one alist argument for now."))
    (loop for (key . value) in alist
  	nconc (funcall function key value)))
  
  (defun mapal* (function alist &rest more-alists)
    "Just like MAPAL except the value is in the second element of each
  entry, not the cdr."
    (if more-alists
        (error "mapal* only supports one alist argument for now."))
    (loop for (key value) in alist
  	do (funcall function key value)))
  
  (defun mapalist* (function alist &rest more-alists)
    "Just like MAPALIST except the value is in the second element of each
  entry, not the cdr."
    (if more-alists
        (error "mapalist only supports one alist argument for now."))
    (loop for (key value) in alist
  	collect (funcall function key value)))
  
  (defun mapacon* (function alist &rest more-alists)
    "Just like MAPACON except the value is in the second element of each
  entry, not the cdr."
    (if more-alists
        (error "mapacon only supports one alist argument for now."))
    (loop for (key value) in alist
  	nconc (funcall function key value)))
  
  (defun mappl (function list &rest more-lists)
    "Analogous to MAPL but for plists. The FUNCTION is passed two
  arguments for each plist entry: the key and value. MAPPL returns nil."
    (if more-lists
        (error "mappl only supports one list argument for now."))
    (loop for (key value) on list by #'cddr
  	do (funcall function key value)))
  
  (defun mapplist (function list &rest more-lists)
    "Analogous to MAPLIST but for plists. The FUNCTION is passed two
  arguments for each plist entry: the key and value. MAPPLIST returns a
  list composed of each value returned by FUNCTION."
    (if more-lists
        (error "mapplist only supports one list argument for now."))
    (loop for (key value) on list by #'cddr
  	collect (funcall function key value)))
  
  (defun mappcon (function list &rest more-lists)
    "Analogous to MAPCON but for plists. The FUNCTION is passed two
  arguments for each plist entry: the key and value. MAPACON returns a
  list composed of the concatenation of each list returned by FUNCTION."
    (if more-lists
        (error "mappcon only supports one list argument for now."))
    (loop for (key value) on list by #'cddr
  	nconc (funcall function key value)))
  
  
  (defmacro for* (bindings &body body)
  
negative.code: 
  Calling this function NCOLLECT has at least two advantages:
  1. The N prefix reminds you that you must pass a fresh list
  that isn't referenced anywhere else because of the destructive behavior;
  \(its tail will be modified the next time COLLECT or NCOLLECT is called).
  2. NCOllect starts the same as NCOnc.
  Other candidates would have been COLLECT-LIST (a bit long)
  