anchor.diff:      (_ nil)))
   
   (defun compile-variable-reference (exp var-env func-env)
  -  (cond ((scalar-variable-reference-p exp)
  -         (compile-scalar-variable-reference exp var-env))
  -        ((vector-variable-reference-p exp)
  +  (cond ((vector-variable-reference-p exp)
            (compile-vector-variable-reference exp var-env func-env))
           ((array-variable-reference-p exp)
            (compile-array-variable-reference exp var-env func-env))
           (t (error "invalid expression: ~A" exp))))
  -
  -(defun compile-scalar-variable-reference (var var-env)
  -  (unless (variable-environment-variable-exists-p var var-env)
  -    (error "unbound variable: ~A" var))
  -  (compile-identifier var))
   
   (defun compile-vector-selector (selector)
     (unless (valid-vector-type-selector-p selector)
  
positive.code:   (cond
      ((macro-form-p exp func-env) (compile-macro exp var-env func-env))
      ((literal-p exp) (compile-literal exp))
      ((cuda-dimension-p exp) (compile-cuda-dimension exp))
      ((variable-reference-p exp)
       (compile-variable-reference exp var-env func-env))
      ((inline-if-p exp) (compile-inline-if exp var-env func-env))
      ((function-p exp) (compile-function exp var-env func-env))
      (t (error "invalid expression: ~A" exp))))
  
  (defun literal-p (exp)
    (or (bool-literal-p exp)
  
negative.code:     (t (error "invalid expression: ~A" exp))))
  
  (defun variable-reference-p (exp)
    (or (vector-variable-reference-p exp)
        (array-variable-reference-p exp)))
  
  (defun vector-variable-reference-p (exp)
    (match exp
  