anchor.diff:      (define-foreign-type `(:enum (,name)) enum)))
   
   (defun define-foreign-alias (name type)
  -  (define-foreign-type name
  -      (make-instance 'foreign-alias
  -                     :name name
  -                     :type (ensure-type type))))
  +  (with-wrap-attempt () name
  +    (define-foreign-type name
  +        (make-instance 'foreign-alias
  +                       :name name
  +                       :type (ensure-type type "alias foreign type ~S to ~S" type name)))))
   
   (defun define-foreign-function (name-and-options return-type params)
     "=> FOREIGN-FUNCTION
  
positive.code:           (setf (foreign-anonymous id) sym)
            sym))))
  
  (defun create-type-from-typespec (typespec)
    "=> TYPE
  
  Create a type from `TYPESPEC` and return the `TYPE` structure representing it."
    (if (not (listp typespec))
        (find-type typespec)
        (let ((type (car typespec)))
          (ecase type
            (enum
             (let ((name (parse-record-name (cadr typespec))))
               (define-foreign-enum name nil (cddr typespec))))
            ((struct union)
             (let ((name (parse-record-name (cadr typespec))))
               (destructuring-bind (_ &key bit-size bit-alignment &allow-other-keys)
                   (cadr typespec)
                 (declare (ignore _))
                 (define-foreign-record name (make-keyword type) bit-size bit-alignment (cddr typespec)))))
            ((:enum :struct :union)
             (let ((name (list type (list (parse-record-name (cadr typespec))))))
               (find-type name)))
            (:array
             (let ((type (ensure-type (cadr typespec)))
                   (size (caddr typespec)))
               (make-instance 'foreign-array :type type :size size)))
            (:string
             (define-foreign-type '(:string) (make-instance 'foreign-string)))
            (:pointer
             (define-foreign-type
                 `(:pointer ,(cdr typespec))
                 (make-instance 'foreign-pointer :type (ensure-type (cadr typespec)))))
            (:void :void)))))
  
   ;; Making Things
  
negative.code: 
  (defun enum-value (foreign-enum key)
    (let ((enum (if (symbolp foreign-enum)
                    (require-type foreign-enum "map key ~S of enum ~S to value" key foreign-enum)
                    foreign-enum)))
      (aval key (foreign-enum-values enum))))
  
  (defun enum-key (foreign-enum val)
    (let ((enum (if (symbolp foreign-enum)
                    (require-type foreign-enum "map value ~S of enum ~S to value" val foreign-enum)
                    foreign-enum)))
      (akey val (foreign-enum-values enum))))
  
  