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:                              0)
                              ((cons (eql :composite))
                               (reduce 'max (mapcar #'r (cdr x))))
                              ((cons (member :vec :mat :literal))
                               (1+ (max (r (second x))
                                        (r (third x)))))
                              ((cons (member :array))
                               (1+ (max (r (second x))
                                        (r (third x)))))
  
negative.code:                          for v in value
                           collect (use-type (composite-literal mt v))))))
      ((cons (member :array :vec))
       (when (eq (car type) :array)
         ;; todo: check # of values for :vec literals
         ;; vec allows things like (vec4 1.0 (vec2 2.0 3.0) 4.0), so
         ;; just relaxing checking on it for now...
         (assert (= (third type) (length value))))
       `(:literal ,type
                  (:composite
                   ,@(loop with mt = (second type)
  