anchor.diff:               (array-delim (elements)
                  (multiple-value-bind (type token) (next)
                    (declare (ignore token))
  -                 (ecase type
  +                 (case type
                      (#\] (apply #'vec (reverse elements)))
  -                   (#\, (array elements))))))
  +                   (#\, (array elements))
  +                   (otherwise (parse-error type "} or ,"))))))
   
         (start))))
   
  
positive.code:              (start ()
                 ;(print 'start)
                 (multiple-value-bind (type token) (next)
                   (cond
                     ((eq token :frame)
                      (cons (frame)
                            (start)))
                     ((null type)
                      nil)
                     (t (parse-error type "frame or EOF")))))
               (body ()
                 ;(print 'body)
                 (let ((type (next)))
                   (assert (eq #\{ type)))
                 (body-first-item ))
               (frame ()
                 (multiple-value-bind (type token) (next)
                   (assert (eq :identifier type))
                   (make-curly-block :type :frame
                                     :line line
                                     :name token
                                     :statements (body))))
  
negative.code:              (body-first-item ()
                 ;(print 'body-first)
                 (multiple-value-bind (type token) (next)
                   (unless (eq type #\})
                     (cons (case type
                             (:geometry
                              (geometry))
                             ((:frame :object)
                              (named-block token))
                             (:identifier ; beginning of block statement
                              (body-statement (list token)))
                             (t (parse-error type "identifier, frame, object, geometry, or }")))
                       (body-first-item)))))
               (body-statement (items)
                 (declare (type list items))
                 ;(format t "~&body statement: ~A" (reverse items))
                 (multiple-value-bind (type token) (next)
                   (case type
                     (#\; (reverse items))
                     ;; (#\{
                     ;;  (assert (= 1 (length items)))
                     ;;  (make-curly-block :name (car items)
                     ;;                    :type (car items)
                     ;;                    :line line
                     ;;                    :statements (body-first-item)))
  
                     (#\[
                      (body-statement (cons (array nil) items)))
                     ((:identifier :integer :float :string)
                      (body-statement (cons token items)))
                     (otherwise (parse-error type "a value")))))
               (array (elements)
                 (multiple-value-bind (type token) (next)
                   (case type
  