anchor.diff:  (in-package #:cl-strftime)
   
   (defun flatten! (list)
  -  (labels ((rec (list)
  -             (mapcan
  -              (lambda (elt)
  -                (if (atom elt)
  -                    (list elt)
  -                    (rec elt)))
  -              list)))
  -    (rec list)))
  +  (mapcan
  +   (lambda (elt)
  +     (if (atom elt)
  +         (list elt)
  +         (flatten! elt)))
  +   list))
   
   (defun toggle-case (string)
     (map-into (make-string (length string))
  
positive.code:                          (parse-integer width)
                           (when (consp action)
                             (second action)))))
      (macrolet ((make-writer (&body body)
                   `(function
                     (lambda (stream time)
                      (declare (ignorable time))
                      ,@body))))
        (cond ((null action)
               (error "~S is not a known directive" directive))
              ((characterp action)
               (make-writer (write-char action stream)))
              ((stringp action)
               (compile-time-format action))
              (t (let ((fn (if (consp action) (third action) action)))
                   (case flag-char
                     (#\- (make-writer (format stream "~A"
                                               (funcall fn time))))
                     (#\_ (make-writer (format stream "~V,VD"
                                               width-size #\Space
                                               (funcall fn time))))
                     (#\0 (make-writer (format stream "~V,VD"
                                               width-size #\0
                                               (funcall fn time))))
                     (#\^ (make-writer (format stream "~:@(~A~)"
                                               (funcall fn time))))
                     (#\# (make-writer
                            (let ((value (funcall fn time)))
                              (format stream "~A"
                                      (if (stringp value)
                                          (toggle-case value)
                                          value)))))
                     (t
                      (make-writer
                        (format stream "~A"
                                (funcall fn time)))))))))))
  
  (defun format-time (stream format &optional (time (get-universal-time)))
    "Write TIME to STREAM as instructed by FORMAT."
  
negative.code:     (#\z . time-zone-offset)
      (#\Z . timezone)))
  
  (defmacro make-writer (&body body)
    `(function
      (lambda (stream time)
  