anchor.diff:      (when warningsp
         (log-message "View function did not compile cleanly: ~A" (remove #\Newline string)))
       (if failurep
  -        ;; FIXME: This is basically a constant.
           (error 'function-compilation-error :string string)
           function)))
   
   (defvar *map-results*)
  -(defun emit (k v)
  +(defun emit (key value)
  +  "Adds an entry to the current map function results."
     (when (boundp *map-results*)
  -    (push (list k v) *map-results*)))
  +    (push (list key value) *map-results*)))
   
   (defun @ (hash key &rest more-keys)
  -  (flet ((hashget (hash key) (gethash key hash)))
  +  "Convenience function for recursively accessing hash tables."
  + (flet ((hashget (hash key) (gethash key hash)))
       (reduce #'hashget more-keys :initial-value (gethash key hash))))
   
   (defun log-message (format-string &rest format-args)
  +  "Like FORMAT, but the resulting string is written to CouchDB's log."
     (format t "~&[\"log\", Chillax View Server: ~S]~%" (apply #'format nil format-string format-args))
     (finish-output))
   
   (defun add-fun (string)
  +  "Compiles and adds a function whose source code is in STRING to the current list of
  +active CouchDB map functions."
     (push (with-user-package (compile-view-function string)) *functions*)
     (respond t))
   
   (defun reset (&optional config)
  +  "Resets the view server. Any caches should be emptied at this point, and any stored
  +map functions should be cleared out."
     (declare (ignore config))
     (setf *functions* nil)
     (respond t))
   
   (defun call-map-function (function doc &aux *map-results*)
  +  "Calls a stored compile function on a document. *MAP-RESULTS* is where EMIT will send k/v pairs."
     (with-user-package (funcall function doc)) (or *map-results* '(#())))
   
   (defun map-doc (doc)
  +  "Responds to CouchDB with the results of calling all the currently-active map functions on DOC."
     (respond (or (mapcar (fun (call-map-function _ doc)) *functions*) '((#())))))
   
  -(defun reduce-map (fun-strings keys-and-values)
  +(defun reduce-results (fun-strings keys-and-values)
  +  "Responds to CouchDb with the results of calling the functions in FUN-STRINGS on KEYS-AND-VALUES."
  +  ;; It's quite possible a good idea to cache the compiled version of these functions in a hash
  +  ;; table, indexed by their source string. The cache will be cleared out whenever couch asks for
  +  ;; a ["reset"].
     (loop for result in keys-and-values
        collect (caar result) into keys
        collect (cadr result) into values
  
positive.code:   "This macro puts the FUN back in FUNCTION."
    `(lambda (&optional _) (declare (ignorable _)) ,@body))
  
  (defun mkhash (&rest keys &aux (table (make-hash-table :test #'equal)))
    (loop for (key val) on keys by #'cddr do (setf (gethash key table) val)
       finally (return table)))
  
  (define-condition chillax-server-error () ())
  
negative.code:     ;; ("update" . update)
      ;; ("list" . couch-list)
      ;; ("filter" . filter)
      )
    "Dispatch table holding Couch command -> Chillax function associations.")
  
  (defun respond (response)
    (handler-case
  