anchor.diff:  ;;; 	 (apply #'concatenate (cons 'string ses)))))
   
   (defun translate-1-1 (f s) 
  -  (let* ((se (explode s))
  -	 (ses (mapcar #'(lambda (ch) (string (funcall f ch))) se)))
  -    (apply #'concatenate (cons 'string ses))))
  +  (let* ((chars (explode s))
  +	 (translated-char-strings (mapcar #'(lambda (ch) (string (funcall f ch)))
  +					  chars)))
  +    (declare (type list translated-chars))
  +    (the lisp:simple-base-string 
  +      (apply #'concatenate 'string translated-char-strings))))
   
   (defun leq (s1 s2)
  -  #-Allegro (declare (simple-base-string s1 s2))
  +  (declare (type lisp:simple-base-string s1 s2))
  +  ;; result is fixnum or nil
     (string<= s1 s2))
   
   ;;; (defun leq-1 (x)  (string<= (car x) (cdr x)))
   
   (defun lt (s1 s2)
  -  #-Allegro (declare (simple-base-string s1 s2))
  +  (declare (type lisp:simple-base-string s1 s2))
  +  ;; result is fixnum or nil
     (string< s1 s2))
   
   ;;; (defun lt-1 (x)  (string< (car x) (cdr x)))
  
positive.code: ;;;       '(:|Greater|))))
  ;;; (defun compare-1 (x) (compare (car x) (cdr x)))
  
  (defun concatList (x) (apply #'concatenate 'string x))
  
  ;;; #| Tests:
  ;;; (funcall (all #'(lambda (ch) (isUpperCase ch))) "asdFasdf")
  
negative.code: ;;; The functions commented out acquire definitions from the compilation of Specware4.sw
  ;;;  before they are used.  [This wasn't true for concat-1 at least, so I restored its definition here.]
  
  ;;; Added various declarations to quiet down cmucl.
  ;;; See Decls.lisp for definition of macro named THE-STRING.
  
  (defun |!length| (x)
    (declare (type lisp:simple-base-string x))
    (the lisp:fixnum 
      (array-dimension x 0)))
  
  (defun concat (x y)
    (declare (type lisp:simple-base-string x y))
    (the lisp:simple-base-string 
      (concatenate 'string x y)))
  
  (defun concat-1 (x)
    (declare (cons x))
    (the lisp:simple-base-string 
      (concatenate 'string 
  		 (the lisp:simple-base-string (car x)) 
  		 (the lisp:simple-base-string (cdr x)))))
  
  (defun |!++| (x y)
    (declare (type lisp:simple-base-string x y))
    (the lisp:simple-base-string 
      (concatenate 'string x y)))
  
  ;;; (defun |!++|-1 (x)
  ;;;    (concatenate 'string (car x) (cdr x)))
  
  (defun ^ (x y)
    (declare (type lisp:simple-base-string x y))
    (the lisp:simple-base-string 
      (concatenate 'string x y)))
  
  
  ;;; (defun ^-1 (x)
  ;;;    (concatenate 'string (car x) (cdr x)))
  
  (defun toScreen (x)
    (declare (type lisp:simple-base-string x))
    (common-lisp::format t "~A" x))
  
  (defun writeLine (x)
    (declare (type lisp:simple-base-string x))
    (common-lisp::format t "~A" x)
    (common-lisp::format t "~%"))
  
  