 
 
 (defn place
-  [interpreter stack args function]
-  (let [result (apply function (map (:locals interpreter) args))]
+  [interpreter stack function]
+  (let [result (apply function [interpreter])]
     (push-item interpreter stack result)))
 
 
-(fact "`place` will apply the specified inline function to the dslstate locals named"
+(fact "`place` will apply the specified inline function to the interpreter"
   (let [integer-added (-> six-ints
                         (consume :integer :as :int1)
                         (consume :integer :as :int2)
-                        (place :integer [:int1 :int2] #(+ %1 %2)))]
-  (get-stack integer-added :integer) => '(11 4 3 2 1))) ;; 
+                        (place :integer #(+ (recall % :int1) (recall % :int2))))]
+  (get-stack integer-added :integer) => '(11 4 3 2 1)))
+
+
+(fact "`place` pays attention the argument order"
+  (let [integer-subtracted (-> six-ints
+                        (consume :integer :as :int1)
+                        (consume :integer :as :int2)
+                        (place :integer #(- (recall % :int1) (recall % :int2))))]
+  (get-stack integer-subtracted :integer) => '(1 4 3 2 1)) 
+  (let [integer-subtracted (-> six-ints
+                        (consume :integer :as :int1)
+                        (consume :integer :as :int2)
+                        (place :integer #(- (recall % :int2) (recall % :int1))))]
+  (get-stack integer-subtracted :integer) => '(-1 4 3 2 1)))
+
+
+;; this would be nicer if it was 
+;; (place :integer #(- (my :int2) (my :int1)))
+
 
 
 ; (def-pushinstruction

; - `remember-stack [stackname :as local]`
;    save the entire stack to the `local`
;    raise an Exception if it's undefined
; - `place [stackname item]`
;    push the item to the named stack
;    raise an Exception if it's undefined
; - `replace-stack [stackname new-stack]`
;    replace the indicated stack with a new list
;    raise an exception if it's undefined
; - `calculate [fn :as local]
;    save the result of `fn` under key `local`

;; And I THINK that supports all defined Push instructions I've ever seen....


;   :transaction
;     (consume :integer :as :int1)
;     (count-of :float :as :how-many)
;     (calculate [:how-many :int1] #(mod %1 %2) :as :which)
;     (remember :float :at :which :as :float1)
;     (place :float (recall :float1))]
;     )


