 
 
 (defn remember-calc
-  [[interpreter locals] args function & {:keys [as]}]
-  (if (nil? as)
-    (vector interpreter locals)
-    (let [result (apply function (map locals args))]
-      (vector interpreter (assoc locals as result)))))
-
-
-(fact "remember-calc stores the result of a calculation in a named local"
+  [[interpreter scratch] args function & {:keys [as]}]
+  (if (nil? as)
+    (vector interpreter scratch)
+    (let [result (apply function (map scratch args))]
+      (vector interpreter (assoc scratch as result)))))
+
+
+(fact "remember-calc stores the result of a calculation in a named scratch"
   (let [integer-added (-> [six-ints {}]
                           (consume :integer :as :int1)
                           (consume :integer :as :int2)



(defn place
  "pushes a named local onto a given stack"
  [[interpreter locals] stack kwd]
  (let [item (kwd locals)
        updated (push-item interpreter stack item)]
  (into [] (list updated locals))))


(fact "`place` will push the saved local value to the indicated stack in the interpreter"
  (let [integer-added (-> [six-ints {}]
                          (consume :integer :as :int1)
                          (consume :integer :as :int2)

;    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

