anchor.diff:           (compile-vector-variable-reference exp type-env def))
           ((array-variable-reference-p exp)
            (compile-array-variable-reference exp type-env def))
  -        (t (error (format nil "invalid expression: ~A" exp)))))
  +        (t (error "invalid expression: ~A" exp))))
   
   (defun compile-scalar-variable-reference (var type-env)
     (let ((type (lookup-type-environment var type-env)))
       (unless type
  -      (error (format nil "unbound variable: ~A" var))))
  +      (error "unbound variable: ~A" var)))
     (compile-identifier var))
   
   (defun compile-vector-selector (selector)
     (unless (valid-vector-type-selector-p selector)
  -    (error (format nil "invalid selector: ~A" selector)))
  +    (error "invalid selector: ~A" selector))
     (string-downcase (subseq (reverse (princ-to-string selector)) 0 1)))
   
   (defun compile-vector-variable-reference (form type-env def)
  
positive.code:     (thread-idx-x "threadIdx.x")
      (thread-idx-y "threadIdx.y")
      (thread-idx-z "threadIdx.z")
      (t (error (format nil "invalid expression: ~A" exp)))))
  
  (defun variable-reference-p (exp)
    (or (scalar-variable-reference-p exp)
  
negative.code: (defun progn-statements (stmt)
    (match stmt
      (('progn . stmts) stmts)
      (_ (error "invalid statement: ~A" stmt))))
  
  (defun compile-progn (stmt type-env def)
    (compile-progn-statements (progn-statements stmt) type-env def))
  