anchor.diff:    (:use #:cl)
     (:export~{ #:~A~})~%"
                 exercise
  -              (mapcar #'(lambda (fn) (string-downcase (car fn))) functions))
  +              (mapcar #'(lambda (fn) (kebab-case (car fn))) functions))
         (format stream "(in-package #:~A)~%~%" exercise)
         (dolist (fn functions)
  -        (let ((name (string-downcase (car fn)))
  -              (args (mapcar #'string-downcase (cdr fn))))
  +        (let ((name (kebab-case (car fn)))
  +              (args (mapcar #'kebab-case (cdr fn))))
             (format stream "(defun ~A ~A)~%~%" name args))))))
   
   (defun make-production-code (test-data)
  
positive.code:   (run-tests :all))")
    (terpri stream))
  
  (defun write-test (stream package case)
    (let ((description (exercise-case-name case))
          (function (exercise-case-function-info case))
          (inputs (exercise-case-inputs case))
          (expected (exercise-case-expected case)))
  
      (format stream "~%(define-test~%  ~A~%" (substitute #\- #\Space description))
  
      (if (and (listp expected) (eq (car expected) :error))
          (progn (format stream "  (assert-error~%")
                 (format stream "    '~A~%"
                         (string-downcase (substitute #\- #\Space (cdr expected))))
                 (format stream "    (~A:~A~{ ~S~}))"
                         package (string-downcase (car function)) inputs))
          (progn (format stream "  (assert-equal~%")
                 (format stream "    ~S~%" expected)
                 (format stream "    (~A:~A~{ ~S~}))"
                         package (string-downcase (car function)) inputs)))
      (format stream ")~%")))
  
  (defun write-tests (stream test-data)
    (let ((cases (exercise-cases test-data))
          (package (exercise-name test-data)))
      (dolist (case cases) (write-test stream package case))))
  
  (defun make-exercise-directory (test-data)
    (ensure-directories-exist
  
negative.code: (defun canonical-data-pathname (exercise)
    (merge-pathnames (make-pathname :directory (list :relative exercise))
                     *canonical-data-pathname-defaults*))
  
  (defun kebab-case (str) (substitute #\- #\Space (string-downcase str)))
  
  (defun write-prologue (stream test-data)
    (let* ((name (exercise-name test-data))
  