anchor.diff:  
   
   (defun test ()
  +  (test/string-designator)
  +  (test/character-designator)
     (test/concatenate-strings)
     (test/implode-explode))
   
  +(test)
  +
   
   ;;;; THE END ;;;;
  
positive.code:     (apply (function concatenate) 'string (nreverse justified))))
  
  
  (defmacro deftranslation (table text language translation
                                  &rest langs-trans)
    "
  
negative.code:   :success)
  
  
  (defgeneric explode (object &optional result-type)
    (:documentation "
  RETURN:         A sequence of character of type RESULT-TYPE containing
                  the character of the OBJECT.
  RESULT-TYPE:    A sequence type accepted by MAP (not NIL). Default: LIST.
  OBJECT:         Can be a string, a symbol (its symbol-name is exploded),
                  or a random object (its prin1 representation is exploded).
  ")
    (:method ((object symbol) &optional (result-type 'list))
      (explode-string (symbol-name object) result-type))
    (:method ((object string) &optional (result-type 'list))
      (explode-string object result-type))
    (:method ((object vector) &optional (result-type 'list))
      (explode-string (implode-string object) result-type))
    (:method ((object t) &optional (result-type 'list))
      (explode-string (prin1-to-string object) result-type)))
   
  
  (defun implode (char-seq &optional (result-type 'symbol) (package *package*))
    "
  RETURN:         An object of type RESULT-TYPE made with the character
                  in the CHAR-SEQ sequence. Default: SYMBOL.
  RESULT-TYPE:    SYMBOL (default), or STRING, or another type, in which
                  case the object is obtained from reading from the
                  string obtained from the implosion of the characters
                  CHAR-SEQ.
  PACKAGE:        When RESULT-TYPE is SYMBOL, then the package where the
                  symbol is interned. Default: *PACKAGE*.
  "
    (case result-type
      (string (implode-string char-seq))
      (symbol (intern (implode-string char-seq) package))
      (otherwise  (let ((object (read-from-string (implode-string char-seq))))
                    (assert (typep object result-type) ()
                            "~S is of type ~S which is not the expected type ~S"
                            object (type-of object) result-type)
                    object))))
  
  
  (defun split-escaped-string (string-designator escape separator)
    "
  STRING-DESIGNATOR:  A string designator.
  ESCAPE:             A character designator.
  SEPARATOR:          A character designator.
  DO:                 Split the STRING-DESIGNATOR on the SEPARATOR
                      character.  It may be escaped with the ESCAPE
                      character, in which case it's not split.
  RETURN:             A list of substrings of the string denoted by
                      STRING-DESIGNATOR.  
  "
    (let ((string    (string string-designator))
          (escape    (character escape))
          (separator (character separator)))
      (do ((result   ())
           (escaped  nil)
           (start    0)
           (curr     0))
          ((>= curr (length string))
           (if (and (null result) (= 0 curr))
               nil
               (progn (push (subseq string start curr) result)
                      (nreverse result))))
        (if escaped
            (progn (incf curr)
                   (setf escaped nil))
            (cond
              ((char= (aref string curr) escape)   (incf curr) (setf escaped t))
              ((char= (aref string curr) separator)
               (push (subseq string start curr) result)
               (incf curr)
               (setf start curr))
              (t (incf curr)))))))
  
  
  (defun split-string (string &optional (separators " ") (remove-empty nil))
  