anchor.diff:           (around-type (car around-cons))
            (around-thunk (cdr around-cons)))
       (cond
  -      ((and primary-thunk (typep obj primary-type))
  +      ((and primary-thunk (subtypep obj-type primary-type))
          (assert (null around-thunk))
          (named-lambda marshal-primary-outer (value stack-item cont)
            (funcall set-thunk
                     (funcall primary-thunk value)
                     stack-item)
            (funcall cont)))
  -      ((and around-thunk (typep obj around-type))
  +      ((and around-thunk (subtypep obj-type around-type))
          (named-lambda marshal-around-outer (value stack-item cont)
            (funcall around-thunk
                     value
  
positive.code: (defun marshal (value type stack-item cont)
    (funcall (marshaller value type) value stack-item cont))
  
  (defun marshaller (obj <type>)
    (let* ((set-thunk
            (macrolet
                ((si (slot)
  
negative.code:             (let ((slot (qtype-stack-item-slot <type>)))
                (case slot
                  (bool  (lambda (val si) (setf (si bool) (if val 1 0))))
                  (class (if qobject-class
                             (let ((<from> qobject-class))
                               (multiple-value-bind (castfn <to>)
                                   (resolve-cast <from> (qtype-class <type>))
                                 (lambda (val si)
  