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: ;;;   (null (find-if (lambda (ch) (not (funcall fn ch))) s)))
  
  (defun sub (s n)
    (declare (type lisp:simple-base-string s) (type lisp:fixnum n))
    (elt s n))
  
  ;;; (defun sub-1 (s)
  ;;;     (elt (car s) (cdr s)))
  
  (defun substring (s start end)
    (declare (type lisp:simple-base-string s) (type lisp:fixnum start end))
    (the lisp:simple-base-string (subseq s start end)))
  
  ;;; (defun substring-1 (x)
  ;;;     (subseq (svref x 0) (svref x 1) (svref x 2)))    
  
  (defun explode (s) 
    ;; convert string to list
    (reduce #'cons s :from-end t :initial-value nil))
  
  (defun implode (s) 
  