anchor.diff:      (declare (ignore type))
       value))
   
  -(defmethod expand-from-foreign :around (value (type enhanced-foreign-type))
  +(defmethod expand-from-foreign :around (value (type translatable-foreign-type))
     (let ((*runtime-translator-form* `(translate-from-foreign ,value ,type)))
       (call-next-method)))
   
  -(defmethod expand-from-foreign (value (type enhanced-foreign-type))
  +(defmethod expand-from-foreign (value (type translatable-foreign-type))
     (declare (ignore value))
     *runtime-translator-form*)
   
  
positive.code: ;;;# Type Translators
  ;;;
  ;;; Type translation is done with generic functions at runtime for
  ;;; subclasses of ENHANCED-FOREIGN-TYPE/
  ;;;
  ;;; The main interface for defining type translations is through the
  ;;; generic functions TRANSLATE-{TO,FROM}-FOREIGN and
  ;;; FREE-TRANSLATED-OBJECT.
  
  (defclass enhanced-foreign-type (foreign-type-alias)
    ((unparsed-type :accessor unparsed-type)))
  
  ;;; If actual-type isn't parsed already, let's parse it.  This way we
  
negative.code: ;;; above *RUNTIME-TRANSLATOR-FORM* which includes a call to
  ;;; FREE-TRANSLATED-OBJECT.  (Or else there would occur no translation
  ;;; at all.)
  (defmethod expand-to-foreign-dyn (value var body (type translatable-foreign-type))
    (multiple-value-bind (expansion default-etp-p)
        (expand-to-foreign value type)
      (if default-etp-p
  