anchor.diff:                ;; (and if so, how they work)
                 (normalize-literals-and-types (third x)) ;; literal or variable
                 layout)))
  -    ((cons (member :vec :mat))
  +    ((cons (member :vec))
  +     (list* (first x)
  +            (normalize-literals-and-types (second x) :force t)
  +            (cddr x)))
  +    ((cons (member :mat))
  +     ;; define the column type
  +     (use-type `(:vec ,(second x) ,(third x)) :force t)
        (list* (first x)
               (normalize-literals-and-types (second x) :force t)
               (cddr x)))
  
positive.code:                          for v in value
                           collect (use-type (composite-literal mt v))))))
      ((cons (member :array :vec))
       (assert (= (third type) (length value)))
       `(:literal ,type
                  (:composite
                   ,@(loop with mt = (second type)
  
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*)
  