 (def six-ints (make-interpreter :stacks {:integer '(6 5 4 3 2 1)}))
 
 
-(defn store-local
-  "stores a local kv pair"
-  [[interpreter locals] k v]
-  (vector interpreter (assoc locals k v)))
-
-
-
-(fact "store-local saves thing to the locals hashmap"
-  (second (store-local [(make-interpreter) {}] :foo 8)) => {:foo 8}
-  (let [foo (store-local [(make-interpreter) {}] :foo 8)]
-    (second (store-local foo :bar 9)) => {:foo 8, :bar 9}))
-
-
-(fact "store-local can overwrite an existing :locals value"
-  (let [foo (store-local [(make-interpreter) {}] :foo 8)]
-    (second (store-local foo :foo 999)) => {:foo 999}))
+
+(defn store-scratch
+  "stores a scratch kv pair; convenience function for DSL"
+  [[interpreter scratch] k v]
+  (vector interpreter (assoc scratch k v)))
+
+
+(fact "store-scratch saves thing to the scratch hashmap"
+  (second (store-scratch [(make-interpreter) {}] :foo 8)) => {:foo 8}
+  (let [foo (store-scratch [(make-interpreter) {}] :foo 8)]
+    (second (store-scratch foo :bar 9)) => {:foo 8, :bar 9}))
+
+
+(fact "store-scratch can overwrite an existing :scratch value"
+  (let [foo (store-scratch [(make-interpreter) {}] :foo 8)]
+    (second (store-scratch foo :foo 999)) => {:foo 999}))
 
 
 (defn consume
-  [[interpreter locals] stack & {:keys [as]}]
+  [[interpreter scratch] stack & {:keys [as]}]
   (let [old-stack (get-stack interpreter stack)]
     (cond (empty? old-stack)
             (throw (Exception. (str "Push DSL Error: " stack " is empty")))
           (nil? as)
-            [(set-stack interpreter stack (pop old-stack)) locals]
+            [(set-stack interpreter stack (pop old-stack)) scratch]
           :else
-            (store-local
-              [(set-stack interpreter stack (pop old-stack)) locals]
+            (store-scratch
+              [(set-stack interpreter stack (pop old-stack)) scratch]
               as
               (first old-stack)))))
 
 
 (defn get-stack-from-dslblob ;; convenience for testing only
-  [[interpreter locals] stackname]
+  [[interpreter scratch] stackname]
   (get-stack interpreter stackname))
 
 

;    store item in `stackname` at position `where` under key `local`
;    raise an Exception if it's empty or undefined

; - `remember-stack [stackname :as local]`
;    save the entire stack to the `local`
;    raise an Exception if it's undefined

; - `place [stackname args kwd]`
;    push the local `kwd` on the named stack
;    raise an Exception if it's undefined




(defn remember-stack
  [[interpreter scratch] stackname & {:keys [as at]}]
  (if (nil? as)
    (vector interpreter scratch)
    (let [stack (get-stack interpreter stackname)]
      (vector interpreter (assoc scratch as stack)))))

(fact "remember-stack stores the stack specified in the :as variable"
  (let [integer-munged (-> [six-ints {}]
