anchor.diff:                 (string (format out-string "~:[ ~;~]~a"
                                  (or firstp (not (letterp (aref part-of-speech 0))))
                                  part-of-speech))
  -               (list
  -                (format out-string "~:[ ~;~]~a"
  -                        firstp
  -                        (first part-of-speech))
  -                (incf pointer))
                  (t
                   (format out-string "~:[ ~;~]~a"
                           firstp (random-word part-of-speech letter))
  
positive.code: (defun get-POS-template (acronym)
    "Returns an appropriate part-of-speech template for a given acronym, ready for use in build-backronym."
    ;; MAYBE: Do common (and irregular) substitutions here, like 2 → to, 4 → for
    (if (find #\Space acronym)
        (loop for i = 0 then (1+ j)
              as j = (position #\Space acronym :start i)
              append (get-POS-template (subseq acronym i j))
              when j collect '("and")
              while j)
        (flet ((%get-POS-template (length)
                 (alexandria:random-elt (aref *master-structures-list* (1- length)))))
          (if (<= (length acronym) (length *master-structures-list*))
              ;; Randomly pick a template to use.
              (%get-POS-template (length acronym))
              ;; If the acronym is too long for any precomposed templates,
              ;; Join up existing templates with prepositions into a final template.
              (loop with length-of-structures-list = (length *master-structures-list*)
                    with length-of-acronym         = (length acronym)
                    for i                          = (1+ (random length-of-structures-list))
                    and target                     = length-of-acronym then (- target i)
                    while (< length-of-structures-list target)
                append (%get-POS-template i) into final-list
                    collect (random-word :prepositions) into final-list
                    finally (return (append final-list
                                            (%get-POS-template target))))))))
  
  (defun letterp (thing)
    (or (char<= #\a thing #\z) (char<= #\A thing #\Z)))
  
negative.code: 
  (defun expand (acronym &optional (times 1 times-supplied-p))
    "Expands an acronym. If 'times' is provided, repeats expansion that many times and collects results into a list."
    (cond (times-supplied-p ; Repeat takes the greatest prescedence
           (loop repeat times collect (%expand acronym)))
          ((every #'letterp acronym) ; Base case.
           (%expand acronym))
          ((every #'letterp (remove-if #'(lambda (p) (char-equal p #\Space)) acronym))
           ; Contains separate words into spaces
           (format nil "~{~a~^ and ~}"
                   (mapcar #'%expand (split-sequence #\Space acronym :remove-empty-subseqs t))))))
    
  ;;; Autoload the list
  (refresh-list)
  