anchor.diff:          ;; all arguments are literals, convert to a constant
           ;; fixme: make sure this catches named constants too
           ((every (lambda (x) (typep x '(cons (eql :literal)))) nv)
  +         (loop for l in nv
  +               do (use-type (second nv)))
            ;; add name as an alias for the literal
            (let* ((l (composite-literal (normalize-literals-and-types type) nv)))
              #+=(format t "~&cc ~s ->~% ~s~% @ ~s (~s)->   ~s~%" values
  
positive.code:                            (cons list)))
  (deftype variable () '(cons (eql :variable)))
  (deftype scalar () '(cons (member :bool :int :uint :float)))
  
  (defvar *types*)
  (defvar *struct-types*)
  
negative.code:      (let ((bt (if *in-struct* :uint :bool)))
         (use-type (gethash bt *base-types*))))
      (unsigned-byte
       (use-type '(:uint 32))
       (use-type `(:literal (:uint 32) ,x)))
      (signed-byte
       (use-type '(:int 32))
       (use-type `(:literal (:int 32) ,x)))
      (real
       (use-type '(:float 32))
       (use-type `(:literal (:float 32) ,x)))
      ((cons (eql the))
       (let* ((nt (normalize-literals-and-types (second x) :force t))
              (.nv (mapcar 'normalize-literals-and-types (cddr x)))
              (nv (if (typep nt 'scalar)
                      (first .nv)
                      .nv)))
         (use-type nt)
         (if (every (lambda (x) (typep x 'literal)) .nv)
             (use-type (composite-literal nt nv))
             (use-type `(the ,nt ,nv)))))
      ((or string symbol)
       (cond
         ((gethash x *base-types*)
  