From 107d969497d482b07c33c4f28123727fa0a0b263 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Inge=20J=C3=B8rgensen?= <inge@manualdesign.no>
Date: Sat, 28 Feb 2015 00:36:27 +0100
Subject: Ruby: Updated for Ruby 1.9+

---
 README.md                |  2 +-
 ruby/core.rb             |  4 ++--
 ruby/mal_readline.rb     |  2 +-
 ruby/printer.rb          |  2 +-
 ruby/reader.rb           |  2 +-
 ruby/step0_repl.rb       |  3 +--
 ruby/step1_read_print.rb |  9 ++++-----
 ruby/step2_eval.rb       |  9 ++++-----
 ruby/step3_env.rb        | 11 +++++------
 ruby/step4_if_fn_do.rb   | 13 ++++++-------
 ruby/step5_tco.rb        | 13 ++++++-------
 ruby/step6_file.rb       | 13 ++++++-------
 ruby/step7_quote.rb      | 13 ++++++-------
 ruby/step8_macros.rb     | 13 ++++++-------
 ruby/step9_try.rb        | 13 ++++++-------
 ruby/stepA_interop.rb    | 13 ++++++-------
 ruby/types.rb            |  2 +-
 17 files changed, 63 insertions(+), 74 deletions(-)

diff --git a/README.md b/README.md
index 612743c..9dac314 100644
--- a/README.md
+++ b/README.md
@@ -286,7 +286,7 @@ cd racket
 ./stepX_YYY.rb
 ```
 
-### Ruby (1.8)
+### Ruby (1.9+)
 
 ```
 cd ruby
diff --git a/ruby/core.rb b/ruby/core.rb
index d55100c..b82bddc 100644
--- a/ruby/core.rb
+++ b/ruby/core.rb
@@ -1,6 +1,6 @@
 require "readline"
-require "reader"
-require "printer"
+require_relative "reader"
+require_relative "printer"
 
 $core_ns = {
     :"=" =>       lambda {|a,b| a == b},
diff --git a/ruby/mal_readline.rb b/ruby/mal_readline.rb
index 63c5571..3799783 100644
--- a/ruby/mal_readline.rb
+++ b/ruby/mal_readline.rb
@@ -4,7 +4,7 @@ $history_loaded = false
 $histfile = "#{ENV['HOME']}/.mal-history"
 
 def _readline(prompt)
-    if not $history_loaded
+    if !$history_loaded && File.exist?($histfile)
         $history_loaded = true
         File.readlines($histfile).each {|l| Readline::HISTORY.push(l.chomp)}
     end
diff --git a/ruby/printer.rb b/ruby/printer.rb
index 37d338a..ef067a5 100644
--- a/ruby/printer.rb
+++ b/ruby/printer.rb
@@ -1,4 +1,4 @@
-require "types"
+require_relative "types"
 
 def _pr_str(obj, print_readably=true)
     _r = print_readably
diff --git a/ruby/reader.rb b/ruby/reader.rb
index 641e65c..badc6ec 100644
--- a/ruby/reader.rb
+++ b/ruby/reader.rb
@@ -1,4 +1,4 @@
-require "types"
+require_relative "types"
 
 class Reader
     def initialize(tokens)
diff --git a/ruby/step0_repl.rb b/ruby/step0_repl.rb
index 9c03cfa..2f9e6a9 100644
--- a/ruby/step0_repl.rb
+++ b/ruby/step0_repl.rb
@@ -1,5 +1,4 @@
-$: << File.expand_path(File.dirname(__FILE__))
-require "mal_readline"
+require_relative "mal_readline"
 
 # read
 def READ(str)
diff --git a/ruby/step1_read_print.rb b/ruby/step1_read_print.rb
index ded992a..ef416c3 100644
--- a/ruby/step1_read_print.rb
+++ b/ruby/step1_read_print.rb
@@ -1,8 +1,7 @@
-$: << File.expand_path(File.dirname(__FILE__))
-require "mal_readline"
-require "types"
-require "reader"
-require "printer"
+require_relative "mal_readline"
+require_relative "types"
+require_relative "reader"
+require_relative "printer"
 
 # read
 def READ(str)
diff --git a/ruby/step2_eval.rb b/ruby/step2_eval.rb
index 50a135d..d2b7e1a 100644
--- a/ruby/step2_eval.rb
+++ b/ruby/step2_eval.rb
@@ -1,8 +1,7 @@
-$: << File.expand_path(File.dirname(__FILE__))
-require "mal_readline"
-require "types"
-require "reader"
-require "printer"
+require_relative "mal_readline"
+require_relative "types"
+require_relative "reader"
+require_relative "printer"
 
 # read
 def READ(str)
diff --git a/ruby/step3_env.rb b/ruby/step3_env.rb
index 17126c5..ec8405b 100644
--- a/ruby/step3_env.rb
+++ b/ruby/step3_env.rb
@@ -1,9 +1,8 @@
-$: << File.expand_path(File.dirname(__FILE__))
-require "mal_readline"
-require "types"
-require "reader"
-require "printer"
-require "env"
+require_relative "mal_readline"
+require_relative "types"
+require_relative "reader"
+require_relative "printer"
+require_relative "env"
 
 # read
 def READ(str)
diff --git a/ruby/step4_if_fn_do.rb b/ruby/step4_if_fn_do.rb
index a93463b..151ecf6 100644
--- a/ruby/step4_if_fn_do.rb
+++ b/ruby/step4_if_fn_do.rb
@@ -1,10 +1,9 @@
-$: << File.expand_path(File.dirname(__FILE__))
-require "mal_readline"
-require "types"
-require "reader"
-require "printer"
-require "env"
-require "core"
+require_relative "mal_readline"
+require_relative "types"
+require_relative "reader"
+require_relative "printer"
+require_relative "env"
+require_relative "core"
 
 # read
 def READ(str)
diff --git a/ruby/step5_tco.rb b/ruby/step5_tco.rb
index 38bb204..80be457 100644
--- a/ruby/step5_tco.rb
+++ b/ruby/step5_tco.rb
@@ -1,10 +1,9 @@
-$: << File.expand_path(File.dirname(__FILE__))
-require "mal_readline"
-require "types"
-require "reader"
-require "printer"
-require "env"
-require "core"
+require_relative "mal_readline"
+require_relative "types"
+require_relative "reader"
+require_relative "printer"
+require_relative "env"
+require_relative "core"
 
 # read
 def READ(str)
diff --git a/ruby/step6_file.rb b/ruby/step6_file.rb
index 0c99cee..4eeca86 100644
--- a/ruby/step6_file.rb
+++ b/ruby/step6_file.rb
@@ -1,10 +1,9 @@
-$: << File.expand_path(File.dirname(__FILE__))
-require "mal_readline"
-require "types"
-require "reader"
-require "printer"
-require "env"
-require "core"
+require_relative "mal_readline"
+require_relative "types"
+require_relative "reader"
+require_relative "printer"
+require_relative "env"
+require_relative "core"
 
 # read
 def READ(str)
diff --git a/ruby/step7_quote.rb b/ruby/step7_quote.rb
index 48385f1..23d9499 100644
--- a/ruby/step7_quote.rb
+++ b/ruby/step7_quote.rb
@@ -1,10 +1,9 @@
-$: << File.expand_path(File.dirname(__FILE__))
-require "mal_readline"
-require "types"
-require "reader"
-require "printer"
-require "env"
-require "core"
+require_relative "mal_readline"
+require_relative "types"
+require_relative "reader"
+require_relative "printer"
+require_relative "env"
+require_relative "core"
 
 # read
 def READ(str)
diff --git a/ruby/step8_macros.rb b/ruby/step8_macros.rb
index 58adaea..488db12 100644
--- a/ruby/step8_macros.rb
+++ b/ruby/step8_macros.rb
@@ -1,10 +1,9 @@
-$: << File.expand_path(File.dirname(__FILE__))
-require "mal_readline"
-require "types"
-require "reader"
-require "printer"
-require "env"
-require "core"
+require_relative "mal_readline"
+require_relative "types"
+require_relative "reader"
+require_relative "printer"
+require_relative "env"
+require_relative "core"
 
 # read
 def READ(str)
diff --git a/ruby/step9_try.rb b/ruby/step9_try.rb
index 74d0f59..533853b 100644
--- a/ruby/step9_try.rb
+++ b/ruby/step9_try.rb
@@ -1,10 +1,9 @@
-$: << File.expand_path(File.dirname(__FILE__))
-require "mal_readline"
-require "types"
-require "reader"
-require "printer"
-require "env"
-require "core"
+require_relative "mal_readline"
+require_relative "types"
+require_relative "reader"
+require_relative "printer"
+require_relative "env"
+require_relative "core"
 
 # read
 def READ(str)
diff --git a/ruby/stepA_interop.rb b/ruby/stepA_interop.rb
index 6123293..3fb4af0 100644
--- a/ruby/stepA_interop.rb
+++ b/ruby/stepA_interop.rb
@@ -1,10 +1,9 @@
-$: << File.expand_path(File.dirname(__FILE__))
-require "mal_readline"
-require "types"
-require "reader"
-require "printer"
-require "env"
-require "core"
+require_relative "mal_readline"
+require_relative "types"
+require_relative "reader"
+require_relative "printer"
+require_relative "env"
+require_relative "core"
 
 # read
 def READ(str)
diff --git a/ruby/types.rb b/ruby/types.rb
index 72d24d1..d64664b 100644
--- a/ruby/types.rb
+++ b/ruby/types.rb
@@ -1,4 +1,4 @@
-require "env"
+require_relative "env"
 
 class MalException < StandardError
   attr_reader :data
-- 
cgit v1.2.3


From 6a767b0d00a9a3ad578bdb8d85eddbd1afb9be35 Mon Sep 17 00:00:00 2001
From: treeform <starplant@gmail.com>
Date: Fri, 27 Feb 2015 17:57:34 -0800
Subject: small typo in example

---
 process/guide.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/process/guide.md b/process/guide.md
index 734dc32..649aee6 100644
--- a/process/guide.md
+++ b/process/guide.md
@@ -321,7 +321,7 @@ manually try some simple inputs:
   * `   abc   ` -> `abc`
   * `(123 456)` -> `(123 456)`
   * `(  123   456 789   )   ` -> `(123 456 789)`
-  * `(  + 2   (+  3  4)  )  ` -> `(+ 2 (* 3 4))`
+  * `(  + 2   (*  3  4)  )  ` -> `(+ 2 (* 3 4))`
 
 To verify that your code is doing more than just eliminating extra
 spaces (and not failing), you can instrument your `reader.qx` functions.
-- 
cgit v1.2.3


From fc03712f7a56e450debfbfeb47d11301a94046ac Mon Sep 17 00:00:00 2001
From: Erik Chancy <erikuchancy@gmail.com>
Date: Sat, 28 Feb 2015 18:00:27 +1100
Subject: Update guide.md

---
 process/guide.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/process/guide.md b/process/guide.md
index 734dc32..669d6a6 100644
--- a/process/guide.md
+++ b/process/guide.md
@@ -68,8 +68,8 @@ git clone git@github.com:YOUR_NAME/mal.git
 cd mal
 ```
 
-* Make a new directory for your implementation. For example, if you
-* language is called "quux":
+* Make a new directory for your implementation. For example, if your
+language is called "quux":
 ```
 mkdir quux
 ```
-- 
cgit v1.2.3


From c10dcb94671ac3c29e503896396d4a413898f415 Mon Sep 17 00:00:00 2001
From: Anton Trunov <trunov@math.tsu.ru>
Date: Sat, 28 Feb 2015 13:55:55 +0300
Subject: guide: insert missing word

---
 process/guide.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/process/guide.md b/process/guide.md
index 734dc32..d8d6db4 100644
--- a/process/guide.md
+++ b/process/guide.md
@@ -15,7 +15,7 @@ So jump right in (er ... start the climb)!
 
 You might already have a language in mind that you want to use.
 Technically speaking, mal can be implemented in any sufficiently
-complete programming (i.e. Turing complete), however, there are a few
+complete programming language (i.e. Turing complete), however, there are a few
 language features that can make the task MUCH easier. Here are some of
 them in rough order of importance:
 
-- 
cgit v1.2.3


From 27696157525984853f7d980b674c05c7ebf857ff Mon Sep 17 00:00:00 2001
From: joelpickup <joelpickup@hotmail.co.uk>
Date: Sat, 28 Feb 2015 13:48:13 +0000
Subject: grammar fix

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 612743c..9efef1f 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 ## Description
 
-Mal is an Clojure inspired Lisp interpreter.
+Mal is a Clojure inspired Lisp interpreter.
 
 Mal is implemented in 26 different languages:
 
-- 
cgit v1.2.3


From 2ab1e5845c213a9951bee46a0c991202e6c46d5c Mon Sep 17 00:00:00 2001
From: Joel Martin <github@martintribe.org>
Date: Sat, 28 Feb 2015 10:35:04 -0600
Subject: Multiple: interop enhancements.

---
 cs/stepA_interop.cs   |  4 ++--
 docs/TODO             |  8 ++++++++
 js/stepA_interop.js   |  8 ++++++--
 js/types.js           |  4 ++++
 php/stepA_interop.php | 14 +++++++++++++-
 ps/interop.ps         |  4 ++--
 ruby/stepA_interop.rb |  6 +++++-
 rust/Makefile         |  7 +++++--
 8 files changed, 45 insertions(+), 10 deletions(-)

diff --git a/cs/stepA_interop.cs b/cs/stepA_interop.cs
index 2e8fc12..6531d50 100644
--- a/cs/stepA_interop.cs
+++ b/cs/stepA_interop.cs
@@ -231,10 +231,10 @@ namespace Mal {
             }
             repl_env.set(new MalSymbol("eval"), new MalFunc(
                         a => EVAL(a[0], repl_env)));
-            int fileIdx = 1;
+            int fileIdx = 0;
             if (args.Length > 0 && args[0] == "--raw") {
                 Mal.readline.mode = Mal.readline.Mode.Raw;
-                fileIdx = 2;
+                fileIdx = 1;
             }
             MalList _argv = new MalList();
             for (int i=fileIdx; i < args.Length; i++) {
diff --git a/docs/TODO b/docs/TODO
index 741d024..e5b135b 100644
--- a/docs/TODO
+++ b/docs/TODO
@@ -1,4 +1,6 @@
 All:
+    - Finish guide.md
+
     - rename stepA_interop to stepA_mal
     - test to check args set properly
     - test to make sure slurp captures final newline
@@ -57,6 +59,8 @@ C:
 C#:
     - fix command line arg processing (doesn't run file specified)
     - accumulates line breaks with mal/clojurewest2014.mal
+    - step9_interop:
+      http://www.ckode.dk/programming/eval-in-c-yes-its-possible/
 
 Clojure:
     - make indent consistent across steps (e.g. step5, step8)
@@ -167,6 +171,10 @@ Future Implementations:
         - http://api.haxe.org/
         - http://haxe.us/haxe_tutorial.html
 
+    - Julia
+
+    - Nim
+
     - Objective-C:
 
     - Pascal:
diff --git a/js/stepA_interop.js b/js/stepA_interop.js
index 456c006..d879cd3 100644
--- a/js/stepA_interop.js
+++ b/js/stepA_interop.js
@@ -5,6 +5,7 @@ if (typeof module !== 'undefined') {
     var printer = require('./printer');
     var Env = require('./env').Env;
     var core = require('./core');
+    var interop = require('./interop');
 }
 
 // read
@@ -108,8 +109,11 @@ function _EVAL(ast, env) {
         return eval(a1.toString());
     case ".":
         var el = eval_ast(ast.slice(2), env),
-            f = eval(a1.toString());
-        return f.apply(f, el);
+            r = interop.resolve_js(a1.toString()),
+            obj = r[0], f = r[1];
+        var res = f.apply(obj, el);
+        console.log("DEBUG3:", res);
+        return interop.js_to_mal(res);
     case "try*":
         try {
             return EVAL(a1, env);
diff --git a/js/types.js b/js/types.js
index 848a484..e3901b7 100644
--- a/js/types.js
+++ b/js/types.js
@@ -79,6 +79,10 @@ function _clone (obj) {
     default:
         throw new Error("clone of non-collection: " + _obj_type(obj));
     }
+    Object.defineProperty(new_obj, "__meta__", {
+        enumerable: false,
+        writable: true
+    });
     return new_obj;
 }
 
diff --git a/php/stepA_interop.php b/php/stepA_interop.php
index 8c67c66..1dc3b04 100644
--- a/php/stepA_interop.php
+++ b/php/stepA_interop.php
@@ -109,7 +109,19 @@ function MAL_EVAL($ast, $env) {
     case "macroexpand":
         return macroexpand($ast[1], $env);
     case "php*":
-        return eval($ast[1]);
+        $res = eval($ast[1]);
+        switch (gettype($res)) {
+        case "array":
+            if ($res !== array_values($res)) {
+                $new_res = _hash_map();
+                $new_res->exchangeArray($res);
+                return $new_res;
+            } else {
+                return call_user_func_array('_list', $res);
+            }
+        default:
+            return $res;
+        }
     case "try*":
         $a1 = $ast[1];
         $a2 = $ast[2];
diff --git a/ps/interop.ps b/ps/interop.ps
index fb3b88d..8020ab0 100644
--- a/ps/interop.ps
+++ b/ps/interop.ps
@@ -1,6 +1,6 @@
-% ps_val -> ps2mal -> mal_val
+% [ ps_val1...] -> ps2mal -> [ mal_val1...]
 /ps2mal {
-    % convert a PS value to a Mal value (recursively)
+    % convert returned values to Mal types
     [ exch
         { %forall returned values
             dup ==
diff --git a/ruby/stepA_interop.rb b/ruby/stepA_interop.rb
index 6123293..1eff1f1 100644
--- a/ruby/stepA_interop.rb
+++ b/ruby/stepA_interop.rb
@@ -96,7 +96,11 @@ def EVAL(ast, env)
     when :macroexpand
         return macroexpand(a1, env)
     when :"rb*"
-        return eval(a1)
+        res = eval(a1)
+        return case res
+            when Array; List.new res
+            else; res
+        end
     when :"try*"
         begin
             return EVAL(a1, env)
diff --git a/rust/Makefile b/rust/Makefile
index 537dac5..6910356 100644
--- a/rust/Makefile
+++ b/rust/Makefile
@@ -8,19 +8,22 @@ SOURCES = $(SOURCES_BASE) $(SOURCES_LISP)
 
 #####################
 
-SRCS = step0_repl.rs step1_read_print.rs step2_eval.rs step3_env.rs \
+SRCS = step1_read_print.rs step2_eval.rs step3_env.rs \
        step4_if_fn_do.rs step5_tco.rs step6_file.rs step7_quote.rs \
        step8_macros.rs step9_try.rs stepA_interop.rs
 BINS = $(SRCS:%.rs=target/%)
 
 #####################
 
-all: $(BINS) mal
+all: mal
 
 mal: ${SOURCES_BASE} $(word $(words ${SOURCES_LISP}),${SOURCES_LISP})
 	cargo build
 	cp $(word $(words ${BINS}),${BINS})  $@
 
+#$(BINS): target/%: src/%.rs
+#	cargo build $*
+
 clean:
 	cargo clean
 	rm -f mal
-- 
cgit v1.2.3


From 699f0ad23aca21076edb6a51838d879ca580ffd5 Mon Sep 17 00:00:00 2001
From: Joel Martin <github@martintribe.org>
Date: Sat, 28 Feb 2015 10:38:17 -0600
Subject: Add long running perf test.

---
 Makefile        |  4 +++-
 perf.mal        | 20 ++++++++++++++++++++
 tests/perf3.mal | 28 ++++++++++++++++++++++++++++
 3 files changed, 51 insertions(+), 1 deletion(-)
 create mode 100644 tests/perf3.mal

diff --git a/Makefile b/Makefile
index 47c7829..e30a6f6 100644
--- a/Makefile
+++ b/Makefile
@@ -193,5 +193,7 @@ $(IMPL_PERF):
 	  echo 'Running: $(call $(impl)_RUNSTEP,stepA,$(call $(impl)_STEP_TO_PROG,stepA),../tests/perf1.mal)'; \
           $(call $(impl)_RUNSTEP,stepA,$(call $(impl)_STEP_TO_PROG,stepA),../tests/perf1.mal); \
 	  echo 'Running: $(call $(impl)_RUNSTEP,stepA,$(call $(impl)_STEP_TO_PROG,stepA),../tests/perf2.mal)'; \
-          $(call $(impl)_RUNSTEP,stepA,$(call $(impl)_STEP_TO_PROG,stepA),../tests/perf2.mal))
+          $(call $(impl)_RUNSTEP,stepA,$(call $(impl)_STEP_TO_PROG,stepA),../tests/perf2.mal); \
+	  echo 'Running: $(call $(impl)_RUNSTEP,stepA,$(call $(impl)_STEP_TO_PROG,stepA),../tests/perf3.mal)'; \
+          $(call $(impl)_RUNSTEP,stepA,$(call $(impl)_STEP_TO_PROG,stepA),../tests/perf3.mal))
 
diff --git a/perf.mal b/perf.mal
index 94da2ff..83bbc0d 100644
--- a/perf.mal
+++ b/perf.mal
@@ -5,3 +5,23 @@
       (do
         (prn (str "Elapsed time: " (- (time-ms) start_FIXME) " msecs"))
         ret_FIXME))))
+
+(def! run-fn-for*
+  (fn* [fn max-ms acc-ms iters]
+    (let* [start (time-ms)
+           _ (fn)
+           elapsed (- (time-ms) start)
+           new-iters (+ 1 iters)
+           new-acc-ms (+ acc-ms elapsed)]
+      ;(do (prn "here:" new-acc-ms "/" max-ms "iters:" new-iters) )
+      (if (>= new-acc-ms max-ms)
+        (/ (* max-ms iters) new-acc-ms)
+        (run-fn-for* fn max-ms new-acc-ms new-iters)))))
+
+(def! run-fn-for
+  (fn* [fn max-secs]
+    (do
+      ;; Warm it up first
+      (run-fn-for* fn 1000 0 0)
+      ;; Now do the test
+      (/ (run-fn-for* fn (* 1000 max-secs) 0 0) 3))))
diff --git a/tests/perf3.mal b/tests/perf3.mal
new file mode 100644
index 0000000..be66239
--- /dev/null
+++ b/tests/perf3.mal
@@ -0,0 +1,28 @@
+(load-file "../core.mal")
+(load-file "../perf.mal")
+
+;;(prn "Start: basic macros/atom test")
+
+(def! atm (atom (list 0 1 2 3 4 5 6 7 8 9)))
+
+(println "iters/s:"
+  (run-fn-for
+    (fn* []
+      (do
+        (or false nil false nil false nil false nil false nil (first @atm))
+        (cond false 1 nil 2 false 3 nil 4 false 5 nil 6 "else" (first @atm))
+        (-> (deref atm) rest rest rest rest rest rest first)
+        (swap! atm (fn* [a] (concat (rest a) (list (first a)))))))
+    10))
+
+;;(def! sumdown (fn* (N) (if (> N 0) (+ N (sumdown  (- N 1))) 0)))
+;;(def! fib (fn* (N) (if (= N 0) 1 (if (= N 1) 1 (+ (fib (- N 1)) (fib (- N 2)))))))
+;;
+;;(println "iters/s:"
+;;  (run-fn-for
+;;    (fn* []
+;;      (do 
+;;        (sumdown 10)
+;;        (fib 12)))
+;;    3))
+;;(prn "Done: basic macros/atom test")
-- 
cgit v1.2.3


From 90f618cbe7ac7740accf501a75be6972bd95be1a Mon Sep 17 00:00:00 2001
From: Joel Martin <github@martintribe.org>
Date: Sat, 28 Feb 2015 11:09:54 -0600
Subject: All: rename stepA_interop to stepA_mal

Also, add missed postscript interop tests.
---
 .gitignore                                |   2 +-
 Makefile                                  |   2 +-
 README.md                                 |   2 +-
 bash/Makefile                             |   2 +-
 bash/stepA_interop.sh                     | 283 ------------------
 bash/stepA_mal.sh                         | 283 ++++++++++++++++++
 bash/tests/stepA_interop.mal              |  17 --
 bash/tests/stepA_mal.mal                  |  17 ++
 c/Makefile                                |   4 +-
 c/stepA_interop.c                         | 356 ----------------------
 c/stepA_mal.c                             | 356 ++++++++++++++++++++++
 c/tests/stepA_interop.mal                 |  23 --
 c/tests/stepA_mal.mal                     |  23 ++
 clojure/Makefile                          |   2 +-
 clojure/src/stepA_interop.clj             | 181 -----------
 clojure/src/stepA_mal.clj                 | 181 +++++++++++
 clojure/tests/stepA_interop.mal           |  17 --
 clojure/tests/stepA_mal.mal               |  17 ++
 coffee/Makefile                           |   2 +-
 coffee/stepA_interop.coffee               | 142 ---------
 coffee/stepA_mal.coffee                   | 142 +++++++++
 coffee/tests/stepA_interop.mal            |  24 --
 coffee/tests/stepA_mal.mal                |  24 ++
 cs/Makefile                               |   4 +-
 cs/stepA_interop.cs                       | 285 ------------------
 cs/stepA_mal.cs                           | 285 ++++++++++++++++++
 docs/TODO                                 |   5 +-
 docs/step_notes.txt                       |   2 +-
 forth/Makefile                            |   2 +-
 forth/stepA_interop.fs                    | 390 ------------------------
 forth/stepA_mal.fs                        | 390 ++++++++++++++++++++++++
 forth/tests/stepA_interop.mal             |  41 ---
 forth/tests/stepA_mal.mal                 |  41 +++
 go/Makefile                               |   4 +-
 go/src/stepA_interop/stepA_interop.go     | 306 -------------------
 go/src/stepA_mal/stepA_mal.go             | 306 +++++++++++++++++++
 haskell/Makefile                          |   2 +-
 haskell/stepA_interop.hs                  | 255 ----------------
 haskell/stepA_mal.hs                      | 255 ++++++++++++++++
 java/Makefile                             |   2 +-
 java/pom.xml                              |   4 +-
 java/src/main/java/mal/stepA_interop.java | 301 -------------------
 java/src/main/java/mal/stepA_mal.java     | 301 +++++++++++++++++++
 js/Makefile                               |   2 +-
 js/stepA_interop.js                       | 203 -------------
 js/stepA_mal.js                           | 203 +++++++++++++
 js/tests/stepA_interop.mal                |  24 --
 js/tests/stepA_mal.mal                    |  24 ++
 lua/Makefile                              |   2 +-
 lua/stepA_interop.lua                     | 200 -------------
 lua/stepA_mal.lua                         | 200 +++++++++++++
 make/Makefile                             |   4 +-
 make/stepA_interop.mk                     | 193 ------------
 make/stepA_mal.mk                         | 193 ++++++++++++
 make/tests/stepA_interop.mal              |  19 --
 make/tests/stepA_mal.mal                  |  19 ++
 mal/Makefile                              |   2 +-
 mal/stepA_interop.mal                     | 181 -----------
 mal/stepA_mal.mal                         | 181 +++++++++++
 matlab/Makefile                           |   2 +-
 matlab/stepA_interop.m                    | 226 --------------
 matlab/stepA_mal.m                        | 226 ++++++++++++++
 miniMAL/Makefile                          |   2 +-
 miniMAL/stepA_interop.json                | 171 -----------
 miniMAL/stepA_mal.json                    | 171 +++++++++++
 ocaml/Makefile                            |   6 +-
 ocaml/stepA_interop.ml                    | 159 ----------
 ocaml/stepA_mal.ml                        | 159 ++++++++++
 perl/Makefile                             |   2 +-
 perl/stepA_interop.pl                     | 265 -----------------
 perl/stepA_mal.pl                         | 265 +++++++++++++++++
 perl/tests/stepA_interop.mal              |  22 --
 perl/tests/stepA_mal.mal                  |  22 ++
 php/Makefile                              |   2 +-
 php/stepA_interop.php                     | 229 --------------
 php/stepA_mal.php                         | 229 ++++++++++++++
 php/tests/stepA_interop.mal               |  25 --
 php/tests/stepA_mal.mal                   |  25 ++
 process/guide.md                          |   6 +-
 process/stepA_interop.gliffy              |   1 -
 process/stepA_interop.png                 | Bin 83168 -> 0 bytes
 process/stepA_interop.txt                 | 136 ---------
 process/stepA_mal.gliffy                  |   1 +
 process/stepA_mal.png                     | Bin 0 -> 83168 bytes
 process/stepA_mal.txt                     | 136 +++++++++
 ps/Makefile                               |   2 +-
 ps/stepA_interop.ps                       | 298 -------------------
 ps/stepA_mal.ps                           | 298 +++++++++++++++++++
 ps/tests/stepA_mal.mal                    |  23 ++
 python/Makefile                           |   2 +-
 python/stepA_interop.py                   | 177 -----------
 python/stepA_mal.py                       | 177 +++++++++++
 r/Makefile                                |   2 +-
 r/stepA_interop.r                         | 198 ------------
 r/stepA_mal.r                             | 198 ++++++++++++
 racket/Makefile                           |   2 +-
 racket/stepA_interop.rkt                  | 163 ----------
 racket/stepA_mal.rkt                      | 163 ++++++++++
 ruby/Makefile                             |   2 +-
 ruby/stepA_interop.rb                     | 184 ------------
 ruby/stepA_mal.rb                         | 184 ++++++++++++
 ruby/tests/stepA_interop.mal              |  27 --
 ruby/tests/stepA_mal.mal                  |  27 ++
 rust/Cargo.toml                           |   2 +-
 rust/Makefile                             |   4 +-
 rust/src/stepA_interop.rs                 | 479 ------------------------------
 rust/src/stepA_mal.rs                     | 479 ++++++++++++++++++++++++++++++
 scala/Makefile                            |   2 +-
 scala/stepA_interop.scala                 | 229 --------------
 scala/stepA_mal.scala                     | 229 ++++++++++++++
 vb/Makefile                               |   4 +-
 vb/stepA_interop.vb                       | 317 --------------------
 vb/stepA_mal.vb                           | 317 ++++++++++++++++++++
 113 files changed, 6816 insertions(+), 6794 deletions(-)
 delete mode 100755 bash/stepA_interop.sh
 create mode 100755 bash/stepA_mal.sh
 delete mode 100644 bash/tests/stepA_interop.mal
 create mode 100644 bash/tests/stepA_mal.mal
 delete mode 100644 c/stepA_interop.c
 create mode 100644 c/stepA_mal.c
 delete mode 100644 c/tests/stepA_interop.mal
 create mode 100644 c/tests/stepA_mal.mal
 delete mode 100644 clojure/src/stepA_interop.clj
 create mode 100644 clojure/src/stepA_mal.clj
 delete mode 100644 clojure/tests/stepA_interop.mal
 create mode 100644 clojure/tests/stepA_mal.mal
 delete mode 100644 coffee/stepA_interop.coffee
 create mode 100644 coffee/stepA_mal.coffee
 delete mode 100644 coffee/tests/stepA_interop.mal
 create mode 100644 coffee/tests/stepA_mal.mal
 delete mode 100644 cs/stepA_interop.cs
 create mode 100644 cs/stepA_mal.cs
 delete mode 100644 forth/stepA_interop.fs
 create mode 100644 forth/stepA_mal.fs
 delete mode 100644 forth/tests/stepA_interop.mal
 create mode 100644 forth/tests/stepA_mal.mal
 delete mode 100644 go/src/stepA_interop/stepA_interop.go
 create mode 100644 go/src/stepA_mal/stepA_mal.go
 delete mode 100644 haskell/stepA_interop.hs
 create mode 100644 haskell/stepA_mal.hs
 delete mode 100644 java/src/main/java/mal/stepA_interop.java
 create mode 100644 java/src/main/java/mal/stepA_mal.java
 delete mode 100644 js/stepA_interop.js
 create mode 100644 js/stepA_mal.js
 delete mode 100644 js/tests/stepA_interop.mal
 create mode 100644 js/tests/stepA_mal.mal
 delete mode 100755 lua/stepA_interop.lua
 create mode 100755 lua/stepA_mal.lua
 delete mode 100644 make/stepA_interop.mk
 create mode 100644 make/stepA_mal.mk
 delete mode 100644 make/tests/stepA_interop.mal
 create mode 100644 make/tests/stepA_mal.mal
 delete mode 100644 mal/stepA_interop.mal
 create mode 100644 mal/stepA_mal.mal
 delete mode 100644 matlab/stepA_interop.m
 create mode 100644 matlab/stepA_mal.m
 delete mode 100644 miniMAL/stepA_interop.json
 create mode 100644 miniMAL/stepA_mal.json
 delete mode 100644 ocaml/stepA_interop.ml
 create mode 100644 ocaml/stepA_mal.ml
 delete mode 100644 perl/stepA_interop.pl
 create mode 100644 perl/stepA_mal.pl
 delete mode 100644 perl/tests/stepA_interop.mal
 create mode 100644 perl/tests/stepA_mal.mal
 delete mode 100644 php/stepA_interop.php
 create mode 100644 php/stepA_mal.php
 delete mode 100644 php/tests/stepA_interop.mal
 create mode 100644 php/tests/stepA_mal.mal
 delete mode 100644 process/stepA_interop.gliffy
 delete mode 100644 process/stepA_interop.png
 delete mode 100644 process/stepA_interop.txt
 create mode 100644 process/stepA_mal.gliffy
 create mode 100644 process/stepA_mal.png
 create mode 100644 process/stepA_mal.txt
 delete mode 100644 ps/stepA_interop.ps
 create mode 100644 ps/stepA_mal.ps
 create mode 100644 ps/tests/stepA_mal.mal
 delete mode 100644 python/stepA_interop.py
 create mode 100644 python/stepA_mal.py
 delete mode 100644 r/stepA_interop.r
 create mode 100644 r/stepA_mal.r
 delete mode 100755 racket/stepA_interop.rkt
 create mode 100755 racket/stepA_mal.rkt
 delete mode 100644 ruby/stepA_interop.rb
 create mode 100644 ruby/stepA_mal.rb
 delete mode 100644 ruby/tests/stepA_interop.mal
 create mode 100644 ruby/tests/stepA_mal.mal
 delete mode 100644 rust/src/stepA_interop.rs
 create mode 100644 rust/src/stepA_mal.rs
 delete mode 100644 scala/stepA_interop.scala
 create mode 100644 scala/stepA_mal.scala
 delete mode 100644 vb/stepA_interop.vb
 create mode 100644 vb/stepA_mal.vb

diff --git a/.gitignore b/.gitignore
index 07d7921..2b05376 100644
--- a/.gitignore
+++ b/.gitignore
@@ -18,7 +18,7 @@ c/*.o
 */step7_quote
 */step8_macros
 */step9_try
-*/stepA_interop
+*/stepA_mal
 cs/*.exe
 cs/*.dll
 cs/*.mdb
diff --git a/Makefile b/Makefile
index e30a6f6..674ad71 100644
--- a/Makefile
+++ b/Makefile
@@ -24,7 +24,7 @@ step6 = step6_file
 step7 = step7_quote
 step8 = step8_macros
 step9 = step9_try
-stepA = stepA_interop
+stepA = stepA_mal
 
 EXCLUDE_TESTS += test^bash^step5 # no stack exhaustion or completion
 EXCLUDE_TESTS += test^c^step5    # segfault
diff --git a/README.md b/README.md
index 612743c..94fdc2b 100644
--- a/README.md
+++ b/README.md
@@ -51,7 +51,7 @@ The mal (make a lisp) steps are:
 * [step7_quote](process/guide.md#step7)
 * [step8_macros](process/guide.md#step8)
 * [step9_try](process/guide.md#step9)
-* [stepA_interop](process/guide.md#stepA)
+* [stepA_mal](process/guide.md#stepA)
 
 
 Mal was presented publicly for the first time in a lightning talk at
diff --git a/bash/Makefile b/bash/Makefile
index 5028788..dc1d1ad 100644
--- a/bash/Makefile
+++ b/bash/Makefile
@@ -1,5 +1,5 @@
 SOURCES_BASE = types.sh reader.sh printer.sh
-SOURCES_LISP = env.sh core.sh stepA_interop.sh
+SOURCES_LISP = env.sh core.sh stepA_mal.sh
 SOURCES = $(SOURCES_BASE) $(SOURCES_LISP)
 
 all: mal.sh
diff --git a/bash/stepA_interop.sh b/bash/stepA_interop.sh
deleted file mode 100755
index 7b43496..0000000
--- a/bash/stepA_interop.sh
+++ /dev/null
@@ -1,283 +0,0 @@
-#!/usr/bin/env bash
-
-source $(dirname $0)/reader.sh
-source $(dirname $0)/printer.sh
-source $(dirname $0)/env.sh
-source $(dirname $0)/core.sh
-
-# read
-READ () {
-    [ "${1}" ] && r="${1}" || READLINE
-    READ_STR "${r}"
-}
-
-# eval
-IS_PAIR () {
-    if _sequential? "${1}"; then
-        _count "${1}"
-        [[ "${r}" > 0 ]] && return 0
-    fi
-    return 1
-}
-
-QUASIQUOTE () {
-    if ! IS_PAIR "${1}"; then
-        _symbol quote
-        _list "${r}" "${1}"
-        return
-    else
-        _nth "${1}" 0; local a0="${r}"
-        if [[ "${ANON["${a0}"]}" == "unquote" ]]; then
-            _nth "${1}" 1
-            return
-        elif IS_PAIR "${a0}"; then
-            _nth "${a0}" 0; local a00="${r}"
-            if [[ "${ANON["${a00}"]}" == "splice-unquote" ]]; then
-                _symbol concat; local a="${r}"
-                _nth "${a0}" 1; local b="${r}"
-                _rest "${1}"
-                QUASIQUOTE "${r}"; local c="${r}"
-                _list "${a}" "${b}" "${c}"
-                return
-            fi
-        fi
-    fi
-    _symbol cons; local a="${r}"
-    QUASIQUOTE "${a0}"; local b="${r}"
-    _rest "${1}"
-    QUASIQUOTE "${r}"; local c="${r}"
-    _list "${a}" "${b}" "${c}"
-    return
-}
-
-IS_MACRO_CALL () {
-    if ! _list? "${1}"; then return 1; fi
-    _nth "${1}" 0; local a0="${r}"
-    if _symbol? "${a0}"; then
-        ENV_FIND "${2}" "${a0}"
-        if [[ "${r}" ]]; then
-            ENV_GET "${2}" "${a0}"
-            [ "${ANON["${r}_ismacro_"]}" ]
-            return $?
-        fi
-    fi
-    return 1
-}
-
-MACROEXPAND () {
-    local ast="${1}" env="${2}"
-    while IS_MACRO_CALL "${ast}" "${env}"; do
-        _nth "${ast}" 0; local a0="${r}"
-        ENV_GET "${env}" "${a0}"; local mac="${ANON["${r}"]}"
-        _rest "${ast}"
-        ${mac%%@*} ${ANON["${r}"]}
-        ast="${r}"
-    done
-    r="${ast}"
-}
-
-
-EVAL_AST () {
-    local ast="${1}" env="${2}"
-    #_pr_str "${ast}"; echo "EVAL_AST '${ast}:${r} / ${env}'"
-    _obj_type "${ast}"; local ot="${r}"
-    case "${ot}" in
-    symbol)
-        ENV_GET "${env}" "${ast}"
-        return ;;
-    list)
-        _map_with_type _list EVAL "${ast}" "${env}" ;;
-    vector)
-        _map_with_type _vector EVAL "${ast}" "${env}" ;;
-    hash_map)
-        local res="" val="" hm="${ANON["${ast}"]}"
-        _hash_map; local new_hm="${r}"
-        eval local keys="\${!${hm}[@]}"
-        for key in ${keys}; do
-            eval val="\${${hm}[\"${key}\"]}"
-            EVAL "${val}" "${env}"
-            _assoc! "${new_hm}" "${key}" "${r}"
-        done
-        r="${new_hm}" ;;
-    *)
-        r="${ast}" ;;
-    esac
-}
-
-EVAL () {
-    local ast="${1}" env="${2}"
-    while true; do
-    r=
-    [[ "${__ERROR}" ]] && return 1
-    #_pr_str "${ast}"; echo "EVAL '${r} / ${env}'"
-    if ! _list? "${ast}"; then
-        EVAL_AST "${ast}" "${env}"
-        return
-    fi
-
-    # apply list
-    MACROEXPAND "${ast}" "${env}"
-    ast="${r}"
-    if ! _list? "${ast}"; then return; fi
-    _nth "${ast}" 0; local a0="${r}"
-    _nth "${ast}" 1; local a1="${r}"
-    _nth "${ast}" 2; local a2="${r}"
-    case "${ANON["${a0}"]}" in
-        def!) EVAL "${a2}" "${env}"
-              [[ "${__ERROR}" ]] && return 1
-              ENV_SET "${env}" "${a1}" "${r}"
-              return ;;
-        let*) ENV "${env}"; local let_env="${r}"
-              local let_pairs=(${ANON["${a1}"]})
-              local idx=0
-              #echo "let: [${let_pairs[*]}] for ${a2}"
-              while [[ "${let_pairs["${idx}"]}" ]]; do
-                  EVAL "${let_pairs[$(( idx + 1))]}" "${let_env}"
-                  ENV_SET "${let_env}" "${let_pairs[${idx}]}" "${r}"
-                  idx=$(( idx + 2))
-              done
-              ast="${a2}"
-              env="${let_env}"
-              # Continue loop
-              ;;
-        quote)
-              r="${a1}"
-              return ;;
-        quasiquote)
-              QUASIQUOTE "${a1}"
-              ast="${r}"
-              # Continue loop
-              ;;
-        defmacro!)
-              EVAL "${a2}" "${env}"
-              [[ "${__ERROR}" ]] && return 1
-              ANON["${r}_ismacro_"]="yes"
-              ENV_SET "${env}" "${a1}" "${r}"
-              return ;;
-        macroexpand)
-              MACROEXPAND "${a1}" "${env}"
-              return ;;
-        sh*)  EVAL "${a1}" "${env}"
-              local output=""
-              local line=""
-              while read line; do
-                  output="${output}${line}\n"
-              done < <(eval ${ANON["${r}"]})
-              _string "${output%\\n}"
-              return ;;
-        try*) EVAL "${a1}" "${env}"
-              [[ -z "${__ERROR}" ]] && return
-              _nth "${a2}" 0; local a20="${r}"
-              if [ "${ANON["${a20}"]}" == "catch__STAR__" ]; then
-                  _nth "${a2}" 1; local a21="${r}"
-                  _nth "${a2}" 2; local a22="${r}"
-                  _list "${a21}"; local binds="${r}"
-                  ENV "${env}" "${binds}" "${__ERROR}"
-                  local try_env="${r}"
-                  __ERROR=
-                  EVAL "${a22}" "${try_env}"
-              fi  # if no catch* clause, just propagate __ERROR
-              return ;;
-        do)   _count "${ast}"
-              _slice "${ast}" 1 $(( ${r} - 2 ))
-              EVAL_AST "${r}" "${env}"
-              [[ "${__ERROR}" ]] && r= && return 1
-              _last "${ast}"
-              ast="${r}"
-              # Continue loop
-              ;;
-        if)   EVAL "${a1}" "${env}"
-              [[ "${__ERROR}" ]] && return 1
-              if [[ "${r}" == "${__false}" || "${r}" == "${__nil}" ]]; then
-                  # eval false form
-                  _nth "${ast}" 3; local a3="${r}"
-                  if [[ "${a3}" ]]; then
-                      ast="${a3}"
-                  else
-                      r="${__nil}"
-                      return
-                  fi
-              else
-                  # eval true condition
-                  ast="${a2}"
-              fi
-              # Continue loop
-              ;;
-        fn*)  _function "ENV \"${env}\" \"${a1}\" \"\${@}\"; \
-                         EVAL \"${a2}\" \"\${r}\"" \
-                        "${a2}" "${env}" "${a1}"
-              return ;;
-        *)    EVAL_AST "${ast}" "${env}"
-              [[ "${__ERROR}" ]] && r= && return 1
-              local el="${r}"
-              _first "${el}"; local f="${ANON["${r}"]}"
-              _rest "${el}"; local args="${ANON["${r}"]}"
-              #echo "invoke: [${f}] ${args}"
-              if [[ "${f//@/ }" != "${f}" ]]; then
-                  set -- ${f//@/ }
-                  ast="${2}"
-                  ENV "${3}" "${4}" ${args}
-                  env="${r}"
-              else
-                  eval ${f%%@*} ${args}
-                  return
-              fi
-              # Continue loop
-              ;;
-    esac
-    done
-}
-
-# print
-PRINT () {
-    if [[ "${__ERROR}" ]]; then
-        _pr_str "${__ERROR}" yes
-        r="Error: ${r}"
-        __ERROR=
-    else
-        _pr_str "${1}" yes
-    fi
-}
-
-# repl
-ENV; REPL_ENV="${r}"
-REP () {
-    r=
-    READ "${1}"
-    EVAL "${r}" "${REPL_ENV}"
-    PRINT "${r}"
-}
-
-# core.sh: defined using bash
-_fref () {
-    _symbol "${1}"; local sym="${r}"
-    _function "${2} \"\${@}\""
-    ENV_SET "${REPL_ENV}" "${sym}" "${r}"
-}
-for n in "${!core_ns[@]}"; do _fref "${n}" "${core_ns["${n}"]}"; done
-_eval () { EVAL "${1}" "${REPL_ENV}"; }
-_fref "eval" _eval
-_list; argv="${r}"
-for _arg in "${@:2}"; do _string "${_arg}"; _conj! "${argv}" "${r}"; done
-_symbol "__STAR__ARGV__STAR__"
-ENV_SET "${REPL_ENV}" "${r}" "${argv}";
-
-# core.mal: defined using the language itself
-REP "(def! *host-language* \"bash\")"
-REP "(def! not (fn* (a) (if a false true)))"
-REP "(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))"
-REP "(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))"
-REP "(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) \`(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))"
-
-# load/run file from command line (then exit)
-if [[ "${1}" ]]; then
-    REP "(load-file \"${1}\")"
-    exit 0
-fi 
-
-# repl loop
-REP "(println (str \"Mal [\" *host-language* \"]\"))"
-while true; do
-    READLINE "user> " || exit "$?"
-    [[ "${r}" ]] && REP "${r}" && echo "${r}"
-done
diff --git a/bash/stepA_mal.sh b/bash/stepA_mal.sh
new file mode 100755
index 0000000..7b43496
--- /dev/null
+++ b/bash/stepA_mal.sh
@@ -0,0 +1,283 @@
+#!/usr/bin/env bash
+
+source $(dirname $0)/reader.sh
+source $(dirname $0)/printer.sh
+source $(dirname $0)/env.sh
+source $(dirname $0)/core.sh
+
+# read
+READ () {
+    [ "${1}" ] && r="${1}" || READLINE
+    READ_STR "${r}"
+}
+
+# eval
+IS_PAIR () {
+    if _sequential? "${1}"; then
+        _count "${1}"
+        [[ "${r}" > 0 ]] && return 0
+    fi
+    return 1
+}
+
+QUASIQUOTE () {
+    if ! IS_PAIR "${1}"; then
+        _symbol quote
+        _list "${r}" "${1}"
+        return
+    else
+        _nth "${1}" 0; local a0="${r}"
+        if [[ "${ANON["${a0}"]}" == "unquote" ]]; then
+            _nth "${1}" 1
+            return
+        elif IS_PAIR "${a0}"; then
+            _nth "${a0}" 0; local a00="${r}"
+            if [[ "${ANON["${a00}"]}" == "splice-unquote" ]]; then
+                _symbol concat; local a="${r}"
+                _nth "${a0}" 1; local b="${r}"
+                _rest "${1}"
+                QUASIQUOTE "${r}"; local c="${r}"
+                _list "${a}" "${b}" "${c}"
+                return
+            fi
+        fi
+    fi
+    _symbol cons; local a="${r}"
+    QUASIQUOTE "${a0}"; local b="${r}"
+    _rest "${1}"
+    QUASIQUOTE "${r}"; local c="${r}"
+    _list "${a}" "${b}" "${c}"
+    return
+}
+
+IS_MACRO_CALL () {
+    if ! _list? "${1}"; then return 1; fi
+    _nth "${1}" 0; local a0="${r}"
+    if _symbol? "${a0}"; then
+        ENV_FIND "${2}" "${a0}"
+        if [[ "${r}" ]]; then
+            ENV_GET "${2}" "${a0}"
+            [ "${ANON["${r}_ismacro_"]}" ]
+            return $?
+        fi
+    fi
+    return 1
+}
+
+MACROEXPAND () {
+    local ast="${1}" env="${2}"
+    while IS_MACRO_CALL "${ast}" "${env}"; do
+        _nth "${ast}" 0; local a0="${r}"
+        ENV_GET "${env}" "${a0}"; local mac="${ANON["${r}"]}"
+        _rest "${ast}"
+        ${mac%%@*} ${ANON["${r}"]}
+        ast="${r}"
+    done
+    r="${ast}"
+}
+
+
+EVAL_AST () {
+    local ast="${1}" env="${2}"
+    #_pr_str "${ast}"; echo "EVAL_AST '${ast}:${r} / ${env}'"
+    _obj_type "${ast}"; local ot="${r}"
+    case "${ot}" in
+    symbol)
+        ENV_GET "${env}" "${ast}"
+        return ;;
+    list)
+        _map_with_type _list EVAL "${ast}" "${env}" ;;
+    vector)
+        _map_with_type _vector EVAL "${ast}" "${env}" ;;
+    hash_map)
+        local res="" val="" hm="${ANON["${ast}"]}"
+        _hash_map; local new_hm="${r}"
+        eval local keys="\${!${hm}[@]}"
+        for key in ${keys}; do
+            eval val="\${${hm}[\"${key}\"]}"
+            EVAL "${val}" "${env}"
+            _assoc! "${new_hm}" "${key}" "${r}"
+        done
+        r="${new_hm}" ;;
+    *)
+        r="${ast}" ;;
+    esac
+}
+
+EVAL () {
+    local ast="${1}" env="${2}"
+    while true; do
+    r=
+    [[ "${__ERROR}" ]] && return 1
+    #_pr_str "${ast}"; echo "EVAL '${r} / ${env}'"
+    if ! _list? "${ast}"; then
+        EVAL_AST "${ast}" "${env}"
+        return
+    fi
+
+    # apply list
+    MACROEXPAND "${ast}" "${env}"
+    ast="${r}"
+    if ! _list? "${ast}"; then return; fi
+    _nth "${ast}" 0; local a0="${r}"
+    _nth "${ast}" 1; local a1="${r}"
+    _nth "${ast}" 2; local a2="${r}"
+    case "${ANON["${a0}"]}" in
+        def!) EVAL "${a2}" "${env}"
+              [[ "${__ERROR}" ]] && return 1
+              ENV_SET "${env}" "${a1}" "${r}"
+              return ;;
+        let*) ENV "${env}"; local let_env="${r}"
+              local let_pairs=(${ANON["${a1}"]})
+              local idx=0
+              #echo "let: [${let_pairs[*]}] for ${a2}"
+              while [[ "${let_pairs["${idx}"]}" ]]; do
+                  EVAL "${let_pairs[$(( idx + 1))]}" "${let_env}"
+                  ENV_SET "${let_env}" "${let_pairs[${idx}]}" "${r}"
+                  idx=$(( idx + 2))
+              done
+              ast="${a2}"
+              env="${let_env}"
+              # Continue loop
+              ;;
+        quote)
+              r="${a1}"
+              return ;;
+        quasiquote)
+              QUASIQUOTE "${a1}"
+              ast="${r}"
+              # Continue loop
+              ;;
+        defmacro!)
+              EVAL "${a2}" "${env}"
+              [[ "${__ERROR}" ]] && return 1
+              ANON["${r}_ismacro_"]="yes"
+              ENV_SET "${env}" "${a1}" "${r}"
+              return ;;
+        macroexpand)
+              MACROEXPAND "${a1}" "${env}"
+              return ;;
+        sh*)  EVAL "${a1}" "${env}"
+              local output=""
+              local line=""
+              while read line; do
+                  output="${output}${line}\n"
+              done < <(eval ${ANON["${r}"]})
+              _string "${output%\\n}"
+              return ;;
+        try*) EVAL "${a1}" "${env}"
+              [[ -z "${__ERROR}" ]] && return
+              _nth "${a2}" 0; local a20="${r}"
+              if [ "${ANON["${a20}"]}" == "catch__STAR__" ]; then
+                  _nth "${a2}" 1; local a21="${r}"
+                  _nth "${a2}" 2; local a22="${r}"
+                  _list "${a21}"; local binds="${r}"
+                  ENV "${env}" "${binds}" "${__ERROR}"
+                  local try_env="${r}"
+                  __ERROR=
+                  EVAL "${a22}" "${try_env}"
+              fi  # if no catch* clause, just propagate __ERROR
+              return ;;
+        do)   _count "${ast}"
+              _slice "${ast}" 1 $(( ${r} - 2 ))
+              EVAL_AST "${r}" "${env}"
+              [[ "${__ERROR}" ]] && r= && return 1
+              _last "${ast}"
+              ast="${r}"
+              # Continue loop
+              ;;
+        if)   EVAL "${a1}" "${env}"
+              [[ "${__ERROR}" ]] && return 1
+              if [[ "${r}" == "${__false}" || "${r}" == "${__nil}" ]]; then
+                  # eval false form
+                  _nth "${ast}" 3; local a3="${r}"
+                  if [[ "${a3}" ]]; then
+                      ast="${a3}"
+                  else
+                      r="${__nil}"
+                      return
+                  fi
+              else
+                  # eval true condition
+                  ast="${a2}"
+              fi
+              # Continue loop
+              ;;
+        fn*)  _function "ENV \"${env}\" \"${a1}\" \"\${@}\"; \
+                         EVAL \"${a2}\" \"\${r}\"" \
+                        "${a2}" "${env}" "${a1}"
+              return ;;
+        *)    EVAL_AST "${ast}" "${env}"
+              [[ "${__ERROR}" ]] && r= && return 1
+              local el="${r}"
+              _first "${el}"; local f="${ANON["${r}"]}"
+              _rest "${el}"; local args="${ANON["${r}"]}"
+              #echo "invoke: [${f}] ${args}"
+              if [[ "${f//@/ }" != "${f}" ]]; then
+                  set -- ${f//@/ }
+                  ast="${2}"
+                  ENV "${3}" "${4}" ${args}
+                  env="${r}"
+              else
+                  eval ${f%%@*} ${args}
+                  return
+              fi
+              # Continue loop
+              ;;
+    esac
+    done
+}
+
+# print
+PRINT () {
+    if [[ "${__ERROR}" ]]; then
+        _pr_str "${__ERROR}" yes
+        r="Error: ${r}"
+        __ERROR=
+    else
+        _pr_str "${1}" yes
+    fi
+}
+
+# repl
+ENV; REPL_ENV="${r}"
+REP () {
+    r=
+    READ "${1}"
+    EVAL "${r}" "${REPL_ENV}"
+    PRINT "${r}"
+}
+
+# core.sh: defined using bash
+_fref () {
+    _symbol "${1}"; local sym="${r}"
+    _function "${2} \"\${@}\""
+    ENV_SET "${REPL_ENV}" "${sym}" "${r}"
+}
+for n in "${!core_ns[@]}"; do _fref "${n}" "${core_ns["${n}"]}"; done
+_eval () { EVAL "${1}" "${REPL_ENV}"; }
+_fref "eval" _eval
+_list; argv="${r}"
+for _arg in "${@:2}"; do _string "${_arg}"; _conj! "${argv}" "${r}"; done
+_symbol "__STAR__ARGV__STAR__"
+ENV_SET "${REPL_ENV}" "${r}" "${argv}";
+
+# core.mal: defined using the language itself
+REP "(def! *host-language* \"bash\")"
+REP "(def! not (fn* (a) (if a false true)))"
+REP "(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))"
+REP "(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))"
+REP "(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) \`(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))"
+
+# load/run file from command line (then exit)
+if [[ "${1}" ]]; then
+    REP "(load-file \"${1}\")"
+    exit 0
+fi 
+
+# repl loop
+REP "(println (str \"Mal [\" *host-language* \"]\"))"
+while true; do
+    READLINE "user> " || exit "$?"
+    [[ "${r}" ]] && REP "${r}" && echo "${r}"
+done
diff --git a/bash/tests/stepA_interop.mal b/bash/tests/stepA_interop.mal
deleted file mode 100644
index bf3eabd..0000000
--- a/bash/tests/stepA_interop.mal
+++ /dev/null
@@ -1,17 +0,0 @@
-;; Testing basic bash interop
-
-(sh* "echo 7")
-;=>"7"
-
-(sh* "echo >&2 hello")
-; hello
-;=>""
-
-(sh* "foo=8; echo ${foo}")
-;=>"8"
-
-(sh* "for x in a b c; do echo -n \"X${x}Y \"; done; echo")
-;=>"XaY XbY XcY"
-
-(sh* "for x in 1 2 3; do echo -n \"$((1+$x)) \"; done; echo")
-;=>"2 3 4"
diff --git a/bash/tests/stepA_mal.mal b/bash/tests/stepA_mal.mal
new file mode 100644
index 0000000..bf3eabd
--- /dev/null
+++ b/bash/tests/stepA_mal.mal
@@ -0,0 +1,17 @@
+;; Testing basic bash interop
+
+(sh* "echo 7")
+;=>"7"
+
+(sh* "echo >&2 hello")
+; hello
+;=>""
+
+(sh* "foo=8; echo ${foo}")
+;=>"8"
+
+(sh* "for x in a b c; do echo -n \"X${x}Y \"; done; echo")
+;=>"XaY XbY XcY"
+
+(sh* "for x in 1 2 3; do echo -n \"$((1+$x)) \"; done; echo")
+;=>"2 3 4"
diff --git a/c/Makefile b/c/Makefile
index 81b384c..e51e04b 100644
--- a/c/Makefile
+++ b/c/Makefile
@@ -9,7 +9,7 @@ TESTS =
 SOURCES_BASE = readline.h readline.c types.h types.c \
                reader.h reader.c printer.h printer.c \
                interop.h interop.c
-SOURCES_LISP = env.c core.h core.c stepA_interop.c
+SOURCES_LISP = env.c core.h core.c stepA_mal.c
 SOURCES = $(SOURCES_BASE) $(SOURCES_LISP)
 
 
@@ -17,7 +17,7 @@ SOURCES = $(SOURCES_BASE) $(SOURCES_LISP)
 
 SRCS = step0_repl.c step1_read_print.c step2_eval.c step3_env.c \
        step4_if_fn_do.c step5_tco.c step6_file.c step7_quote.c \
-       step8_macros.c step9_try.c stepA_interop.c
+       step8_macros.c step9_try.c stepA_mal.c
 OBJS = $(SRCS:%.c=%.o)
 BINS = $(OBJS:%.o=%)
 OTHER_OBJS = types.o readline.o reader.o printer.o env.o core.o interop.o
diff --git a/c/stepA_interop.c b/c/stepA_interop.c
deleted file mode 100644
index 05e9f65..0000000
--- a/c/stepA_interop.c
+++ /dev/null
@@ -1,356 +0,0 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include <unistd.h>
-
-#include "types.h"
-#include "readline.h"
-#include "reader.h"
-#include "core.h"
-#include "interop.h"
-
-// Declarations
-MalVal *EVAL(MalVal *ast, Env *env);
-MalVal *macroexpand(MalVal *ast, Env *env);
-
-// read
-MalVal *READ(char prompt[], char *str) {
-    char *line;
-    MalVal *ast;
-    if (str) {
-        line = str;
-    } else {
-        line = _readline(prompt);
-        if (!line) {
-            _error("EOF");
-            return NULL;
-        }
-    }
-    ast = read_str(line);
-    if (!str) { free(line); }
-    return ast;
-}
-
-// eval
-int is_pair(MalVal *x) {
-    return _sequential_Q(x) && (_count(x) > 0);
-}
-
-MalVal *quasiquote(MalVal *ast) {
-    if (!is_pair(ast)) {
-        return _listX(2, malval_new_symbol("quote"), ast);
-    } else {
-        MalVal *a0 = _nth(ast, 0);
-        if ((a0->type & MAL_SYMBOL) &&
-            strcmp("unquote", a0->val.string) == 0) {
-            return _nth(ast, 1);
-        } else if (is_pair(a0)) {
-            MalVal *a00 = _nth(a0, 0);
-            if ((a00->type & MAL_SYMBOL) &&
-                strcmp("splice-unquote", a00->val.string) == 0) {
-                return _listX(3, malval_new_symbol("concat"),
-                                 _nth(a0, 1),
-                                 quasiquote(_rest(ast)));
-            }
-        }
-        return _listX(3, malval_new_symbol("cons"),
-                         quasiquote(a0),
-                         quasiquote(_rest(ast)));
-    }
-}
-
-int is_macro_call(MalVal *ast, Env *env) {
-    if (!ast || ast->type != MAL_LIST) { return 0; }
-    MalVal *a0 = _nth(ast, 0);
-    return (a0->type & MAL_SYMBOL) &&
-            env_find(env, a0) &&
-            env_get(env, a0)->ismacro;
-}
-    
-MalVal *macroexpand(MalVal *ast, Env *env) {
-    if (!ast || mal_error) return NULL;
-    while (is_macro_call(ast, env)) {
-        MalVal *a0 = _nth(ast, 0);
-        MalVal *mac = env_get(env, a0);
-        // TODO: this is weird and limits it to 20. FIXME
-        ast = _apply(mac, _rest(ast));
-    }
-    return ast;
-}
-
-MalVal *eval_ast(MalVal *ast, Env *env) {
-    if (!ast || mal_error) return NULL;
-    if (ast->type == MAL_SYMBOL) {
-        //g_print("EVAL symbol: %s\n", ast->val.string);
-        return env_get(env, ast);
-    } else if ((ast->type == MAL_LIST) || (ast->type == MAL_VECTOR)) {
-        //g_print("EVAL sequential: %s\n", _pr_str(ast,1));
-        MalVal *el = _map2((MalVal *(*)(void*, void*))EVAL, ast, env);
-        if (!el || mal_error) return NULL;
-        el->type = ast->type;
-        return el;
-    } else if (ast->type == MAL_HASH_MAP) {
-        //g_print("EVAL hash_map: %s\n", _pr_str(ast,1));
-        GHashTableIter iter;
-        gpointer key, value;
-        MalVal *seq = malval_new_list(MAL_LIST,
-                                    g_array_sized_new(TRUE, TRUE, sizeof(MalVal*),
-                                                        _count(ast)));
-        g_hash_table_iter_init (&iter, ast->val.hash_table);
-        while (g_hash_table_iter_next (&iter, &key, &value)) {
-            MalVal *kname = malval_new_string((char *)key);
-            g_array_append_val(seq->val.array, kname);
-            MalVal *new_val = EVAL((MalVal *)value, env);
-            g_array_append_val(seq->val.array, new_val);
-        }
-        return _hash_map(seq);
-    } else {
-        //g_print("EVAL scalar: %s\n", _pr_str(ast,1));
-        return ast;
-    }
-}
-
-MalVal *EVAL(MalVal *ast, Env *env) {
-    while (TRUE) {
-
-    if (!ast || mal_error) return NULL;
-    //g_print("EVAL: %s\n", _pr_str(ast,1));
-    if (ast->type != MAL_LIST) {
-        return eval_ast(ast, env);
-    }
-    if (!ast || mal_error) return NULL;
-
-    // apply list
-    //g_print("EVAL apply list: %s\n", _pr_str(ast,1));
-    ast = macroexpand(ast, env);
-    if (!ast || mal_error) return NULL;
-    if (ast->type != MAL_LIST) { return ast; }
-    if (_count(ast) == 0) { return ast; }
-
-    int i, len;
-    MalVal *a0 = _nth(ast, 0);
-    if ((a0->type & MAL_SYMBOL) &&
-        strcmp("def!", a0->val.string) == 0) {
-        //g_print("eval apply def!\n");
-        MalVal *a1 = _nth(ast, 1),
-               *a2 = _nth(ast, 2);
-        MalVal *res = EVAL(a2, env);
-        if (mal_error) return NULL;
-        env_set(env, a1, res);
-        return res;
-    } else if ((a0->type & MAL_SYMBOL) &&
-               strcmp("let*", a0->val.string) == 0) {
-        //g_print("eval apply let*\n");
-        MalVal *a1 = _nth(ast, 1),
-               *a2 = _nth(ast, 2),
-               *key, *val;
-        assert_type(a1, MAL_LIST|MAL_VECTOR,
-                    "let* bindings must be list or vector");
-        len = _count(a1);
-        assert((len % 2) == 0, "odd number of let* bindings forms");
-        Env *let_env = new_env(env, NULL, NULL);
-        for(i=0; i<len; i+=2) {
-            key = g_array_index(a1->val.array, MalVal*, i);
-            val = g_array_index(a1->val.array, MalVal*, i+1);
-            assert_type(key, MAL_SYMBOL, "let* bind to non-symbol");
-            env_set(let_env, key, EVAL(val, let_env));
-        }
-        ast = a2;
-        env = let_env;
-        // Continue loop
-    } else if ((a0->type & MAL_SYMBOL) &&
-               strcmp("quote", a0->val.string) == 0) {
-        //g_print("eval apply quote\n");
-        return _nth(ast, 1);
-    } else if ((a0->type & MAL_SYMBOL) &&
-               strcmp("quasiquote", a0->val.string) == 0) {
-        //g_print("eval apply quasiquote\n");
-        MalVal *a1 = _nth(ast, 1);
-        ast = quasiquote(a1);
-        // Continue loop
-    } else if ((a0->type & MAL_SYMBOL) &&
-               strcmp("defmacro!", a0->val.string) == 0) {
-        //g_print("eval apply defmacro!\n");
-        MalVal *a1 = _nth(ast, 1),
-               *a2 = _nth(ast, 2);
-        MalVal *res = EVAL(a2, env);
-        if (mal_error) return NULL;
-        res->ismacro = TRUE;
-        env_set(env, a1, res);
-        return res;
-    } else if ((a0->type & MAL_SYMBOL) &&
-               strcmp("macroexpand", a0->val.string) == 0) {
-        //g_print("eval apply macroexpand\n");
-        MalVal *a1 = _nth(ast, 1);
-        return macroexpand(a1, env);
-    } else if ((a0->type & MAL_SYMBOL) &&
-               strcmp(".", a0->val.string) == 0) {
-        //g_print("eval apply .\n");
-        MalVal *el = eval_ast(_slice(ast, 1, _count(ast)), env);
-        return invoke_native(el);
-    } else if ((a0->type & MAL_SYMBOL) &&
-               strcmp("try*", a0->val.string) == 0) {
-        //g_print("eval apply try*\n");
-        MalVal *a1 = _nth(ast, 1);
-        MalVal *a2 = _nth(ast, 2);
-        MalVal *res = EVAL(a1, env);
-        if (!mal_error) { return res; }
-        MalVal *a20 = _nth(a2, 0);
-        if (strcmp("catch*", a20->val.string) == 0) {
-            MalVal *a21 = _nth(a2, 1);
-            MalVal *a22 = _nth(a2, 2);
-            Env *catch_env = new_env(env,
-                                     _listX(1, a21),
-                                     _listX(1, mal_error));
-            //malval_free(mal_error);
-            mal_error = NULL;
-            res = EVAL(a22, catch_env);
-            return res;
-        } else {
-            return &mal_nil;
-        }
-    } else if ((a0->type & MAL_SYMBOL) &&
-               strcmp("do", a0->val.string) == 0) {
-        //g_print("eval apply do\n");
-        eval_ast(_slice(ast, 1, _count(ast)-1), env);
-        ast = _last(ast);
-        // Continue loop
-    } else if ((a0->type & MAL_SYMBOL) &&
-               strcmp("if", a0->val.string) == 0) {
-        //g_print("eval apply if\n");
-        MalVal *a1 = _nth(ast, 1);
-        MalVal *cond = EVAL(a1, env);
-        if (!cond || mal_error) return NULL;
-        if (cond->type & (MAL_FALSE|MAL_NIL)) {
-            // eval false slot form
-            if (ast->val.array->len > 3) {
-                ast = _nth(ast, 3);
-            } else {
-                return &mal_nil;
-            }
-        } else {
-            // eval true slot form
-            ast = _nth(ast, 2);
-        }
-        // Continue loop
-    } else if ((a0->type & MAL_SYMBOL) &&
-               strcmp("fn*", a0->val.string) == 0) {
-        //g_print("eval apply fn*\n");
-        MalVal *mf = malval_new(MAL_FUNCTION_MAL, NULL);
-        mf->ismacro = FALSE;
-        mf->val.func.evaluator = EVAL;
-        mf->val.func.args = _nth(ast, 1);
-        mf->val.func.body = _nth(ast, 2);
-        mf->val.func.env = env;
-        return mf;
-    } else {
-        //g_print("eval apply\n");
-        MalVal *el = eval_ast(ast, env);
-        if (!el || mal_error) { return NULL; }
-        MalVal *f = _first(el),
-               *args = _rest(el);
-        assert_type(f, MAL_FUNCTION_C|MAL_FUNCTION_MAL,
-                    "cannot apply '%s'", _pr_str(f,1));
-        if (f->type & MAL_FUNCTION_MAL) {
-            ast = f->val.func.body;
-            env = new_env(f->val.func.env, f->val.func.args, args);
-            // Continue loop
-        } else {
-            return _apply(f, args);
-        }
-    }
-
-    } // TCO while loop
-}
-
-// print
-char *PRINT(MalVal *exp) {
-    if (mal_error) {
-        fprintf(stderr, "Error: %s\n", mal_error->val.string);
-        malval_free(mal_error);
-        mal_error = NULL;
-        return NULL;
-    }
-    return _pr_str(exp,1);
-}
-
-// repl
-
-// read and eval
-MalVal *RE(Env *env, char *prompt, char *str) {
-    MalVal *ast, *exp;
-    ast = READ(prompt, str);
-    if (!ast || mal_error) return NULL;
-    exp = EVAL(ast, env);
-    if (ast != exp) {
-        malval_free(ast);    // Free input structure
-    }
-    return exp;
-}
-
-// Setup the initial REPL environment
-Env *repl_env;
-
-void init_repl_env(int argc, char *argv[]) {
-    repl_env = new_env(NULL, NULL, NULL);
-
-    // core.c: defined using C
-    int i;
-    for(i=0; i < (sizeof(core_ns) / sizeof(core_ns[0])); i++) {
-        env_set(repl_env,
-                malval_new_symbol(core_ns[i].name),
-                malval_new_function(core_ns[i].func, core_ns[i].arg_cnt));
-    }
-    MalVal *do_eval(MalVal *ast) { return EVAL(ast, repl_env); }
-    env_set(repl_env,
-            malval_new_symbol("eval"),
-            malval_new_function((void*(*)(void *))do_eval, 1));
-
-    MalVal *_argv = _listX(0);
-    for (i=2; i < argc; i++) {
-        MalVal *arg = malval_new_string(argv[i]);
-        g_array_append_val(_argv->val.array, arg);
-    }
-    env_set(repl_env, malval_new_symbol("*ARGV*"), _argv);
-
-    // core.mal: defined using the language itself
-    RE(repl_env, "", "(def! *host-language* \"c\")");
-    RE(repl_env, "", "(def! not (fn* (a) (if a false true)))");
-    RE(repl_env, "",
-       "(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))");
-    RE(repl_env, "", "(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))");
-    RE(repl_env, "", "(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))");
-}
-
-int main(int argc, char *argv[])
-{
-    MalVal *exp;
-    char *output;
-    char prompt[100];
-
-    // Set the initial prompt and environment
-    snprintf(prompt, sizeof(prompt), "user> ");
-    init_repl_env(argc, argv);
- 
-    if (argc > 1) {
-        char *cmd = g_strdup_printf("(load-file \"%s\")", argv[1]);
-        RE(repl_env, "", cmd);
-        return 0;
-    }
-
-    // repl loop
-    RE(repl_env, "", "(println (str \"Mal [\" *host-language* \"]\"))");
-    for(;;) {
-        exp = RE(repl_env, prompt, NULL);
-        if (mal_error && strcmp("EOF", mal_error->val.string) == 0) {
-            return 0;
-        }
-        output = PRINT(exp);
-
-        if (output) { 
-            g_print("%s\n", output);
-            free(output);        // Free output string
-        }
-
-        //malval_free(exp);    // Free evaluated expression
-    }
-}
diff --git a/c/stepA_mal.c b/c/stepA_mal.c
new file mode 100644
index 0000000..05e9f65
--- /dev/null
+++ b/c/stepA_mal.c
@@ -0,0 +1,356 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#include "types.h"
+#include "readline.h"
+#include "reader.h"
+#include "core.h"
+#include "interop.h"
+
+// Declarations
+MalVal *EVAL(MalVal *ast, Env *env);
+MalVal *macroexpand(MalVal *ast, Env *env);
+
+// read
+MalVal *READ(char prompt[], char *str) {
+    char *line;
+    MalVal *ast;
+    if (str) {
+        line = str;
+    } else {
+        line = _readline(prompt);
+        if (!line) {
+            _error("EOF");
+            return NULL;
+        }
+    }
+    ast = read_str(line);
+    if (!str) { free(line); }
+    return ast;
+}
+
+// eval
+int is_pair(MalVal *x) {
+    return _sequential_Q(x) && (_count(x) > 0);
+}
+
+MalVal *quasiquote(MalVal *ast) {
+    if (!is_pair(ast)) {
+        return _listX(2, malval_new_symbol("quote"), ast);
+    } else {
+        MalVal *a0 = _nth(ast, 0);
+        if ((a0->type & MAL_SYMBOL) &&
+            strcmp("unquote", a0->val.string) == 0) {
+            return _nth(ast, 1);
+        } else if (is_pair(a0)) {
+            MalVal *a00 = _nth(a0, 0);
+            if ((a00->type & MAL_SYMBOL) &&
+                strcmp("splice-unquote", a00->val.string) == 0) {
+                return _listX(3, malval_new_symbol("concat"),
+                                 _nth(a0, 1),
+                                 quasiquote(_rest(ast)));
+            }
+        }
+        return _listX(3, malval_new_symbol("cons"),
+                         quasiquote(a0),
+                         quasiquote(_rest(ast)));
+    }
+}
+
+int is_macro_call(MalVal *ast, Env *env) {
+    if (!ast || ast->type != MAL_LIST) { return 0; }
+    MalVal *a0 = _nth(ast, 0);
+    return (a0->type & MAL_SYMBOL) &&
+            env_find(env, a0) &&
+            env_get(env, a0)->ismacro;
+}
+    
+MalVal *macroexpand(MalVal *ast, Env *env) {
+    if (!ast || mal_error) return NULL;
+    while (is_macro_call(ast, env)) {
+        MalVal *a0 = _nth(ast, 0);
+        MalVal *mac = env_get(env, a0);
+        // TODO: this is weird and limits it to 20. FIXME
+        ast = _apply(mac, _rest(ast));
+    }
+    return ast;
+}
+
+MalVal *eval_ast(MalVal *ast, Env *env) {
+    if (!ast || mal_error) return NULL;
+    if (ast->type == MAL_SYMBOL) {
+        //g_print("EVAL symbol: %s\n", ast->val.string);
+        return env_get(env, ast);
+    } else if ((ast->type == MAL_LIST) || (ast->type == MAL_VECTOR)) {
+        //g_print("EVAL sequential: %s\n", _pr_str(ast,1));
+        MalVal *el = _map2((MalVal *(*)(void*, void*))EVAL, ast, env);
+        if (!el || mal_error) return NULL;
+        el->type = ast->type;
+        return el;
+    } else if (ast->type == MAL_HASH_MAP) {
+        //g_print("EVAL hash_map: %s\n", _pr_str(ast,1));
+        GHashTableIter iter;
+        gpointer key, value;
+        MalVal *seq = malval_new_list(MAL_LIST,
+                                    g_array_sized_new(TRUE, TRUE, sizeof(MalVal*),
+                                                        _count(ast)));
+        g_hash_table_iter_init (&iter, ast->val.hash_table);
+        while (g_hash_table_iter_next (&iter, &key, &value)) {
+            MalVal *kname = malval_new_string((char *)key);
+            g_array_append_val(seq->val.array, kname);
+            MalVal *new_val = EVAL((MalVal *)value, env);
+            g_array_append_val(seq->val.array, new_val);
+        }
+        return _hash_map(seq);
+    } else {
+        //g_print("EVAL scalar: %s\n", _pr_str(ast,1));
+        return ast;
+    }
+}
+
+MalVal *EVAL(MalVal *ast, Env *env) {
+    while (TRUE) {
+
+    if (!ast || mal_error) return NULL;
+    //g_print("EVAL: %s\n", _pr_str(ast,1));
+    if (ast->type != MAL_LIST) {
+        return eval_ast(ast, env);
+    }
+    if (!ast || mal_error) return NULL;
+
+    // apply list
+    //g_print("EVAL apply list: %s\n", _pr_str(ast,1));
+    ast = macroexpand(ast, env);
+    if (!ast || mal_error) return NULL;
+    if (ast->type != MAL_LIST) { return ast; }
+    if (_count(ast) == 0) { return ast; }
+
+    int i, len;
+    MalVal *a0 = _nth(ast, 0);
+    if ((a0->type & MAL_SYMBOL) &&
+        strcmp("def!", a0->val.string) == 0) {
+        //g_print("eval apply def!\n");
+        MalVal *a1 = _nth(ast, 1),
+               *a2 = _nth(ast, 2);
+        MalVal *res = EVAL(a2, env);
+        if (mal_error) return NULL;
+        env_set(env, a1, res);
+        return res;
+    } else if ((a0->type & MAL_SYMBOL) &&
+               strcmp("let*", a0->val.string) == 0) {
+        //g_print("eval apply let*\n");
+        MalVal *a1 = _nth(ast, 1),
+               *a2 = _nth(ast, 2),
+               *key, *val;
+        assert_type(a1, MAL_LIST|MAL_VECTOR,
+                    "let* bindings must be list or vector");
+        len = _count(a1);
+        assert((len % 2) == 0, "odd number of let* bindings forms");
+        Env *let_env = new_env(env, NULL, NULL);
+        for(i=0; i<len; i+=2) {
+            key = g_array_index(a1->val.array, MalVal*, i);
+            val = g_array_index(a1->val.array, MalVal*, i+1);
+            assert_type(key, MAL_SYMBOL, "let* bind to non-symbol");
+            env_set(let_env, key, EVAL(val, let_env));
+        }
+        ast = a2;
+        env = let_env;
+        // Continue loop
+    } else if ((a0->type & MAL_SYMBOL) &&
+               strcmp("quote", a0->val.string) == 0) {
+        //g_print("eval apply quote\n");
+        return _nth(ast, 1);
+    } else if ((a0->type & MAL_SYMBOL) &&
+               strcmp("quasiquote", a0->val.string) == 0) {
+        //g_print("eval apply quasiquote\n");
+        MalVal *a1 = _nth(ast, 1);
+        ast = quasiquote(a1);
+        // Continue loop
+    } else if ((a0->type & MAL_SYMBOL) &&
+               strcmp("defmacro!", a0->val.string) == 0) {
+        //g_print("eval apply defmacro!\n");
+        MalVal *a1 = _nth(ast, 1),
+               *a2 = _nth(ast, 2);
+        MalVal *res = EVAL(a2, env);
+        if (mal_error) return NULL;
+        res->ismacro = TRUE;
+        env_set(env, a1, res);
+        return res;
+    } else if ((a0->type & MAL_SYMBOL) &&
+               strcmp("macroexpand", a0->val.string) == 0) {
+        //g_print("eval apply macroexpand\n");
+        MalVal *a1 = _nth(ast, 1);
+        return macroexpand(a1, env);
+    } else if ((a0->type & MAL_SYMBOL) &&
+               strcmp(".", a0->val.string) == 0) {
+        //g_print("eval apply .\n");
+        MalVal *el = eval_ast(_slice(ast, 1, _count(ast)), env);
+        return invoke_native(el);
+    } else if ((a0->type & MAL_SYMBOL) &&
+               strcmp("try*", a0->val.string) == 0) {
+        //g_print("eval apply try*\n");
+        MalVal *a1 = _nth(ast, 1);
+        MalVal *a2 = _nth(ast, 2);
+        MalVal *res = EVAL(a1, env);
+        if (!mal_error) { return res; }
+        MalVal *a20 = _nth(a2, 0);
+        if (strcmp("catch*", a20->val.string) == 0) {
+            MalVal *a21 = _nth(a2, 1);
+            MalVal *a22 = _nth(a2, 2);
+            Env *catch_env = new_env(env,
+                                     _listX(1, a21),
+                                     _listX(1, mal_error));
+            //malval_free(mal_error);
+            mal_error = NULL;
+            res = EVAL(a22, catch_env);
+            return res;
+        } else {
+            return &mal_nil;
+        }
+    } else if ((a0->type & MAL_SYMBOL) &&
+               strcmp("do", a0->val.string) == 0) {
+        //g_print("eval apply do\n");
+        eval_ast(_slice(ast, 1, _count(ast)-1), env);
+        ast = _last(ast);
+        // Continue loop
+    } else if ((a0->type & MAL_SYMBOL) &&
+               strcmp("if", a0->val.string) == 0) {
+        //g_print("eval apply if\n");
+        MalVal *a1 = _nth(ast, 1);
+        MalVal *cond = EVAL(a1, env);
+        if (!cond || mal_error) return NULL;
+        if (cond->type & (MAL_FALSE|MAL_NIL)) {
+            // eval false slot form
+            if (ast->val.array->len > 3) {
+                ast = _nth(ast, 3);
+            } else {
+                return &mal_nil;
+            }
+        } else {
+            // eval true slot form
+            ast = _nth(ast, 2);
+        }
+        // Continue loop
+    } else if ((a0->type & MAL_SYMBOL) &&
+               strcmp("fn*", a0->val.string) == 0) {
+        //g_print("eval apply fn*\n");
+        MalVal *mf = malval_new(MAL_FUNCTION_MAL, NULL);
+        mf->ismacro = FALSE;
+        mf->val.func.evaluator = EVAL;
+        mf->val.func.args = _nth(ast, 1);
+        mf->val.func.body = _nth(ast, 2);
+        mf->val.func.env = env;
+        return mf;
+    } else {
+        //g_print("eval apply\n");
+        MalVal *el = eval_ast(ast, env);
+        if (!el || mal_error) { return NULL; }
+        MalVal *f = _first(el),
+               *args = _rest(el);
+        assert_type(f, MAL_FUNCTION_C|MAL_FUNCTION_MAL,
+                    "cannot apply '%s'", _pr_str(f,1));
+        if (f->type & MAL_FUNCTION_MAL) {
+            ast = f->val.func.body;
+            env = new_env(f->val.func.env, f->val.func.args, args);
+            // Continue loop
+        } else {
+            return _apply(f, args);
+        }
+    }
+
+    } // TCO while loop
+}
+
+// print
+char *PRINT(MalVal *exp) {
+    if (mal_error) {
+        fprintf(stderr, "Error: %s\n", mal_error->val.string);
+        malval_free(mal_error);
+        mal_error = NULL;
+        return NULL;
+    }
+    return _pr_str(exp,1);
+}
+
+// repl
+
+// read and eval
+MalVal *RE(Env *env, char *prompt, char *str) {
+    MalVal *ast, *exp;
+    ast = READ(prompt, str);
+    if (!ast || mal_error) return NULL;
+    exp = EVAL(ast, env);
+    if (ast != exp) {
+        malval_free(ast);    // Free input structure
+    }
+    return exp;
+}
+
+// Setup the initial REPL environment
+Env *repl_env;
+
+void init_repl_env(int argc, char *argv[]) {
+    repl_env = new_env(NULL, NULL, NULL);
+
+    // core.c: defined using C
+    int i;
+    for(i=0; i < (sizeof(core_ns) / sizeof(core_ns[0])); i++) {
+        env_set(repl_env,
+                malval_new_symbol(core_ns[i].name),
+                malval_new_function(core_ns[i].func, core_ns[i].arg_cnt));
+    }
+    MalVal *do_eval(MalVal *ast) { return EVAL(ast, repl_env); }
+    env_set(repl_env,
+            malval_new_symbol("eval"),
+            malval_new_function((void*(*)(void *))do_eval, 1));
+
+    MalVal *_argv = _listX(0);
+    for (i=2; i < argc; i++) {
+        MalVal *arg = malval_new_string(argv[i]);
+        g_array_append_val(_argv->val.array, arg);
+    }
+    env_set(repl_env, malval_new_symbol("*ARGV*"), _argv);
+
+    // core.mal: defined using the language itself
+    RE(repl_env, "", "(def! *host-language* \"c\")");
+    RE(repl_env, "", "(def! not (fn* (a) (if a false true)))");
+    RE(repl_env, "",
+       "(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))");
+    RE(repl_env, "", "(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))");
+    RE(repl_env, "", "(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))");
+}
+
+int main(int argc, char *argv[])
+{
+    MalVal *exp;
+    char *output;
+    char prompt[100];
+
+    // Set the initial prompt and environment
+    snprintf(prompt, sizeof(prompt), "user> ");
+    init_repl_env(argc, argv);
+ 
+    if (argc > 1) {
+        char *cmd = g_strdup_printf("(load-file \"%s\")", argv[1]);
+        RE(repl_env, "", cmd);
+        return 0;
+    }
+
+    // repl loop
+    RE(repl_env, "", "(println (str \"Mal [\" *host-language* \"]\"))");
+    for(;;) {
+        exp = RE(repl_env, prompt, NULL);
+        if (mal_error && strcmp("EOF", mal_error->val.string) == 0) {
+            return 0;
+        }
+        output = PRINT(exp);
+
+        if (output) { 
+            g_print("%s\n", output);
+            free(output);        // Free output string
+        }
+
+        //malval_free(exp);    // Free evaluated expression
+    }
+}
diff --git a/c/tests/stepA_interop.mal b/c/tests/stepA_interop.mal
deleted file mode 100644
index 657e3e7..0000000
--- a/c/tests/stepA_interop.mal
+++ /dev/null
@@ -1,23 +0,0 @@
-
-;; Testing FFI of "strlen"
-(. nil "int32" "strlen" "string" "abcde")
-;=>5
-(. nil "int32" "strlen" "string" "")
-;=>0
-
-;; Testing FFI of "strcmp"
-
-(. nil "int32" "strcmp" "string" "abc" "string" "abcA")
-;=>-65
-(. nil "int32" "strcmp" "string" "abcA" "string" "abc")
-;=>65
-(. nil "int32" "strcmp" "string" "abc" "string" "abc")
-;=>0
-
-
-;; Testing FFI of "pow" (libm.so)
-
-(. "libm.so" "double" "pow" "double" 2.0 "double" 3.0)
-;=>8.000000
-(. "libm.so" "double" "pow" "double" 3.0 "double" 2.0)
-;=>9.000000
diff --git a/c/tests/stepA_mal.mal b/c/tests/stepA_mal.mal
new file mode 100644
index 0000000..657e3e7
--- /dev/null
+++ b/c/tests/stepA_mal.mal
@@ -0,0 +1,23 @@
+
+;; Testing FFI of "strlen"
+(. nil "int32" "strlen" "string" "abcde")
+;=>5
+(. nil "int32" "strlen" "string" "")
+;=>0
+
+;; Testing FFI of "strcmp"
+
+(. nil "int32" "strcmp" "string" "abc" "string" "abcA")
+;=>-65
+(. nil "int32" "strcmp" "string" "abcA" "string" "abc")
+;=>65
+(. nil "int32" "strcmp" "string" "abc" "string" "abc")
+;=>0
+
+
+;; Testing FFI of "pow" (libm.so)
+
+(. "libm.so" "double" "pow" "double" 2.0 "double" 3.0)
+;=>8.000000
+(. "libm.so" "double" "pow" "double" 3.0 "double" 2.0)
+;=>9.000000
diff --git a/clojure/Makefile b/clojure/Makefile
index 6d227a2..ec55ac1 100644
--- a/clojure/Makefile
+++ b/clojure/Makefile
@@ -1,5 +1,5 @@
 SOURCES_BASE = src/readline.clj src/reader.clj src/printer.clj
-SOURCES_LISP = src/env.clj src/core.clj src/stepA_interop.clj
+SOURCES_LISP = src/env.clj src/core.clj src/stepA_mal.clj
 SOURCES = $(SOURCES_BASE) $(SOURCES_LISP)
 
 all:
diff --git a/clojure/src/stepA_interop.clj b/clojure/src/stepA_interop.clj
deleted file mode 100644
index 6ed9964..0000000
--- a/clojure/src/stepA_interop.clj
+++ /dev/null
@@ -1,181 +0,0 @@
-(ns stepA-interop
-    (:refer-clojure :exclude [macroexpand])
-    (:require [clojure.repl]
-              [readline]
-              [reader]
-              [printer]
-              [env]
-              [core]))
-
-;; read
-(defn READ [& [strng]]
-  (let [line (if strng strng (read-line))]
-    (reader/read-string strng)))
-
-;; eval
-(declare EVAL)
-(defn is-pair [x]
-  (and (sequential? x) (> (count x) 0)))
-
-(defn quasiquote [ast]
-  (cond
-    (not (is-pair ast))
-    (list 'quote ast)
-
-    (= 'unquote (first ast))
-    (second ast)
-
-    (and (is-pair (first ast)) (= 'splice-unquote (ffirst ast)))
-    (list 'concat (-> ast first second) (quasiquote (rest ast)))
-
-    :else
-    (list 'cons (quasiquote (first ast)) (quasiquote (rest ast)))))
-
-(defn is-macro-call [ast env]
-  (and (seq? ast)
-       (symbol? (first ast))
-       (env/env-find env (first ast))
-       (:ismacro (meta (env/env-get env (first ast))))))
-
-(defn macroexpand [ast env]
-  (loop [ast ast]
-    (if (is-macro-call ast env)
-      (let [mac (env/env-get env (first ast))]
-        (recur (apply mac (rest ast))))
-      ast)))
-
-(defn eval-ast [ast env]
-  (cond
-    (symbol? ast) (env/env-get env ast)
-   
-    (seq? ast)    (doall (map #(EVAL % env) ast))
-
-    (vector? ast) (vec (doall (map #(EVAL % env) ast)))
-   
-    (map? ast)    (apply hash-map (doall (map #(EVAL % env)
-                                              (mapcat identity ast))))
-
-    :else         ast))
-
-(defn EVAL [ast env]
-  (loop [ast ast
-         env env]
-    ;;(prn "EVAL" ast (keys @env)) (flush)
-    (if (not (seq? ast))
-      (eval-ast ast env)
-  
-      ;; apply list
-      (let [ast (macroexpand ast env)]
-        (if (not (seq? ast))
-          ast
-
-          (let [[a0 a1 a2 a3] ast]
-            (condp = a0
-              'def!
-              (env/env-set env a1 (EVAL a2 env))
-      
-              'let*
-              (let [let-env (env/env env)]
-                (doseq [[b e] (partition 2 a1)]
-                  (env/env-set let-env b (EVAL e let-env)))
-                (recur a2 let-env))
-    
-              'quote
-              a1
-    
-              'quasiquote
-              (recur (quasiquote a1) env)
-    
-              'defmacro!
-              (let [func (with-meta (EVAL a2 env)
-                                    {:ismacro true})]
-                (env/env-set env a1 func))
-    
-              'macroexpand
-              (macroexpand a1 env)
-      
-              'clj*
-              (eval (reader/read-string a1))
-      
-              'try*
-              (if (= 'catch* (nth a2 0))
-                (try
-                  (EVAL a1 env)
-                  (catch clojure.lang.ExceptionInfo ei
-                    (EVAL (nth a2 2) (env/env env
-                                              [(nth a2 1)]
-                                              [(:data (ex-data ei))])))
-                  (catch Throwable t
-                    (EVAL (nth a2 2) (env/env env
-                                              [(nth a2 1)]
-                                              [(.getMessage t)]))))
-                (EVAL a1 env))
-    
-              'do
-              (do (eval-ast (->> ast (drop-last) (drop 1)) env)
-                  (recur (last ast) env))
-      
-              'if
-              (let [cond (EVAL a1 env)]
-                (if (or (= cond nil) (= cond false))
-                  (if (> (count ast) 2)
-                    (recur a3 env)
-                    nil)
-                  (recur a2 env)))
-      
-              'fn*
-              (with-meta
-                (fn [& args]
-                  (EVAL a2 (env/env env a1 args)))
-                {:expression a2
-                 :environment env
-                 :parameters a1})
-      
-              ;; apply
-              (let [el (eval-ast ast env)
-                       f (first el)
-                       args (rest el)
-                       {:keys [expression environment parameters]} (meta f)]
-                (if expression
-                  (recur expression (env/env environment parameters args))
-                  (apply f args))))))))))
-
-;; print
-(defn PRINT [exp] (pr-str exp))
-
-;; repl
-(def repl-env (env/env))
-(defn rep
-  [strng]
-  (PRINT (EVAL (READ strng) repl-env)))
-
-;; core.clj: defined using Clojure
-(doseq [[k v] core/core_ns] (env/env-set repl-env k v))
-(env/env-set repl-env 'eval (fn [ast] (EVAL ast repl-env)))
-(env/env-set repl-env '*ARGV* ())
-
-;; core.mal: defined using the language itself
-(rep "(def! *host-language* \"clojure\")")
-(rep "(def! not (fn* [a] (if a false true)))")
-(rep "(def! load-file (fn* [f] (eval (read-string (str \"(do \" (slurp f) \")\")))))")
-(rep "(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))")
-(rep "(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))")
-
-;; repl loop
-(defn repl-loop []
-  (let [line (readline/readline "user> ")]
-    (when line
-      (when-not (re-seq #"^\s*$|^\s*;.*$" line) ; blank/comment
-        (try
-          (println (rep line))
-          (catch Throwable e
-            (clojure.repl/pst e))))
-      (recur))))
-
-(defn -main [& args]
-  (env/env-set repl-env '*ARGV* (rest args))
-  (if args
-    (rep (str "(load-file \"" (first args) "\")"))
-    (do
-      (rep "(println (str \"Mal [\" *host-language* \"]\"))")
-      (repl-loop))))
diff --git a/clojure/src/stepA_mal.clj b/clojure/src/stepA_mal.clj
new file mode 100644
index 0000000..6ed9964
--- /dev/null
+++ b/clojure/src/stepA_mal.clj
@@ -0,0 +1,181 @@
+(ns stepA-interop
+    (:refer-clojure :exclude [macroexpand])
+    (:require [clojure.repl]
+              [readline]
+              [reader]
+              [printer]
+              [env]
+              [core]))
+
+;; read
+(defn READ [& [strng]]
+  (let [line (if strng strng (read-line))]
+    (reader/read-string strng)))
+
+;; eval
+(declare EVAL)
+(defn is-pair [x]
+  (and (sequential? x) (> (count x) 0)))
+
+(defn quasiquote [ast]
+  (cond
+    (not (is-pair ast))
+    (list 'quote ast)
+
+    (= 'unquote (first ast))
+    (second ast)
+
+    (and (is-pair (first ast)) (= 'splice-unquote (ffirst ast)))
+    (list 'concat (-> ast first second) (quasiquote (rest ast)))
+
+    :else
+    (list 'cons (quasiquote (first ast)) (quasiquote (rest ast)))))
+
+(defn is-macro-call [ast env]
+  (and (seq? ast)
+       (symbol? (first ast))
+       (env/env-find env (first ast))
+       (:ismacro (meta (env/env-get env (first ast))))))
+
+(defn macroexpand [ast env]
+  (loop [ast ast]
+    (if (is-macro-call ast env)
+      (let [mac (env/env-get env (first ast))]
+        (recur (apply mac (rest ast))))
+      ast)))
+
+(defn eval-ast [ast env]
+  (cond
+    (symbol? ast) (env/env-get env ast)
+   
+    (seq? ast)    (doall (map #(EVAL % env) ast))
+
+    (vector? ast) (vec (doall (map #(EVAL % env) ast)))
+   
+    (map? ast)    (apply hash-map (doall (map #(EVAL % env)
+                                              (mapcat identity ast))))
+
+    :else         ast))
+
+(defn EVAL [ast env]
+  (loop [ast ast
+         env env]
+    ;;(prn "EVAL" ast (keys @env)) (flush)
+    (if (not (seq? ast))
+      (eval-ast ast env)
+  
+      ;; apply list
+      (let [ast (macroexpand ast env)]
+        (if (not (seq? ast))
+          ast
+
+          (let [[a0 a1 a2 a3] ast]
+            (condp = a0
+              'def!
+              (env/env-set env a1 (EVAL a2 env))
+      
+              'let*
+              (let [let-env (env/env env)]
+                (doseq [[b e] (partition 2 a1)]
+                  (env/env-set let-env b (EVAL e let-env)))
+                (recur a2 let-env))
+    
+              'quote
+              a1
+    
+              'quasiquote
+              (recur (quasiquote a1) env)
+    
+              'defmacro!
+              (let [func (with-meta (EVAL a2 env)
+                                    {:ismacro true})]
+                (env/env-set env a1 func))
+    
+              'macroexpand
+              (macroexpand a1 env)
+      
+              'clj*
+              (eval (reader/read-string a1))
+      
+              'try*
+              (if (= 'catch* (nth a2 0))
+                (try
+                  (EVAL a1 env)
+                  (catch clojure.lang.ExceptionInfo ei
+                    (EVAL (nth a2 2) (env/env env
+                                              [(nth a2 1)]
+                                              [(:data (ex-data ei))])))
+                  (catch Throwable t
+                    (EVAL (nth a2 2) (env/env env
+                                              [(nth a2 1)]
+                                              [(.getMessage t)]))))
+                (EVAL a1 env))
+    
+              'do
+              (do (eval-ast (->> ast (drop-last) (drop 1)) env)
+                  (recur (last ast) env))
+      
+              'if
+              (let [cond (EVAL a1 env)]
+                (if (or (= cond nil) (= cond false))
+                  (if (> (count ast) 2)
+                    (recur a3 env)
+                    nil)
+                  (recur a2 env)))
+      
+              'fn*
+              (with-meta
+                (fn [& args]
+                  (EVAL a2 (env/env env a1 args)))
+                {:expression a2
+                 :environment env
+                 :parameters a1})
+      
+              ;; apply
+              (let [el (eval-ast ast env)
+                       f (first el)
+                       args (rest el)
+                       {:keys [expression environment parameters]} (meta f)]
+                (if expression
+                  (recur expression (env/env environment parameters args))
+                  (apply f args))))))))))
+
+;; print
+(defn PRINT [exp] (pr-str exp))
+
+;; repl
+(def repl-env (env/env))
+(defn rep
+  [strng]
+  (PRINT (EVAL (READ strng) repl-env)))
+
+;; core.clj: defined using Clojure
+(doseq [[k v] core/core_ns] (env/env-set repl-env k v))
+(env/env-set repl-env 'eval (fn [ast] (EVAL ast repl-env)))
+(env/env-set repl-env '*ARGV* ())
+
+;; core.mal: defined using the language itself
+(rep "(def! *host-language* \"clojure\")")
+(rep "(def! not (fn* [a] (if a false true)))")
+(rep "(def! load-file (fn* [f] (eval (read-string (str \"(do \" (slurp f) \")\")))))")
+(rep "(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))")
+(rep "(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))")
+
+;; repl loop
+(defn repl-loop []
+  (let [line (readline/readline "user> ")]
+    (when line
+      (when-not (re-seq #"^\s*$|^\s*;.*$" line) ; blank/comment
+        (try
+          (println (rep line))
+          (catch Throwable e
+            (clojure.repl/pst e))))
+      (recur))))
+
+(defn -main [& args]
+  (env/env-set repl-env '*ARGV* (rest args))
+  (if args
+    (rep (str "(load-file \"" (first args) "\")"))
+    (do
+      (rep "(println (str \"Mal [\" *host-language* \"]\"))")
+      (repl-loop))))
diff --git a/clojure/tests/stepA_interop.mal b/clojure/tests/stepA_interop.mal
deleted file mode 100644
index b323222..0000000
--- a/clojure/tests/stepA_interop.mal
+++ /dev/null
@@ -1,17 +0,0 @@
-;; Testing basic clojure interop
-
-(clj* "7")
-;=>7
-
-(clj* "\"abc\"")
-;=>"abc"
-
-(clj* "{\"abc\" 123}")
-;=>{"abc" 123}
-
-(clj* "(prn \"foo\")")
-; "foo"
-;=>nil
-
-(clj* "(for [x [1 2 3]] (+ 1 x))")
-;=>(2 3 4)
diff --git a/clojure/tests/stepA_mal.mal b/clojure/tests/stepA_mal.mal
new file mode 100644
index 0000000..b323222
--- /dev/null
+++ b/clojure/tests/stepA_mal.mal
@@ -0,0 +1,17 @@
+;; Testing basic clojure interop
+
+(clj* "7")
+;=>7
+
+(clj* "\"abc\"")
+;=>"abc"
+
+(clj* "{\"abc\" 123}")
+;=>{"abc" 123}
+
+(clj* "(prn \"foo\")")
+; "foo"
+;=>nil
+
+(clj* "(for [x [1 2 3]] (+ 1 x))")
+;=>(2 3 4)
diff --git a/coffee/Makefile b/coffee/Makefile
index d2212ed..728d9f2 100644
--- a/coffee/Makefile
+++ b/coffee/Makefile
@@ -2,7 +2,7 @@ TESTS =
 
 SOURCES_BASE = node_readline.coffee types.coffee \
 	       reader.coffee printer.coffee
-SOURCES_LISP = env.coffee core.coffee stepA_interop.coffee
+SOURCES_LISP = env.coffee core.coffee stepA_mal.coffee
 SOURCES = $(SOURCES_BASE) $(SOURCES_LISP)
 
 #all: mal.rb
diff --git a/coffee/stepA_interop.coffee b/coffee/stepA_interop.coffee
deleted file mode 100644
index 751f9ad..0000000
--- a/coffee/stepA_interop.coffee
+++ /dev/null
@@ -1,142 +0,0 @@
-readline = require "./node_readline.coffee"
-types = require "./types.coffee"
-reader = require "./reader.coffee"
-printer = require "./printer.coffee"
-Env = require("./env.coffee").Env
-core = require("./core.coffee")
-
-# read
-READ = (str) -> reader.read_str str
-
-# eval
-is_pair = (x) -> types._sequential_Q(x) && x.length > 0
-
-quasiquote = (ast) ->
-  if !is_pair(ast) then [types._symbol('quote'), ast]
-  else if ast[0].name == 'unquote' then ast[1]
-  else if is_pair(ast[0]) && ast[0][0].name == 'splice-unquote'
-    [types._symbol('concat'), ast[0][1], quasiquote(ast[1..])]
-  else
-    [types._symbol('cons'), quasiquote(ast[0]), quasiquote(ast[1..])]
-
-is_macro_call = (ast, env) ->
-  return types._list_Q(ast) && types._symbol_Q(ast[0]) &&
-         env.find(ast[0]) && env.get(ast[0]).__ismacro__
-
-macroexpand = (ast, env) ->
-  while is_macro_call(ast, env)
-    ast = env.get(ast[0])(ast[1..]...)
-  ast
-    
-    
-
-eval_ast = (ast, env) ->
-  if types._symbol_Q(ast) then env.get ast
-  else if types._list_Q(ast) then ast.map((a) -> EVAL(a, env))
-  else if types._vector_Q(ast)
-    types._vector(ast.map((a) -> EVAL(a, env))...)
-  else if types._hash_map_Q(ast)
-    new_hm = {}
-    new_hm[k] = EVAL(ast[k],env) for k,v of ast
-    new_hm
-  else ast
-
-EVAL = (ast, env) ->
- loop
-  #console.log "EVAL:", printer._pr_str ast
-  if !types._list_Q ast then return eval_ast ast, env
-
-  # apply list
-  ast = macroexpand ast, env 
-  if !types._list_Q ast then return ast
-
-  [a0, a1, a2, a3] = ast
-  switch a0.name
-    when "def!"
-      return env.set(a1, EVAL(a2, env))
-    when "let*"
-      let_env = new Env(env)
-      for k,i in a1 when i %% 2 == 0
-        let_env.set(a1[i], EVAL(a1[i+1], let_env))
-      ast = a2
-      env = let_env
-    when "quote"
-      return a1
-    when "quasiquote"
-      ast = quasiquote(a1)
-    when "defmacro!"
-      f = EVAL(a2, env)
-      f.__ismacro__ = true
-      return env.set(a1, f)
-    when "macroexpand"
-      return macroexpand(a1, env)
-    when "try*"
-      try return EVAL(a1, env)
-      catch exc
-        if a2 && a2[0].name == "catch*"
-          if exc instanceof Error then exc = exc.message
-          return EVAL a2[2], new Env(env, [a2[1]], [exc])
-        else
-          throw exc
-    when "js*"
-      res = eval(a1.toString())
-      return if typeof(res) == 'undefined' then null else res
-    when "."
-      el = eval_ast(ast[2..], env)
-      return eval(a1.toString())(el...)
-    when "do"
-      eval_ast(ast[1..-2], env)
-      ast = ast[ast.length-1]
-    when "if"
-      cond = EVAL(a1, env)
-      if cond == null or cond == false
-        if a3? then ast = a3 else return null
-      else
-        ast = a2
-    when "fn*"
-      return types._function(EVAL, a2, env, a1)
-    else
-      [f, args...] = eval_ast ast, env
-      if types._function_Q(f)
-        ast = f.__ast__
-        env = f.__gen_env__(args)
-      else
-        return f(args...)
-
-
-# print
-PRINT = (exp) -> printer._pr_str exp, true
-
-# repl
-repl_env = new Env()
-rep = (str) -> PRINT(EVAL(READ(str), repl_env))
-
-# core.coffee: defined using CoffeeScript
-repl_env.set types._symbol(k), v for k,v of core.ns
-repl_env.set types._symbol('eval'), (ast) -> EVAL(ast, repl_env)
-repl_env.set types._symbol('*ARGV*'), []
-
-# core.mal: defined using the language itself
-rep("(def! *host-language* \"CoffeeScript\")")
-rep("(def! not (fn* (a) (if a false true)))");
-rep("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))");
-rep("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))")
-rep("(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))")
-
-if process? && process.argv.length > 2
-  repl_env.set types._symbol('*ARGV*'), process.argv[3..]
-  rep('(load-file "' + process.argv[2] + '")')
-  process.exit 0
-
-# repl loop
-rep("(println (str \"Mal [\" *host-language* \"]\"))")
-while (line = readline.readline("user> ")) != null
-  continue if line == ""
-  try
-    console.log rep line
-  catch exc
-    continue if exc instanceof reader.BlankException
-    if exc.stack then console.log exc.stack
-    else              console.log exc
-
-# vim: ts=2:sw=2
diff --git a/coffee/stepA_mal.coffee b/coffee/stepA_mal.coffee
new file mode 100644
index 0000000..751f9ad
--- /dev/null
+++ b/coffee/stepA_mal.coffee
@@ -0,0 +1,142 @@
+readline = require "./node_readline.coffee"
+types = require "./types.coffee"
+reader = require "./reader.coffee"
+printer = require "./printer.coffee"
+Env = require("./env.coffee").Env
+core = require("./core.coffee")
+
+# read
+READ = (str) -> reader.read_str str
+
+# eval
+is_pair = (x) -> types._sequential_Q(x) && x.length > 0
+
+quasiquote = (ast) ->
+  if !is_pair(ast) then [types._symbol('quote'), ast]
+  else if ast[0].name == 'unquote' then ast[1]
+  else if is_pair(ast[0]) && ast[0][0].name == 'splice-unquote'
+    [types._symbol('concat'), ast[0][1], quasiquote(ast[1..])]
+  else
+    [types._symbol('cons'), quasiquote(ast[0]), quasiquote(ast[1..])]
+
+is_macro_call = (ast, env) ->
+  return types._list_Q(ast) && types._symbol_Q(ast[0]) &&
+         env.find(ast[0]) && env.get(ast[0]).__ismacro__
+
+macroexpand = (ast, env) ->
+  while is_macro_call(ast, env)
+    ast = env.get(ast[0])(ast[1..]...)
+  ast
+    
+    
+
+eval_ast = (ast, env) ->
+  if types._symbol_Q(ast) then env.get ast
+  else if types._list_Q(ast) then ast.map((a) -> EVAL(a, env))
+  else if types._vector_Q(ast)
+    types._vector(ast.map((a) -> EVAL(a, env))...)
+  else if types._hash_map_Q(ast)
+    new_hm = {}
+    new_hm[k] = EVAL(ast[k],env) for k,v of ast
+    new_hm
+  else ast
+
+EVAL = (ast, env) ->
+ loop
+  #console.log "EVAL:", printer._pr_str ast
+  if !types._list_Q ast then return eval_ast ast, env
+
+  # apply list
+  ast = macroexpand ast, env 
+  if !types._list_Q ast then return ast
+
+  [a0, a1, a2, a3] = ast
+  switch a0.name
+    when "def!"
+      return env.set(a1, EVAL(a2, env))
+    when "let*"
+      let_env = new Env(env)
+      for k,i in a1 when i %% 2 == 0
+        let_env.set(a1[i], EVAL(a1[i+1], let_env))
+      ast = a2
+      env = let_env
+    when "quote"
+      return a1
+    when "quasiquote"
+      ast = quasiquote(a1)
+    when "defmacro!"
+      f = EVAL(a2, env)
+      f.__ismacro__ = true
+      return env.set(a1, f)
+    when "macroexpand"
+      return macroexpand(a1, env)
+    when "try*"
+      try return EVAL(a1, env)
+      catch exc
+        if a2 && a2[0].name == "catch*"
+          if exc instanceof Error then exc = exc.message
+          return EVAL a2[2], new Env(env, [a2[1]], [exc])
+        else
+          throw exc
+    when "js*"
+      res = eval(a1.toString())
+      return if typeof(res) == 'undefined' then null else res
+    when "."
+      el = eval_ast(ast[2..], env)
+      return eval(a1.toString())(el...)
+    when "do"
+      eval_ast(ast[1..-2], env)
+      ast = ast[ast.length-1]
+    when "if"
+      cond = EVAL(a1, env)
+      if cond == null or cond == false
+        if a3? then ast = a3 else return null
+      else
+        ast = a2
+    when "fn*"
+      return types._function(EVAL, a2, env, a1)
+    else
+      [f, args...] = eval_ast ast, env
+      if types._function_Q(f)
+        ast = f.__ast__
+        env = f.__gen_env__(args)
+      else
+        return f(args...)
+
+
+# print
+PRINT = (exp) -> printer._pr_str exp, true
+
+# repl
+repl_env = new Env()
+rep = (str) -> PRINT(EVAL(READ(str), repl_env))
+
+# core.coffee: defined using CoffeeScript
+repl_env.set types._symbol(k), v for k,v of core.ns
+repl_env.set types._symbol('eval'), (ast) -> EVAL(ast, repl_env)
+repl_env.set types._symbol('*ARGV*'), []
+
+# core.mal: defined using the language itself
+rep("(def! *host-language* \"CoffeeScript\")")
+rep("(def! not (fn* (a) (if a false true)))");
+rep("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))");
+rep("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))")
+rep("(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))")
+
+if process? && process.argv.length > 2
+  repl_env.set types._symbol('*ARGV*'), process.argv[3..]
+  rep('(load-file "' + process.argv[2] + '")')
+  process.exit 0
+
+# repl loop
+rep("(println (str \"Mal [\" *host-language* \"]\"))")
+while (line = readline.readline("user> ")) != null
+  continue if line == ""
+  try
+    console.log rep line
+  catch exc
+    continue if exc instanceof reader.BlankException
+    if exc.stack then console.log exc.stack
+    else              console.log exc
+
+# vim: ts=2:sw=2
diff --git a/coffee/tests/stepA_interop.mal b/coffee/tests/stepA_interop.mal
deleted file mode 100644
index f785292..0000000
--- a/coffee/tests/stepA_interop.mal
+++ /dev/null
@@ -1,24 +0,0 @@
-;; Testing basic bash interop
-
-(js* "7")
-;=>7
-
-(js* "'7'")
-;=>"7"
-
-(js* "[7,8,9]")
-;=>(7 8 9)
-
-(js* "console.log('hello');")
-; hello
-;=>nil
-
-(js* "foo=8;")
-(js* "foo;")
-;=>8
-
-(js* "['a','b','c'].map(function(x){return 'X'+x+'Y'}).join(' ')")
-;=>"XaY XbY XcY"
-
-(js* "[1,2,3].map(function(x){return 1+x})")
-;=>(2 3 4)
diff --git a/coffee/tests/stepA_mal.mal b/coffee/tests/stepA_mal.mal
new file mode 100644
index 0000000..f785292
--- /dev/null
+++ b/coffee/tests/stepA_mal.mal
@@ -0,0 +1,24 @@
+;; Testing basic bash interop
+
+(js* "7")
+;=>7
+
+(js* "'7'")
+;=>"7"
+
+(js* "[7,8,9]")
+;=>(7 8 9)
+
+(js* "console.log('hello');")
+; hello
+;=>nil
+
+(js* "foo=8;")
+(js* "foo;")
+;=>8
+
+(js* "['a','b','c'].map(function(x){return 'X'+x+'Y'}).join(' ')")
+;=>"XaY XbY XcY"
+
+(js* "[1,2,3].map(function(x){return 1+x})")
+;=>(2 3 4)
diff --git a/cs/Makefile b/cs/Makefile
index 1fd1f7a..70d54ad 100644
--- a/cs/Makefile
+++ b/cs/Makefile
@@ -5,7 +5,7 @@ DEBUG =
 TESTS =
 
 SOURCES_BASE = readline.cs types.cs reader.cs printer.cs
-SOURCES_LISP = env.cs core.cs stepA_interop.cs
+SOURCES_LISP = env.cs core.cs stepA_mal.cs
 SOURCES = $(SOURCES_BASE) $(SOURCES_LISP)
 
 OTHER_SOURCES = getline.cs
@@ -14,7 +14,7 @@ OTHER_SOURCES = getline.cs
 
 SRCS = step0_repl.cs step1_read_print.cs step2_eval.cs step3_env.cs \
        step4_if_fn_do.cs step5_tco.cs step6_file.cs step7_quote.cs \
-       step8_macros.cs step9_try.cs stepA_interop.cs
+       step8_macros.cs step9_try.cs stepA_mal.cs
 
 LIB_SRCS = $(filter-out step%,$(OTHER_SOURCES) $(SOURCES))
 
diff --git a/cs/stepA_interop.cs b/cs/stepA_interop.cs
deleted file mode 100644
index 6531d50..0000000
--- a/cs/stepA_interop.cs
+++ /dev/null
@@ -1,285 +0,0 @@
-using System;
-using System.IO;
-using System.Collections;
-using System.Collections.Generic;
-using Mal;
-using MalVal = Mal.types.MalVal;
-using MalString = Mal.types.MalString;
-using MalSymbol = Mal.types.MalSymbol;
-using MalInt = Mal.types.MalInt;
-using MalList = Mal.types.MalList;
-using MalVector = Mal.types.MalVector;
-using MalHashMap = Mal.types.MalHashMap;
-using MalFunc = Mal.types.MalFunc;
-using Env = Mal.env.Env;
-
-namespace Mal {
-    class stepA_interop {
-        // read
-        static MalVal READ(string str) {
-            return reader.read_str(str);
-        }
-
-        // eval
-        public static bool is_pair(MalVal x) {
-            return x is MalList && ((MalList)x).size() > 0;
-        }
-
-        public static MalVal quasiquote(MalVal ast) {
-            if (!is_pair(ast)) {
-                return new MalList(new MalSymbol("quote"), ast);
-            } else {
-                MalVal a0 = ((MalList)ast)[0];
-                if ((a0 is MalSymbol) &&
-                    (((MalSymbol)a0).getName() == "unquote")) {
-                    return ((MalList)ast)[1];
-                } else if (is_pair(a0)) {
-                    MalVal a00 = ((MalList)a0)[0];
-                    if ((a00 is MalSymbol) &&
-                        (((MalSymbol)a00).getName() == "splice-unquote")) {
-                        return new MalList(new MalSymbol("concat"),
-                                           ((MalList)a0)[1],
-                                           quasiquote(((MalList)ast).rest()));
-                    }
-                }
-                return new MalList(new MalSymbol("cons"),
-                                   quasiquote(a0),
-                                   quasiquote(((MalList)ast).rest()));
-            }
-        }
-
-        public static bool is_macro_call(MalVal ast, Env env) {
-            if (ast is MalList) {
-                MalVal a0 = ((MalList)ast)[0];
-                if (a0 is MalSymbol &&
-                    env.find((MalSymbol)a0) != null) {
-                    MalVal mac = env.get((MalSymbol)a0);
-                    if (mac is MalFunc &&
-                        ((MalFunc)mac).isMacro()) {
-                        return true;
-                    }
-                }
-            }
-            return false;
-        }
-
-        public static MalVal macroexpand(MalVal ast, Env env) {
-            while (is_macro_call(ast, env)) {
-                MalSymbol a0 = (MalSymbol)((MalList)ast)[0];
-                MalFunc mac = (MalFunc) env.get(a0);
-                ast = mac.apply(((MalList)ast).rest());
-            }
-            return ast;
-        }
-
-        static MalVal eval_ast(MalVal ast, Env env) {
-            if (ast is MalSymbol) {
-                return env.get((MalSymbol)ast);
-            } else if (ast is MalList) {
-                MalList old_lst = (MalList)ast;
-                MalList new_lst = ast.list_Q() ? new MalList()
-                                            : (MalList)new MalVector();
-                foreach (MalVal mv in old_lst.getValue()) {
-                    new_lst.conj_BANG(EVAL(mv, env));
-                }
-                return new_lst;
-            } else if (ast is MalHashMap) {
-                var new_dict = new Dictionary<string, MalVal>();
-                foreach (var entry in ((MalHashMap)ast).getValue()) {
-                    new_dict.Add(entry.Key, EVAL((MalVal)entry.Value, env));
-                }
-                return new MalHashMap(new_dict);
-            } else {
-                return ast;
-            }
-        }
-
-
-        static MalVal EVAL(MalVal orig_ast, Env env) {
-            MalVal a0, a1, a2, res;
-            MalList el;
-
-            while (true) {
-
-            //Console.WriteLine("EVAL: " + printer._pr_str(orig_ast, true));
-            if (!orig_ast.list_Q()) {
-                return eval_ast(orig_ast, env);
-            }
-
-            // apply list
-            MalVal expanded = macroexpand(orig_ast, env);
-            if (!expanded.list_Q()) { return expanded; } 
-            MalList ast = (MalList) expanded;
-
-            if (ast.size() == 0) { return ast; }
-            a0 = ast[0];
-
-            String a0sym = a0 is MalSymbol ? ((MalSymbol)a0).getName()
-                                           : "__<*fn*>__";
-
-            switch (a0sym) {
-            case "def!":
-                a1 = ast[1];
-                a2 = ast[2];
-                res = EVAL(a2, env);
-                env.set((MalSymbol)a1, res);
-                return res;
-            case "let*":
-                a1 = ast[1];
-                a2 = ast[2];
-                MalSymbol key;
-                MalVal val;
-                Env let_env = new Env(env);
-                for(int i=0; i<((MalList)a1).size(); i+=2) {
-                    key = (MalSymbol)((MalList)a1)[i];
-                    val = ((MalList)a1)[i+1];
-                    let_env.set(key, EVAL(val, let_env));
-                }
-                orig_ast = a2;
-                env = let_env;
-                break;
-            case "quote":
-                return ast[1];
-            case "quasiquote":
-                orig_ast = quasiquote(ast[1]);
-                break;
-            case "defmacro!":
-                a1 = ast[1];
-                a2 = ast[2];
-                res = EVAL(a2, env);
-                ((MalFunc)res).setMacro();
-                env.set(((MalSymbol)a1), res);
-                return res;
-            case "macroexpand":
-                a1 = ast[1];
-                return macroexpand(a1, env);
-            case "try*":
-                try {
-                    return EVAL(ast[1], env);
-                } catch (Exception e) {
-                    if (ast.size() > 2) {
-                        MalVal exc;
-                        a2 = ast[2];
-                        MalVal a20 = ((MalList)a2)[0];
-                        if (((MalSymbol)a20).getName() == "catch*") {
-                            if (e is Mal.types.MalException) {
-                                exc = ((Mal.types.MalException)e).getValue();
-                            } else {
-                                exc = new MalString(e.StackTrace);
-                            }
-                            return EVAL(((MalList)a2)[2],
-                                        new Env(env, ((MalList)a2).slice(1,2),
-                                                new MalList(exc)));
-                        }
-                    }
-                    throw e;
-                }
-            case "do":
-                eval_ast(ast.slice(1, ast.size()-1), env);
-                orig_ast = ast[ast.size()-1];
-                break;
-            case "if":
-                a1 = ast[1];
-                MalVal cond = EVAL(a1, env);
-                if (cond == Mal.types.Nil || cond == Mal.types.False) {
-                    // eval false slot form
-                    if (ast.size() > 3) {
-                        orig_ast = ast[3];
-                    } else {
-                        return Mal.types.Nil;
-                    }
-                } else {
-                    // eval true slot form
-                    orig_ast = ast[2];
-                }
-                break;
-            case "fn*":
-                MalList a1f = (MalList)ast[1];
-                MalVal a2f = ast[2];
-                Env cur_env = env;
-                return new MalFunc(a2f, env, a1f,
-                    args => EVAL(a2f, new Env(cur_env, a1f, args)) );
-            default:
-                el = (MalList)eval_ast(ast, env);
-                var f = (MalFunc)el[0];
-                MalVal fnast = f.getAst();
-                if (fnast != null) {
-                    orig_ast = fnast;
-                    env = f.genEnv(el.rest());
-                } else {
-                    return f.apply(el.rest());
-                }
-                break;
-            }
-
-            }
-        }
-
-        // print
-        static string PRINT(MalVal exp) {
-            return printer._pr_str(exp, true);
-        }
-
-        // repl
-        static void Main(string[] args) {
-            var repl_env = new Mal.env.Env(null);
-            Func<string, MalVal> RE = (string str) => EVAL(READ(str), repl_env);
-            
-            // core.cs: defined using C#
-            foreach (var entry in core.ns) {
-                repl_env.set(new MalSymbol(entry.Key), entry.Value);
-            }
-            repl_env.set(new MalSymbol("eval"), new MalFunc(
-                        a => EVAL(a[0], repl_env)));
-            int fileIdx = 0;
-            if (args.Length > 0 && args[0] == "--raw") {
-                Mal.readline.mode = Mal.readline.Mode.Raw;
-                fileIdx = 1;
-            }
-            MalList _argv = new MalList();
-            for (int i=fileIdx; i < args.Length; i++) {
-                _argv.conj_BANG(new MalString(args[i]));
-            }
-            repl_env.set(new MalSymbol("*ARGV*"), _argv);
-
-            // core.mal: defined using the language itself
-            RE("(def! *host-language* \"c#\")");
-            RE("(def! not (fn* (a) (if a false true)))");
-            RE("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))");
-            RE("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))");
-            RE("(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))");
-
-            if (args.Length > fileIdx) {
-                RE("(load-file \"" + args[fileIdx] + "\")");
-                return;
-            }
-
-            // repl loop
-            RE("(println (str \"Mal [\" *host-language* \"]\"))");
-            while (true) {
-                string line;
-                try {
-                    line = Mal.readline.Readline("user> ");
-                    if (line == null) { break; }
-                    if (line == "") { continue; }
-                } catch (IOException e) {
-                    Console.WriteLine("IOException: " + e.Message);
-                    break;
-                }
-                try {
-                    Console.WriteLine(PRINT(RE(line)));
-                } catch (Mal.types.MalContinue) {
-                    continue;
-                } catch (Mal.types.MalException e) {
-                    Console.WriteLine("Error: " +
-                            printer._pr_str(e.getValue(), false));
-                    continue;
-                } catch (Exception e) {
-                    Console.WriteLine("Error: " + e.Message);
-                    Console.WriteLine(e.StackTrace);
-                    continue;
-                }
-            }
-        }
-    }
-}
diff --git a/cs/stepA_mal.cs b/cs/stepA_mal.cs
new file mode 100644
index 0000000..0ccb39e
--- /dev/null
+++ b/cs/stepA_mal.cs
@@ -0,0 +1,285 @@
+using System;
+using System.IO;
+using System.Collections;
+using System.Collections.Generic;
+using Mal;
+using MalVal = Mal.types.MalVal;
+using MalString = Mal.types.MalString;
+using MalSymbol = Mal.types.MalSymbol;
+using MalInt = Mal.types.MalInt;
+using MalList = Mal.types.MalList;
+using MalVector = Mal.types.MalVector;
+using MalHashMap = Mal.types.MalHashMap;
+using MalFunc = Mal.types.MalFunc;
+using Env = Mal.env.Env;
+
+namespace Mal {
+    class stepA_mal {
+        // read
+        static MalVal READ(string str) {
+            return reader.read_str(str);
+        }
+
+        // eval
+        public static bool is_pair(MalVal x) {
+            return x is MalList && ((MalList)x).size() > 0;
+        }
+
+        public static MalVal quasiquote(MalVal ast) {
+            if (!is_pair(ast)) {
+                return new MalList(new MalSymbol("quote"), ast);
+            } else {
+                MalVal a0 = ((MalList)ast)[0];
+                if ((a0 is MalSymbol) &&
+                    (((MalSymbol)a0).getName() == "unquote")) {
+                    return ((MalList)ast)[1];
+                } else if (is_pair(a0)) {
+                    MalVal a00 = ((MalList)a0)[0];
+                    if ((a00 is MalSymbol) &&
+                        (((MalSymbol)a00).getName() == "splice-unquote")) {
+                        return new MalList(new MalSymbol("concat"),
+                                           ((MalList)a0)[1],
+                                           quasiquote(((MalList)ast).rest()));
+                    }
+                }
+                return new MalList(new MalSymbol("cons"),
+                                   quasiquote(a0),
+                                   quasiquote(((MalList)ast).rest()));
+            }
+        }
+
+        public static bool is_macro_call(MalVal ast, Env env) {
+            if (ast is MalList) {
+                MalVal a0 = ((MalList)ast)[0];
+                if (a0 is MalSymbol &&
+                    env.find((MalSymbol)a0) != null) {
+                    MalVal mac = env.get((MalSymbol)a0);
+                    if (mac is MalFunc &&
+                        ((MalFunc)mac).isMacro()) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+
+        public static MalVal macroexpand(MalVal ast, Env env) {
+            while (is_macro_call(ast, env)) {
+                MalSymbol a0 = (MalSymbol)((MalList)ast)[0];
+                MalFunc mac = (MalFunc) env.get(a0);
+                ast = mac.apply(((MalList)ast).rest());
+            }
+            return ast;
+        }
+
+        static MalVal eval_ast(MalVal ast, Env env) {
+            if (ast is MalSymbol) {
+                return env.get((MalSymbol)ast);
+            } else if (ast is MalList) {
+                MalList old_lst = (MalList)ast;
+                MalList new_lst = ast.list_Q() ? new MalList()
+                                            : (MalList)new MalVector();
+                foreach (MalVal mv in old_lst.getValue()) {
+                    new_lst.conj_BANG(EVAL(mv, env));
+                }
+                return new_lst;
+            } else if (ast is MalHashMap) {
+                var new_dict = new Dictionary<string, MalVal>();
+                foreach (var entry in ((MalHashMap)ast).getValue()) {
+                    new_dict.Add(entry.Key, EVAL((MalVal)entry.Value, env));
+                }
+                return new MalHashMap(new_dict);
+            } else {
+                return ast;
+            }
+        }
+
+
+        static MalVal EVAL(MalVal orig_ast, Env env) {
+            MalVal a0, a1, a2, res;
+            MalList el;
+
+            while (true) {
+
+            //Console.WriteLine("EVAL: " + printer._pr_str(orig_ast, true));
+            if (!orig_ast.list_Q()) {
+                return eval_ast(orig_ast, env);
+            }
+
+            // apply list
+            MalVal expanded = macroexpand(orig_ast, env);
+            if (!expanded.list_Q()) { return expanded; } 
+            MalList ast = (MalList) expanded;
+
+            if (ast.size() == 0) { return ast; }
+            a0 = ast[0];
+
+            String a0sym = a0 is MalSymbol ? ((MalSymbol)a0).getName()
+                                           : "__<*fn*>__";
+
+            switch (a0sym) {
+            case "def!":
+                a1 = ast[1];
+                a2 = ast[2];
+                res = EVAL(a2, env);
+                env.set((MalSymbol)a1, res);
+                return res;
+            case "let*":
+                a1 = ast[1];
+                a2 = ast[2];
+                MalSymbol key;
+                MalVal val;
+                Env let_env = new Env(env);
+                for(int i=0; i<((MalList)a1).size(); i+=2) {
+                    key = (MalSymbol)((MalList)a1)[i];
+                    val = ((MalList)a1)[i+1];
+                    let_env.set(key, EVAL(val, let_env));
+                }
+                orig_ast = a2;
+                env = let_env;
+                break;
+            case "quote":
+                return ast[1];
+            case "quasiquote":
+                orig_ast = quasiquote(ast[1]);
+                break;
+            case "defmacro!":
+                a1 = ast[1];
+                a2 = ast[2];
+                res = EVAL(a2, env);
+                ((MalFunc)res).setMacro();
+                env.set(((MalSymbol)a1), res);
+                return res;
+            case "macroexpand":
+                a1 = ast[1];
+                return macroexpand(a1, env);
+            case "try*":
+                try {
+                    return EVAL(ast[1], env);
+                } catch (Exception e) {
+                    if (ast.size() > 2) {
+                        MalVal exc;
+                        a2 = ast[2];
+                        MalVal a20 = ((MalList)a2)[0];
+                        if (((MalSymbol)a20).getName() == "catch*") {
+                            if (e is Mal.types.MalException) {
+                                exc = ((Mal.types.MalException)e).getValue();
+                            } else {
+                                exc = new MalString(e.StackTrace);
+                            }
+                            return EVAL(((MalList)a2)[2],
+                                        new Env(env, ((MalList)a2).slice(1,2),
+                                                new MalList(exc)));
+                        }
+                    }
+                    throw e;
+                }
+            case "do":
+                eval_ast(ast.slice(1, ast.size()-1), env);
+                orig_ast = ast[ast.size()-1];
+                break;
+            case "if":
+                a1 = ast[1];
+                MalVal cond = EVAL(a1, env);
+                if (cond == Mal.types.Nil || cond == Mal.types.False) {
+                    // eval false slot form
+                    if (ast.size() > 3) {
+                        orig_ast = ast[3];
+                    } else {
+                        return Mal.types.Nil;
+                    }
+                } else {
+                    // eval true slot form
+                    orig_ast = ast[2];
+                }
+                break;
+            case "fn*":
+                MalList a1f = (MalList)ast[1];
+                MalVal a2f = ast[2];
+                Env cur_env = env;
+                return new MalFunc(a2f, env, a1f,
+                    args => EVAL(a2f, new Env(cur_env, a1f, args)) );
+            default:
+                el = (MalList)eval_ast(ast, env);
+                var f = (MalFunc)el[0];
+                MalVal fnast = f.getAst();
+                if (fnast != null) {
+                    orig_ast = fnast;
+                    env = f.genEnv(el.rest());
+                } else {
+                    return f.apply(el.rest());
+                }
+                break;
+            }
+
+            }
+        }
+
+        // print
+        static string PRINT(MalVal exp) {
+            return printer._pr_str(exp, true);
+        }
+
+        // repl
+        static void Main(string[] args) {
+            var repl_env = new Mal.env.Env(null);
+            Func<string, MalVal> RE = (string str) => EVAL(READ(str), repl_env);
+            
+            // core.cs: defined using C#
+            foreach (var entry in core.ns) {
+                repl_env.set(new MalSymbol(entry.Key), entry.Value);
+            }
+            repl_env.set(new MalSymbol("eval"), new MalFunc(
+                        a => EVAL(a[0], repl_env)));
+            int fileIdx = 0;
+            if (args.Length > 0 && args[0] == "--raw") {
+                Mal.readline.mode = Mal.readline.Mode.Raw;
+                fileIdx = 1;
+            }
+            MalList _argv = new MalList();
+            for (int i=fileIdx; i < args.Length; i++) {
+                _argv.conj_BANG(new MalString(args[i]));
+            }
+            repl_env.set(new MalSymbol("*ARGV*"), _argv);
+
+            // core.mal: defined using the language itself
+            RE("(def! *host-language* \"c#\")");
+            RE("(def! not (fn* (a) (if a false true)))");
+            RE("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))");
+            RE("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))");
+            RE("(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))");
+
+            if (args.Length > fileIdx) {
+                RE("(load-file \"" + args[fileIdx] + "\")");
+                return;
+            }
+
+            // repl loop
+            RE("(println (str \"Mal [\" *host-language* \"]\"))");
+            while (true) {
+                string line;
+                try {
+                    line = Mal.readline.Readline("user> ");
+                    if (line == null) { break; }
+                    if (line == "") { continue; }
+                } catch (IOException e) {
+                    Console.WriteLine("IOException: " + e.Message);
+                    break;
+                }
+                try {
+                    Console.WriteLine(PRINT(RE(line)));
+                } catch (Mal.types.MalContinue) {
+                    continue;
+                } catch (Mal.types.MalException e) {
+                    Console.WriteLine("Error: " +
+                            printer._pr_str(e.getValue(), false));
+                    continue;
+                } catch (Exception e) {
+                    Console.WriteLine("Error: " + e.Message);
+                    Console.WriteLine(e.StackTrace);
+                    continue;
+                }
+            }
+        }
+    }
+}
diff --git a/docs/TODO b/docs/TODO
index e5b135b..e5a4fc1 100644
--- a/docs/TODO
+++ b/docs/TODO
@@ -1,7 +1,6 @@
 All:
     - Finish guide.md
 
-    - rename stepA_interop to stepA_mal
     - test to check args set properly
     - test to make sure slurp captures final newline
     - make sure errors propagate/print properly when self-hosted
@@ -94,7 +93,7 @@ Lua:
 Make:
     - allow '_' in make variable names
     - hash-map with space in key string
-    - Fix: make -f stepA_interop.mk ../mal/step6_file.mal
+    - Fix: make -f stepA_mal.mk ../mal/step6_file.mal
         (slurp "../tests/incA.mal")
         (read-string "(+ 2 3)")
     - errors should propagate up from within load-file
@@ -121,7 +120,7 @@ Postscript:
     - formatting messed up with mal/clojurewest2014.mal
 
 Python:
-    - error: python ../python/stepA_interop.py ../mal/stepA_interop.mal ../mal/stepA_interop.mal
+    - error: python ../python/stepA_mal.py ../mal/stepA_mal.mal ../mal/stepA_mal.mal
     - interop tests
 
 R:
diff --git a/docs/step_notes.txt b/docs/step_notes.txt
index f36575d..e28761a 100644
--- a/docs/step_notes.txt
+++ b/docs/step_notes.txt
@@ -405,7 +405,7 @@ Step Notes:
 - Other misc:
     - conj function
 
-- stepA_interop
+- stepA_mal
     - convert returned data to mal data
         - recursive, similar to pr_str
     - Details:
diff --git a/forth/Makefile b/forth/Makefile
index 400b463..29bf799 100644
--- a/forth/Makefile
+++ b/forth/Makefile
@@ -1,5 +1,5 @@
 SOURCES_BASE = types.fs str.fs reader.fs printer.fs
-SOURCES_LISP = env.fs core.fs stepA_interop.fs
+SOURCES_LISP = env.fs core.fs stepA_mal.fs
 SOURCES = $(SOURCES_BASE) $(SOURCES_LISP)
 
 .PHONY: stats tests $(TESTS)
diff --git a/forth/stepA_interop.fs b/forth/stepA_interop.fs
deleted file mode 100644
index af5f5d8..0000000
--- a/forth/stepA_interop.fs
+++ /dev/null
@@ -1,390 +0,0 @@
-require reader.fs
-require printer.fs
-require core.fs
-
-core MalEnv. constant repl-env
-
-99999999 constant TCO-eval
-
-: read read-str ;
-: eval ( env obj )
-    begin
-        \ ." eval-> " dup pr-str safe-type cr
-        mal-eval
-        dup TCO-eval =
-    while
-        drop
-    repeat ;
-: print
-    \ ." Type: " dup mal-type @ type-name safe-type cr
-    pr-str ;
-
-MalDefault extend mal-eval nip ;; drop \ By default, evalutate to yourself
-
-MalKeyword
-  extend eval-invoke { env list kw -- val }
-    0   kw   env list MalList/start @ cell+ @ eval   get
-    ?dup 0= if
-        \ compute not-found value
-        list MalList/count @ 1 > if
-            env  list MalList/start @ 2 cells + @  TCO-eval
-        else
-            mal-nil
-        endif
-    endif ;;
-  extend invoke { argv argc kw -- val }
-    0   kw   argv @   get
-    ?dup 0= if
-        argc 1 > if
-            argv cell+ @
-        else
-            mal-nil
-        endif
-    endif ;;
-drop
-
-\ eval all but the first item of list
-: eval-rest { env list -- argv argc }
-    list MalList/start @ cell+ { expr-start }
-    list MalList/count @ 1- { argc }
-    argc cells allocate throw { target }
-    argc 0 ?do
-        env expr-start i cells + @ eval
-        target i cells + !
-    loop
-    target argc ;
-
-MalNativeFn
-  extend eval-invoke { env list this -- list }
-    env list eval-rest ( argv argc )
-    this invoke ;;
-  extend invoke ( argv argc this -- val )
-    MalNativeFn/xt @ execute ;;
-drop
-
-SpecialOp
-  extend eval-invoke ( env list this -- list )
-    SpecialOp/xt @ execute ;;
-drop
-
-: install-special ( symbol xt )
-    SpecialOp. repl-env env/set ;
-
-: defspecial
-    parse-allot-name MalSymbol.
-    ['] install-special
-    :noname
-    ;
-
-: is-pair? ( obj -- bool )
-    empty? mal-false = ;
-
-defspecial quote ( env list -- form )
-    nip MalList/start @ cell+ @ ;;
-
-s" concat" MalSymbol. constant concat-sym
-s" cons" MalSymbol. constant cons-sym
-
-defer quasiquote
-: quasiquote0 { ast -- form }
-    ast is-pair? 0= if
-        here quote-sym , ast , here>MalList
-    else
-        ast to-list MalList/start @ { ast-start }
-        ast-start @ { ast[0] }
-        ast[0] unquote-sym m= if
-            ast-start cell+ @
-        else
-            ast[0] is-pair? if
-                ast[0] to-list MalList/start @ { ast[0]-start }
-                ast[0]-start @ splice-unquote-sym m= if
-                    here
-                    concat-sym ,
-                    ast[0]-start cell+ @ ,
-                    ast to-list MalList/rest quasiquote ,
-                    here>MalList
-                    false
-                else true endif
-            else true endif
-            if
-                here
-                cons-sym ,
-                ast[0] quasiquote ,
-                ast to-list MalList/rest quasiquote ,
-                here>MalList
-            endif
-        endif
-    endif ;
-' quasiquote0 is quasiquote
-
-defspecial quasiquote ( env list )
-    MalList/start @ cell+ @ ( ast )
-    quasiquote TCO-eval ;;
-
-defspecial def! { env list -- val }
-    list MalList/start @ cell+ { arg0 }
-    arg0 @ ( key )
-    env arg0 cell+ @ eval dup { val } ( key val )
-    env env/set val ;;
-
-defspecial defmacro! { env list -- val }
-    list MalList/start @ cell+ { arg0 }
-    arg0 @ ( key )
-    env arg0 cell+ @ eval { val }
-    true val MalUserFn/is-macro? !
-    val env env/set
-    val ;;
-
-defspecial let* { old-env list -- val }
-    old-env MalEnv. { env }
-    list MalList/start @ cell+ dup { arg0 }
-    @ to-list
-    dup MalList/start @ { bindings-start } ( list )
-    MalList/count @ 0 +do
-        bindings-start i cells + dup @ swap cell+ @ ( sym expr )
-        env swap eval
-        env env/set
-    2 +loop
-    env arg0 cell+ @ TCO-eval
-    \ TODO: dec refcount of env
-    ;;
-
-defspecial do { env list -- val }
-    list MalList/start @ { start }
-    list MalList/count @ dup 1- { last } 1 ?do
-        env   start i cells + @
-        i last = if
-            TCO-eval
-        else
-            eval drop
-        endif
-    loop ;;
-
-defspecial if { env list -- val }
-    list MalList/start @ cell+ { arg0 }
-    env arg0 @ eval ( test-val )
-    dup mal-false = if
-        drop -1
-    else
-        mal-nil =
-    endif
-    if
-        \ branch to false
-        list MalList/count @ 3 > if
-            env arg0 cell+ cell+ @ TCO-eval
-        else
-            mal-nil
-        endif
-    else
-        \ branch to true
-        env arg0 cell+ @ TCO-eval
-    endif ;;
-
-s" &" MalSymbol. constant &-sym
-
-: new-user-fn-env { argv argc mal-fn -- env }
-    mal-fn MalUserFn/formal-args @ { f-args-list }
-    mal-fn MalUserFn/env @ MalEnv. { env }
-
-    f-args-list MalList/start @ { f-args }
-    f-args-list MalList/count @ ?dup 0= if else
-        \ pass nil for last arg, unless overridden below
-        1- cells f-args + @ mal-nil env env/set
-    endif
-    argc 0 ?do
-        f-args i cells + @
-        dup &-sym m= if
-            drop
-            argc i - { c }
-            c cells allocate throw { start }
-            argv i cells +  start  c cells  cmove
-            f-args i 1+ cells + @ ( more-args-symbol )
-            start c MalList. env env/set
-            leave
-        endif
-        argv i cells + @
-        env env/set
-    loop
-    env ;
-
-MalUserFn
-  extend eval-invoke { call-env list mal-fn -- list }
-    mal-fn MalUserFn/is-macro? @ if
-        list MalList/start @ cell+  \ argv
-        list MalList/count @ 1-     \ argc
-        mal-fn new-user-fn-env { env }
-        env   mal-fn MalUserFn/body @   eval
-        call-env swap TCO-eval
-    else
-        call-env list eval-rest
-        mal-fn invoke
-    endif ;;
-
-  extend invoke ( argv argc mal-fn )
-    dup { mal-fn } new-user-fn-env { env }
-    env   mal-fn MalUserFn/body @   TCO-eval ;;
-drop
-
-defspecial fn* { env list -- val }
-    list MalList/start @ cell+ { arg0 }
-    MalUserFn new
-    false over MalUserFn/is-macro? !
-    env over MalUserFn/env !
-    arg0 @ to-list over MalUserFn/formal-args !
-    arg0 cell+ @ over MalUserFn/body ! ;;
-
-defspecial macroexpand ( env list[_,form] -- form )
-    MalList/start @ cell+ @ swap over ( form env form )
-    MalList/start @ @ ( form env macro-name-expr )
-    eval { macro-fn } ( form )
-    dup MalList/start @ cell+  swap MalList/count @ 1- macro-fn ( argv argc fn )
-    new-user-fn-env ( env )
-    macro-fn MalUserFn/body @   TCO-eval ;;
-
-5555555555 constant pre-try
-
-defspecial try* { env list -- val }
-    list MalList/start @ cell+ { arg0 }
-    pre-try
-    env arg0 @ ['] eval catch ?dup 0= if
-        nip
-    else { errno }
-        begin pre-try = until
-        errno 1 <> if
-            s" forth-errno" MalKeyword. errno MalInt. MalMap/Empty assoc
-            to exception-object
-        endif
-        arg0 cell+ @ ( list[catch*,sym,form] )
-        MalList/start @ cell+ { catch0 }
-        env MalEnv. { catch-env }
-        catch0 @ exception-object catch-env env/set
-        catch-env  catch0 cell+ @  TCO-eval
-    endif ;;
-
-defspecial . { env coll -- rtn-list }
-    depth { old-depth }
-    coll to-list dup MalList/count @ swap MalList/start @ { count start }
-    count cells start +  start cell+  +do
-        env i @ eval as-native
-    cell +loop ;;
-
-MalSymbol
-  extend mal-eval { env sym -- val }
-    sym env env/get-addr
-    dup 0= if
-        drop
-        0 0 s" ' not found" sym pr-str s" '" ...throw-str
-    else
-        @
-    endif ;;
-drop
-
-: eval-ast { env list -- list }
-    here
-    list MalList/start @ { expr-start }
-    list MalList/count @ 0 ?do
-        env expr-start i cells + @ eval ,
-    loop
-    here>MalList ;
-
-MalList
-  extend mal-eval { env list -- val }
-    env list MalList/start @ @ eval
-    env list rot eval-invoke ;;
-drop
-
-MalVector
-  extend mal-eval ( env vector -- vector )
-    MalVector/list @ eval-ast
-    MalVector new swap over MalVector/list ! ;;
-drop
-
-MalMap
-  extend mal-eval ( env map -- map )
-    MalMap/list @ eval-ast
-    MalMap new swap over MalMap/list ! ;;
-drop
-
-defcore eval ( argv argc )
-  drop @ repl-env swap eval ;;
-
-: rep ( str-addr str-len -- str-addr str-len )
-    read
-    repl-env swap eval
-    print ;
-
-: mk-args-list ( -- )
-    here
-    begin
-        next-arg 2dup 0 0 d<> while
-            MalString. ,
-    repeat
-    2drop here>MalList ;
-
-create buff 128 allot
-77777777777 constant stack-leak-detect
-
-: nop ;
-
-defcore map ( argv argc -- list )
-    drop dup @ swap cell+ @ to-list { fn list }
-    here
-    list MalList/start @   list MalList/count @  cells   over + swap   +do
-        i 1 fn invoke
-        dup TCO-eval = if drop eval endif
-        ,
-    cell +loop
-    here>MalList ;;
-
-defcore readline ( argv argc -- mal-string )
-    drop @ unpack-str type stdout flush-file drop
-    buff 128 stdin read-line throw
-    if buff swap MalString. else drop mal-nil endif ;;
-
-s\" (def! *host-language* \"forth\")" rep 2drop
-s\" (def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))" rep 2drop
-s\" (defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))" rep 2drop
-s\" (defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))" rep 2drop
-s\" (def! swap! (fn* [a f & args] (reset! a (apply f @a args))))" rep 2drop
-
-: repl ( -- )
-    s\" (println (str \"Mal [\" *host-language* \"]\"))" rep 2drop
-    begin
-      ." user> "
-      stack-leak-detect
-      buff 128 stdin read-line throw
-    while ( num-bytes-read )
-      buff swap ( str-addr str-len )
-      ['] rep
-      \ execute ['] nop \ uncomment to see stack traces
-      catch ?dup 0= if
-          safe-type cr
-          stack-leak-detect <> if ." --stack leak--" cr endif
-      else { errno }
-          begin stack-leak-detect = until
-          errno 1 <> if
-              s" forth-errno" MalKeyword. errno MalInt. MalMap/Empty assoc
-              to exception-object
-          endif
-          ." Uncaught exception: "
-          exception-object pr-str safe-type cr
-      endif
-    repeat ;
-
-: main ( -- )
-    mk-args-list { args-list }
-    args-list MalList/count @ 0= if
-        s" *ARGV*" MalSymbol. MalList/Empty repl-env env/set
-        repl
-    else
-        args-list MalList/start @ @ { filename }
-        s" *ARGV*" MalSymbol. args-list MalList/rest repl-env env/set
-
-        repl-env
-        here s" load-file" MalSymbol. , filename , here>MalList
-        eval print
-    endif ;
-
-main
-cr
-bye
diff --git a/forth/stepA_mal.fs b/forth/stepA_mal.fs
new file mode 100644
index 0000000..af5f5d8
--- /dev/null
+++ b/forth/stepA_mal.fs
@@ -0,0 +1,390 @@
+require reader.fs
+require printer.fs
+require core.fs
+
+core MalEnv. constant repl-env
+
+99999999 constant TCO-eval
+
+: read read-str ;
+: eval ( env obj )
+    begin
+        \ ." eval-> " dup pr-str safe-type cr
+        mal-eval
+        dup TCO-eval =
+    while
+        drop
+    repeat ;
+: print
+    \ ." Type: " dup mal-type @ type-name safe-type cr
+    pr-str ;
+
+MalDefault extend mal-eval nip ;; drop \ By default, evalutate to yourself
+
+MalKeyword
+  extend eval-invoke { env list kw -- val }
+    0   kw   env list MalList/start @ cell+ @ eval   get
+    ?dup 0= if
+        \ compute not-found value
+        list MalList/count @ 1 > if
+            env  list MalList/start @ 2 cells + @  TCO-eval
+        else
+            mal-nil
+        endif
+    endif ;;
+  extend invoke { argv argc kw -- val }
+    0   kw   argv @   get
+    ?dup 0= if
+        argc 1 > if
+            argv cell+ @
+        else
+            mal-nil
+        endif
+    endif ;;
+drop
+
+\ eval all but the first item of list
+: eval-rest { env list -- argv argc }
+    list MalList/start @ cell+ { expr-start }
+    list MalList/count @ 1- { argc }
+    argc cells allocate throw { target }
+    argc 0 ?do
+        env expr-start i cells + @ eval
+        target i cells + !
+    loop
+    target argc ;
+
+MalNativeFn
+  extend eval-invoke { env list this -- list }
+    env list eval-rest ( argv argc )
+    this invoke ;;
+  extend invoke ( argv argc this -- val )
+    MalNativeFn/xt @ execute ;;
+drop
+
+SpecialOp
+  extend eval-invoke ( env list this -- list )
+    SpecialOp/xt @ execute ;;
+drop
+
+: install-special ( symbol xt )
+    SpecialOp. repl-env env/set ;
+
+: defspecial
+    parse-allot-name MalSymbol.
+    ['] install-special
+    :noname
+    ;
+
+: is-pair? ( obj -- bool )
+    empty? mal-false = ;
+
+defspecial quote ( env list -- form )
+    nip MalList/start @ cell+ @ ;;
+
+s" concat" MalSymbol. constant concat-sym
+s" cons" MalSymbol. constant cons-sym
+
+defer quasiquote
+: quasiquote0 { ast -- form }
+    ast is-pair? 0= if
+        here quote-sym , ast , here>MalList
+    else
+        ast to-list MalList/start @ { ast-start }
+        ast-start @ { ast[0] }
+        ast[0] unquote-sym m= if
+            ast-start cell+ @
+        else
+            ast[0] is-pair? if
+                ast[0] to-list MalList/start @ { ast[0]-start }
+                ast[0]-start @ splice-unquote-sym m= if
+                    here
+                    concat-sym ,
+                    ast[0]-start cell+ @ ,
+                    ast to-list MalList/rest quasiquote ,
+                    here>MalList
+                    false
+                else true endif
+            else true endif
+            if
+                here
+                cons-sym ,
+                ast[0] quasiquote ,
+                ast to-list MalList/rest quasiquote ,
+                here>MalList
+            endif
+        endif
+    endif ;
+' quasiquote0 is quasiquote
+
+defspecial quasiquote ( env list )
+    MalList/start @ cell+ @ ( ast )
+    quasiquote TCO-eval ;;
+
+defspecial def! { env list -- val }
+    list MalList/start @ cell+ { arg0 }
+    arg0 @ ( key )
+    env arg0 cell+ @ eval dup { val } ( key val )
+    env env/set val ;;
+
+defspecial defmacro! { env list -- val }
+    list MalList/start @ cell+ { arg0 }
+    arg0 @ ( key )
+    env arg0 cell+ @ eval { val }
+    true val MalUserFn/is-macro? !
+    val env env/set
+    val ;;
+
+defspecial let* { old-env list -- val }
+    old-env MalEnv. { env }
+    list MalList/start @ cell+ dup { arg0 }
+    @ to-list
+    dup MalList/start @ { bindings-start } ( list )
+    MalList/count @ 0 +do
+        bindings-start i cells + dup @ swap cell+ @ ( sym expr )
+        env swap eval
+        env env/set
+    2 +loop
+    env arg0 cell+ @ TCO-eval
+    \ TODO: dec refcount of env
+    ;;
+
+defspecial do { env list -- val }
+    list MalList/start @ { start }
+    list MalList/count @ dup 1- { last } 1 ?do
+        env   start i cells + @
+        i last = if
+            TCO-eval
+        else
+            eval drop
+        endif
+    loop ;;
+
+defspecial if { env list -- val }
+    list MalList/start @ cell+ { arg0 }
+    env arg0 @ eval ( test-val )
+    dup mal-false = if
+        drop -1
+    else
+        mal-nil =
+    endif
+    if
+        \ branch to false
+        list MalList/count @ 3 > if
+            env arg0 cell+ cell+ @ TCO-eval
+        else
+            mal-nil
+        endif
+    else
+        \ branch to true
+        env arg0 cell+ @ TCO-eval
+    endif ;;
+
+s" &" MalSymbol. constant &-sym
+
+: new-user-fn-env { argv argc mal-fn -- env }
+    mal-fn MalUserFn/formal-args @ { f-args-list }
+    mal-fn MalUserFn/env @ MalEnv. { env }
+
+    f-args-list MalList/start @ { f-args }
+    f-args-list MalList/count @ ?dup 0= if else
+        \ pass nil for last arg, unless overridden below
+        1- cells f-args + @ mal-nil env env/set
+    endif
+    argc 0 ?do
+        f-args i cells + @
+        dup &-sym m= if
+            drop
+            argc i - { c }
+            c cells allocate throw { start }
+            argv i cells +  start  c cells  cmove
+            f-args i 1+ cells + @ ( more-args-symbol )
+            start c MalList. env env/set
+            leave
+        endif
+        argv i cells + @
+        env env/set
+    loop
+    env ;
+
+MalUserFn
+  extend eval-invoke { call-env list mal-fn -- list }
+    mal-fn MalUserFn/is-macro? @ if
+        list MalList/start @ cell+  \ argv
+        list MalList/count @ 1-     \ argc
+        mal-fn new-user-fn-env { env }
+        env   mal-fn MalUserFn/body @   eval
+        call-env swap TCO-eval
+    else
+        call-env list eval-rest
+        mal-fn invoke
+    endif ;;
+
+  extend invoke ( argv argc mal-fn )
+    dup { mal-fn } new-user-fn-env { env }
+    env   mal-fn MalUserFn/body @   TCO-eval ;;
+drop
+
+defspecial fn* { env list -- val }
+    list MalList/start @ cell+ { arg0 }
+    MalUserFn new
+    false over MalUserFn/is-macro? !
+    env over MalUserFn/env !
+    arg0 @ to-list over MalUserFn/formal-args !
+    arg0 cell+ @ over MalUserFn/body ! ;;
+
+defspecial macroexpand ( env list[_,form] -- form )
+    MalList/start @ cell+ @ swap over ( form env form )
+    MalList/start @ @ ( form env macro-name-expr )
+    eval { macro-fn } ( form )
+    dup MalList/start @ cell+  swap MalList/count @ 1- macro-fn ( argv argc fn )
+    new-user-fn-env ( env )
+    macro-fn MalUserFn/body @   TCO-eval ;;
+
+5555555555 constant pre-try
+
+defspecial try* { env list -- val }
+    list MalList/start @ cell+ { arg0 }
+    pre-try
+    env arg0 @ ['] eval catch ?dup 0= if
+        nip
+    else { errno }
+        begin pre-try = until
+        errno 1 <> if
+            s" forth-errno" MalKeyword. errno MalInt. MalMap/Empty assoc
+            to exception-object
+        endif
+        arg0 cell+ @ ( list[catch*,sym,form] )
+        MalList/start @ cell+ { catch0 }
+        env MalEnv. { catch-env }
+        catch0 @ exception-object catch-env env/set
+        catch-env  catch0 cell+ @  TCO-eval
+    endif ;;
+
+defspecial . { env coll -- rtn-list }
+    depth { old-depth }
+    coll to-list dup MalList/count @ swap MalList/start @ { count start }
+    count cells start +  start cell+  +do
+        env i @ eval as-native
+    cell +loop ;;
+
+MalSymbol
+  extend mal-eval { env sym -- val }
+    sym env env/get-addr
+    dup 0= if
+        drop
+        0 0 s" ' not found" sym pr-str s" '" ...throw-str
+    else
+        @
+    endif ;;
+drop
+
+: eval-ast { env list -- list }
+    here
+    list MalList/start @ { expr-start }
+    list MalList/count @ 0 ?do
+        env expr-start i cells + @ eval ,
+    loop
+    here>MalList ;
+
+MalList
+  extend mal-eval { env list -- val }
+    env list MalList/start @ @ eval
+    env list rot eval-invoke ;;
+drop
+
+MalVector
+  extend mal-eval ( env vector -- vector )
+    MalVector/list @ eval-ast
+    MalVector new swap over MalVector/list ! ;;
+drop
+
+MalMap
+  extend mal-eval ( env map -- map )
+    MalMap/list @ eval-ast
+    MalMap new swap over MalMap/list ! ;;
+drop
+
+defcore eval ( argv argc )
+  drop @ repl-env swap eval ;;
+
+: rep ( str-addr str-len -- str-addr str-len )
+    read
+    repl-env swap eval
+    print ;
+
+: mk-args-list ( -- )
+    here
+    begin
+        next-arg 2dup 0 0 d<> while
+            MalString. ,
+    repeat
+    2drop here>MalList ;
+
+create buff 128 allot
+77777777777 constant stack-leak-detect
+
+: nop ;
+
+defcore map ( argv argc -- list )
+    drop dup @ swap cell+ @ to-list { fn list }
+    here
+    list MalList/start @   list MalList/count @  cells   over + swap   +do
+        i 1 fn invoke
+        dup TCO-eval = if drop eval endif
+        ,
+    cell +loop
+    here>MalList ;;
+
+defcore readline ( argv argc -- mal-string )
+    drop @ unpack-str type stdout flush-file drop
+    buff 128 stdin read-line throw
+    if buff swap MalString. else drop mal-nil endif ;;
+
+s\" (def! *host-language* \"forth\")" rep 2drop
+s\" (def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))" rep 2drop
+s\" (defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))" rep 2drop
+s\" (defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))" rep 2drop
+s\" (def! swap! (fn* [a f & args] (reset! a (apply f @a args))))" rep 2drop
+
+: repl ( -- )
+    s\" (println (str \"Mal [\" *host-language* \"]\"))" rep 2drop
+    begin
+      ." user> "
+      stack-leak-detect
+      buff 128 stdin read-line throw
+    while ( num-bytes-read )
+      buff swap ( str-addr str-len )
+      ['] rep
+      \ execute ['] nop \ uncomment to see stack traces
+      catch ?dup 0= if
+          safe-type cr
+          stack-leak-detect <> if ." --stack leak--" cr endif
+      else { errno }
+          begin stack-leak-detect = until
+          errno 1 <> if
+              s" forth-errno" MalKeyword. errno MalInt. MalMap/Empty assoc
+              to exception-object
+          endif
+          ." Uncaught exception: "
+          exception-object pr-str safe-type cr
+      endif
+    repeat ;
+
+: main ( -- )
+    mk-args-list { args-list }
+    args-list MalList/count @ 0= if
+        s" *ARGV*" MalSymbol. MalList/Empty repl-env env/set
+        repl
+    else
+        args-list MalList/start @ @ { filename }
+        s" *ARGV*" MalSymbol. args-list MalList/rest repl-env env/set
+
+        repl-env
+        here s" load-file" MalSymbol. , filename , here>MalList
+        eval print
+    endif ;
+
+main
+cr
+bye
diff --git a/forth/tests/stepA_interop.mal b/forth/tests/stepA_interop.mal
deleted file mode 100644
index c4a0e75..0000000
--- a/forth/tests/stepA_interop.mal
+++ /dev/null
@@ -1,41 +0,0 @@
-;; Basic interop
-(. 5 'MalInt.)
-;=>5
-(. 11 31 '+ 'MalInt.)
-;=>42
-(. "greetings" 'MalString.)
-;=>"greetings"
-(. "hello" 'type 'cr 'mal-nil)
-; hello
-;=>nil
-
-;; Interop on non-literals
-(. (+ 15 27) 'MalInt.)
-;=>42
-(let* [a 17] (. a 25 '+ 'MalInt.))
-;=>42
-(let* [a "hello"] (. a 1 '- 'MalString.))
-;=>"hell"
-
-;; Use of annoyingly-named forth words
-(. 1 'MalInt. (symbol ",") 'here (symbol "@"))
-;=>1
-(let* (i 'MalInt.) (. 5 i))
-;=>5
-(let* (comma (symbol ",") fetch (symbol "@")) (. 'here 42 'MalInt. comma fetch))
-;=>42
-
-;; Multiple .-forms interacting via heap memory and mal locals
-(def! string-parts (fn* (s) (. s 'MalInt. 'swap 'MalInt. 'here '-rot (symbol ",") (symbol ",") 'here>MalList)))
-(first (rest (string-parts "sketchy")))
-;=>7
-(def! prn-chars (fn* (start count) (if (> count 0) (do (prn (. start 1 'MalString.)) (prn-chars (+ start 1) (- count 1))))))
-(let* (msg (string-parts "sketchy")) (prn-chars (first msg) (first (rest msg))))
-; "s"
-; "k"
-; "e"
-; "t"
-; "c"
-; "h"
-; "y"
-;=>nil
diff --git a/forth/tests/stepA_mal.mal b/forth/tests/stepA_mal.mal
new file mode 100644
index 0000000..c4a0e75
--- /dev/null
+++ b/forth/tests/stepA_mal.mal
@@ -0,0 +1,41 @@
+;; Basic interop
+(. 5 'MalInt.)
+;=>5
+(. 11 31 '+ 'MalInt.)
+;=>42
+(. "greetings" 'MalString.)
+;=>"greetings"
+(. "hello" 'type 'cr 'mal-nil)
+; hello
+;=>nil
+
+;; Interop on non-literals
+(. (+ 15 27) 'MalInt.)
+;=>42
+(let* [a 17] (. a 25 '+ 'MalInt.))
+;=>42
+(let* [a "hello"] (. a 1 '- 'MalString.))
+;=>"hell"
+
+;; Use of annoyingly-named forth words
+(. 1 'MalInt. (symbol ",") 'here (symbol "@"))
+;=>1
+(let* (i 'MalInt.) (. 5 i))
+;=>5
+(let* (comma (symbol ",") fetch (symbol "@")) (. 'here 42 'MalInt. comma fetch))
+;=>42
+
+;; Multiple .-forms interacting via heap memory and mal locals
+(def! string-parts (fn* (s) (. s 'MalInt. 'swap 'MalInt. 'here '-rot (symbol ",") (symbol ",") 'here>MalList)))
+(first (rest (string-parts "sketchy")))
+;=>7
+(def! prn-chars (fn* (start count) (if (> count 0) (do (prn (. start 1 'MalString.)) (prn-chars (+ start 1) (- count 1))))))
+(let* (msg (string-parts "sketchy")) (prn-chars (first msg) (first (rest msg))))
+; "s"
+; "k"
+; "e"
+; "t"
+; "c"
+; "h"
+; "y"
+;=>nil
diff --git a/go/Makefile b/go/Makefile
index 5c966f5..67e967b 100644
--- a/go/Makefile
+++ b/go/Makefile
@@ -6,14 +6,14 @@ SOURCES_BASE = src/types/types.go src/readline/readline.go \
 	       src/reader/reader.go src/printer/printer.go \
 	       src/env/env.go src/core/core.go
 SOURCES_LISP = src/env/env.go src/core/core.go \
-	       src/stepA_interop/stepA_interop.go
+	       src/stepA_mal/stepA_mal.go
 SOURCES = $(SOURCES_BASE) $(word $(words $(SOURCES_LISP)),${SOURCES_LISP})
 
 #####################
 
 SRCS = step0_repl.go step1_read_print.go step2_eval.go step3_env.go \
        step4_if_fn_do.go step5_tco.go step6_file.go step7_quote.go \
-       step8_macros.go step9_try.go stepA_interop.go
+       step8_macros.go step9_try.go stepA_mal.go
 BINS = $(SRCS:%.go=%)
 
 #####################
diff --git a/go/src/stepA_interop/stepA_interop.go b/go/src/stepA_interop/stepA_interop.go
deleted file mode 100644
index 808022a..0000000
--- a/go/src/stepA_interop/stepA_interop.go
+++ /dev/null
@@ -1,306 +0,0 @@
-package main
-
-import (
-    "fmt"
-    "strings"
-    "errors"
-    "os"
-)
-
-import (
-    "readline"
-    . "types"
-    "reader"
-    "printer"
-    . "env"
-    "core"
-)
-
-// read
-func READ(str string) (MalType, error) {
-    return reader.Read_str(str)
-}
-
-// eval
-func is_pair(x MalType) bool {
-    slc, e := GetSlice(x)
-    if e != nil { return false }
-    return len(slc) > 0
-}
-
-func quasiquote(ast MalType) MalType {
-    if !is_pair(ast) {
-        return List{[]MalType{Symbol{"quote"}, ast},nil}
-    } else {
-        slc, _ := GetSlice(ast)
-        a0 := slc[0]
-        if Symbol_Q(a0) && (a0.(Symbol).Val == "unquote") {
-            return slc[1]
-        } else if is_pair(a0) {
-            slc0, _ := GetSlice(a0)
-            a00 := slc0[0]
-            if Symbol_Q(a00) && (a00.(Symbol).Val == "splice-unquote") {
-                return List{[]MalType{Symbol{"concat"},
-                                      slc0[1],
-                                      quasiquote(List{slc[1:],nil})},nil}
-            }
-        }
-        return List{[]MalType{Symbol{"cons"},
-                              quasiquote(a0),
-                              quasiquote(List{slc[1:],nil})},nil}
-    }
-}
-
-func is_macro_call(ast MalType, env EnvType) bool {
-    if List_Q(ast) {
-        slc, _ := GetSlice(ast)
-        a0 := slc[0]
-        if Symbol_Q(a0) && env.Find(a0.(Symbol)) != nil {
-            mac, e := env.Get(a0.(Symbol))
-            if e != nil { return false }
-            if MalFunc_Q(mac) {
-                return mac.(MalFunc).GetMacro()
-            }
-        }
-    }
-    return false
-}
-
-func macroexpand(ast MalType, env EnvType)  (MalType, error) {
-    var mac MalType
-    var e error
-    for ; is_macro_call(ast, env) ; {
-        slc, _ := GetSlice(ast)
-        a0 := slc[0]
-        mac, e = env.Get(a0.(Symbol)); if e != nil { return nil, e }
-        fn := mac.(MalFunc)
-        ast, e = Apply(fn, slc[1:]); if e != nil { return nil, e }
-    }
-    return ast, nil
-}
-
-func eval_ast(ast MalType, env EnvType) (MalType, error) {
-    //fmt.Printf("eval_ast: %#v\n", ast)
-    if Symbol_Q(ast) {
-        return env.Get(ast.(Symbol))
-    } else if List_Q(ast) {
-        lst := []MalType{}
-        for _, a := range ast.(List).Val {
-            exp, e := EVAL(a, env)
-            if e != nil { return nil, e }
-            lst = append(lst, exp)
-        }
-        return List{lst,nil}, nil
-    } else if Vector_Q(ast) {
-        lst := []MalType{}
-        for _, a := range ast.(Vector).Val {
-            exp, e := EVAL(a, env)
-            if e != nil { return nil, e }
-            lst = append(lst, exp)
-        }
-        return Vector{lst,nil}, nil
-    } else if HashMap_Q(ast) {
-        m := ast.(HashMap)
-        new_hm := HashMap{map[string]MalType{},nil}
-        for k, v := range m.Val {
-            ke, e1 := EVAL(k, env)
-            if e1 != nil { return nil, e1 }
-            if _, ok := ke.(string); !ok {
-                return nil, errors.New("non string hash-map key")
-            }
-            kv, e2 := EVAL(v, env)
-            if e2 != nil { return nil, e2 }
-            new_hm.Val[ke.(string)] = kv
-        }
-        return new_hm, nil
-    } else {
-        return ast, nil
-    }
-}
-
-func EVAL(ast MalType, env EnvType) (MalType, error) {
-    var e error
-    for {
-
-    //fmt.Printf("EVAL: %v\n", printer.Pr_str(ast, true))
-    switch ast.(type) {
-    case List: // continue
-    default:   return eval_ast(ast, env)
-    }
-
-    // apply list
-    ast, e = macroexpand(ast, env); if e != nil { return nil, e }
-    if (!List_Q(ast)) { return ast, nil }
-
-    a0 := ast.(List).Val[0]
-    var a1 MalType = nil; var a2 MalType = nil
-    switch len(ast.(List).Val) {
-    case 1:
-        a1 = nil; a2 = nil
-    case 2:
-        a1 = ast.(List).Val[1]; a2 = nil
-    default:
-        a1 = ast.(List).Val[1]; a2 = ast.(List).Val[2]
-    }
-    a0sym := "__<*fn*>__"
-    if Symbol_Q(a0) { a0sym = a0.(Symbol).Val } 
-    switch a0sym {
-    case "def!":
-        res, e := EVAL(a2, env)
-        if e != nil { return nil, e }
-        return env.Set(a1.(Symbol), res), nil
-    case "let*":
-        let_env, e := NewEnv(env, nil, nil)
-        if e != nil { return nil, e }
-        arr1, e := GetSlice(a1)
-        if e != nil { return nil, e }
-        for i := 0; i < len(arr1); i+=2 {
-            if !Symbol_Q(arr1[i]) {
-                return nil, errors.New("non-symbol bind value")
-            }
-            exp, e := EVAL(arr1[i+1], let_env)
-            if e != nil { return nil, e }
-            let_env.Set(arr1[i].(Symbol), exp)
-        }
-        ast = a2
-        env = let_env
-    case "quote":
-        return a1, nil
-    case "quasiquote":
-        ast = quasiquote(a1)
-    case "defmacro!":
-        fn, e := EVAL(a2, env)
-        fn = fn.(MalFunc).SetMacro()
-        if e != nil { return nil, e }
-        return env.Set(a1.(Symbol), fn), nil
-    case "macroexpand":
-        return macroexpand(a1, env)
-    case "try*":        
-        var exc MalType
-        exp, e := EVAL(a1, env)
-        if e == nil {
-            return exp, nil
-        } else {
-            if a2 != nil && List_Q(a2) {
-                a2s, _ := GetSlice(a2)
-                if Symbol_Q(a2s[0]) && (a2s[0].(Symbol).Val == "catch*") {
-                    switch e.(type) {
-                    case MalError: exc = e.(MalError).Obj
-                    default:       exc = e.Error()
-                    }
-                    binds := NewList(a2s[1])
-                    new_env, e := NewEnv(env, binds, NewList(exc))
-                    if e != nil { return nil, e }
-                    exp, e = EVAL(a2s[2], new_env)
-                    if e == nil { return exp, nil }
-                }
-            }
-            return nil, e
-        }
-    case "do":
-        lst := ast.(List).Val
-        _, e := eval_ast(List{lst[1:len(lst)-1],nil}, env) 
-        if e != nil { return nil, e }
-        if len(lst) == 1 { return nil, nil }
-        ast = lst[len(lst)-1]
-    case "if":
-        cond, e := EVAL(a1, env)
-        if e != nil { return nil, e }
-        if cond == nil || cond == false {
-            if len(ast.(List).Val) >= 4 {
-                ast = ast.(List).Val[3]
-            } else {
-                return nil, nil
-            }
-        } else {
-            ast = a2
-        }
-    case "fn*":
-        fn := MalFunc{EVAL, a2, env, a1, false, NewEnv, nil}
-        return fn, nil
-    default:
-        el, e := eval_ast(ast, env)
-        if e != nil { return nil, e }
-        f := el.(List).Val[0]
-        if MalFunc_Q(f) {
-            fn := f.(MalFunc)
-            ast = fn.Exp
-            env, e = NewEnv(fn.Env, fn.Params, List{el.(List).Val[1:],nil})
-            if e != nil { return nil, e }
-        } else {
-            fn, ok := f.(Func)
-            if !ok { return nil, errors.New("attempt to call non-function") }
-            return fn.Fn(el.(List).Val[1:])
-        }
-    }
-
-    } // TCO loop
-}
-
-// print
-func PRINT(exp MalType) (string, error) {
-    return printer.Pr_str(exp, true), nil
-}
-
-
-var repl_env, _ = NewEnv(nil, nil, nil)
-
-// repl
-func rep(str string) (MalType, error) {
-    var exp MalType
-    var res string
-    var e error
-    if exp, e = READ(str); e != nil { return nil, e }
-    if exp, e = EVAL(exp, repl_env); e != nil { return nil, e }
-    if res, e = PRINT(exp); e != nil { return nil, e }
-    return res, nil
-}
-
-func main() {
-    // core.go: defined using go
-    for k, v := range core.NS {
-        repl_env.Set(Symbol{k}, Func{v.(func([]MalType)(MalType,error)),nil})
-    }
-    repl_env.Set(Symbol{"eval"}, Func{func(a []MalType) (MalType, error) {
-        return EVAL(a[0], repl_env) },nil})
-    repl_env.Set(Symbol{"*ARGV*"}, List{})
-
-    // core.mal: defined using the language itself
-    rep("(def! *host-language* \"go\")")
-    rep("(def! not (fn* (a) (if a false true)))")
-    rep("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))")
-    rep("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))")
-    rep("(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))")
-
-    // called with mal script to load and eval
-    if len(os.Args) > 1 {
-        args := make([]MalType, 0, len(os.Args)-2)
-        for _,a := range os.Args[2:] {
-            args = append(args, a)
-        }
-        repl_env.Set(Symbol{"*ARGV*"}, List{args,nil})
-        if _,e := rep("(load-file \"" + os.Args[1] + "\")"); e != nil {
-            fmt.Printf("Error: %v\n", e)
-            os.Exit(1)
-        }
-        os.Exit(0)
-    }
-
-    // repl loop
-    rep("(println (str \"Mal [\" *host-language* \"]\"))")
-    for {
-        text, err := readline.Readline("user> ")
-        text = strings.TrimRight(text, "\n");
-        if (err != nil) {
-            return
-        }
-        var out MalType
-        var e error
-        if out, e = rep(text); e != nil {
-            if e.Error() == "<empty line>" { continue }
-            fmt.Printf("Error: %v\n", e)
-            continue
-        }
-        fmt.Printf("%v\n", out)
-    }
-}
diff --git a/go/src/stepA_mal/stepA_mal.go b/go/src/stepA_mal/stepA_mal.go
new file mode 100644
index 0000000..808022a
--- /dev/null
+++ b/go/src/stepA_mal/stepA_mal.go
@@ -0,0 +1,306 @@
+package main
+
+import (
+    "fmt"
+    "strings"
+    "errors"
+    "os"
+)
+
+import (
+    "readline"
+    . "types"
+    "reader"
+    "printer"
+    . "env"
+    "core"
+)
+
+// read
+func READ(str string) (MalType, error) {
+    return reader.Read_str(str)
+}
+
+// eval
+func is_pair(x MalType) bool {
+    slc, e := GetSlice(x)
+    if e != nil { return false }
+    return len(slc) > 0
+}
+
+func quasiquote(ast MalType) MalType {
+    if !is_pair(ast) {
+        return List{[]MalType{Symbol{"quote"}, ast},nil}
+    } else {
+        slc, _ := GetSlice(ast)
+        a0 := slc[0]
+        if Symbol_Q(a0) && (a0.(Symbol).Val == "unquote") {
+            return slc[1]
+        } else if is_pair(a0) {
+            slc0, _ := GetSlice(a0)
+            a00 := slc0[0]
+            if Symbol_Q(a00) && (a00.(Symbol).Val == "splice-unquote") {
+                return List{[]MalType{Symbol{"concat"},
+                                      slc0[1],
+                                      quasiquote(List{slc[1:],nil})},nil}
+            }
+        }
+        return List{[]MalType{Symbol{"cons"},
+                              quasiquote(a0),
+                              quasiquote(List{slc[1:],nil})},nil}
+    }
+}
+
+func is_macro_call(ast MalType, env EnvType) bool {
+    if List_Q(ast) {
+        slc, _ := GetSlice(ast)
+        a0 := slc[0]
+        if Symbol_Q(a0) && env.Find(a0.(Symbol)) != nil {
+            mac, e := env.Get(a0.(Symbol))
+            if e != nil { return false }
+            if MalFunc_Q(mac) {
+                return mac.(MalFunc).GetMacro()
+            }
+        }
+    }
+    return false
+}
+
+func macroexpand(ast MalType, env EnvType)  (MalType, error) {
+    var mac MalType
+    var e error
+    for ; is_macro_call(ast, env) ; {
+        slc, _ := GetSlice(ast)
+        a0 := slc[0]
+        mac, e = env.Get(a0.(Symbol)); if e != nil { return nil, e }
+        fn := mac.(MalFunc)
+        ast, e = Apply(fn, slc[1:]); if e != nil { return nil, e }
+    }
+    return ast, nil
+}
+
+func eval_ast(ast MalType, env EnvType) (MalType, error) {
+    //fmt.Printf("eval_ast: %#v\n", ast)
+    if Symbol_Q(ast) {
+        return env.Get(ast.(Symbol))
+    } else if List_Q(ast) {
+        lst := []MalType{}
+        for _, a := range ast.(List).Val {
+            exp, e := EVAL(a, env)
+            if e != nil { return nil, e }
+            lst = append(lst, exp)
+        }
+        return List{lst,nil}, nil
+    } else if Vector_Q(ast) {
+        lst := []MalType{}
+        for _, a := range ast.(Vector).Val {
+            exp, e := EVAL(a, env)
+            if e != nil { return nil, e }
+            lst = append(lst, exp)
+        }
+        return Vector{lst,nil}, nil
+    } else if HashMap_Q(ast) {
+        m := ast.(HashMap)
+        new_hm := HashMap{map[string]MalType{},nil}
+        for k, v := range m.Val {
+            ke, e1 := EVAL(k, env)
+            if e1 != nil { return nil, e1 }
+            if _, ok := ke.(string); !ok {
+                return nil, errors.New("non string hash-map key")
+            }
+            kv, e2 := EVAL(v, env)
+            if e2 != nil { return nil, e2 }
+            new_hm.Val[ke.(string)] = kv
+        }
+        return new_hm, nil
+    } else {
+        return ast, nil
+    }
+}
+
+func EVAL(ast MalType, env EnvType) (MalType, error) {
+    var e error
+    for {
+
+    //fmt.Printf("EVAL: %v\n", printer.Pr_str(ast, true))
+    switch ast.(type) {
+    case List: // continue
+    default:   return eval_ast(ast, env)
+    }
+
+    // apply list
+    ast, e = macroexpand(ast, env); if e != nil { return nil, e }
+    if (!List_Q(ast)) { return ast, nil }
+
+    a0 := ast.(List).Val[0]
+    var a1 MalType = nil; var a2 MalType = nil
+    switch len(ast.(List).Val) {
+    case 1:
+        a1 = nil; a2 = nil
+    case 2:
+        a1 = ast.(List).Val[1]; a2 = nil
+    default:
+        a1 = ast.(List).Val[1]; a2 = ast.(List).Val[2]
+    }
+    a0sym := "__<*fn*>__"
+    if Symbol_Q(a0) { a0sym = a0.(Symbol).Val } 
+    switch a0sym {
+    case "def!":
+        res, e := EVAL(a2, env)
+        if e != nil { return nil, e }
+        return env.Set(a1.(Symbol), res), nil
+    case "let*":
+        let_env, e := NewEnv(env, nil, nil)
+        if e != nil { return nil, e }
+        arr1, e := GetSlice(a1)
+        if e != nil { return nil, e }
+        for i := 0; i < len(arr1); i+=2 {
+            if !Symbol_Q(arr1[i]) {
+                return nil, errors.New("non-symbol bind value")
+            }
+            exp, e := EVAL(arr1[i+1], let_env)
+            if e != nil { return nil, e }
+            let_env.Set(arr1[i].(Symbol), exp)
+        }
+        ast = a2
+        env = let_env
+    case "quote":
+        return a1, nil
+    case "quasiquote":
+        ast = quasiquote(a1)
+    case "defmacro!":
+        fn, e := EVAL(a2, env)
+        fn = fn.(MalFunc).SetMacro()
+        if e != nil { return nil, e }
+        return env.Set(a1.(Symbol), fn), nil
+    case "macroexpand":
+        return macroexpand(a1, env)
+    case "try*":        
+        var exc MalType
+        exp, e := EVAL(a1, env)
+        if e == nil {
+            return exp, nil
+        } else {
+            if a2 != nil && List_Q(a2) {
+                a2s, _ := GetSlice(a2)
+                if Symbol_Q(a2s[0]) && (a2s[0].(Symbol).Val == "catch*") {
+                    switch e.(type) {
+                    case MalError: exc = e.(MalError).Obj
+                    default:       exc = e.Error()
+                    }
+                    binds := NewList(a2s[1])
+                    new_env, e := NewEnv(env, binds, NewList(exc))
+                    if e != nil { return nil, e }
+                    exp, e = EVAL(a2s[2], new_env)
+                    if e == nil { return exp, nil }
+                }
+            }
+            return nil, e
+        }
+    case "do":
+        lst := ast.(List).Val
+        _, e := eval_ast(List{lst[1:len(lst)-1],nil}, env) 
+        if e != nil { return nil, e }
+        if len(lst) == 1 { return nil, nil }
+        ast = lst[len(lst)-1]
+    case "if":
+        cond, e := EVAL(a1, env)
+        if e != nil { return nil, e }
+        if cond == nil || cond == false {
+            if len(ast.(List).Val) >= 4 {
+                ast = ast.(List).Val[3]
+            } else {
+                return nil, nil
+            }
+        } else {
+            ast = a2
+        }
+    case "fn*":
+        fn := MalFunc{EVAL, a2, env, a1, false, NewEnv, nil}
+        return fn, nil
+    default:
+        el, e := eval_ast(ast, env)
+        if e != nil { return nil, e }
+        f := el.(List).Val[0]
+        if MalFunc_Q(f) {
+            fn := f.(MalFunc)
+            ast = fn.Exp
+            env, e = NewEnv(fn.Env, fn.Params, List{el.(List).Val[1:],nil})
+            if e != nil { return nil, e }
+        } else {
+            fn, ok := f.(Func)
+            if !ok { return nil, errors.New("attempt to call non-function") }
+            return fn.Fn(el.(List).Val[1:])
+        }
+    }
+
+    } // TCO loop
+}
+
+// print
+func PRINT(exp MalType) (string, error) {
+    return printer.Pr_str(exp, true), nil
+}
+
+
+var repl_env, _ = NewEnv(nil, nil, nil)
+
+// repl
+func rep(str string) (MalType, error) {
+    var exp MalType
+    var res string
+    var e error
+    if exp, e = READ(str); e != nil { return nil, e }
+    if exp, e = EVAL(exp, repl_env); e != nil { return nil, e }
+    if res, e = PRINT(exp); e != nil { return nil, e }
+    return res, nil
+}
+
+func main() {
+    // core.go: defined using go
+    for k, v := range core.NS {
+        repl_env.Set(Symbol{k}, Func{v.(func([]MalType)(MalType,error)),nil})
+    }
+    repl_env.Set(Symbol{"eval"}, Func{func(a []MalType) (MalType, error) {
+        return EVAL(a[0], repl_env) },nil})
+    repl_env.Set(Symbol{"*ARGV*"}, List{})
+
+    // core.mal: defined using the language itself
+    rep("(def! *host-language* \"go\")")
+    rep("(def! not (fn* (a) (if a false true)))")
+    rep("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))")
+    rep("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))")
+    rep("(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))")
+
+    // called with mal script to load and eval
+    if len(os.Args) > 1 {
+        args := make([]MalType, 0, len(os.Args)-2)
+        for _,a := range os.Args[2:] {
+            args = append(args, a)
+        }
+        repl_env.Set(Symbol{"*ARGV*"}, List{args,nil})
+        if _,e := rep("(load-file \"" + os.Args[1] + "\")"); e != nil {
+            fmt.Printf("Error: %v\n", e)
+            os.Exit(1)
+        }
+        os.Exit(0)
+    }
+
+    // repl loop
+    rep("(println (str \"Mal [\" *host-language* \"]\"))")
+    for {
+        text, err := readline.Readline("user> ")
+        text = strings.TrimRight(text, "\n");
+        if (err != nil) {
+            return
+        }
+        var out MalType
+        var e error
+        if out, e = rep(text); e != nil {
+            if e.Error() == "<empty line>" { continue }
+            fmt.Printf("Error: %v\n", e)
+            continue
+        }
+        fmt.Printf("%v\n", out)
+    }
+}
diff --git a/haskell/Makefile b/haskell/Makefile
index 28c3d26..0ac1a75 100644
--- a/haskell/Makefile
+++ b/haskell/Makefile
@@ -6,7 +6,7 @@ SOURCES = $(SOURCES_BASE) $(SOURCES_LISP)
 
 SRCS = step0_repl.hs step1_read_print.hs step2_eval.hs step3_env.hs \
        step4_if_fn_do.hs step5_tco.hs step6_file.hs step7_quote.hs \
-       step8_macros.hs step9_try.hs stepA_interop.hs
+       step8_macros.hs step9_try.hs stepA_mal.hs
 OTHER_SRCS = Readline.hs Types.hs Reader.hs Printer.hs Env.hs Core.hs
 BINS = $(SRCS:%.hs=%)
 
diff --git a/haskell/stepA_interop.hs b/haskell/stepA_interop.hs
deleted file mode 100644
index f1d4b38..0000000
--- a/haskell/stepA_interop.hs
+++ /dev/null
@@ -1,255 +0,0 @@
-import System.IO (hFlush, stdout)
-import System.Environment (getArgs)
-import Control.Monad (mapM)
-import Control.Monad.Error (runErrorT)
-import Control.Monad.Trans (liftIO)
-import qualified Data.Map as Map
-import qualified Data.Traversable as DT
-
-import Readline (readline, load_history)
-import Types
-import Reader (read_str)
-import Printer (_pr_str)
-import Env (Env, env_new, env_bind, env_find, env_get, env_set)
-import Core as Core
-
--- read
-mal_read :: String -> IOThrows MalVal
-mal_read str = read_str str
-
--- eval
-is_pair (MalList x _:xs) = True
-is_pair (MalVector x _:xs) = True
-is_pair _ = False
-
-quasiquote :: MalVal -> MalVal
-quasiquote ast =
-    case ast of
-         (MalList (MalSymbol "unquote" : a1 : []) _) -> a1
-         (MalList (MalList (MalSymbol "splice-unquote" : a01 : []) _ : rest) _) ->
-            MalList [(MalSymbol "concat"), a01, quasiquote (MalList rest Nil)] Nil
-         (MalVector (MalList (MalSymbol "splice-unquote" : a01 : []) _ : rest) _) ->
-            MalList [(MalSymbol "concat"), a01, quasiquote (MalVector rest Nil)] Nil
-         (MalList (a0 : rest) _) -> MalList [(MalSymbol "cons"),
-                                             quasiquote a0,
-                                             quasiquote (MalList rest Nil)] Nil
-         (MalVector (a0 : rest) _) -> MalList [(MalSymbol "cons"),
-                                               quasiquote a0,
-                                               quasiquote (MalVector rest Nil)] Nil
-         _ -> MalList [(MalSymbol "quote"), ast] Nil
-
-is_macro_call :: MalVal -> Env -> IOThrows Bool
-is_macro_call (MalList (a0@(MalSymbol _) : rest) _) env = do
-    e <- liftIO $ env_find env a0
-    case e of
-         Just e -> do
-            f <- env_get e a0
-            case f of
-                 MalFunc {macro=True} -> return True
-                 _                    -> return False
-         Nothing -> return False
-is_macro_call _ _ = return False
-
-macroexpand :: MalVal -> Env -> IOThrows MalVal
-macroexpand ast@(MalList (a0 : args) _) env = do
-    mc <- is_macro_call ast env
-    if mc then do
-        mac <- env_get env a0
-        case mac of 
-             MalFunc {fn=(Fn f)} -> do
-                new_ast <- f args
-                macroexpand new_ast env
-             _ ->
-                return ast
-    else
-        return ast
-macroexpand ast _ = return ast
-
-eval_ast :: MalVal -> Env -> IOThrows MalVal
-eval_ast sym@(MalSymbol _) env = env_get env sym
-eval_ast ast@(MalList lst m) env = do
-    new_lst <- mapM (\x -> (eval x env)) lst
-    return $ MalList new_lst m
-eval_ast ast@(MalVector lst m) env = do
-    new_lst <- mapM (\x -> (eval x env)) lst
-    return $ MalVector new_lst m
-eval_ast ast@(MalHashMap lst m) env = do
-    new_hm <- DT.mapM (\x -> (eval x env)) lst
-    return $ MalHashMap new_hm m
-eval_ast ast env = return ast
-
-let_bind :: Env -> [MalVal] -> IOThrows Env
-let_bind env [] = return env
-let_bind env (b:e:xs) = do
-    evaled <- eval e env
-    x <- liftIO $ env_set env b evaled
-    let_bind env xs
-
-apply_ast :: MalVal -> Env -> IOThrows MalVal
-apply_ast ast@(MalList (MalSymbol "def!" : args) _) env = do
-    case args of
-         (a1@(MalSymbol _): a2 : []) -> do
-            evaled <- eval a2 env
-            liftIO $ env_set env a1 evaled
-         _ -> throwStr "invalid def!"
-apply_ast ast@(MalList (MalSymbol "let*" : args) _) env = do
-    case args of
-         (a1 : a2 : []) -> do
-            params <- (_to_list a1)
-            let_env <- liftIO $ env_new $ Just env
-            let_bind let_env params
-            eval a2 let_env
-         _ -> throwStr "invalid let*"
-apply_ast ast@(MalList (MalSymbol "quote" : args) _) env = do
-    case args of
-         a1 : [] -> return a1
-         _ -> throwStr "invalid quote"
-apply_ast ast@(MalList (MalSymbol "quasiquote" : args) _) env = do
-    case args of
-         a1 : [] -> eval (quasiquote a1) env
-         _ -> throwStr "invalid quasiquote"
-
-apply_ast ast@(MalList (MalSymbol "defmacro!" : args) _) env = do
-    case args of
-         (a1 : a2 : []) -> do
-            func <- eval a2 env
-            case func of
-                MalFunc {fn=f, ast=a, env=e, params=p} -> do
-                    let new_func = MalFunc {fn=f, ast=a, env=e,
-                                            params=p, macro=True,
-                                            meta=Nil} in
-                        liftIO $ env_set env a1 new_func
-                _ -> throwStr "defmacro! on non-function"
-         _ -> throwStr "invalid defmacro!" 
-apply_ast ast@(MalList (MalSymbol "macroexpand" : args) _) env = do
-    case args of
-         (a1 : []) -> macroexpand a1 env
-         _ -> throwStr "invalid macroexpand" 
-apply_ast ast@(MalList (MalSymbol "try*" : args) _) env = do
-    case args of
-         (a1 : []) -> eval a1 env
-         (a1 : (MalList ((MalSymbol "catch*") : a21 : a22 : []) _) : []) -> do
-            res <- liftIO $ runErrorT $ eval a1 env
-            case res of
-                Right val -> return val
-                Left err -> do
-                    exc <- case err of
-                        (StringError str) -> return $ MalString str
-                        (MalValError mv) -> return $ mv
-                    try_env <- liftIO $ env_new $ Just env
-                    liftIO $ env_set try_env a21 exc
-                    eval a22 try_env
-         _ -> throwStr "invalid try*"
-apply_ast ast@(MalList (MalSymbol "do" : args) _) env = do
-    case args of
-         ([]) -> return Nil
-         _  -> do
-            el <- eval_ast (MalList args Nil) env
-            case el of
-                 (MalList lst _) -> return $ last lst
-            
-apply_ast ast@(MalList (MalSymbol "if" : args) _) env = do
-    case args of
-         (a1 : a2 : a3 : []) -> do
-            cond <- eval a1 env
-            if cond == MalFalse || cond == Nil
-                then eval a3 env
-                else eval a2 env
-         (a1 : a2 : []) -> do
-            cond <- eval a1 env
-            if cond == MalFalse || cond == Nil
-                then return Nil
-                else eval a2 env
-         _ -> throwStr "invalid if"
-apply_ast ast@(MalList (MalSymbol "fn*" : args) _) env = do
-    case args of
-         (a1 : a2 : []) -> do
-            params <- (_to_list a1)
-            return $ (_malfunc a2 env (MalList params Nil)
-                      (\args -> do
-                        fn_env1 <- liftIO $ env_new $ Just env
-                        fn_env2 <- liftIO $ env_bind fn_env1 params args
-                        eval a2 fn_env2))
-         _ -> throwStr "invalid fn*"
-apply_ast ast@(MalList _ _) env = do
-    mc <- is_macro_call ast env
-    if mc then do
-        new_ast <- macroexpand ast env
-        eval new_ast env
-    else
-        case ast of
-            MalList _ _ -> do
-                el <- eval_ast ast env
-                case el of
-                    (MalList ((Func (Fn f) _) : rest) _) ->
-                        f $ rest
-                    (MalList ((MalFunc {ast=ast,
-                                        env=fn_env,
-                                        params=(MalList params Nil)} : rest)) _) -> do
-                        fn_env1 <- liftIO $ env_new $ Just fn_env
-                        fn_env2 <- liftIO $ env_bind fn_env1 params rest
-                        eval ast fn_env2
-                    el ->
-                        throwStr $ "invalid apply: " ++ (show el)
-            _ -> return ast
-
-eval :: MalVal -> Env -> IOThrows MalVal
-eval ast env = do
-    case ast of
-         (MalList _ _) -> apply_ast ast env
-         _             -> eval_ast ast env
-
-
--- print
-mal_print :: MalVal -> String
-mal_print exp = show exp
-
--- repl
-
-rep :: Env -> String -> IOThrows String
-rep env line = do
-    ast <- mal_read line
-    exp <- eval ast env
-    return $ mal_print exp
-
-repl_loop :: Env -> IO ()
-repl_loop env = do
-    line <- readline "user> "
-    case line of
-        Nothing -> return ()
-        Just "" -> repl_loop env
-        Just str -> do
-            res <- runErrorT $ rep env str
-            out <- case res of
-                Left (StringError str) -> return $ "Error: " ++ str
-                Left (MalValError mv) -> return $ "Error: " ++ (show mv)
-                Right val -> return val
-            putStrLn out
-            hFlush stdout
-            repl_loop env
-
-main = do
-    args <- getArgs
-    load_history
-
-    repl_env <- env_new Nothing
-
-    -- core.hs: defined using Haskell
-    (mapM (\(k,v) -> (env_set repl_env (MalSymbol k) v)) Core.ns)
-    env_set repl_env (MalSymbol "eval") (_func (\[ast] -> eval ast repl_env))
-    env_set repl_env (MalSymbol "*ARGV*") (MalList [] Nil)
-
-    -- core.mal: defined using the language itself
-    runErrorT $ rep repl_env "(def! *host-language* \"haskell\")"
-    runErrorT $ rep repl_env "(def! not (fn* (a) (if a false true)))"
-    runErrorT $ rep repl_env "(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))"
-    runErrorT $ rep repl_env "(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))"
-    runErrorT $ rep repl_env "(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))"
-
-    if length args > 0 then do
-        env_set repl_env (MalSymbol "*ARGV*") (MalList (map MalString (drop 1 args)) Nil)
-        runErrorT $ rep repl_env $ "(load-file \"" ++ (args !! 0) ++ "\")" 
-        return ()
-    else do
-        runErrorT $ rep repl_env "(println (str \"Mal [\" *host-language* \"]\"))"
-        repl_loop repl_env
diff --git a/haskell/stepA_mal.hs b/haskell/stepA_mal.hs
new file mode 100644
index 0000000..f1d4b38
--- /dev/null
+++ b/haskell/stepA_mal.hs
@@ -0,0 +1,255 @@
+import System.IO (hFlush, stdout)
+import System.Environment (getArgs)
+import Control.Monad (mapM)
+import Control.Monad.Error (runErrorT)
+import Control.Monad.Trans (liftIO)
+import qualified Data.Map as Map
+import qualified Data.Traversable as DT
+
+import Readline (readline, load_history)
+import Types
+import Reader (read_str)
+import Printer (_pr_str)
+import Env (Env, env_new, env_bind, env_find, env_get, env_set)
+import Core as Core
+
+-- read
+mal_read :: String -> IOThrows MalVal
+mal_read str = read_str str
+
+-- eval
+is_pair (MalList x _:xs) = True
+is_pair (MalVector x _:xs) = True
+is_pair _ = False
+
+quasiquote :: MalVal -> MalVal
+quasiquote ast =
+    case ast of
+         (MalList (MalSymbol "unquote" : a1 : []) _) -> a1
+         (MalList (MalList (MalSymbol "splice-unquote" : a01 : []) _ : rest) _) ->
+            MalList [(MalSymbol "concat"), a01, quasiquote (MalList rest Nil)] Nil
+         (MalVector (MalList (MalSymbol "splice-unquote" : a01 : []) _ : rest) _) ->
+            MalList [(MalSymbol "concat"), a01, quasiquote (MalVector rest Nil)] Nil
+         (MalList (a0 : rest) _) -> MalList [(MalSymbol "cons"),
+                                             quasiquote a0,
+                                             quasiquote (MalList rest Nil)] Nil
+         (MalVector (a0 : rest) _) -> MalList [(MalSymbol "cons"),
+                                               quasiquote a0,
+                                               quasiquote (MalVector rest Nil)] Nil
+         _ -> MalList [(MalSymbol "quote"), ast] Nil
+
+is_macro_call :: MalVal -> Env -> IOThrows Bool
+is_macro_call (MalList (a0@(MalSymbol _) : rest) _) env = do
+    e <- liftIO $ env_find env a0
+    case e of
+         Just e -> do
+            f <- env_get e a0
+            case f of
+                 MalFunc {macro=True} -> return True
+                 _                    -> return False
+         Nothing -> return False
+is_macro_call _ _ = return False
+
+macroexpand :: MalVal -> Env -> IOThrows MalVal
+macroexpand ast@(MalList (a0 : args) _) env = do
+    mc <- is_macro_call ast env
+    if mc then do
+        mac <- env_get env a0
+        case mac of 
+             MalFunc {fn=(Fn f)} -> do
+                new_ast <- f args
+                macroexpand new_ast env
+             _ ->
+                return ast
+    else
+        return ast
+macroexpand ast _ = return ast
+
+eval_ast :: MalVal -> Env -> IOThrows MalVal
+eval_ast sym@(MalSymbol _) env = env_get env sym
+eval_ast ast@(MalList lst m) env = do
+    new_lst <- mapM (\x -> (eval x env)) lst
+    return $ MalList new_lst m
+eval_ast ast@(MalVector lst m) env = do
+    new_lst <- mapM (\x -> (eval x env)) lst
+    return $ MalVector new_lst m
+eval_ast ast@(MalHashMap lst m) env = do
+    new_hm <- DT.mapM (\x -> (eval x env)) lst
+    return $ MalHashMap new_hm m
+eval_ast ast env = return ast
+
+let_bind :: Env -> [MalVal] -> IOThrows Env
+let_bind env [] = return env
+let_bind env (b:e:xs) = do
+    evaled <- eval e env
+    x <- liftIO $ env_set env b evaled
+    let_bind env xs
+
+apply_ast :: MalVal -> Env -> IOThrows MalVal
+apply_ast ast@(MalList (MalSymbol "def!" : args) _) env = do
+    case args of
+         (a1@(MalSymbol _): a2 : []) -> do
+            evaled <- eval a2 env
+            liftIO $ env_set env a1 evaled
+         _ -> throwStr "invalid def!"
+apply_ast ast@(MalList (MalSymbol "let*" : args) _) env = do
+    case args of
+         (a1 : a2 : []) -> do
+            params <- (_to_list a1)
+            let_env <- liftIO $ env_new $ Just env
+            let_bind let_env params
+            eval a2 let_env
+         _ -> throwStr "invalid let*"
+apply_ast ast@(MalList (MalSymbol "quote" : args) _) env = do
+    case args of
+         a1 : [] -> return a1
+         _ -> throwStr "invalid quote"
+apply_ast ast@(MalList (MalSymbol "quasiquote" : args) _) env = do
+    case args of
+         a1 : [] -> eval (quasiquote a1) env
+         _ -> throwStr "invalid quasiquote"
+
+apply_ast ast@(MalList (MalSymbol "defmacro!" : args) _) env = do
+    case args of
+         (a1 : a2 : []) -> do
+            func <- eval a2 env
+            case func of
+                MalFunc {fn=f, ast=a, env=e, params=p} -> do
+                    let new_func = MalFunc {fn=f, ast=a, env=e,
+                                            params=p, macro=True,
+                                            meta=Nil} in
+                        liftIO $ env_set env a1 new_func
+                _ -> throwStr "defmacro! on non-function"
+         _ -> throwStr "invalid defmacro!" 
+apply_ast ast@(MalList (MalSymbol "macroexpand" : args) _) env = do
+    case args of
+         (a1 : []) -> macroexpand a1 env
+         _ -> throwStr "invalid macroexpand" 
+apply_ast ast@(MalList (MalSymbol "try*" : args) _) env = do
+    case args of
+         (a1 : []) -> eval a1 env
+         (a1 : (MalList ((MalSymbol "catch*") : a21 : a22 : []) _) : []) -> do
+            res <- liftIO $ runErrorT $ eval a1 env
+            case res of
+                Right val -> return val
+                Left err -> do
+                    exc <- case err of
+                        (StringError str) -> return $ MalString str
+                        (MalValError mv) -> return $ mv
+                    try_env <- liftIO $ env_new $ Just env
+                    liftIO $ env_set try_env a21 exc
+                    eval a22 try_env
+         _ -> throwStr "invalid try*"
+apply_ast ast@(MalList (MalSymbol "do" : args) _) env = do
+    case args of
+         ([]) -> return Nil
+         _  -> do
+            el <- eval_ast (MalList args Nil) env
+            case el of
+                 (MalList lst _) -> return $ last lst
+            
+apply_ast ast@(MalList (MalSymbol "if" : args) _) env = do
+    case args of
+         (a1 : a2 : a3 : []) -> do
+            cond <- eval a1 env
+            if cond == MalFalse || cond == Nil
+                then eval a3 env
+                else eval a2 env
+         (a1 : a2 : []) -> do
+            cond <- eval a1 env
+            if cond == MalFalse || cond == Nil
+                then return Nil
+                else eval a2 env
+         _ -> throwStr "invalid if"
+apply_ast ast@(MalList (MalSymbol "fn*" : args) _) env = do
+    case args of
+         (a1 : a2 : []) -> do
+            params <- (_to_list a1)
+            return $ (_malfunc a2 env (MalList params Nil)
+                      (\args -> do
+                        fn_env1 <- liftIO $ env_new $ Just env
+                        fn_env2 <- liftIO $ env_bind fn_env1 params args
+                        eval a2 fn_env2))
+         _ -> throwStr "invalid fn*"
+apply_ast ast@(MalList _ _) env = do
+    mc <- is_macro_call ast env
+    if mc then do
+        new_ast <- macroexpand ast env
+        eval new_ast env
+    else
+        case ast of
+            MalList _ _ -> do
+                el <- eval_ast ast env
+                case el of
+                    (MalList ((Func (Fn f) _) : rest) _) ->
+                        f $ rest
+                    (MalList ((MalFunc {ast=ast,
+                                        env=fn_env,
+                                        params=(MalList params Nil)} : rest)) _) -> do
+                        fn_env1 <- liftIO $ env_new $ Just fn_env
+                        fn_env2 <- liftIO $ env_bind fn_env1 params rest
+                        eval ast fn_env2
+                    el ->
+                        throwStr $ "invalid apply: " ++ (show el)
+            _ -> return ast
+
+eval :: MalVal -> Env -> IOThrows MalVal
+eval ast env = do
+    case ast of
+         (MalList _ _) -> apply_ast ast env
+         _             -> eval_ast ast env
+
+
+-- print
+mal_print :: MalVal -> String
+mal_print exp = show exp
+
+-- repl
+
+rep :: Env -> String -> IOThrows String
+rep env line = do
+    ast <- mal_read line
+    exp <- eval ast env
+    return $ mal_print exp
+
+repl_loop :: Env -> IO ()
+repl_loop env = do
+    line <- readline "user> "
+    case line of
+        Nothing -> return ()
+        Just "" -> repl_loop env
+        Just str -> do
+            res <- runErrorT $ rep env str
+            out <- case res of
+                Left (StringError str) -> return $ "Error: " ++ str
+                Left (MalValError mv) -> return $ "Error: " ++ (show mv)
+                Right val -> return val
+            putStrLn out
+            hFlush stdout
+            repl_loop env
+
+main = do
+    args <- getArgs
+    load_history
+
+    repl_env <- env_new Nothing
+
+    -- core.hs: defined using Haskell
+    (mapM (\(k,v) -> (env_set repl_env (MalSymbol k) v)) Core.ns)
+    env_set repl_env (MalSymbol "eval") (_func (\[ast] -> eval ast repl_env))
+    env_set repl_env (MalSymbol "*ARGV*") (MalList [] Nil)
+
+    -- core.mal: defined using the language itself
+    runErrorT $ rep repl_env "(def! *host-language* \"haskell\")"
+    runErrorT $ rep repl_env "(def! not (fn* (a) (if a false true)))"
+    runErrorT $ rep repl_env "(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))"
+    runErrorT $ rep repl_env "(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))"
+    runErrorT $ rep repl_env "(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))"
+
+    if length args > 0 then do
+        env_set repl_env (MalSymbol "*ARGV*") (MalList (map MalString (drop 1 args)) Nil)
+        runErrorT $ rep repl_env $ "(load-file \"" ++ (args !! 0) ++ "\")" 
+        return ()
+    else do
+        runErrorT $ rep repl_env "(println (str \"Mal [\" *host-language* \"]\"))"
+        repl_loop repl_env
diff --git a/java/Makefile b/java/Makefile
index eff6e6f..f242ec0 100644
--- a/java/Makefile
+++ b/java/Makefile
@@ -5,7 +5,7 @@ TESTS =
 SOURCES_BASE = src/main/java/mal/readline.java src/main/java/mal/types.java \
                src/main/java/mal/reader.java src/main/java/mal/printer.java
 SOURCES_LISP = src/main/java/mal/env.java src/main/java/mal/core.java \
-               src/main/java/mal/stepA_interop.java
+               src/main/java/mal/stepA_mal.java
 SOURCES = $(SOURCES_BASE) $(SOURCES_LISP)
 
 #.PHONY: stats tests $(TESTS)
diff --git a/java/pom.xml b/java/pom.xml
index ae53194..fa2b567 100644
--- a/java/pom.xml
+++ b/java/pom.xml
@@ -47,7 +47,7 @@
                 </executions>
                 <configuration>
                     <!--
-                    <mainClass>mal.stepA_interop</mainClass>
+                    <mainClass>mal.stepA_mal</mainClass>
                     <arguments>
                         <argument>foo</argument>
                         <argument>bar</argument>
@@ -69,7 +69,7 @@
                             <transformers>
                                 <transformer
                                     implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
-                                    <mainClass>mal.stepA_interop</mainClass>
+                                    <mainClass>mal.stepA_mal</mainClass>
                                 </transformer>
                             </transformers>
                         </configuration>
diff --git a/java/src/main/java/mal/stepA_interop.java b/java/src/main/java/mal/stepA_interop.java
deleted file mode 100644
index 1fa1125..0000000
--- a/java/src/main/java/mal/stepA_interop.java
+++ /dev/null
@@ -1,301 +0,0 @@
-package mal;
-
-import java.io.IOException;
-
-import java.io.StringWriter;
-import java.io.PrintWriter;
-import java.util.List;
-import java.util.Map;
-import java.util.HashMap;
-import java.util.Iterator;
-import mal.types.*;
-import mal.readline;
-import mal.reader;
-import mal.printer;
-import mal.env.Env;
-import mal.core;
-
-public class stepA_interop {
-    // read
-    public static MalVal READ(String str) throws MalThrowable {
-        return reader.read_str(str);
-    }
-
-    // eval
-    public static Boolean is_pair(MalVal x) {
-        return x instanceof MalList && ((MalList)x).size() > 0;
-    }
-
-    public static MalVal quasiquote(MalVal ast) {
-        if (!is_pair(ast)) {
-            return new MalList(new MalSymbol("quote"), ast);
-        } else {
-            MalVal a0 = ((MalList)ast).nth(0);
-            if ((a0 instanceof MalSymbol) &&
-                (((MalSymbol)a0).getName() == "unquote")) {
-                return ((MalList)ast).nth(1);
-            } else if (is_pair(a0)) {
-                MalVal a00 = ((MalList)a0).nth(0);
-                if ((a00 instanceof MalSymbol) &&
-                    (((MalSymbol)a00).getName() == "splice-unquote")) {
-                    return new MalList(new MalSymbol("concat"),
-                                       ((MalList)a0).nth(1),
-                                       quasiquote(((MalList)ast).rest()));
-                }
-            }
-            return new MalList(new MalSymbol("cons"),
-                               quasiquote(a0),
-                               quasiquote(((MalList)ast).rest()));
-        }
-    }
-
-    public static Boolean is_macro_call(MalVal ast, Env env)
-            throws MalThrowable {
-        if (ast instanceof MalList) {
-            MalVal a0 = ((MalList)ast).nth(0);
-            if (a0 instanceof MalSymbol &&
-                env.find(((MalSymbol)a0)) != null) {
-                MalVal mac = env.get(((MalSymbol)a0));
-                if (mac instanceof MalFunction &&
-                    ((MalFunction)mac).isMacro()) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    public static MalVal macroexpand(MalVal ast, Env env)
-            throws MalThrowable {
-        while (is_macro_call(ast, env)) {
-            MalSymbol a0 = (MalSymbol)((MalList)ast).nth(0);
-            MalFunction mac = (MalFunction) env.get(a0);
-            ast = mac.apply(((MalList)ast).rest());
-        }
-        return ast;
-    }
-
-    public static MalVal eval_ast(MalVal ast, Env env) throws MalThrowable {
-        if (ast instanceof MalSymbol) {
-            return env.get((MalSymbol)ast);
-        } else if (ast instanceof MalList) {
-            MalList old_lst = (MalList)ast;
-            MalList new_lst = ast.list_Q() ? new MalList()
-                                           : (MalList)new MalVector();
-            for (MalVal mv : (List<MalVal>)old_lst.value) {
-                new_lst.conj_BANG(EVAL(mv, env));
-            }
-            return new_lst;
-        } else if (ast instanceof MalHashMap) {
-            MalHashMap new_hm = new MalHashMap();
-            Iterator it = ((MalHashMap)ast).value.entrySet().iterator();
-            while (it.hasNext()) {
-                Map.Entry entry = (Map.Entry)it.next();
-                new_hm.value.put(entry.getKey(), EVAL((MalVal)entry.getValue(), env));
-            }
-            return new_hm;
-        } else {
-            return ast;
-        }
-    }
-
-    public static MalVal EVAL(MalVal orig_ast, Env env) throws MalThrowable {
-        MalVal a0, a1,a2, a3, res;
-        MalList el;
-
-        while (true) {
-
-        //System.out.println("EVAL: " + printer._pr_str(orig_ast, true));
-        if (!orig_ast.list_Q()) {
-            return eval_ast(orig_ast, env);
-        }
-
-        // apply list
-        MalVal expanded = macroexpand(orig_ast, env);
-        if (!expanded.list_Q()) { return expanded; } 
-        MalList ast = (MalList) expanded;
-        if (ast.size() == 0) { return ast; }
-        a0 = ast.nth(0);
-        String a0sym = a0 instanceof MalSymbol ? ((MalSymbol)a0).getName()
-                                               : "__<*fn*>__";
-        switch (a0sym) {
-        case "def!":
-            a1 = ast.nth(1);
-            a2 = ast.nth(2);
-            res = EVAL(a2, env);
-            env.set(((MalSymbol)a1), res);
-            return res;
-        case "let*":
-            a1 = ast.nth(1);
-            a2 = ast.nth(2);
-            MalSymbol key;
-            MalVal val;
-            Env let_env = new Env(env);
-            for(int i=0; i<((MalList)a1).size(); i+=2) {
-                key = (MalSymbol)((MalList)a1).nth(i);
-                val = ((MalList)a1).nth(i+1);
-                let_env.set(key, EVAL(val, let_env));
-            }
-            orig_ast = a2;
-            env = let_env;
-            break;
-        case "quote":
-            return ast.nth(1);
-        case "quasiquote":
-            orig_ast = quasiquote(ast.nth(1));
-            break;
-        case "defmacro!":
-            a1 = ast.nth(1);
-            a2 = ast.nth(2);
-            res = EVAL(a2, env);
-            ((MalFunction)res).setMacro();
-            env.set((MalSymbol)a1, res);
-            return res;
-        case "macroexpand":
-            a1 = ast.nth(1);
-            return macroexpand(a1, env);
-        case "try*":
-            try {
-                return EVAL(ast.nth(1), env);
-            } catch (Throwable t) {
-                if (ast.size() > 2) {
-                    MalVal exc;
-                    a2 = ast.nth(2);
-                    MalVal a20 = ((MalList)a2).nth(0);
-                    if (((MalSymbol)a20).getName().equals("catch*")) {
-                        if (t instanceof MalException) {
-                            exc = ((MalException)t).getValue();
-                        } else {
-                            StringWriter sw = new StringWriter();
-                            t.printStackTrace(new PrintWriter(sw));
-                            String tstr = sw.toString();
-                            exc = new MalString(t.getMessage() + ": " + tstr);
-                        }
-                        return EVAL(((MalList)a2).nth(2),
-                                    new Env(env, ((MalList)a2).slice(1,2),
-                                                 new MalList(exc)));
-                    }
-                }
-                throw t;
-            }
-        case "do":
-            eval_ast(ast.slice(1, ast.size()-1), env);
-            orig_ast = ast.nth(ast.size()-1);
-            break;
-        case "if":
-            a1 = ast.nth(1);
-            MalVal cond = EVAL(a1, env);
-            if (cond == types.Nil || cond == types.False) {
-                // eval false slot form
-                if (ast.size() > 3) {
-                    orig_ast = ast.nth(3);
-                } else {
-                    return types.Nil;
-                }
-            } else {
-                // eval true slot form
-                orig_ast = ast.nth(2);
-            }
-            break;
-        case "fn*":
-            final MalList a1f = (MalList)ast.nth(1);
-            final MalVal a2f = ast.nth(2);
-            final Env cur_env = env;
-            return new MalFunction (a2f, (mal.env.Env)env, a1f) {
-                public MalVal apply(MalList args) throws MalThrowable {
-                    return EVAL(a2f, new Env(cur_env, a1f, args));
-                }
-            };
-        default:
-            el = (MalList)eval_ast(ast, env);
-            MalFunction f = (MalFunction)el.nth(0);
-            MalVal fnast = f.getAst();
-            if (fnast != null) {
-                orig_ast = fnast;
-                env = f.genEnv(el.slice(1));
-            } else {
-                return f.apply(el.rest());
-            }
-        }
-
-        }
-    }
-
-    // print
-    public static String PRINT(MalVal exp) {
-        return printer._pr_str(exp, true);
-    }
-
-    // repl
-    public static MalVal RE(Env env, String str) throws MalThrowable {
-        return EVAL(READ(str), env);
-    }
-
-    public static void main(String[] args) throws MalThrowable {
-        String prompt = "user> ";
-
-        final Env repl_env = new Env(null);
-
-        // core.java: defined using Java
-        for (String key : core.ns.keySet()) {
-            repl_env.set(new MalSymbol(key), core.ns.get(key));
-        }
-        repl_env.set(new MalSymbol("eval"), new MalFunction() {
-            public MalVal apply(MalList args) throws MalThrowable {
-                return EVAL(args.nth(0), repl_env);
-            }
-        });
-        MalList _argv = new MalList();
-        for (Integer i=1; i < args.length; i++) {
-            _argv.conj_BANG(new MalString(args[i]));
-        }
-        repl_env.set(new MalSymbol("*ARGV*"), _argv);
-
-
-        // core.mal: defined using the language itself
-        RE(repl_env, "(def! *host-language* \"java\")");
-        RE(repl_env, "(def! not (fn* (a) (if a false true)))");
-        RE(repl_env, "(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))");
-        RE(repl_env, "(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))");
-        RE(repl_env, "(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))");
-        
-        Integer fileIdx = 0;
-        if (args.length > 0 && args[0].equals("--raw")) {
-            readline.mode = readline.Mode.JAVA;
-            fileIdx = 1;
-        }
-        if (args.length > fileIdx) {
-            RE(repl_env, "(load-file \"" + args[fileIdx] + "\")");
-            return;
-        }
-
-        // repl loop
-        RE(repl_env, "(println (str \"Mal [\" *host-language* \"]\"))");
-        while (true) {
-            String line;
-            try {
-                line = readline.readline(prompt);
-                if (line == null) { continue; }
-            } catch (readline.EOFException e) {
-                break;
-            } catch (IOException e) {
-                System.out.println("IOException: " + e.getMessage());
-                break;
-            }
-            try {
-                System.out.println(PRINT(RE(repl_env, line)));
-            } catch (MalContinue e) {
-                continue;
-            } catch (MalException e) {
-                System.out.println("Error: " + printer._pr_str(e.getValue(), false));
-                continue;
-            } catch (MalThrowable t) {
-                System.out.println("Error: " + t.getMessage());
-                continue;
-            } catch (Throwable t) {
-                System.out.println("Uncaught " + t + ": " + t.getMessage());
-                continue;
-            }
-        }
-    }
-}
diff --git a/java/src/main/java/mal/stepA_mal.java b/java/src/main/java/mal/stepA_mal.java
new file mode 100644
index 0000000..f8d4056
--- /dev/null
+++ b/java/src/main/java/mal/stepA_mal.java
@@ -0,0 +1,301 @@
+package mal;
+
+import java.io.IOException;
+
+import java.io.StringWriter;
+import java.io.PrintWriter;
+import java.util.List;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Iterator;
+import mal.types.*;
+import mal.readline;
+import mal.reader;
+import mal.printer;
+import mal.env.Env;
+import mal.core;
+
+public class stepA_mal {
+    // read
+    public static MalVal READ(String str) throws MalThrowable {
+        return reader.read_str(str);
+    }
+
+    // eval
+    public static Boolean is_pair(MalVal x) {
+        return x instanceof MalList && ((MalList)x).size() > 0;
+    }
+
+    public static MalVal quasiquote(MalVal ast) {
+        if (!is_pair(ast)) {
+            return new MalList(new MalSymbol("quote"), ast);
+        } else {
+            MalVal a0 = ((MalList)ast).nth(0);
+            if ((a0 instanceof MalSymbol) &&
+                (((MalSymbol)a0).getName() == "unquote")) {
+                return ((MalList)ast).nth(1);
+            } else if (is_pair(a0)) {
+                MalVal a00 = ((MalList)a0).nth(0);
+                if ((a00 instanceof MalSymbol) &&
+                    (((MalSymbol)a00).getName() == "splice-unquote")) {
+                    return new MalList(new MalSymbol("concat"),
+                                       ((MalList)a0).nth(1),
+                                       quasiquote(((MalList)ast).rest()));
+                }
+            }
+            return new MalList(new MalSymbol("cons"),
+                               quasiquote(a0),
+                               quasiquote(((MalList)ast).rest()));
+        }
+    }
+
+    public static Boolean is_macro_call(MalVal ast, Env env)
+            throws MalThrowable {
+        if (ast instanceof MalList) {
+            MalVal a0 = ((MalList)ast).nth(0);
+            if (a0 instanceof MalSymbol &&
+                env.find(((MalSymbol)a0)) != null) {
+                MalVal mac = env.get(((MalSymbol)a0));
+                if (mac instanceof MalFunction &&
+                    ((MalFunction)mac).isMacro()) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    public static MalVal macroexpand(MalVal ast, Env env)
+            throws MalThrowable {
+        while (is_macro_call(ast, env)) {
+            MalSymbol a0 = (MalSymbol)((MalList)ast).nth(0);
+            MalFunction mac = (MalFunction) env.get(a0);
+            ast = mac.apply(((MalList)ast).rest());
+        }
+        return ast;
+    }
+
+    public static MalVal eval_ast(MalVal ast, Env env) throws MalThrowable {
+        if (ast instanceof MalSymbol) {
+            return env.get((MalSymbol)ast);
+        } else if (ast instanceof MalList) {
+            MalList old_lst = (MalList)ast;
+            MalList new_lst = ast.list_Q() ? new MalList()
+                                           : (MalList)new MalVector();
+            for (MalVal mv : (List<MalVal>)old_lst.value) {
+                new_lst.conj_BANG(EVAL(mv, env));
+            }
+            return new_lst;
+        } else if (ast instanceof MalHashMap) {
+            MalHashMap new_hm = new MalHashMap();
+            Iterator it = ((MalHashMap)ast).value.entrySet().iterator();
+            while (it.hasNext()) {
+                Map.Entry entry = (Map.Entry)it.next();
+                new_hm.value.put(entry.getKey(), EVAL((MalVal)entry.getValue(), env));
+            }
+            return new_hm;
+        } else {
+            return ast;
+        }
+    }
+
+    public static MalVal EVAL(MalVal orig_ast, Env env) throws MalThrowable {
+        MalVal a0, a1,a2, a3, res;
+        MalList el;
+
+        while (true) {
+
+        //System.out.println("EVAL: " + printer._pr_str(orig_ast, true));
+        if (!orig_ast.list_Q()) {
+            return eval_ast(orig_ast, env);
+        }
+
+        // apply list
+        MalVal expanded = macroexpand(orig_ast, env);
+        if (!expanded.list_Q()) { return expanded; } 
+        MalList ast = (MalList) expanded;
+        if (ast.size() == 0) { return ast; }
+        a0 = ast.nth(0);
+        String a0sym = a0 instanceof MalSymbol ? ((MalSymbol)a0).getName()
+                                               : "__<*fn*>__";
+        switch (a0sym) {
+        case "def!":
+            a1 = ast.nth(1);
+            a2 = ast.nth(2);
+            res = EVAL(a2, env);
+            env.set(((MalSymbol)a1), res);
+            return res;
+        case "let*":
+            a1 = ast.nth(1);
+            a2 = ast.nth(2);
+            MalSymbol key;
+            MalVal val;
+            Env let_env = new Env(env);
+            for(int i=0; i<((MalList)a1).size(); i+=2) {
+                key = (MalSymbol)((MalList)a1).nth(i);
+                val = ((MalList)a1).nth(i+1);
+                let_env.set(key, EVAL(val, let_env));
+            }
+            orig_ast = a2;
+            env = let_env;
+            break;
+        case "quote":
+            return ast.nth(1);
+        case "quasiquote":
+            orig_ast = quasiquote(ast.nth(1));
+            break;
+        case "defmacro!":
+            a1 = ast.nth(1);
+            a2 = ast.nth(2);
+            res = EVAL(a2, env);
+            ((MalFunction)res).setMacro();
+            env.set((MalSymbol)a1, res);
+            return res;
+        case "macroexpand":
+            a1 = ast.nth(1);
+            return macroexpand(a1, env);
+        case "try*":
+            try {
+                return EVAL(ast.nth(1), env);
+            } catch (Throwable t) {
+                if (ast.size() > 2) {
+                    MalVal exc;
+                    a2 = ast.nth(2);
+                    MalVal a20 = ((MalList)a2).nth(0);
+                    if (((MalSymbol)a20).getName().equals("catch*")) {
+                        if (t instanceof MalException) {
+                            exc = ((MalException)t).getValue();
+                        } else {
+                            StringWriter sw = new StringWriter();
+                            t.printStackTrace(new PrintWriter(sw));
+                            String tstr = sw.toString();
+                            exc = new MalString(t.getMessage() + ": " + tstr);
+                        }
+                        return EVAL(((MalList)a2).nth(2),
+                                    new Env(env, ((MalList)a2).slice(1,2),
+                                                 new MalList(exc)));
+                    }
+                }
+                throw t;
+            }
+        case "do":
+            eval_ast(ast.slice(1, ast.size()-1), env);
+            orig_ast = ast.nth(ast.size()-1);
+            break;
+        case "if":
+            a1 = ast.nth(1);
+            MalVal cond = EVAL(a1, env);
+            if (cond == types.Nil || cond == types.False) {
+                // eval false slot form
+                if (ast.size() > 3) {
+                    orig_ast = ast.nth(3);
+                } else {
+                    return types.Nil;
+                }
+            } else {
+                // eval true slot form
+                orig_ast = ast.nth(2);
+            }
+            break;
+        case "fn*":
+            final MalList a1f = (MalList)ast.nth(1);
+            final MalVal a2f = ast.nth(2);
+            final Env cur_env = env;
+            return new MalFunction (a2f, (mal.env.Env)env, a1f) {
+                public MalVal apply(MalList args) throws MalThrowable {
+                    return EVAL(a2f, new Env(cur_env, a1f, args));
+                }
+            };
+        default:
+            el = (MalList)eval_ast(ast, env);
+            MalFunction f = (MalFunction)el.nth(0);
+            MalVal fnast = f.getAst();
+            if (fnast != null) {
+                orig_ast = fnast;
+                env = f.genEnv(el.slice(1));
+            } else {
+                return f.apply(el.rest());
+            }
+        }
+
+        }
+    }
+
+    // print
+    public static String PRINT(MalVal exp) {
+        return printer._pr_str(exp, true);
+    }
+
+    // repl
+    public static MalVal RE(Env env, String str) throws MalThrowable {
+        return EVAL(READ(str), env);
+    }
+
+    public static void main(String[] args) throws MalThrowable {
+        String prompt = "user> ";
+
+        final Env repl_env = new Env(null);
+
+        // core.java: defined using Java
+        for (String key : core.ns.keySet()) {
+            repl_env.set(new MalSymbol(key), core.ns.get(key));
+        }
+        repl_env.set(new MalSymbol("eval"), new MalFunction() {
+            public MalVal apply(MalList args) throws MalThrowable {
+                return EVAL(args.nth(0), repl_env);
+            }
+        });
+        MalList _argv = new MalList();
+        for (Integer i=1; i < args.length; i++) {
+            _argv.conj_BANG(new MalString(args[i]));
+        }
+        repl_env.set(new MalSymbol("*ARGV*"), _argv);
+
+
+        // core.mal: defined using the language itself
+        RE(repl_env, "(def! *host-language* \"java\")");
+        RE(repl_env, "(def! not (fn* (a) (if a false true)))");
+        RE(repl_env, "(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))");
+        RE(repl_env, "(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))");
+        RE(repl_env, "(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))");
+        
+        Integer fileIdx = 0;
+        if (args.length > 0 && args[0].equals("--raw")) {
+            readline.mode = readline.Mode.JAVA;
+            fileIdx = 1;
+        }
+        if (args.length > fileIdx) {
+            RE(repl_env, "(load-file \"" + args[fileIdx] + "\")");
+            return;
+        }
+
+        // repl loop
+        RE(repl_env, "(println (str \"Mal [\" *host-language* \"]\"))");
+        while (true) {
+            String line;
+            try {
+                line = readline.readline(prompt);
+                if (line == null) { continue; }
+            } catch (readline.EOFException e) {
+                break;
+            } catch (IOException e) {
+                System.out.println("IOException: " + e.getMessage());
+                break;
+            }
+            try {
+                System.out.println(PRINT(RE(repl_env, line)));
+            } catch (MalContinue e) {
+                continue;
+            } catch (MalException e) {
+                System.out.println("Error: " + printer._pr_str(e.getValue(), false));
+                continue;
+            } catch (MalThrowable t) {
+                System.out.println("Error: " + t.getMessage());
+                continue;
+            } catch (Throwable t) {
+                System.out.println("Uncaught " + t + ": " + t.getMessage());
+                continue;
+            }
+        }
+    }
+}
diff --git a/js/Makefile b/js/Makefile
index 09ed5a4..98c4291 100644
--- a/js/Makefile
+++ b/js/Makefile
@@ -2,7 +2,7 @@
 TESTS = tests/types.js tests/reader.js
 
 SOURCES_BASE = node_readline.js types.js reader.js printer.js
-SOURCES_LISP = env.js core.js stepA_interop.js
+SOURCES_LISP = env.js core.js stepA_mal.js
 SOURCES = $(SOURCES_BASE) $(SOURCES_LISP)
 WEB_SOURCES = $(SOURCES:node_readline.js=jq_readline.js)
 
diff --git a/js/stepA_interop.js b/js/stepA_interop.js
deleted file mode 100644
index d879cd3..0000000
--- a/js/stepA_interop.js
+++ /dev/null
@@ -1,203 +0,0 @@
-if (typeof module !== 'undefined') {
-    var types = require('./types');
-    var readline = require('./node_readline');
-    var reader = require('./reader');
-    var printer = require('./printer');
-    var Env = require('./env').Env;
-    var core = require('./core');
-    var interop = require('./interop');
-}
-
-// read
-function READ(str) {
-    return reader.read_str(str);
-}
-
-// eval
-function is_pair(x) {
-    return types._sequential_Q(x) && x.length > 0;
-}
-
-function quasiquote(ast) {
-    if (!is_pair(ast)) {
-        return [types._symbol("quote"), ast];
-    } else if (ast[0].value === 'unquote') {
-        return ast[1];
-    } else if (is_pair(ast[0]) && ast[0][0].value === 'splice-unquote') {
-        return [types._symbol("concat"),
-                ast[0][1],
-                quasiquote(ast.slice(1))];
-    } else {
-        return [types._symbol("cons"),
-                quasiquote(ast[0]),
-                quasiquote(ast.slice(1))];
-    }
-}
-
-function is_macro_call(ast, env) {
-    return types._list_Q(ast) &&
-           types._symbol_Q(ast[0]) &&
-           env.find(ast[0]) &&
-           env.get(ast[0])._ismacro_;
-}
-
-function macroexpand(ast, env) {
-    while (is_macro_call(ast, env)) {
-        var mac = env.get(ast[0]);
-        ast = mac.apply(mac, ast.slice(1));
-    }
-    return ast;
-}
-
-function eval_ast(ast, env) {
-    if (types._symbol_Q(ast)) {
-        return env.get(ast);
-    } else if (types._list_Q(ast)) {
-        return ast.map(function(a) { return EVAL(a, env); });
-    } else if (types._vector_Q(ast)) {
-        var v = ast.map(function(a) { return EVAL(a, env); });
-        v.__isvector__ = true;
-        return v;
-    } else if (types._hash_map_Q(ast)) {
-        var new_hm = {};
-        for (k in ast) {
-            new_hm[EVAL(k, env)] = EVAL(ast[k], env);
-        }
-        return new_hm;
-    } else {
-        return ast;
-    }
-}
-
-function _EVAL(ast, env) {
-    while (true) {
-
-    //printer.println("EVAL:", printer._pr_str(ast, true));
-    if (!types._list_Q(ast)) {
-        return eval_ast(ast, env);
-    }
-
-    // apply list
-    ast = macroexpand(ast, env);
-    if (!types._list_Q(ast)) { return ast; }
-
-    var a0 = ast[0], a1 = ast[1], a2 = ast[2], a3 = ast[3];
-    switch (a0.value) {
-    case "def!":
-        var res = EVAL(a2, env);
-        return env.set(a1, res);
-    case "let*":
-        var let_env = new Env(env);
-        for (var i=0; i < a1.length; i+=2) {
-            let_env.set(a1[i], EVAL(a1[i+1], let_env));
-        }
-        ast = a2;
-        env = let_env;
-        break;
-    case "quote":
-        return a1;
-    case "quasiquote":
-        ast = quasiquote(a1);
-        break;
-    case 'defmacro!':
-        var func = EVAL(a2, env);
-        func._ismacro_ = true;
-        return env.set(a1, func);
-    case 'macroexpand':
-        return macroexpand(a1, env);
-    case "js*":
-        return eval(a1.toString());
-    case ".":
-        var el = eval_ast(ast.slice(2), env),
-            r = interop.resolve_js(a1.toString()),
-            obj = r[0], f = r[1];
-        var res = f.apply(obj, el);
-        console.log("DEBUG3:", res);
-        return interop.js_to_mal(res);
-    case "try*":
-        try {
-            return EVAL(a1, env);
-        } catch (exc) {
-            if (a2 && a2[0].value === "catch*") {
-                if (exc instanceof Error) { exc = exc.message; }
-                return EVAL(a2[2], new Env(env, [a2[1]], [exc]));
-            } else {
-                throw exc;
-            }
-        }
-    case "do":
-        eval_ast(ast.slice(1, -1), env);
-        ast = ast[ast.length-1];
-        break;
-    case "if":
-        var cond = EVAL(a1, env);
-        if (cond === null || cond === false) {
-            ast = (typeof a3 !== "undefined") ? a3 : null;
-        } else {
-            ast = a2;
-        }
-        break;
-    case "fn*":
-        return types._function(EVAL, Env, a2, env, a1);
-    default:
-        var el = eval_ast(ast, env), f = el[0];
-        if (f.__ast__) {
-            ast = f.__ast__;
-            env = f.__gen_env__(el.slice(1));
-        } else {
-            return f.apply(f, el.slice(1));
-        }
-    }
-
-    }
-}
-
-function EVAL(ast, env) {
-    var result = _EVAL(ast, env);
-    return (typeof result !== "undefined") ? result : null;
-}
-
-// print
-function PRINT(exp) {
-    return printer._pr_str(exp, true);
-}
-
-// repl
-var repl_env = new Env();
-var rep = function(str) { return PRINT(EVAL(READ(str), repl_env)); };
-
-// core.js: defined using javascript
-for (var n in core.ns) { repl_env.set(types._symbol(n), core.ns[n]); }
-repl_env.set(types._symbol('eval'), function(ast) {
-    return EVAL(ast, repl_env); });
-repl_env.set(types._symbol('*ARGV*'), []);
-
-// core.mal: defined using the language itself
-rep("(def! *host-language* \"javascript\")")
-rep("(def! not (fn* (a) (if a false true)))");
-rep("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))");
-rep("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))");
-rep("(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))");
-
-if (typeof process !== 'undefined' && process.argv.length > 2) {
-    repl_env.set(types._symbol('*ARGV*'), process.argv.slice(3));
-    rep('(load-file "' + process.argv[2] + '")');
-    process.exit(0);
-}
-
-// repl loop
-if (typeof require !== 'undefined' && require.main === module) {
-    // Synchronous node.js commandline mode
-    rep("(println (str \"Mal [\" *host-language* \"]\"))");
-    while (true) {
-        var line = readline.readline("user> ");
-        if (line === null) { break; }
-        try {
-            if (line) { printer.println(rep(line)); }
-        } catch (exc) {
-            if (exc instanceof reader.BlankException) { continue; }
-            if (exc.stack) { printer.println(exc.stack); }
-            else           { printer.println(exc); }
-        }
-    }
-}
diff --git a/js/stepA_mal.js b/js/stepA_mal.js
new file mode 100644
index 0000000..d879cd3
--- /dev/null
+++ b/js/stepA_mal.js
@@ -0,0 +1,203 @@
+if (typeof module !== 'undefined') {
+    var types = require('./types');
+    var readline = require('./node_readline');
+    var reader = require('./reader');
+    var printer = require('./printer');
+    var Env = require('./env').Env;
+    var core = require('./core');
+    var interop = require('./interop');
+}
+
+// read
+function READ(str) {
+    return reader.read_str(str);
+}
+
+// eval
+function is_pair(x) {
+    return types._sequential_Q(x) && x.length > 0;
+}
+
+function quasiquote(ast) {
+    if (!is_pair(ast)) {
+        return [types._symbol("quote"), ast];
+    } else if (ast[0].value === 'unquote') {
+        return ast[1];
+    } else if (is_pair(ast[0]) && ast[0][0].value === 'splice-unquote') {
+        return [types._symbol("concat"),
+                ast[0][1],
+                quasiquote(ast.slice(1))];
+    } else {
+        return [types._symbol("cons"),
+                quasiquote(ast[0]),
+                quasiquote(ast.slice(1))];
+    }
+}
+
+function is_macro_call(ast, env) {
+    return types._list_Q(ast) &&
+           types._symbol_Q(ast[0]) &&
+           env.find(ast[0]) &&
+           env.get(ast[0])._ismacro_;
+}
+
+function macroexpand(ast, env) {
+    while (is_macro_call(ast, env)) {
+        var mac = env.get(ast[0]);
+        ast = mac.apply(mac, ast.slice(1));
+    }
+    return ast;
+}
+
+function eval_ast(ast, env) {
+    if (types._symbol_Q(ast)) {
+        return env.get(ast);
+    } else if (types._list_Q(ast)) {
+        return ast.map(function(a) { return EVAL(a, env); });
+    } else if (types._vector_Q(ast)) {
+        var v = ast.map(function(a) { return EVAL(a, env); });
+        v.__isvector__ = true;
+        return v;
+    } else if (types._hash_map_Q(ast)) {
+        var new_hm = {};
+        for (k in ast) {
+            new_hm[EVAL(k, env)] = EVAL(ast[k], env);
+        }
+        return new_hm;
+    } else {
+        return ast;
+    }
+}
+
+function _EVAL(ast, env) {
+    while (true) {
+
+    //printer.println("EVAL:", printer._pr_str(ast, true));
+    if (!types._list_Q(ast)) {
+        return eval_ast(ast, env);
+    }
+
+    // apply list
+    ast = macroexpand(ast, env);
+    if (!types._list_Q(ast)) { return ast; }
+
+    var a0 = ast[0], a1 = ast[1], a2 = ast[2], a3 = ast[3];
+    switch (a0.value) {
+    case "def!":
+        var res = EVAL(a2, env);
+        return env.set(a1, res);
+    case "let*":
+        var let_env = new Env(env);
+        for (var i=0; i < a1.length; i+=2) {
+            let_env.set(a1[i], EVAL(a1[i+1], let_env));
+        }
+        ast = a2;
+        env = let_env;
+        break;
+    case "quote":
+        return a1;
+    case "quasiquote":
+        ast = quasiquote(a1);
+        break;
+    case 'defmacro!':
+        var func = EVAL(a2, env);
+        func._ismacro_ = true;
+        return env.set(a1, func);
+    case 'macroexpand':
+        return macroexpand(a1, env);
+    case "js*":
+        return eval(a1.toString());
+    case ".":
+        var el = eval_ast(ast.slice(2), env),
+            r = interop.resolve_js(a1.toString()),
+            obj = r[0], f = r[1];
+        var res = f.apply(obj, el);
+        console.log("DEBUG3:", res);
+        return interop.js_to_mal(res);
+    case "try*":
+        try {
+            return EVAL(a1, env);
+        } catch (exc) {
+            if (a2 && a2[0].value === "catch*") {
+                if (exc instanceof Error) { exc = exc.message; }
+                return EVAL(a2[2], new Env(env, [a2[1]], [exc]));
+            } else {
+                throw exc;
+            }
+        }
+    case "do":
+        eval_ast(ast.slice(1, -1), env);
+        ast = ast[ast.length-1];
+        break;
+    case "if":
+        var cond = EVAL(a1, env);
+        if (cond === null || cond === false) {
+            ast = (typeof a3 !== "undefined") ? a3 : null;
+        } else {
+            ast = a2;
+        }
+        break;
+    case "fn*":
+        return types._function(EVAL, Env, a2, env, a1);
+    default:
+        var el = eval_ast(ast, env), f = el[0];
+        if (f.__ast__) {
+            ast = f.__ast__;
+            env = f.__gen_env__(el.slice(1));
+        } else {
+            return f.apply(f, el.slice(1));
+        }
+    }
+
+    }
+}
+
+function EVAL(ast, env) {
+    var result = _EVAL(ast, env);
+    return (typeof result !== "undefined") ? result : null;
+}
+
+// print
+function PRINT(exp) {
+    return printer._pr_str(exp, true);
+}
+
+// repl
+var repl_env = new Env();
+var rep = function(str) { return PRINT(EVAL(READ(str), repl_env)); };
+
+// core.js: defined using javascript
+for (var n in core.ns) { repl_env.set(types._symbol(n), core.ns[n]); }
+repl_env.set(types._symbol('eval'), function(ast) {
+    return EVAL(ast, repl_env); });
+repl_env.set(types._symbol('*ARGV*'), []);
+
+// core.mal: defined using the language itself
+rep("(def! *host-language* \"javascript\")")
+rep("(def! not (fn* (a) (if a false true)))");
+rep("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))");
+rep("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))");
+rep("(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))");
+
+if (typeof process !== 'undefined' && process.argv.length > 2) {
+    repl_env.set(types._symbol('*ARGV*'), process.argv.slice(3));
+    rep('(load-file "' + process.argv[2] + '")');
+    process.exit(0);
+}
+
+// repl loop
+if (typeof require !== 'undefined' && require.main === module) {
+    // Synchronous node.js commandline mode
+    rep("(println (str \"Mal [\" *host-language* \"]\"))");
+    while (true) {
+        var line = readline.readline("user> ");
+        if (line === null) { break; }
+        try {
+            if (line) { printer.println(rep(line)); }
+        } catch (exc) {
+            if (exc instanceof reader.BlankException) { continue; }
+            if (exc.stack) { printer.println(exc.stack); }
+            else           { printer.println(exc); }
+        }
+    }
+}
diff --git a/js/tests/stepA_interop.mal b/js/tests/stepA_interop.mal
deleted file mode 100644
index f785292..0000000
--- a/js/tests/stepA_interop.mal
+++ /dev/null
@@ -1,24 +0,0 @@
-;; Testing basic bash interop
-
-(js* "7")
-;=>7
-
-(js* "'7'")
-;=>"7"
-
-(js* "[7,8,9]")
-;=>(7 8 9)
-
-(js* "console.log('hello');")
-; hello
-;=>nil
-
-(js* "foo=8;")
-(js* "foo;")
-;=>8
-
-(js* "['a','b','c'].map(function(x){return 'X'+x+'Y'}).join(' ')")
-;=>"XaY XbY XcY"
-
-(js* "[1,2,3].map(function(x){return 1+x})")
-;=>(2 3 4)
diff --git a/js/tests/stepA_mal.mal b/js/tests/stepA_mal.mal
new file mode 100644
index 0000000..f785292
--- /dev/null
+++ b/js/tests/stepA_mal.mal
@@ -0,0 +1,24 @@
+;; Testing basic bash interop
+
+(js* "7")
+;=>7
+
+(js* "'7'")
+;=>"7"
+
+(js* "[7,8,9]")
+;=>(7 8 9)
+
+(js* "console.log('hello');")
+; hello
+;=>nil
+
+(js* "foo=8;")
+(js* "foo;")
+;=>8
+
+(js* "['a','b','c'].map(function(x){return 'X'+x+'Y'}).join(' ')")
+;=>"XaY XbY XcY"
+
+(js* "[1,2,3].map(function(x){return 1+x})")
+;=>(2 3 4)
diff --git a/lua/Makefile b/lua/Makefile
index d1498bd..169c587 100644
--- a/lua/Makefile
+++ b/lua/Makefile
@@ -1,7 +1,7 @@
 TESTS =
 
 SOURCES_BASE = utils.lua types.lua reader.lua printer.lua
-SOURCES_LISP = env.lua core.lua stepA_interop.lua
+SOURCES_LISP = env.lua core.lua stepA_mal.lua
 SOURCES = $(SOURCES_BASE) $(SOURCES_LISP)
 
 all: libs
diff --git a/lua/stepA_interop.lua b/lua/stepA_interop.lua
deleted file mode 100755
index 430fffc..0000000
--- a/lua/stepA_interop.lua
+++ /dev/null
@@ -1,200 +0,0 @@
-#!/usr/bin/env lua
-
-local table = require('table')
-
-local readline = require('readline')
-local utils = require('utils')
-local types = require('types')
-local reader = require('reader')
-local printer = require('printer')
-local Env = require('env')
-local core = require('core')
-local List, Vector, HashMap = types.List, types.Vector, types.HashMap
-
--- read
-function READ(str)
-    return reader.read_str(str)
-end
-
--- eval
-function is_pair(x)
-    return types._sequential_Q(x) and #x > 0
-end
-
-function quasiquote(ast)
-    if not is_pair(ast) then
-        return types.List:new({types.Symbol:new("quote"), ast})
-    elseif types._symbol_Q(ast[1]) and ast[1].val == 'unquote' then
-        return ast[2]
-    elseif is_pair(ast[1]) and
-           types._symbol_Q(ast[1][1]) and
-           ast[1][1].val == 'splice-unquote' then
-        return types.List:new({types.Symbol:new("concat"),
-                               ast[1][2],
-                               quasiquote(ast:slice(2))})
-    else
-        return types.List:new({types.Symbol:new("cons"),
-                               quasiquote(ast[1]),
-                               quasiquote(ast:slice(2))})
-    end
-end
-
-function is_macro_call(ast, env)
-    if types._list_Q(ast) and
-       types._symbol_Q(ast[1]) and
-       env:find(ast[1]) then
-        local f = env:get(ast[1])
-        return types._malfunc_Q(f) and f.ismacro
-    end
-end
-
-function macroexpand(ast, env)
-    while is_macro_call(ast, env) do
-        local mac = env:get(ast[1])
-        ast = mac.fn(unpack(ast:slice(2)))
-    end
-    return ast
-end
-
-function eval_ast(ast, env)
-    if types._symbol_Q(ast) then
-        return env:get(ast)
-    elseif types._list_Q(ast) then
-        return List:new(utils.map(function(x) return EVAL(x,env) end,ast))
-    elseif types._vector_Q(ast) then
-        return Vector:new(utils.map(function(x) return EVAL(x,env) end,ast))
-    elseif types._hash_map_Q(ast) then
-        local new_hm = {}
-        for k,v in pairs(ast) do
-            new_hm[EVAL(k, env)] = EVAL(v, env)
-        end
-        return HashMap:new(new_hm)
-    else
-        return ast
-    end
-end
-
-function EVAL(ast, env)
-  while true do
-    --print("EVAL: "..printer._pr_str(ast,true))
-    if not types._list_Q(ast) then return eval_ast(ast, env) end
-
-    -- apply list
-    ast = macroexpand(ast, env)
-    if not types._list_Q(ast) then return ast end
-
-    local a0,a1,a2,a3 = ast[1], ast[2],ast[3],ast[4]
-    local a0sym = types._symbol_Q(a0) and a0.val or ""
-    if 'def!' == a0sym then
-        return env:set(a1, EVAL(a2, env))
-    elseif 'let*' == a0sym then
-        local let_env = Env:new(env)
-        for i = 1,#a1,2 do
-            let_env:set(a1[i], EVAL(a1[i+1], let_env))
-        end
-        env = let_env
-        ast = a2 -- TCO
-    elseif 'quote' == a0sym then
-        return a1
-    elseif 'quasiquote' == a0sym then
-        ast = quasiquote(a1) -- TCO
-    elseif 'defmacro!' == a0sym then
-        local mac = EVAL(a2, env)
-        mac.ismacro = true
-        return env:set(a1, mac)
-    elseif 'macroexpand' == a0sym then
-        return macroexpand(a1, env)
-    elseif 'try*' == a0sym then
-        local exc, result = nil, nil
-        xpcall(function()
-            result = EVAL(a1, env)
-        end, function(err)
-            exc = err
-        end)
-        if exc ~= nil then
-            if types._malexception_Q(exc) then
-                exc = exc.val
-            end
-            if a2 and a2[1].val == 'catch*' then
-                result = EVAL(a2[3], Env:new(env, {a2[2]}, {exc}))
-            else
-                types.throw(exc)
-            end
-        end
-        return result
-    elseif 'do' == a0sym then
-        local el = eval_ast(ast:slice(2,#ast-1), env)
-        ast = ast[#ast]  -- TCO
-    elseif 'if' == a0sym then
-        local cond = EVAL(a1, env)
-        if cond == types.Nil or cond == false then
-            if a3 then ast = a3 else return types.Nil end -- TCO
-        else
-            ast = a2 -- TCO
-        end
-    elseif 'fn*' == a0sym then
-        return types.MalFunc:new(function(...)
-            return EVAL(a2, Env:new(env, a1, arg))
-        end, a2, env, a1)
-    else
-        local args = eval_ast(ast, env)
-        local f = table.remove(args, 1)
-        if types._malfunc_Q(f) then
-            ast = f.ast
-            env = Env:new(f.env, f.params, args) -- TCO
-        else
-            return f(unpack(args))
-        end
-    end
-  end
-end
-
--- print
-function PRINT(exp)
-    return printer._pr_str(exp, true)
-end
-
--- repl
-local repl_env = Env:new()
-function rep(str)
-    return PRINT(EVAL(READ(str),repl_env))
-end
-
--- core.lua: defined using Lua
-for k,v in pairs(core.ns) do
-    repl_env:set(types.Symbol:new(k), v)
-end
-repl_env:set(types.Symbol:new('eval'),
-             function(ast) return EVAL(ast, repl_env) end)
-repl_env:set(types.Symbol:new('*ARGV*'), types.List:new(types.slice(arg,2)))
-
--- core.mal: defined using mal
-rep("(def! *host-language* \"lua\")")
-rep("(def! not (fn* (a) (if a false true)))")
-rep("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))")
-rep("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))")
-rep("(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))")
-
-function print_exception(exc)
-    if exc then
-        if types._malexception_Q(exc) then
-            exc = printer._pr_str(exc.val, true)
-        end
-        print("Error: " .. exc)
-        print(debug.traceback())
-    end
-end
-
-if #arg > 0 then
-    xpcall(function() rep("(load-file \""..arg[1].."\")") end,
-           print_exception)
-    os.exit(0)
-end
-
-rep("(println (str \"Mal [\" *host-language* \"]\"))")
-while true do
-    line = readline.readline("user> ")
-    if not line then break end
-    xpcall(function() print(rep(line)) end,
-           print_exception)
-end
diff --git a/lua/stepA_mal.lua b/lua/stepA_mal.lua
new file mode 100755
index 0000000..430fffc
--- /dev/null
+++ b/lua/stepA_mal.lua
@@ -0,0 +1,200 @@
+#!/usr/bin/env lua
+
+local table = require('table')
+
+local readline = require('readline')
+local utils = require('utils')
+local types = require('types')
+local reader = require('reader')
+local printer = require('printer')
+local Env = require('env')
+local core = require('core')
+local List, Vector, HashMap = types.List, types.Vector, types.HashMap
+
+-- read
+function READ(str)
+    return reader.read_str(str)
+end
+
+-- eval
+function is_pair(x)
+    return types._sequential_Q(x) and #x > 0
+end
+
+function quasiquote(ast)
+    if not is_pair(ast) then
+        return types.List:new({types.Symbol:new("quote"), ast})
+    elseif types._symbol_Q(ast[1]) and ast[1].val == 'unquote' then
+        return ast[2]
+    elseif is_pair(ast[1]) and
+           types._symbol_Q(ast[1][1]) and
+           ast[1][1].val == 'splice-unquote' then
+        return types.List:new({types.Symbol:new("concat"),
+                               ast[1][2],
+                               quasiquote(ast:slice(2))})
+    else
+        return types.List:new({types.Symbol:new("cons"),
+                               quasiquote(ast[1]),
+                               quasiquote(ast:slice(2))})
+    end
+end
+
+function is_macro_call(ast, env)
+    if types._list_Q(ast) and
+       types._symbol_Q(ast[1]) and
+       env:find(ast[1]) then
+        local f = env:get(ast[1])
+        return types._malfunc_Q(f) and f.ismacro
+    end
+end
+
+function macroexpand(ast, env)
+    while is_macro_call(ast, env) do
+        local mac = env:get(ast[1])
+        ast = mac.fn(unpack(ast:slice(2)))
+    end
+    return ast
+end
+
+function eval_ast(ast, env)
+    if types._symbol_Q(ast) then
+        return env:get(ast)
+    elseif types._list_Q(ast) then
+        return List:new(utils.map(function(x) return EVAL(x,env) end,ast))
+    elseif types._vector_Q(ast) then
+        return Vector:new(utils.map(function(x) return EVAL(x,env) end,ast))
+    elseif types._hash_map_Q(ast) then
+        local new_hm = {}
+        for k,v in pairs(ast) do
+            new_hm[EVAL(k, env)] = EVAL(v, env)
+        end
+        return HashMap:new(new_hm)
+    else
+        return ast
+    end
+end
+
+function EVAL(ast, env)
+  while true do
+    --print("EVAL: "..printer._pr_str(ast,true))
+    if not types._list_Q(ast) then return eval_ast(ast, env) end
+
+    -- apply list
+    ast = macroexpand(ast, env)
+    if not types._list_Q(ast) then return ast end
+
+    local a0,a1,a2,a3 = ast[1], ast[2],ast[3],ast[4]
+    local a0sym = types._symbol_Q(a0) and a0.val or ""
+    if 'def!' == a0sym then
+        return env:set(a1, EVAL(a2, env))
+    elseif 'let*' == a0sym then
+        local let_env = Env:new(env)
+        for i = 1,#a1,2 do
+            let_env:set(a1[i], EVAL(a1[i+1], let_env))
+        end
+        env = let_env
+        ast = a2 -- TCO
+    elseif 'quote' == a0sym then
+        return a1
+    elseif 'quasiquote' == a0sym then
+        ast = quasiquote(a1) -- TCO
+    elseif 'defmacro!' == a0sym then
+        local mac = EVAL(a2, env)
+        mac.ismacro = true
+        return env:set(a1, mac)
+    elseif 'macroexpand' == a0sym then
+        return macroexpand(a1, env)
+    elseif 'try*' == a0sym then
+        local exc, result = nil, nil
+        xpcall(function()
+            result = EVAL(a1, env)
+        end, function(err)
+            exc = err
+        end)
+        if exc ~= nil then
+            if types._malexception_Q(exc) then
+                exc = exc.val
+            end
+            if a2 and a2[1].val == 'catch*' then
+                result = EVAL(a2[3], Env:new(env, {a2[2]}, {exc}))
+            else
+                types.throw(exc)
+            end
+        end
+        return result
+    elseif 'do' == a0sym then
+        local el = eval_ast(ast:slice(2,#ast-1), env)
+        ast = ast[#ast]  -- TCO
+    elseif 'if' == a0sym then
+        local cond = EVAL(a1, env)
+        if cond == types.Nil or cond == false then
+            if a3 then ast = a3 else return types.Nil end -- TCO
+        else
+            ast = a2 -- TCO
+        end
+    elseif 'fn*' == a0sym then
+        return types.MalFunc:new(function(...)
+            return EVAL(a2, Env:new(env, a1, arg))
+        end, a2, env, a1)
+    else
+        local args = eval_ast(ast, env)
+        local f = table.remove(args, 1)
+        if types._malfunc_Q(f) then
+            ast = f.ast
+            env = Env:new(f.env, f.params, args) -- TCO
+        else
+            return f(unpack(args))
+        end
+    end
+  end
+end
+
+-- print
+function PRINT(exp)
+    return printer._pr_str(exp, true)
+end
+
+-- repl
+local repl_env = Env:new()
+function rep(str)
+    return PRINT(EVAL(READ(str),repl_env))
+end
+
+-- core.lua: defined using Lua
+for k,v in pairs(core.ns) do
+    repl_env:set(types.Symbol:new(k), v)
+end
+repl_env:set(types.Symbol:new('eval'),
+             function(ast) return EVAL(ast, repl_env) end)
+repl_env:set(types.Symbol:new('*ARGV*'), types.List:new(types.slice(arg,2)))
+
+-- core.mal: defined using mal
+rep("(def! *host-language* \"lua\")")
+rep("(def! not (fn* (a) (if a false true)))")
+rep("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))")
+rep("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))")
+rep("(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))")
+
+function print_exception(exc)
+    if exc then
+        if types._malexception_Q(exc) then
+            exc = printer._pr_str(exc.val, true)
+        end
+        print("Error: " .. exc)
+        print(debug.traceback())
+    end
+end
+
+if #arg > 0 then
+    xpcall(function() rep("(load-file \""..arg[1].."\")") end,
+           print_exception)
+    os.exit(0)
+end
+
+rep("(println (str \"Mal [\" *host-language* \"]\"))")
+while true do
+    line = readline.readline("user> ")
+    if not line then break end
+    xpcall(function() print(rep(line)) end,
+           print_exception)
+end
diff --git a/make/Makefile b/make/Makefile
index 39658ac..70dea08 100644
--- a/make/Makefile
+++ b/make/Makefile
@@ -1,9 +1,9 @@
 
-TESTS = tests/types.mk tests/reader.mk tests/stepA_interop.mk
+TESTS = tests/types.mk tests/reader.mk tests/stepA_mal.mk
 
 SOURCES_BASE = util.mk numbers.mk readline.mk gmsl.mk types.mk \
                reader.mk printer.mk
-SOURCES_LISP = env.mk core.mk stepA_interop.mk
+SOURCES_LISP = env.mk core.mk stepA_mal.mk
 SOURCES = $(SOURCES_BASE) $(SOURCES_LISP)
 
 mal.mk: $(SOURCES)
diff --git a/make/stepA_interop.mk b/make/stepA_interop.mk
deleted file mode 100644
index 80909c7..0000000
--- a/make/stepA_interop.mk
+++ /dev/null
@@ -1,193 +0,0 @@
-#
-# mal (Make Lisp)
-#
-_TOP_DIR := $(dir $(lastword $(MAKEFILE_LIST)))
-include $(_TOP_DIR)types.mk
-include $(_TOP_DIR)reader.mk
-include $(_TOP_DIR)printer.mk
-include $(_TOP_DIR)env.mk
-include $(_TOP_DIR)core.mk
-
-SHELL := /bin/bash
-INTERACTIVE ?= yes
-EVAL_DEBUG ?=
-
-# READ: read and parse input
-define READ
-$(if $(READLINE_EOF)$(__ERROR),,$(call READ_STR,$(if $(1),$(1),$(call READLINE,"user> "))))
-endef
-
-# EVAL: evaluate the parameter
-IS_PAIR = $(if $(call _sequential?,$(1)),$(if $(call _EQ,0,$(call _count,$(1))),,true),)
-
-define QUASIQUOTE
-$(strip \
-  $(if $(call _NOT,$(call IS_PAIR,$(1))),\
-    $(call _list,$(call _symbol,quote) $(1)),\
-    $(if $(call _EQ,unquote,$($(call _nth,$(1),0)_value)),\
-      $(call _nth,$(1),1),\
-      $(if $(and $(call IS_PAIR,$(call _nth,$(1),0)),$(call _EQ,splice-unquote,$($(call _nth,$(call _nth,$(1),0),0)_value))),\
-        $(call _list,$(call _symbol,concat) $(call _nth,$(call _nth,$(1),0),1) $(call QUASIQUOTE,$(call srest,$(1)))),\
-        $(call _list,$(call _symbol,cons) $(call QUASIQUOTE,$(call _nth,$(1),0)) $(call QUASIQUOTE,$(call srest,$(1))))))))
-endef
-
-define IS_MACRO_CALL
-$(if $(call _list?,$(1)),$(call ENV_FIND,$(2),_macro_$($(call _nth,$(1),0)_value)),)
-endef
-
-define MACROEXPAND
-$(strip $(if $(__ERROR),,\
-  $(if $(call IS_MACRO_CALL,$(1),$(2)),\
-    $(foreach mac,$(call ENV_GET,$(2),$($(call _nth,$(1),0)_value)),\
-      $(call MACROEXPAND,$(call apply,$(mac),$(call srest,$(1))),$(2))),\
-    $(1))))
-endef
-
-define LET
-$(strip \
-  $(word 1,$(2) \
-    $(foreach var,$(call _nth,$(1),0),\
-      $(foreach val,$(call _nth,$(1),1),\
-        $(call ENV_SET,$(2),$($(var)_value),$(call EVAL,$(val),$(2)))\
-        $(foreach left,$(call srest,$(call srest,$(1))),
-          $(if $(call _EQ,0,$(call _count,$(left))),\
-            ,\
-            $(call LET,$(left),$(2))))))))
-endef
-
-define EVAL_AST
-$(strip \
-  $(and $(EVAL_DEBUG),$(info EVAL_AST: $(call _pr_str,$(1))))\
-  $(if $(call _symbol?,$(1)),\
-    $(foreach key,$($(1)_value),\
-      $(call ENV_GET,$(2),$(key))),\
-  $(if $(call _list?,$(1)),\
-    $(call _smap,EVAL,$(1),$(2)),\
-  $(if $(call _vector?,$(1)),\
-    $(call _smap_vec,EVAL,$(1),$(2)),\
-  $(if $(call _hash_map?,$(1)),\
-    $(foreach new_hmap,$(call __new_obj,hmap),\
-      $(foreach v,$(call __get_obj_values,$(1)),\
-        $(eval $(v:$(1)_%=$(new_hmap)_%) := $(call EVAL,$($(v)),$(2))))\
-      $(eval $(new_hmap)_size := $($(1)_size))\
-      $(new_hmap)),\
-  $(1))))))
-endef
-
-define EVAL_INVOKE
-$(if $(__ERROR),,\
-  $(and $(EVAL_DEBUG),$(info EVAL_INVOKE: $(call _pr_str,$(1))))
-  $(foreach a0,$(call _nth,$(1),0),\
-    $(if $(call _EQ,def!,$($(a0)_value)),\
-      $(foreach a1,$(call _nth,$(1),1),\
-        $(foreach a2,$(call _nth,$(1),2),\
-          $(foreach res,$(call EVAL,$(a2),$(2)),\
-            $(if $(__ERROR),,\
-              $(if $(call ENV_SET,$(2),$($(a1)_value),$(res)),$(res),))))),\
-    $(if $(call _EQ,let*,$($(a0)_value)),\
-      $(foreach a1,$(call _nth,$(1),1),\
-        $(foreach a2,$(call _nth,$(1),2),\
-          $(call EVAL,$(a2),$(call LET,$(a1),$(call ENV,$(2)))))),\
-    $(if $(call _EQ,quote,$($(a0)_value)),\
-      $(call _nth,$(1),1),\
-    $(if $(call _EQ,quasiquote,$($(a0)_value)),\
-      $(call EVAL,$(call QUASIQUOTE,$(call _nth,$(1),1)),$(2)),\
-    $(if $(call _EQ,defmacro!,$($(a0)_value)),\
-      $(foreach a1,$(call _nth,$(1),1),\
-        $(foreach a2,$(call _nth,$(1),2),\
-          $(foreach res,$(call EVAL,$(a2),$(2)),\
-            $(if $(call ENV_SET,$(2),_macro_$($(a1)_value),true),,)\
-            $(if $(call ENV_SET,$(2),$($(a1)_value),$(res)),$(res),)))),\
-    $(if $(call _EQ,macroexpand,$($(a0)_value)),\
-      $(call MACROEXPAND,$(call _nth,$(1),1),$(2)),\
-    $(if $(call _EQ,make*,$($(a0)_value)),\
-      $(foreach a1,$(call _nth,$(1),1),\
-        $(and $(EVAL_DEBUG),$(info make*: $$(eval __result := $(call str_decode,$(value $(a1)_value)))))\
-        $(eval __result := $(call str_decode,$(value $(a1)_value)))$(call _string,$(__result))),\
-    $(if $(call _EQ,try*,$($(a0)_value)),\
-      $(foreach a1,$(call _nth,$(1),1),\
-        $(foreach res,$(call EVAL,$(a1),$(2)),\
-          $(if $(__ERROR),\
-            $(foreach a2,$(call _nth,$(1),2),\
-              $(foreach a20,$(call _nth,$(a2),0),\
-                $(if $(call _EQ,catch*,$($(a20)_value)),\
-                  $(foreach a21,$(call _nth,$(a2),1),\
-                    $(foreach a22,$(call _nth,$(a2),2),\
-                      $(foreach binds,$(call _list,$(a21)),\
-                        $(foreach catch_env,$(call ENV,$(2),$(binds),$(__ERROR)),\
-			  $(eval __ERROR :=)\
-                          $(call EVAL,$(a22),$(catch_env)))))),\
-                  $(res)))),\
-            $(res)))),\
-    $(if $(call _EQ,do,$($(a0)_value)),\
-      $(call slast,$(call EVAL_AST,$(call srest,$(1)),$(2))),\
-    $(if $(call _EQ,if,$($(a0)_value)),\
-      $(foreach a1,$(call _nth,$(1),1),\
-        $(foreach a2,$(call _nth,$(1),2),\
-          $(foreach cond,$(call EVAL,$(a1),$(2)),\
-            $(if $(or $(call _EQ,$(__nil),$(cond)),$(call _EQ,$(__false),$(cond))),\
-              $(foreach a3,$(call _nth,$(1),3),$(call EVAL,$(a3),$(2))),\
-              $(call EVAL,$(a2),$(2)))))),\
-    $(if $(call _EQ,fn*,$($(a0)_value)),\
-      $(foreach a1,$(call _nth,$(1),1),\
-        $(foreach a2,$(call _nth,$(1),2),\
-          $(call _function,$$(call EVAL,$(a2),$$(call ENV,$(2),$(a1),$$1))))),\
-      $(foreach el,$(call EVAL_AST,$(1),$(2)),\
-        $(and $(EVAL_DEBUG),$(info invoke: $(call _pr_str,$(el))))\
-        $(foreach f,$(call sfirst,$(el)),\
-          $(foreach args,$(call srest,$(el)),\
-            $(call apply,$(f),$(args))))))))))))))))))
-endef
-
-define EVAL
-$(strip $(if $(__ERROR),,\
-  $(and $(EVAL_DEBUG),$(info EVAL: $(call _pr_str,$(1))))\
-  $(if $(call _list?,$(1)),\
-    $(foreach ast,$(call MACROEXPAND,$(1),$(2)),
-      $(if $(call _list?,$(ast)),\
-        $(word 1,$(strip $(call EVAL_INVOKE,$(ast),$(2)) $(__nil))),\
-	$(ast))),\
-    $(call EVAL_AST,$(1),$(2)))))
-endef
-
-
-# PRINT:
-define PRINT
-$(if $(__ERROR),Error: $(call _pr_str,$(__ERROR),yes),$(if $(1),$(call _pr_str,$(1),yes)))$(if $(__ERROR),$(eval __ERROR :=),)
-endef
-
-# REPL:
-REPL_ENV := $(call ENV)
-REP = $(call PRINT,$(strip $(call EVAL,$(strip $(call READ,$(1))),$(REPL_ENV))))
-REPL = $(info $(call REP,$(call READLINE,"user> ")))$(if $(READLINE_EOF),,$(call REPL))
-
-# core.mk: defined using Make
-_fref = $(eval REPL_ENV := $(call ENV_SET,$(REPL_ENV),$(1),$(call _function,$$(call $(2),$$1))))
-_import_core = $(if $(strip $(1)),$(call _fref,$(word 1,$(1)),$(word 2,$(1)))$(call _import_core,$(wordlist 3,$(words $(1)),$(1))),)
-$(call _import_core,$(core_ns))
-REPL_ENV := $(call ENV_SET,$(REPL_ENV),eval,$(call _function,$$(call EVAL,$$(1),$$(REPL_ENV))))
-_argv := $(call _list)
-REPL_ENV := $(call ENV_SET,$(REPL_ENV),*ARGV*,$(_argv))
-
-# core.mal: defined in terms of the language itself
-$(call do,$(call REP, (def! *host-language* "make") ))
-$(call do,$(call REP, (def! not (fn* (a) (if a false true))) ))
-$(call do,$(call REP, (def! load-file (fn* (f) (eval (read-string (str "(do " (slurp f) ")"))))) ))
-$(call do,$(call REP, (defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw "odd number of forms to cond")) (cons 'cond (rest (rest xs))))))) ))
-$(call do,$(call REP, (defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs)))))))) ))
-
-# Load and eval any files specified on the command line
-$(if $(MAKECMDGOALS),\
-  $(foreach arg,$(wordlist 2,$(words $(MAKECMDGOALS)),$(MAKECMDGOALS)),\
-    $(call do,$(call _conj!,$(_argv),$(call _string,$(arg)))))\
-  $(call do,$(call REP, (load-file "$(word 1,$(MAKECMDGOALS))") )) \
-  $(eval INTERACTIVE :=),)
-
-# repl loop
-$(if $(strip $(INTERACTIVE)),\
-  $(call do,$(call REP, (println (str "Mal [" *host-language* "]")) )) \
-  $(call REPL))
-
-.PHONY: none $(MAKECMDGOALS)
-none $(MAKECMDGOALS):
-	@true
diff --git a/make/stepA_mal.mk b/make/stepA_mal.mk
new file mode 100644
index 0000000..80909c7
--- /dev/null
+++ b/make/stepA_mal.mk
@@ -0,0 +1,193 @@
+#
+# mal (Make Lisp)
+#
+_TOP_DIR := $(dir $(lastword $(MAKEFILE_LIST)))
+include $(_TOP_DIR)types.mk
+include $(_TOP_DIR)reader.mk
+include $(_TOP_DIR)printer.mk
+include $(_TOP_DIR)env.mk
+include $(_TOP_DIR)core.mk
+
+SHELL := /bin/bash
+INTERACTIVE ?= yes
+EVAL_DEBUG ?=
+
+# READ: read and parse input
+define READ
+$(if $(READLINE_EOF)$(__ERROR),,$(call READ_STR,$(if $(1),$(1),$(call READLINE,"user> "))))
+endef
+
+# EVAL: evaluate the parameter
+IS_PAIR = $(if $(call _sequential?,$(1)),$(if $(call _EQ,0,$(call _count,$(1))),,true),)
+
+define QUASIQUOTE
+$(strip \
+  $(if $(call _NOT,$(call IS_PAIR,$(1))),\
+    $(call _list,$(call _symbol,quote) $(1)),\
+    $(if $(call _EQ,unquote,$($(call _nth,$(1),0)_value)),\
+      $(call _nth,$(1),1),\
+      $(if $(and $(call IS_PAIR,$(call _nth,$(1),0)),$(call _EQ,splice-unquote,$($(call _nth,$(call _nth,$(1),0),0)_value))),\
+        $(call _list,$(call _symbol,concat) $(call _nth,$(call _nth,$(1),0),1) $(call QUASIQUOTE,$(call srest,$(1)))),\
+        $(call _list,$(call _symbol,cons) $(call QUASIQUOTE,$(call _nth,$(1),0)) $(call QUASIQUOTE,$(call srest,$(1))))))))
+endef
+
+define IS_MACRO_CALL
+$(if $(call _list?,$(1)),$(call ENV_FIND,$(2),_macro_$($(call _nth,$(1),0)_value)),)
+endef
+
+define MACROEXPAND
+$(strip $(if $(__ERROR),,\
+  $(if $(call IS_MACRO_CALL,$(1),$(2)),\
+    $(foreach mac,$(call ENV_GET,$(2),$($(call _nth,$(1),0)_value)),\
+      $(call MACROEXPAND,$(call apply,$(mac),$(call srest,$(1))),$(2))),\
+    $(1))))
+endef
+
+define LET
+$(strip \
+  $(word 1,$(2) \
+    $(foreach var,$(call _nth,$(1),0),\
+      $(foreach val,$(call _nth,$(1),1),\
+        $(call ENV_SET,$(2),$($(var)_value),$(call EVAL,$(val),$(2)))\
+        $(foreach left,$(call srest,$(call srest,$(1))),
+          $(if $(call _EQ,0,$(call _count,$(left))),\
+            ,\
+            $(call LET,$(left),$(2))))))))
+endef
+
+define EVAL_AST
+$(strip \
+  $(and $(EVAL_DEBUG),$(info EVAL_AST: $(call _pr_str,$(1))))\
+  $(if $(call _symbol?,$(1)),\
+    $(foreach key,$($(1)_value),\
+      $(call ENV_GET,$(2),$(key))),\
+  $(if $(call _list?,$(1)),\
+    $(call _smap,EVAL,$(1),$(2)),\
+  $(if $(call _vector?,$(1)),\
+    $(call _smap_vec,EVAL,$(1),$(2)),\
+  $(if $(call _hash_map?,$(1)),\
+    $(foreach new_hmap,$(call __new_obj,hmap),\
+      $(foreach v,$(call __get_obj_values,$(1)),\
+        $(eval $(v:$(1)_%=$(new_hmap)_%) := $(call EVAL,$($(v)),$(2))))\
+      $(eval $(new_hmap)_size := $($(1)_size))\
+      $(new_hmap)),\
+  $(1))))))
+endef
+
+define EVAL_INVOKE
+$(if $(__ERROR),,\
+  $(and $(EVAL_DEBUG),$(info EVAL_INVOKE: $(call _pr_str,$(1))))
+  $(foreach a0,$(call _nth,$(1),0),\
+    $(if $(call _EQ,def!,$($(a0)_value)),\
+      $(foreach a1,$(call _nth,$(1),1),\
+        $(foreach a2,$(call _nth,$(1),2),\
+          $(foreach res,$(call EVAL,$(a2),$(2)),\
+            $(if $(__ERROR),,\
+              $(if $(call ENV_SET,$(2),$($(a1)_value),$(res)),$(res),))))),\
+    $(if $(call _EQ,let*,$($(a0)_value)),\
+      $(foreach a1,$(call _nth,$(1),1),\
+        $(foreach a2,$(call _nth,$(1),2),\
+          $(call EVAL,$(a2),$(call LET,$(a1),$(call ENV,$(2)))))),\
+    $(if $(call _EQ,quote,$($(a0)_value)),\
+      $(call _nth,$(1),1),\
+    $(if $(call _EQ,quasiquote,$($(a0)_value)),\
+      $(call EVAL,$(call QUASIQUOTE,$(call _nth,$(1),1)),$(2)),\
+    $(if $(call _EQ,defmacro!,$($(a0)_value)),\
+      $(foreach a1,$(call _nth,$(1),1),\
+        $(foreach a2,$(call _nth,$(1),2),\
+          $(foreach res,$(call EVAL,$(a2),$(2)),\
+            $(if $(call ENV_SET,$(2),_macro_$($(a1)_value),true),,)\
+            $(if $(call ENV_SET,$(2),$($(a1)_value),$(res)),$(res),)))),\
+    $(if $(call _EQ,macroexpand,$($(a0)_value)),\
+      $(call MACROEXPAND,$(call _nth,$(1),1),$(2)),\
+    $(if $(call _EQ,make*,$($(a0)_value)),\
+      $(foreach a1,$(call _nth,$(1),1),\
+        $(and $(EVAL_DEBUG),$(info make*: $$(eval __result := $(call str_decode,$(value $(a1)_value)))))\
+        $(eval __result := $(call str_decode,$(value $(a1)_value)))$(call _string,$(__result))),\
+    $(if $(call _EQ,try*,$($(a0)_value)),\
+      $(foreach a1,$(call _nth,$(1),1),\
+        $(foreach res,$(call EVAL,$(a1),$(2)),\
+          $(if $(__ERROR),\
+            $(foreach a2,$(call _nth,$(1),2),\
+              $(foreach a20,$(call _nth,$(a2),0),\
+                $(if $(call _EQ,catch*,$($(a20)_value)),\
+                  $(foreach a21,$(call _nth,$(a2),1),\
+                    $(foreach a22,$(call _nth,$(a2),2),\
+                      $(foreach binds,$(call _list,$(a21)),\
+                        $(foreach catch_env,$(call ENV,$(2),$(binds),$(__ERROR)),\
+			  $(eval __ERROR :=)\
+                          $(call EVAL,$(a22),$(catch_env)))))),\
+                  $(res)))),\
+            $(res)))),\
+    $(if $(call _EQ,do,$($(a0)_value)),\
+      $(call slast,$(call EVAL_AST,$(call srest,$(1)),$(2))),\
+    $(if $(call _EQ,if,$($(a0)_value)),\
+      $(foreach a1,$(call _nth,$(1),1),\
+        $(foreach a2,$(call _nth,$(1),2),\
+          $(foreach cond,$(call EVAL,$(a1),$(2)),\
+            $(if $(or $(call _EQ,$(__nil),$(cond)),$(call _EQ,$(__false),$(cond))),\
+              $(foreach a3,$(call _nth,$(1),3),$(call EVAL,$(a3),$(2))),\
+              $(call EVAL,$(a2),$(2)))))),\
+    $(if $(call _EQ,fn*,$($(a0)_value)),\
+      $(foreach a1,$(call _nth,$(1),1),\
+        $(foreach a2,$(call _nth,$(1),2),\
+          $(call _function,$$(call EVAL,$(a2),$$(call ENV,$(2),$(a1),$$1))))),\
+      $(foreach el,$(call EVAL_AST,$(1),$(2)),\
+        $(and $(EVAL_DEBUG),$(info invoke: $(call _pr_str,$(el))))\
+        $(foreach f,$(call sfirst,$(el)),\
+          $(foreach args,$(call srest,$(el)),\
+            $(call apply,$(f),$(args))))))))))))))))))
+endef
+
+define EVAL
+$(strip $(if $(__ERROR),,\
+  $(and $(EVAL_DEBUG),$(info EVAL: $(call _pr_str,$(1))))\
+  $(if $(call _list?,$(1)),\
+    $(foreach ast,$(call MACROEXPAND,$(1),$(2)),
+      $(if $(call _list?,$(ast)),\
+        $(word 1,$(strip $(call EVAL_INVOKE,$(ast),$(2)) $(__nil))),\
+	$(ast))),\
+    $(call EVAL_AST,$(1),$(2)))))
+endef
+
+
+# PRINT:
+define PRINT
+$(if $(__ERROR),Error: $(call _pr_str,$(__ERROR),yes),$(if $(1),$(call _pr_str,$(1),yes)))$(if $(__ERROR),$(eval __ERROR :=),)
+endef
+
+# REPL:
+REPL_ENV := $(call ENV)
+REP = $(call PRINT,$(strip $(call EVAL,$(strip $(call READ,$(1))),$(REPL_ENV))))
+REPL = $(info $(call REP,$(call READLINE,"user> ")))$(if $(READLINE_EOF),,$(call REPL))
+
+# core.mk: defined using Make
+_fref = $(eval REPL_ENV := $(call ENV_SET,$(REPL_ENV),$(1),$(call _function,$$(call $(2),$$1))))
+_import_core = $(if $(strip $(1)),$(call _fref,$(word 1,$(1)),$(word 2,$(1)))$(call _import_core,$(wordlist 3,$(words $(1)),$(1))),)
+$(call _import_core,$(core_ns))
+REPL_ENV := $(call ENV_SET,$(REPL_ENV),eval,$(call _function,$$(call EVAL,$$(1),$$(REPL_ENV))))
+_argv := $(call _list)
+REPL_ENV := $(call ENV_SET,$(REPL_ENV),*ARGV*,$(_argv))
+
+# core.mal: defined in terms of the language itself
+$(call do,$(call REP, (def! *host-language* "make") ))
+$(call do,$(call REP, (def! not (fn* (a) (if a false true))) ))
+$(call do,$(call REP, (def! load-file (fn* (f) (eval (read-string (str "(do " (slurp f) ")"))))) ))
+$(call do,$(call REP, (defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw "odd number of forms to cond")) (cons 'cond (rest (rest xs))))))) ))
+$(call do,$(call REP, (defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs)))))))) ))
+
+# Load and eval any files specified on the command line
+$(if $(MAKECMDGOALS),\
+  $(foreach arg,$(wordlist 2,$(words $(MAKECMDGOALS)),$(MAKECMDGOALS)),\
+    $(call do,$(call _conj!,$(_argv),$(call _string,$(arg)))))\
+  $(call do,$(call REP, (load-file "$(word 1,$(MAKECMDGOALS))") )) \
+  $(eval INTERACTIVE :=),)
+
+# repl loop
+$(if $(strip $(INTERACTIVE)),\
+  $(call do,$(call REP, (println (str "Mal [" *host-language* "]")) )) \
+  $(call REPL))
+
+.PHONY: none $(MAKECMDGOALS)
+none $(MAKECMDGOALS):
+	@true
diff --git a/make/tests/stepA_interop.mal b/make/tests/stepA_interop.mal
deleted file mode 100644
index 9b1a2f9..0000000
--- a/make/tests/stepA_interop.mal
+++ /dev/null
@@ -1,19 +0,0 @@
-;; Testing basic make interop
-
-(make* "7")
-;=>"7"
-
-(make* "$(info foo)")
-; foo
-;=>""
-
-(make* "$(eval foo := 8)")
-(make* "$(foo)")
-;=>"8"
-
-(make* "$(foreach v,a b c,X$(v)Y)")
-;=>"XaY XbY XcY"
-
-(read-string (make* "($(foreach v,1 2 3,$(call gmsl_plus,1,$(v))))"))
-;=>(2 3 4)
-
diff --git a/make/tests/stepA_mal.mal b/make/tests/stepA_mal.mal
new file mode 100644
index 0000000..9b1a2f9
--- /dev/null
+++ b/make/tests/stepA_mal.mal
@@ -0,0 +1,19 @@
+;; Testing basic make interop
+
+(make* "7")
+;=>"7"
+
+(make* "$(info foo)")
+; foo
+;=>""
+
+(make* "$(eval foo := 8)")
+(make* "$(foo)")
+;=>"8"
+
+(make* "$(foreach v,a b c,X$(v)Y)")
+;=>"XaY XbY XcY"
+
+(read-string (make* "($(foreach v,1 2 3,$(call gmsl_plus,1,$(v))))"))
+;=>(2 3 4)
+
diff --git a/mal/Makefile b/mal/Makefile
index 1990b6b..0848621 100644
--- a/mal/Makefile
+++ b/mal/Makefile
@@ -2,7 +2,7 @@
 TESTS =
 
 SOURCES_BASE =
-SOURCES_LISP = env.mal core.mal stepA_interop.mal
+SOURCES_LISP = env.mal core.mal stepA_mal.mal
 SOURCES = $(SOURCES_BASE) $(SOURCES_LISP)
 
 #.PHONY: stats tests $(TESTS)
diff --git a/mal/stepA_interop.mal b/mal/stepA_interop.mal
deleted file mode 100644
index 3e2a258..0000000
--- a/mal/stepA_interop.mal
+++ /dev/null
@@ -1,181 +0,0 @@
-(load-file "../mal/env.mal")
-(load-file "../mal/core.mal")
-
-;; read
-(def! READ (fn* [strng]
-  (read-string strng)))
-
-
-;; eval
-(def! is-pair (fn* [x]
-  (if (sequential? x)
-    (if (> (count x) 0)
-      true))))
-
-(def! QUASIQUOTE (fn* [ast]
-  (cond
-    (not (is-pair ast))
-    (list 'quote ast)
-
-    (= 'unquote (first ast))
-    (nth ast 1)
-
-    (if (is-pair (first ast))
-      (if (= 'splice-unquote (first (first ast)))
-        true))
-    (list 'concat (nth (first ast) 1) (QUASIQUOTE (rest ast)))
-
-    "else"
-    (list 'cons (QUASIQUOTE (first ast)) (QUASIQUOTE (rest ast))))))
-
-(def! is-macro-call (fn* [ast env]
-  (if (list? ast)
-    (let* [a0 (first ast)]
-      (if (symbol? a0)
-        (if (env-find env a0)
-          (let* [m (meta (env-get env a0))]
-            (if m
-              (if (get m "ismacro")
-                true)))))))))
-
-(def! MACROEXPAND (fn* [ast env]
-  (if (is-macro-call ast env)
-    (let* [mac (env-get env (first ast))]
-      (MACROEXPAND (apply mac (rest ast)) env))
-    ast)))
-
-(def! eval-ast (fn* [ast env] (do
-  ;;(do (prn "eval-ast" ast "/" (keys env)) )
-  (cond
-    (symbol? ast) (env-get env ast)
-
-    (list? ast)   (map (fn* [exp] (EVAL exp env)) ast)
-
-    (vector? ast) (apply vector (map (fn* [exp] (EVAL exp env)) ast))
-
-    (map? ast)    (apply hash-map
-                      (apply concat
-                        (map (fn* [k] [k (EVAL (get ast k) env)])
-                             (keys ast))))
-
-    "else"        ast))))
-
-(def! LET (fn* [env args]
-  (if (> (count args) 0)
-    (do
-      (env-set env (nth args 0) (EVAL (nth args 1) env))
-      (LET env (rest (rest args)))))))
-
-(def! EVAL (fn* [ast env] (do
-  ;;(do (prn "EVAL" ast "/" (keys @env)) )
-  (if (not (list? ast))
-    (eval-ast ast env)
-
-    ;; apply list
-    (let* [ast (MACROEXPAND ast env)]
-      (if (not (list? ast))
-        ast
-
-        (let* [a0 (first ast)]
-          (cond
-            (= 'def! a0)
-            (env-set env (nth ast 1) (EVAL (nth ast 2) env))
-
-            (= 'let* a0)
-            (let* [let-env (new-env env)]
-              (do
-                (LET let-env (nth ast 1))
-                (EVAL (nth ast 2) let-env)))
-
-            (= 'quote a0)
-            (nth ast 1)
-
-            (= 'quasiquote a0)
-            (let* [a1 (nth ast 1)]
-              (EVAL (QUASIQUOTE a1) env))
-
-            (= 'defmacro! a0)
-            (let* [a1 (nth ast 1)
-                   a2 (nth ast 2)
-                   f (EVAL a2 env)
-                   m (or (meta f) {})
-                   mac (with-meta f (assoc m "ismacro" true))]
-              (env-set env a1 mac))
-
-            (= 'macroexpand a0)
-            (let* [a1 (nth ast 1)]
-              (MACROEXPAND a1 env))
-
-            (= 'try* a0)
-            (if (= 'catch* (nth (nth ast 2) 0))
-              (try*
-                (EVAL (nth ast 1) env)
-                (catch* exc
-                  (EVAL (nth (nth ast 2) 2)
-                        (new-env env
-                                 [(nth (nth ast 2)1)]
-                                 [exc]))))
-              (EVAL (nth ast 1) env))
-
-            (= 'do a0)
-            (let* [el (eval-ast (rest ast) env)]
-              (nth el (- (count el) 1)))
-
-            (= 'if a0)
-            (let* [cond (EVAL (nth ast 1) env)]
-              (if (or (= cond nil) (= cond false))
-                (if (> (count ast) 3)
-                  (EVAL (nth ast 3) env)
-                  nil)
-                (EVAL (nth ast 2) env)))
-
-            (= 'fn* a0)
-            (fn* [& args]
-              (EVAL (nth ast 2) (new-env env (nth ast 1) args)))
-
-            "else"
-            (let* [el (eval-ast ast env)
-                  f (first el)
-                  args (rest el)]
-              (apply f args))))))))))
-
-
-;; print
-(def! PRINT (fn* [exp] (pr-str exp)))
-
-;; repl
-(def! repl-env (new-env))
-(def! rep (fn* [strng]
-  (PRINT (EVAL (READ strng) repl-env))))
-
-;; core.mal: defined directly using mal
-(map (fn* [data] (env-set repl-env (nth data 0) (nth data 1))) core_ns)
-(env-set repl-env 'eval (fn* [ast] (EVAL ast repl-env)))
-(env-set repl-env '*ARGV* (rest *ARGV*))
-
-;; core.mal: defined using the new language itself 
-(rep (str "(def! *host-language* \"" *host-language* "-mal\")"))
-(rep "(def! not (fn* [a] (if a false true)))")
-(rep "(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))")
-(rep "(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))")
-(rep "(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))")
-
-;; repl loop
-(def! repl-loop (fn* []
-  (let* [line (readline "mal-user> ")]
-    (if line
-      (do
-        (if (not (= "" line))
-          (try*
-            (println (rep line))
-            (catch* exc
-              (println "Uncaught exception:" exc))))
-        (repl-loop))))))
-
-(def! -main (fn* [& args] 
-  (if (> (count args) 0)
-    (rep (str "(load-file \"" (first args) "\")"))
-    (do
-      (rep "(println (str \"Mal [\" *host-language* \"]\"))")
-      (repl-loop)))))
-(apply -main *ARGV*)
diff --git a/mal/stepA_mal.mal b/mal/stepA_mal.mal
new file mode 100644
index 0000000..3e2a258
--- /dev/null
+++ b/mal/stepA_mal.mal
@@ -0,0 +1,181 @@
+(load-file "../mal/env.mal")
+(load-file "../mal/core.mal")
+
+;; read
+(def! READ (fn* [strng]
+  (read-string strng)))
+
+
+;; eval
+(def! is-pair (fn* [x]
+  (if (sequential? x)
+    (if (> (count x) 0)
+      true))))
+
+(def! QUASIQUOTE (fn* [ast]
+  (cond
+    (not (is-pair ast))
+    (list 'quote ast)
+
+    (= 'unquote (first ast))
+    (nth ast 1)
+
+    (if (is-pair (first ast))
+      (if (= 'splice-unquote (first (first ast)))
+        true))
+    (list 'concat (nth (first ast) 1) (QUASIQUOTE (rest ast)))
+
+    "else"
+    (list 'cons (QUASIQUOTE (first ast)) (QUASIQUOTE (rest ast))))))
+
+(def! is-macro-call (fn* [ast env]
+  (if (list? ast)
+    (let* [a0 (first ast)]
+      (if (symbol? a0)
+        (if (env-find env a0)
+          (let* [m (meta (env-get env a0))]
+            (if m
+              (if (get m "ismacro")
+                true)))))))))
+
+(def! MACROEXPAND (fn* [ast env]
+  (if (is-macro-call ast env)
+    (let* [mac (env-get env (first ast))]
+      (MACROEXPAND (apply mac (rest ast)) env))
+    ast)))
+
+(def! eval-ast (fn* [ast env] (do
+  ;;(do (prn "eval-ast" ast "/" (keys env)) )
+  (cond
+    (symbol? ast) (env-get env ast)
+
+    (list? ast)   (map (fn* [exp] (EVAL exp env)) ast)
+
+    (vector? ast) (apply vector (map (fn* [exp] (EVAL exp env)) ast))
+
+    (map? ast)    (apply hash-map
+                      (apply concat
+                        (map (fn* [k] [k (EVAL (get ast k) env)])
+                             (keys ast))))
+
+    "else"        ast))))
+
+(def! LET (fn* [env args]
+  (if (> (count args) 0)
+    (do
+      (env-set env (nth args 0) (EVAL (nth args 1) env))
+      (LET env (rest (rest args)))))))
+
+(def! EVAL (fn* [ast env] (do
+  ;;(do (prn "EVAL" ast "/" (keys @env)) )
+  (if (not (list? ast))
+    (eval-ast ast env)
+
+    ;; apply list
+    (let* [ast (MACROEXPAND ast env)]
+      (if (not (list? ast))
+        ast
+
+        (let* [a0 (first ast)]
+          (cond
+            (= 'def! a0)
+            (env-set env (nth ast 1) (EVAL (nth ast 2) env))
+
+            (= 'let* a0)
+            (let* [let-env (new-env env)]
+              (do
+                (LET let-env (nth ast 1))
+                (EVAL (nth ast 2) let-env)))
+
+            (= 'quote a0)
+            (nth ast 1)
+
+            (= 'quasiquote a0)
+            (let* [a1 (nth ast 1)]
+              (EVAL (QUASIQUOTE a1) env))
+
+            (= 'defmacro! a0)
+            (let* [a1 (nth ast 1)
+                   a2 (nth ast 2)
+                   f (EVAL a2 env)
+                   m (or (meta f) {})
+                   mac (with-meta f (assoc m "ismacro" true))]
+              (env-set env a1 mac))
+
+            (= 'macroexpand a0)
+            (let* [a1 (nth ast 1)]
+              (MACROEXPAND a1 env))
+
+            (= 'try* a0)
+            (if (= 'catch* (nth (nth ast 2) 0))
+              (try*
+                (EVAL (nth ast 1) env)
+                (catch* exc
+                  (EVAL (nth (nth ast 2) 2)
+                        (new-env env
+                                 [(nth (nth ast 2)1)]
+                                 [exc]))))
+              (EVAL (nth ast 1) env))
+
+            (= 'do a0)
+            (let* [el (eval-ast (rest ast) env)]
+              (nth el (- (count el) 1)))
+
+            (= 'if a0)
+            (let* [cond (EVAL (nth ast 1) env)]
+              (if (or (= cond nil) (= cond false))
+                (if (> (count ast) 3)
+                  (EVAL (nth ast 3) env)
+                  nil)
+                (EVAL (nth ast 2) env)))
+
+            (= 'fn* a0)
+            (fn* [& args]
+              (EVAL (nth ast 2) (new-env env (nth ast 1) args)))
+
+            "else"
+            (let* [el (eval-ast ast env)
+                  f (first el)
+                  args (rest el)]
+              (apply f args))))))))))
+
+
+;; print
+(def! PRINT (fn* [exp] (pr-str exp)))
+
+;; repl
+(def! repl-env (new-env))
+(def! rep (fn* [strng]
+  (PRINT (EVAL (READ strng) repl-env))))
+
+;; core.mal: defined directly using mal
+(map (fn* [data] (env-set repl-env (nth data 0) (nth data 1))) core_ns)
+(env-set repl-env 'eval (fn* [ast] (EVAL ast repl-env)))
+(env-set repl-env '*ARGV* (rest *ARGV*))
+
+;; core.mal: defined using the new language itself 
+(rep (str "(def! *host-language* \"" *host-language* "-mal\")"))
+(rep "(def! not (fn* [a] (if a false true)))")
+(rep "(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))")
+(rep "(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))")
+(rep "(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))")
+
+;; repl loop
+(def! repl-loop (fn* []
+  (let* [line (readline "mal-user> ")]
+    (if line
+      (do
+        (if (not (= "" line))
+          (try*
+            (println (rep line))
+            (catch* exc
+              (println "Uncaught exception:" exc))))
+        (repl-loop))))))
+
+(def! -main (fn* [& args] 
+  (if (> (count args) 0)
+    (rep (str "(load-file \"" (first args) "\")"))
+    (do
+      (rep "(println (str \"Mal [\" *host-language* \"]\"))")
+      (repl-loop)))))
+(apply -main *ARGV*)
diff --git a/matlab/Makefile b/matlab/Makefile
index a603822..f03d94d 100644
--- a/matlab/Makefile
+++ b/matlab/Makefile
@@ -2,7 +2,7 @@ SOURCES_BASE = types.m types/Nil.m types/MalException.m \
 	       types/Symbol.m types/List.m types/Vector.m \
 	       types/HashMap.m types/Function.m types/Atom.m \
 	       Reader.m reader.m printer.m
-SOURCES_LISP = Env.m core.m stepA_interop.m
+SOURCES_LISP = Env.m core.m stepA_mal.m
 SOURCES = $(SOURCES_BASE) $(SOURCES_LISP)
 
 
diff --git a/matlab/stepA_interop.m b/matlab/stepA_interop.m
deleted file mode 100644
index 5b8e720..0000000
--- a/matlab/stepA_interop.m
+++ /dev/null
@@ -1,226 +0,0 @@
-function stepA_interop(varargin), main(varargin), end
-
-% read
-function ret = READ(str)
-    ret = reader.read_str(str);
-end
-
-% eval
-function ret = is_pair(ast)
-    ret = types.sequential_Q(ast) && length(ast) > 0;
-end
-
-function ret = quasiquote(ast)
-    if ~is_pair(ast)
-        ret = types.List(types.Symbol('quote'), ast);
-    elseif isa(ast.get(1),'types.Symbol') && ...
-           strcmp(ast.get(1).name, 'unquote')
-        ret = ast.get(2);
-    elseif is_pair(ast.get(1)) && ...
-           isa(ast.get(1).get(1),'types.Symbol') && ...
-           strcmp(ast.get(1).get(1).name, 'splice-unquote')
-        ret = types.List(types.Symbol('concat'), ...
-                         ast.get(1).get(2), ...
-                         quasiquote(ast.slice(2)));
-    else
-        ret = types.List(types.Symbol('cons'), ...
-                         quasiquote(ast.get(1)), ...
-                         quasiquote(ast.slice(2)));
-    end
-end
-
-function ret = is_macro_call(ast, env)
-    if types.list_Q(ast) && isa(ast.get(1), 'types.Symbol') && ...
-       ~islogical(env.find(ast.get(1)))
-        f = env.get(ast.get(1));
-        ret = isa(f,'types.Function') && f.is_macro;
-    else
-        ret = false;
-    end
-end
-
-function ret = macroexpand(ast, env)
-    while is_macro_call(ast, env)
-        mac = env.get(ast.get(1));
-        args = ast.slice(2);
-        ast = mac.fn(args.data{:});
-    end
-    ret = ast;
-end
-
-function ret = eval_ast(ast, env)
-    switch class(ast)
-    case 'types.Symbol'
-        ret = env.get(ast);
-    case 'types.List'
-        ret = types.List();
-        for i=1:length(ast)
-            ret.append(EVAL(ast.get(i), env));
-        end
-    case 'types.Vector'
-        ret = types.Vector();
-        for i=1:length(ast)
-            ret.append(EVAL(ast.get(i), env));
-        end
-    case 'types.HashMap'
-        ret = types.HashMap();
-        ks = ast.keys();
-        for i=1:length(ks)
-            k = ks{i};
-            ret.set(EVAL(k, env), EVAL(ast.get(k), env));
-        end
-    otherwise
-        ret = ast;
-    end
-end
-
-function ret = EVAL(ast, env)
-  while true
-    %fprintf('EVAL: %s\n', printer.pr_str(ast, true));
-    if ~types.list_Q(ast)
-        ret = eval_ast(ast, env);
-        return;
-    end
-
-    % apply
-    ast = macroexpand(ast, env);
-    if ~types.list_Q(ast)
-        ret = ast;
-        return;
-    end
-
-    if isa(ast.get(1),'types.Symbol')
-        a1sym = ast.get(1).name;
-    else
-        a1sym = '_@$fn$@_';
-    end
-    switch (a1sym)
-    case 'def!'
-        ret = env.set(ast.get(2), EVAL(ast.get(3), env));
-        return;
-    case 'let*'
-        let_env = Env(env);
-        for i=1:2:length(ast.get(2))
-            let_env.set(ast.get(2).get(i), EVAL(ast.get(2).get(i+1), let_env));
-        end
-        env = let_env;
-        ast = ast.get(3); % TCO
-    case 'quote'
-        ret = ast.get(2);
-        return;
-    case 'quasiquote'
-        ast = quasiquote(ast.get(2)); % TCO
-    case 'defmacro!'
-        ret = env.set(ast.get(2), EVAL(ast.get(3), env));
-        ret.is_macro = true;
-        return;
-    case 'macroexpand'
-        ret = macroexpand(ast.get(2), env);
-        return;
-    case 'try*'
-        try
-            ret = EVAL(ast.get(2), env);
-            return;
-        catch e
-            if length(ast) > 2 && strcmp(ast.get(3).get(1).name, 'catch*')
-                if isa(e, 'types.MalException')
-                    exc = e.obj;
-                else
-                    exc = e.message;
-                end
-                catch_env = Env(env, types.List(ast.get(3).get(2)), ...
-                                types.List(exc));
-                ret = EVAL(ast.get(3).get(3), catch_env);
-                return;
-            else
-                throw(e);
-            end
-        end
-    case 'do'
-        el = eval_ast(ast.slice(2,length(ast)-1), env);
-        ast = ast.get(length(ast)); % TCO
-    case 'if'
-        cond = EVAL(ast.get(2), env);
-        if strcmp(class(cond), 'types.Nil') || ...
-           (islogical(cond) && cond == false)
-           if length(ast) > 3
-               ast = ast.get(4); % TCO
-            else
-               ret = types.nil;
-               return;
-            end
-        else
-            ast = ast.get(3); % TCO
-        end
-    case 'fn*'
-        fn = @(varargin) EVAL(ast.get(3), Env(env, ast.get(2), ...
-                                              types.List(varargin{:})));
-        ret = types.Function(fn, ast.get(3), env, ast.get(2));
-        return;
-    otherwise
-        el = eval_ast(ast, env);
-        f = el.get(1);
-        args = el.slice(2);
-        if isa(f, 'types.Function')
-            env = Env(f.env, f.params, args);
-            ast = f.ast; % TCO
-        else
-            ret = f(args.data{:});
-            return
-        end
-    end
-  end
-end
-
-% print
-function ret = PRINT(ast)
-    ret = printer.pr_str(ast, true);
-end
-
-% REPL
-function ret = rep(str, env)
-    ret = PRINT(EVAL(READ(str), env));
-end
-
-function main(args)
-    repl_env = Env(false);
-
-    % core.m: defined using matlab
-    ns = core.ns(); ks = ns.keys();
-    for i=1:length(ks)
-        k = ks{i};
-        repl_env.set(types.Symbol(k), ns(k));
-    end
-    repl_env.set(types.Symbol('eval'), @(a) EVAL(a, repl_env));
-    rest_args = args(2:end);
-    repl_env.set(types.Symbol('*ARGV*'), types.List(rest_args{:}));
-
-    % core.mal: defined using the langauge itself
-    rep('(def! *host-language* "matlab")', repl_env);
-    rep('(def! not (fn* (a) (if a false true)))', repl_env);
-    rep('(def! load-file (fn* (f) (eval (read-string (str "(do " (slurp f) ")")))))"', repl_env);
-    rep('(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list ''if (first xs) (if (> (count xs) 1) (nth xs 1) (throw "odd number of forms to cond")) (cons ''cond (rest (rest xs)))))))', repl_env);
-    rep('(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))', repl_env);
-
-    if ~isempty(args)
-        rep(sprintf('(load-file "%s")', args{1}), repl_env);
-        quit;
-    end
-
-    %cleanObj = onCleanup(@() disp('*** here1 ***'));
-    rep('(println (str "Mal [" *host-language* "]"))', repl_env);
-    while (true)
-        line = input('user> ', 's');
-        if strcmp(strtrim(line),''), continue, end
-        try
-            fprintf('%s\n', rep(line, repl_env));
-        catch err
-            if isa(err, 'types.MalException')
-                fprintf('Error: %s\n', printer.pr_str(err.obj, true));
-            else
-                fprintf('Error: %s\n', err.message);
-            end
-            fprintf('%s\n', getReport(err, 'extended'));
-        end
-    end
-end
diff --git a/matlab/stepA_mal.m b/matlab/stepA_mal.m
new file mode 100644
index 0000000..6f74b6a
--- /dev/null
+++ b/matlab/stepA_mal.m
@@ -0,0 +1,226 @@
+function stepA_mal(varargin), main(varargin), end
+
+% read
+function ret = READ(str)
+    ret = reader.read_str(str);
+end
+
+% eval
+function ret = is_pair(ast)
+    ret = types.sequential_Q(ast) && length(ast) > 0;
+end
+
+function ret = quasiquote(ast)
+    if ~is_pair(ast)
+        ret = types.List(types.Symbol('quote'), ast);
+    elseif isa(ast.get(1),'types.Symbol') && ...
+           strcmp(ast.get(1).name, 'unquote')
+        ret = ast.get(2);
+    elseif is_pair(ast.get(1)) && ...
+           isa(ast.get(1).get(1),'types.Symbol') && ...
+           strcmp(ast.get(1).get(1).name, 'splice-unquote')
+        ret = types.List(types.Symbol('concat'), ...
+                         ast.get(1).get(2), ...
+                         quasiquote(ast.slice(2)));
+    else
+        ret = types.List(types.Symbol('cons'), ...
+                         quasiquote(ast.get(1)), ...
+                         quasiquote(ast.slice(2)));
+    end
+end
+
+function ret = is_macro_call(ast, env)
+    if types.list_Q(ast) && isa(ast.get(1), 'types.Symbol') && ...
+       ~islogical(env.find(ast.get(1)))
+        f = env.get(ast.get(1));
+        ret = isa(f,'types.Function') && f.is_macro;
+    else
+        ret = false;
+    end
+end
+
+function ret = macroexpand(ast, env)
+    while is_macro_call(ast, env)
+        mac = env.get(ast.get(1));
+        args = ast.slice(2);
+        ast = mac.fn(args.data{:});
+    end
+    ret = ast;
+end
+
+function ret = eval_ast(ast, env)
+    switch class(ast)
+    case 'types.Symbol'
+        ret = env.get(ast);
+    case 'types.List'
+        ret = types.List();
+        for i=1:length(ast)
+            ret.append(EVAL(ast.get(i), env));
+        end
+    case 'types.Vector'
+        ret = types.Vector();
+        for i=1:length(ast)
+            ret.append(EVAL(ast.get(i), env));
+        end
+    case 'types.HashMap'
+        ret = types.HashMap();
+        ks = ast.keys();
+        for i=1:length(ks)
+            k = ks{i};
+            ret.set(EVAL(k, env), EVAL(ast.get(k), env));
+        end
+    otherwise
+        ret = ast;
+    end
+end
+
+function ret = EVAL(ast, env)
+  while true
+    %fprintf('EVAL: %s\n', printer.pr_str(ast, true));
+    if ~types.list_Q(ast)
+        ret = eval_ast(ast, env);
+        return;
+    end
+
+    % apply
+    ast = macroexpand(ast, env);
+    if ~types.list_Q(ast)
+        ret = ast;
+        return;
+    end
+
+    if isa(ast.get(1),'types.Symbol')
+        a1sym = ast.get(1).name;
+    else
+        a1sym = '_@$fn$@_';
+    end
+    switch (a1sym)
+    case 'def!'
+        ret = env.set(ast.get(2), EVAL(ast.get(3), env));
+        return;
+    case 'let*'
+        let_env = Env(env);
+        for i=1:2:length(ast.get(2))
+            let_env.set(ast.get(2).get(i), EVAL(ast.get(2).get(i+1), let_env));
+        end
+        env = let_env;
+        ast = ast.get(3); % TCO
+    case 'quote'
+        ret = ast.get(2);
+        return;
+    case 'quasiquote'
+        ast = quasiquote(ast.get(2)); % TCO
+    case 'defmacro!'
+        ret = env.set(ast.get(2), EVAL(ast.get(3), env));
+        ret.is_macro = true;
+        return;
+    case 'macroexpand'
+        ret = macroexpand(ast.get(2), env);
+        return;
+    case 'try*'
+        try
+            ret = EVAL(ast.get(2), env);
+            return;
+        catch e
+            if length(ast) > 2 && strcmp(ast.get(3).get(1).name, 'catch*')
+                if isa(e, 'types.MalException')
+                    exc = e.obj;
+                else
+                    exc = e.message;
+                end
+                catch_env = Env(env, types.List(ast.get(3).get(2)), ...
+                                types.List(exc));
+                ret = EVAL(ast.get(3).get(3), catch_env);
+                return;
+            else
+                throw(e);
+            end
+        end
+    case 'do'
+        el = eval_ast(ast.slice(2,length(ast)-1), env);
+        ast = ast.get(length(ast)); % TCO
+    case 'if'
+        cond = EVAL(ast.get(2), env);
+        if strcmp(class(cond), 'types.Nil') || ...
+           (islogical(cond) && cond == false)
+           if length(ast) > 3
+               ast = ast.get(4); % TCO
+            else
+               ret = types.nil;
+               return;
+            end
+        else
+            ast = ast.get(3); % TCO
+        end
+    case 'fn*'
+        fn = @(varargin) EVAL(ast.get(3), Env(env, ast.get(2), ...
+                                              types.List(varargin{:})));
+        ret = types.Function(fn, ast.get(3), env, ast.get(2));
+        return;
+    otherwise
+        el = eval_ast(ast, env);
+        f = el.get(1);
+        args = el.slice(2);
+        if isa(f, 'types.Function')
+            env = Env(f.env, f.params, args);
+            ast = f.ast; % TCO
+        else
+            ret = f(args.data{:});
+            return
+        end
+    end
+  end
+end
+
+% print
+function ret = PRINT(ast)
+    ret = printer.pr_str(ast, true);
+end
+
+% REPL
+function ret = rep(str, env)
+    ret = PRINT(EVAL(READ(str), env));
+end
+
+function main(args)
+    repl_env = Env(false);
+
+    % core.m: defined using matlab
+    ns = core.ns(); ks = ns.keys();
+    for i=1:length(ks)
+        k = ks{i};
+        repl_env.set(types.Symbol(k), ns(k));
+    end
+    repl_env.set(types.Symbol('eval'), @(a) EVAL(a, repl_env));
+    rest_args = args(2:end);
+    repl_env.set(types.Symbol('*ARGV*'), types.List(rest_args{:}));
+
+    % core.mal: defined using the langauge itself
+    rep('(def! *host-language* "matlab")', repl_env);
+    rep('(def! not (fn* (a) (if a false true)))', repl_env);
+    rep('(def! load-file (fn* (f) (eval (read-string (str "(do " (slurp f) ")")))))"', repl_env);
+    rep('(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list ''if (first xs) (if (> (count xs) 1) (nth xs 1) (throw "odd number of forms to cond")) (cons ''cond (rest (rest xs)))))))', repl_env);
+    rep('(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))', repl_env);
+
+    if ~isempty(args)
+        rep(sprintf('(load-file "%s")', args{1}), repl_env);
+        quit;
+    end
+
+    %cleanObj = onCleanup(@() disp('*** here1 ***'));
+    rep('(println (str "Mal [" *host-language* "]"))', repl_env);
+    while (true)
+        line = input('user> ', 's');
+        if strcmp(strtrim(line),''), continue, end
+        try
+            fprintf('%s\n', rep(line, repl_env));
+        catch err
+            if isa(err, 'types.MalException')
+                fprintf('Error: %s\n', printer.pr_str(err.obj, true));
+            else
+                fprintf('Error: %s\n', err.message);
+            end
+            fprintf('%s\n', getReport(err, 'extended'));
+        end
+    end
+end
diff --git a/miniMAL/Makefile b/miniMAL/Makefile
index 9e31c40..8c838d3 100644
--- a/miniMAL/Makefile
+++ b/miniMAL/Makefile
@@ -1,7 +1,7 @@
 
 SOURCES_BASE = node_readline.js miniMAL-core.json \
 	       types.json reader.json printer.json
-SOURCES_LISP = env.json core.json stepA_interop.json
+SOURCES_LISP = env.json core.json stepA_mal.json
 SOURCES = $(SOURCES_BASE) $(SOURCES_LISP)
 
 .PHONY: stats tests $(TESTS)
diff --git a/miniMAL/stepA_interop.json b/miniMAL/stepA_interop.json
deleted file mode 100644
index 2181d30..0000000
--- a/miniMAL/stepA_interop.json
+++ /dev/null
@@ -1,171 +0,0 @@
-["do",
-
-["load-file", ["`", "miniMAL-core.json"]],
-["load-file", ["`", "types.json"]],
-["load-file", ["`", "reader.json"]],
-["load-file", ["`", "printer.json"]],
-["load-file", ["`", "env.json"]],
-["load-file", ["`", "core.json"]],
-
-["def", "READ", ["fn", ["strng"], ["read-str", "strng"]]],
-
-["def", "pair?", ["fn", ["x"],
-  ["if", ["sequential?", "x"],
-    ["if", [">", ["count", "x"], 0], true, false],
-    false]]],
-
-["def", "quasiquote", ["fn", ["ast"],
-  ["if", ["not", ["pair?", "ast"]],
-    ["list", ["symbol", ["`", "quote"]], "ast"],
-  ["if", ["=", ["`", "unquote"], ["get", ["nth", "ast", 0], ["`", "val"]]],
-    ["nth", "ast", 1],
-  ["if", ["and", ["pair?", ["nth", "ast", 0]],
-                 ["=", ["`", "splice-unquote"],
-                       ["get", ["nth", ["nth", "ast", 0], 0], ["`", "val"]]]],
-    ["list", ["symbol", ["`", "concat"]],
-             ["nth", ["nth", "ast", 0], 1],
-             ["quasiquote", ["rest", "ast"]]],
-    ["list", ["symbol", ["`", "cons"]],
-             ["quasiquote", ["nth", "ast", 0]],
-             ["quasiquote", ["rest", "ast"]]]]]]]],
-
-["def", "macro?", ["fn", ["ast", "env"],
-  ["and", ["list?", "ast"],
-          ["symbol?", ["first", "ast"]],
-          ["not", ["=", null, ["env-find", "env", ["first", "ast"]]]],
-          ["let", ["fn", ["env-get", "env", ["first", "ast"]]],
-            ["and", ["malfunc?", "fn"],
-                    ["get", "fn", ["`", "macro?"]]]]]]],
-
-["def", "macroexpand", ["fn", ["ast", "env"],
-  ["if", ["macro?", "ast", "env"],
-    ["let", ["mac", ["get", ["env-get", "env", ["first", "ast"]], ["`", "fn"]]],
-      ["macroexpand", ["apply", "mac", ["rest", "ast"]], "env"]],
-    "ast"]]],
-
-["def", "eval-ast", ["fn", ["ast", "env"],
-  ["if", ["symbol?", "ast"],
-    ["env-get", "env", "ast"],
-  ["if", ["list?", "ast"],
-    ["map", ["fn", ["x"], ["EVAL", "x", "env"]], "ast"],
-  ["if", ["vector?", "ast"],
-    ["vectorl", ["map", ["fn", ["x"], ["EVAL", "x", "env"]], "ast"]],
-  ["if", ["map?", "ast"],
-    ["let", ["new-hm", ["hash-map"]],
-      ["do",
-        ["map", ["fn", ["k"], ["set", "new-hm",
-                                ["EVAL", "k", "env"],
-                                ["EVAL", ["get", "ast", "k"], "env"]]],
-                ["keys", "ast"]],
-        "new-hm"]],
-  "ast"]]]]]],
-
-["def", "LET", ["fn", ["env", "args"],
-  ["if", [">", ["count", "args"], 0],
-    ["do",
-      ["env-set", "env", ["nth", "args", 0],
-                         ["EVAL", ["nth", "args", 1], "env"]],
-      ["LET", "env", ["rest", ["rest", "args"]]]]]]],
-
-["def", "EVAL", ["fn", ["ast", "env"],
-  ["if", ["not", ["list?", "ast"]],
-    ["eval-ast", "ast", "env"],
-    ["let", ["ast", ["macroexpand", "ast", "env"]],
-      ["if", ["not", ["list?", "ast"]],
-        "ast",
-        ["let", ["a0", ["get", ["first", "ast"], ["`", "val"]]],
-          ["if", ["=", ["`", "def!"], "a0"],
-            ["env-set", "env", ["nth", "ast", 1],
-                               ["EVAL", ["nth", "ast", 2], "env"]],
-          ["if", ["=", ["`", "let*"], "a0"],
-            ["let", ["let-env", ["env-new", "env"]],
-              ["do",
-                ["LET", "let-env", ["nth", "ast", 1]],
-                ["EVAL", ["nth", "ast", 2], "let-env"]]],
-          ["if", ["=", ["`", "quote"], "a0"],
-            ["nth", "ast", 1],
-          ["if", ["=", ["`", "quasiquote"], "a0"],
-            ["EVAL", ["quasiquote", ["nth", "ast", 1]], "env"],
-          ["if", ["=", ["`", "defmacro!"], "a0"],
-            ["let", ["func", ["EVAL", ["nth", "ast", 2], "env"]],
-              ["do",
-                ["set", "func", ["`", "macro?"], true],
-                ["env-set", "env", ["nth", "ast", 1], "func"]]],
-          ["if", ["=", ["`", "macroexpand"], "a0"],
-            ["macroexpand", ["nth", "ast", 1], "env"],
-          ["if", ["=", ["`", "try*"], "a0"],
-            ["if", ["=", ["`", "catch*"],
-                         ["get", ["nth", ["nth", "ast", 2], 0], ["`", "val"]]],
-              ["try",
-                ["EVAL", ["nth", "ast", 1], "env"],
-                ["catch", "exc",
-                  ["EVAL", ["nth", ["nth", "ast", 2], 2],
-                           ["env-new", "env",
-                                       ["list", ["nth", ["nth", "ast", 2], 1]],
-                                       ["list", "exc"]]]]],
-              ["EVAL", ["nth", "ast", 1], "env"]],
-          ["if", ["=", ["`", "do"], "a0"],
-            ["do",
-              ["eval-ast", ["slice", "ast", 1, ["-", ["count", "ast"], 1]], "env"],
-              ["EVAL", ["nth", "ast", ["-", ["count", "ast"], 1]], "env"]],
-          ["if", ["=", ["`", "if"], "a0"],
-            ["let", ["cond", ["EVAL", ["nth", "ast", 1], "env"]],
-              ["if", ["or", ["=", "cond", null], ["=", "cond", false]],
-                ["if", [">", ["count", "ast"], 3],
-                  ["EVAL", ["nth", "ast", 3], "env"],
-                  null],
-                ["EVAL", ["nth", "ast", 2], "env"]]],
-          ["if", ["=", ["`", "fn*"], "a0"],
-            ["malfunc",
-              ["fn", ["&", "args"],
-                ["let", ["e", ["env-new", "env", ["nth", "ast", 1], "args"]],
-                  ["EVAL", ["nth", "ast", 2], "e"]]],
-              ["nth", "ast", 2], "env", ["nth", "ast", 1]],
-            ["let", ["el", ["eval-ast", "ast", "env"],
-                     "f", ["first", "el"],
-                     "args", ["rest", "el"]],
-              ["if", ["malfunc?", "f"],
-                ["EVAL", ["get", "f", ["`", "ast"]],
-                         ["env-new", ["get", "f", ["`", "env"]],
-                                     ["get", "f", ["`", "params"]],
-                                     "args"]],
-                ["apply", "f", "args"]]]]]]]]]]]]]]]]]]],
-
-["def", "PRINT", ["fn", ["exp"],
-  ["pr-str", "exp", true]]],
-
-
-["def", "repl-env", ["env-new"]],
-
-["def", "rep", ["fn", ["strng"],
-  ["try",
-    ["PRINT", ["EVAL", ["READ", "strng"], "repl-env"]],
-    ["catch", "exc",
-      ["str", ["`", "Error: "], [".", "exc", ["`", "toString"]]]]]]],
-
-["`", "core.mal: defined using miniMAL"],
-["map", ["fn", ["k"], ["env-set", "repl-env",
-                                  ["symbol", "k"],
-                                  ["get", "core-ns", "k"]]],
-        ["keys", "core-ns"]],
-["env-set", "repl-env", ["symbol", ["`", "eval"]],
-                        ["fn", ["ast"], ["EVAL", "ast", "repl-env"]]],
-["env-set", "repl-env", ["symbol", ["`", "*ARGV*"]],
-                        ["slice", "*ARGV*", 1]],
-
-["`", "core.mal: defined using mal itself"],
-["rep", ["`", "(def! *host-language* \"miniMAL\")"]],
-["rep", ["`", "(def! not (fn* (a) (if a false true)))"]],
-["rep", ["`", "(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))"]],
-["rep", ["`", "(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))"]],
-["rep", ["`", "(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))"]],
-
-["if", ["not", ["empty?", "*ARGV*"]],
-  ["println", ["rep", ["str", ["`", "(load-file \""], ["get", "*ARGV*", 0], ["`", "\")"]]]],
-  ["do",
-    ["rep", ["`", "(println (str \"Mal [\" *host-language* \"]\"))"]],
-    ["repl", ["`", "user> "], "rep"]]],
-
-null
-
-]
diff --git a/miniMAL/stepA_mal.json b/miniMAL/stepA_mal.json
new file mode 100644
index 0000000..2181d30
--- /dev/null
+++ b/miniMAL/stepA_mal.json
@@ -0,0 +1,171 @@
+["do",
+
+["load-file", ["`", "miniMAL-core.json"]],
+["load-file", ["`", "types.json"]],
+["load-file", ["`", "reader.json"]],
+["load-file", ["`", "printer.json"]],
+["load-file", ["`", "env.json"]],
+["load-file", ["`", "core.json"]],
+
+["def", "READ", ["fn", ["strng"], ["read-str", "strng"]]],
+
+["def", "pair?", ["fn", ["x"],
+  ["if", ["sequential?", "x"],
+    ["if", [">", ["count", "x"], 0], true, false],
+    false]]],
+
+["def", "quasiquote", ["fn", ["ast"],
+  ["if", ["not", ["pair?", "ast"]],
+    ["list", ["symbol", ["`", "quote"]], "ast"],
+  ["if", ["=", ["`", "unquote"], ["get", ["nth", "ast", 0], ["`", "val"]]],
+    ["nth", "ast", 1],
+  ["if", ["and", ["pair?", ["nth", "ast", 0]],
+                 ["=", ["`", "splice-unquote"],
+                       ["get", ["nth", ["nth", "ast", 0], 0], ["`", "val"]]]],
+    ["list", ["symbol", ["`", "concat"]],
+             ["nth", ["nth", "ast", 0], 1],
+             ["quasiquote", ["rest", "ast"]]],
+    ["list", ["symbol", ["`", "cons"]],
+             ["quasiquote", ["nth", "ast", 0]],
+             ["quasiquote", ["rest", "ast"]]]]]]]],
+
+["def", "macro?", ["fn", ["ast", "env"],
+  ["and", ["list?", "ast"],
+          ["symbol?", ["first", "ast"]],
+          ["not", ["=", null, ["env-find", "env", ["first", "ast"]]]],
+          ["let", ["fn", ["env-get", "env", ["first", "ast"]]],
+            ["and", ["malfunc?", "fn"],
+                    ["get", "fn", ["`", "macro?"]]]]]]],
+
+["def", "macroexpand", ["fn", ["ast", "env"],
+  ["if", ["macro?", "ast", "env"],
+    ["let", ["mac", ["get", ["env-get", "env", ["first", "ast"]], ["`", "fn"]]],
+      ["macroexpand", ["apply", "mac", ["rest", "ast"]], "env"]],
+    "ast"]]],
+
+["def", "eval-ast", ["fn", ["ast", "env"],
+  ["if", ["symbol?", "ast"],
+    ["env-get", "env", "ast"],
+  ["if", ["list?", "ast"],
+    ["map", ["fn", ["x"], ["EVAL", "x", "env"]], "ast"],
+  ["if", ["vector?", "ast"],
+    ["vectorl", ["map", ["fn", ["x"], ["EVAL", "x", "env"]], "ast"]],
+  ["if", ["map?", "ast"],
+    ["let", ["new-hm", ["hash-map"]],
+      ["do",
+        ["map", ["fn", ["k"], ["set", "new-hm",
+                                ["EVAL", "k", "env"],
+                                ["EVAL", ["get", "ast", "k"], "env"]]],
+                ["keys", "ast"]],
+        "new-hm"]],
+  "ast"]]]]]],
+
+["def", "LET", ["fn", ["env", "args"],
+  ["if", [">", ["count", "args"], 0],
+    ["do",
+      ["env-set", "env", ["nth", "args", 0],
+                         ["EVAL", ["nth", "args", 1], "env"]],
+      ["LET", "env", ["rest", ["rest", "args"]]]]]]],
+
+["def", "EVAL", ["fn", ["ast", "env"],
+  ["if", ["not", ["list?", "ast"]],
+    ["eval-ast", "ast", "env"],
+    ["let", ["ast", ["macroexpand", "ast", "env"]],
+      ["if", ["not", ["list?", "ast"]],
+        "ast",
+        ["let", ["a0", ["get", ["first", "ast"], ["`", "val"]]],
+          ["if", ["=", ["`", "def!"], "a0"],
+            ["env-set", "env", ["nth", "ast", 1],
+                               ["EVAL", ["nth", "ast", 2], "env"]],
+          ["if", ["=", ["`", "let*"], "a0"],
+            ["let", ["let-env", ["env-new", "env"]],
+              ["do",
+                ["LET", "let-env", ["nth", "ast", 1]],
+                ["EVAL", ["nth", "ast", 2], "let-env"]]],
+          ["if", ["=", ["`", "quote"], "a0"],
+            ["nth", "ast", 1],
+          ["if", ["=", ["`", "quasiquote"], "a0"],
+            ["EVAL", ["quasiquote", ["nth", "ast", 1]], "env"],
+          ["if", ["=", ["`", "defmacro!"], "a0"],
+            ["let", ["func", ["EVAL", ["nth", "ast", 2], "env"]],
+              ["do",
+                ["set", "func", ["`", "macro?"], true],
+                ["env-set", "env", ["nth", "ast", 1], "func"]]],
+          ["if", ["=", ["`", "macroexpand"], "a0"],
+            ["macroexpand", ["nth", "ast", 1], "env"],
+          ["if", ["=", ["`", "try*"], "a0"],
+            ["if", ["=", ["`", "catch*"],
+                         ["get", ["nth", ["nth", "ast", 2], 0], ["`", "val"]]],
+              ["try",
+                ["EVAL", ["nth", "ast", 1], "env"],
+                ["catch", "exc",
+                  ["EVAL", ["nth", ["nth", "ast", 2], 2],
+                           ["env-new", "env",
+                                       ["list", ["nth", ["nth", "ast", 2], 1]],
+                                       ["list", "exc"]]]]],
+              ["EVAL", ["nth", "ast", 1], "env"]],
+          ["if", ["=", ["`", "do"], "a0"],
+            ["do",
+              ["eval-ast", ["slice", "ast", 1, ["-", ["count", "ast"], 1]], "env"],
+              ["EVAL", ["nth", "ast", ["-", ["count", "ast"], 1]], "env"]],
+          ["if", ["=", ["`", "if"], "a0"],
+            ["let", ["cond", ["EVAL", ["nth", "ast", 1], "env"]],
+              ["if", ["or", ["=", "cond", null], ["=", "cond", false]],
+                ["if", [">", ["count", "ast"], 3],
+                  ["EVAL", ["nth", "ast", 3], "env"],
+                  null],
+                ["EVAL", ["nth", "ast", 2], "env"]]],
+          ["if", ["=", ["`", "fn*"], "a0"],
+            ["malfunc",
+              ["fn", ["&", "args"],
+                ["let", ["e", ["env-new", "env", ["nth", "ast", 1], "args"]],
+                  ["EVAL", ["nth", "ast", 2], "e"]]],
+              ["nth", "ast", 2], "env", ["nth", "ast", 1]],
+            ["let", ["el", ["eval-ast", "ast", "env"],
+                     "f", ["first", "el"],
+                     "args", ["rest", "el"]],
+              ["if", ["malfunc?", "f"],
+                ["EVAL", ["get", "f", ["`", "ast"]],
+                         ["env-new", ["get", "f", ["`", "env"]],
+                                     ["get", "f", ["`", "params"]],
+                                     "args"]],
+                ["apply", "f", "args"]]]]]]]]]]]]]]]]]]],
+
+["def", "PRINT", ["fn", ["exp"],
+  ["pr-str", "exp", true]]],
+
+
+["def", "repl-env", ["env-new"]],
+
+["def", "rep", ["fn", ["strng"],
+  ["try",
+    ["PRINT", ["EVAL", ["READ", "strng"], "repl-env"]],
+    ["catch", "exc",
+      ["str", ["`", "Error: "], [".", "exc", ["`", "toString"]]]]]]],
+
+["`", "core.mal: defined using miniMAL"],
+["map", ["fn", ["k"], ["env-set", "repl-env",
+                                  ["symbol", "k"],
+                                  ["get", "core-ns", "k"]]],
+        ["keys", "core-ns"]],
+["env-set", "repl-env", ["symbol", ["`", "eval"]],
+                        ["fn", ["ast"], ["EVAL", "ast", "repl-env"]]],
+["env-set", "repl-env", ["symbol", ["`", "*ARGV*"]],
+                        ["slice", "*ARGV*", 1]],
+
+["`", "core.mal: defined using mal itself"],
+["rep", ["`", "(def! *host-language* \"miniMAL\")"]],
+["rep", ["`", "(def! not (fn* (a) (if a false true)))"]],
+["rep", ["`", "(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))"]],
+["rep", ["`", "(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))"]],
+["rep", ["`", "(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))"]],
+
+["if", ["not", ["empty?", "*ARGV*"]],
+  ["println", ["rep", ["str", ["`", "(load-file \""], ["get", "*ARGV*", 0], ["`", "\")"]]]],
+  ["do",
+    ["rep", ["`", "(println (str \"Mal [\" *host-language* \"]\"))"]],
+    ["repl", ["`", "user> "], "rep"]]],
+
+null
+
+]
diff --git a/ocaml/Makefile b/ocaml/Makefile
index 71c7e6b..9245dd5 100644
--- a/ocaml/Makefile
+++ b/ocaml/Makefile
@@ -1,6 +1,6 @@
 STEPS = step0_repl.ml step1_read_print.ml step2_eval.ml step3_env.ml \
         step4_if_fn_do.ml step5_tco.ml step6_file.ml step7_quote.ml \
-	step8_macros.ml step9_try.ml stepA_interop.ml
+	step8_macros.ml step9_try.ml stepA_mal.ml
 MODULES = types.ml reader.ml printer.ml env.ml core.ml
 LIBS = str.cmxa unix.cmxa
 MAL_LIB = mal_lib.cmxa
@@ -28,10 +28,10 @@ $(STEP_BINS): %: %.ml $(MAL_LIB)
 clean:
 	rm -f $(STEP_BINS) mal mal_lib.* *.cmo *.cmx *.cmi *.o
 
-stats: $(MODULES) stepA_interop.ml
+stats: $(MODULES) stepA_mal.ml
 	@wc $^
 
-stats-lisp: env.ml core.ml stepA_interop.ml
+stats-lisp: env.ml core.ml stepA_mal.ml
 	@wc $^
 
 .PHONY: all repl clean stats stats-lisp
diff --git a/ocaml/stepA_interop.ml b/ocaml/stepA_interop.ml
deleted file mode 100644
index 1aab28a..0000000
--- a/ocaml/stepA_interop.ml
+++ /dev/null
@@ -1,159 +0,0 @@
-module T = Types.Types
-
-let repl_env = Env.make (Some Core.ns)
-
-let rec quasiquote ast =
-  match ast with
-    | T.List   { T.value = [T.Symbol {T.value = "unquote"}; ast] } -> ast
-    | T.Vector { T.value = [T.Symbol {T.value = "unquote"}; ast] } -> ast
-    | T.List   { T.value = T.List { T.value = [T.Symbol {T.value = "splice-unquote"}; head]} :: tail }
-    | T.Vector { T.value = T.List { T.value = [T.Symbol {T.value = "splice-unquote"}; head]} :: tail } ->
-       Types.list [Types.symbol "concat"; head; quasiquote (Types.list tail)]
-    | T.List   { T.value = head :: tail }
-    | T.Vector { T.value = head :: tail } ->
-       Types.list [Types.symbol "cons"; quasiquote head; quasiquote (Types.list tail) ]
-    | ast -> Types.list [Types.symbol "quote"; ast]
-
-let kw_macro = T.Keyword "macro"
-
-let is_macro_call ast env =
-  match ast with
-  | T.List { T.value = s :: args } ->
-     (match (try Env.get env s with _ -> T.Nil) with
-      | T.Fn { T.meta = T.Map { T.value = meta } }
-        -> Types.MalMap.mem kw_macro meta && Types.to_bool (Types.MalMap.find kw_macro meta)
-      | _ -> false)
-  | _ -> false
-
-let rec macroexpand ast env =
-  if is_macro_call ast env
-  then match ast with
-       | T.List { T.value = s :: args } ->
-          (match (try Env.get env s with _ -> T.Nil) with
-           | T.Fn { T.value = f } -> macroexpand (f args) env
-           | _ -> ast)
-       | _ -> ast
-  else ast
-
-let rec eval_ast ast env =
-  match ast with
-    | T.Symbol s -> Env.get env ast
-    | T.List { T.value = xs; T.meta = meta }
-      -> T.List { T.value = (List.map (fun x -> eval x env) xs);
-                  T.meta = meta }
-    | T.Vector { T.value = xs; T.meta = meta }
-      -> T.Vector { T.value = (List.map (fun x -> eval x env) xs);
-                    T.meta = meta }
-    | T.Map { T.value = xs; T.meta = meta }
-      -> T.Map {T.meta = meta;
-                T.value = (Types.MalMap.fold
-                             (fun k v m
-                              -> Types.MalMap.add (eval k env) (eval v env) m)
-                             xs
-                             Types.MalMap.empty)}
-    | _ -> ast
-and eval ast env =
-  match macroexpand ast env with
-    | T.List { T.value = [(T.Symbol { T.value = "def!" }); key; expr] } ->
-        let value = (eval expr env) in
-          Env.set env key value; value
-    | T.List { T.value = [(T.Symbol { T.value = "defmacro!" }); key; expr] } ->
-       (match (eval expr env) with
-          | T.Fn { T.value = f; T.meta = meta } ->
-             let fn = T.Fn { T.value = f; meta = Core.assoc [meta; kw_macro; (T.Bool true)]}
-             in Env.set env key fn; fn
-          | _ -> raise (Invalid_argument "devmacro! value must be a fn"))
-    | T.List { T.value = [(T.Symbol { T.value = "let*" }); (T.Vector { T.value = bindings }); body] }
-    | T.List { T.value = [(T.Symbol { T.value = "let*" }); (T.List   { T.value = bindings }); body] } ->
-        (let sub_env = Env.make (Some env) in
-          let rec bind_pairs = (function
-            | sym :: expr :: more ->
-                Env.set sub_env sym (eval expr sub_env);
-                bind_pairs more
-            | _::[] -> raise (Invalid_argument "let* bindings must be an even number of forms")
-            | [] -> ())
-            in bind_pairs bindings;
-          eval body sub_env)
-    | T.List { T.value = ((T.Symbol { T.value = "do" }) :: body) } ->
-        List.fold_left (fun x expr -> eval expr env) T.Nil body
-    | T.List { T.value = [T.Symbol { T.value = "if" }; test; then_expr; else_expr] } ->
-        if Types.to_bool (eval test env) then (eval then_expr env) else (eval else_expr env)
-    | T.List { T.value = [T.Symbol { T.value = "if" }; test; then_expr] } ->
-        if Types.to_bool (eval test env) then (eval then_expr env) else T.Nil
-    | T.List { T.value = [T.Symbol { T.value = "fn*" }; T.Vector { T.value = arg_names }; expr] }
-    | T.List { T.value = [T.Symbol { T.value = "fn*" }; T.List   { T.value = arg_names }; expr] } ->
-        Types.fn
-          (function args ->
-            let sub_env = Env.make (Some env) in
-              let rec bind_args a b =
-                (match a, b with
-                  | [T.Symbol { T.value = "&" }; name], args -> Env.set sub_env name (Types.list args);
-                  | (name :: names), (arg :: args) ->
-                      Env.set sub_env name arg;
-                      bind_args names args;
-                  | [], [] -> ()
-                  | _ -> raise (Invalid_argument "Bad param count in fn call"))
-              in bind_args arg_names args;
-              eval expr sub_env)
-    | T.List { T.value = [T.Symbol { T.value = "quote" }; ast] } -> ast
-    | T.List { T.value = [T.Symbol { T.value = "quasiquote" }; ast] } ->
-       eval (quasiquote ast) env
-    | T.List { T.value = [T.Symbol { T.value = "macroexpand" }; ast] } ->
-       macroexpand ast env
-    | T.List { T.value = [T.Symbol { T.value = "try*" }; scary ;
-                          T.List { T.value = [T.Symbol { T.value = "catch*" };
-                                              local ; handler]}]} ->
-       (try (eval scary env)
-        with exn ->
-           let value = match exn with
-             | Types.MalExn value -> value
-             | Invalid_argument msg -> T.String msg
-             | _ -> (T.String "OCaml exception") in
-           let sub_env = Env.make (Some env) in
-           Env.set sub_env local value;
-           eval handler sub_env)
-    | T.List _ as ast ->
-      (match eval_ast ast env with
-         | T.List { T.value = ((T.Fn { T.value = f }) :: args) } -> f args
-         | _ -> raise (Invalid_argument "Cannot invoke non-function"))
-    | ast -> eval_ast ast env
-
-let read str = Reader.read_str str
-let print exp = Printer.pr_str exp true
-let rep str env = print (eval (read str) env)
-
-let rec main =
-  try
-    Core.init Core.ns;
-    Env.set repl_env (Types.symbol "*ARGV*")
-            (Types.list (if Array.length Sys.argv > 1
-                         then (List.map (fun x -> T.String x) (List.tl (List.tl (Array.to_list Sys.argv))))
-                         else []));
-    Env.set repl_env (Types.symbol "eval")
-            (Types.fn (function [ast] -> eval ast repl_env | _ -> T.Nil));
-
-    ignore (rep "(def! *host-language* \"ocaml\")" repl_env);
-    ignore (rep "(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))" repl_env);
-    ignore (rep "(def! not (fn* (a) (if a false true)))" repl_env);
-    ignore (rep "(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))" repl_env);
-    ignore (rep "(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))" repl_env);
-
-    if Array.length Sys.argv > 1 then
-      ignore (rep ("(load-file \"" ^ Sys.argv.(1) ^ "\")") repl_env)
-    else begin
-        ignore (rep "(println (str \"Mal [\" *host-language* \"]\"))" repl_env);
-        while true do
-          print_string "user> ";
-          let line = read_line () in
-          try
-            print_endline (rep line repl_env);
-          with End_of_file -> ()
-             | Invalid_argument x ->
-                output_string stderr ("Invalid_argument exception: " ^ x ^ "\n");
-                flush stderr
-             | _ ->
-                output_string stderr ("Erroringness!\n");
-                flush stderr
-        done
-      end
-  with End_of_file -> ()
diff --git a/ocaml/stepA_mal.ml b/ocaml/stepA_mal.ml
new file mode 100644
index 0000000..1aab28a
--- /dev/null
+++ b/ocaml/stepA_mal.ml
@@ -0,0 +1,159 @@
+module T = Types.Types
+
+let repl_env = Env.make (Some Core.ns)
+
+let rec quasiquote ast =
+  match ast with
+    | T.List   { T.value = [T.Symbol {T.value = "unquote"}; ast] } -> ast
+    | T.Vector { T.value = [T.Symbol {T.value = "unquote"}; ast] } -> ast
+    | T.List   { T.value = T.List { T.value = [T.Symbol {T.value = "splice-unquote"}; head]} :: tail }
+    | T.Vector { T.value = T.List { T.value = [T.Symbol {T.value = "splice-unquote"}; head]} :: tail } ->
+       Types.list [Types.symbol "concat"; head; quasiquote (Types.list tail)]
+    | T.List   { T.value = head :: tail }
+    | T.Vector { T.value = head :: tail } ->
+       Types.list [Types.symbol "cons"; quasiquote head; quasiquote (Types.list tail) ]
+    | ast -> Types.list [Types.symbol "quote"; ast]
+
+let kw_macro = T.Keyword "macro"
+
+let is_macro_call ast env =
+  match ast with
+  | T.List { T.value = s :: args } ->
+     (match (try Env.get env s with _ -> T.Nil) with
+      | T.Fn { T.meta = T.Map { T.value = meta } }
+        -> Types.MalMap.mem kw_macro meta && Types.to_bool (Types.MalMap.find kw_macro meta)
+      | _ -> false)
+  | _ -> false
+
+let rec macroexpand ast env =
+  if is_macro_call ast env
+  then match ast with
+       | T.List { T.value = s :: args } ->
+          (match (try Env.get env s with _ -> T.Nil) with
+           | T.Fn { T.value = f } -> macroexpand (f args) env
+           | _ -> ast)
+       | _ -> ast
+  else ast
+
+let rec eval_ast ast env =
+  match ast with
+    | T.Symbol s -> Env.get env ast
+    | T.List { T.value = xs; T.meta = meta }
+      -> T.List { T.value = (List.map (fun x -> eval x env) xs);
+                  T.meta = meta }
+    | T.Vector { T.value = xs; T.meta = meta }
+      -> T.Vector { T.value = (List.map (fun x -> eval x env) xs);
+                    T.meta = meta }
+    | T.Map { T.value = xs; T.meta = meta }
+      -> T.Map {T.meta = meta;
+                T.value = (Types.MalMap.fold
+                             (fun k v m
+                              -> Types.MalMap.add (eval k env) (eval v env) m)
+                             xs
+                             Types.MalMap.empty)}
+    | _ -> ast
+and eval ast env =
+  match macroexpand ast env with
+    | T.List { T.value = [(T.Symbol { T.value = "def!" }); key; expr] } ->
+        let value = (eval expr env) in
+          Env.set env key value; value
+    | T.List { T.value = [(T.Symbol { T.value = "defmacro!" }); key; expr] } ->
+       (match (eval expr env) with
+          | T.Fn { T.value = f; T.meta = meta } ->
+             let fn = T.Fn { T.value = f; meta = Core.assoc [meta; kw_macro; (T.Bool true)]}
+             in Env.set env key fn; fn
+          | _ -> raise (Invalid_argument "devmacro! value must be a fn"))
+    | T.List { T.value = [(T.Symbol { T.value = "let*" }); (T.Vector { T.value = bindings }); body] }
+    | T.List { T.value = [(T.Symbol { T.value = "let*" }); (T.List   { T.value = bindings }); body] } ->
+        (let sub_env = Env.make (Some env) in
+          let rec bind_pairs = (function
+            | sym :: expr :: more ->
+                Env.set sub_env sym (eval expr sub_env);
+                bind_pairs more
+            | _::[] -> raise (Invalid_argument "let* bindings must be an even number of forms")
+            | [] -> ())
+            in bind_pairs bindings;
+          eval body sub_env)
+    | T.List { T.value = ((T.Symbol { T.value = "do" }) :: body) } ->
+        List.fold_left (fun x expr -> eval expr env) T.Nil body
+    | T.List { T.value = [T.Symbol { T.value = "if" }; test; then_expr; else_expr] } ->
+        if Types.to_bool (eval test env) then (eval then_expr env) else (eval else_expr env)
+    | T.List { T.value = [T.Symbol { T.value = "if" }; test; then_expr] } ->
+        if Types.to_bool (eval test env) then (eval then_expr env) else T.Nil
+    | T.List { T.value = [T.Symbol { T.value = "fn*" }; T.Vector { T.value = arg_names }; expr] }
+    | T.List { T.value = [T.Symbol { T.value = "fn*" }; T.List   { T.value = arg_names }; expr] } ->
+        Types.fn
+          (function args ->
+            let sub_env = Env.make (Some env) in
+              let rec bind_args a b =
+                (match a, b with
+                  | [T.Symbol { T.value = "&" }; name], args -> Env.set sub_env name (Types.list args);
+                  | (name :: names), (arg :: args) ->
+                      Env.set sub_env name arg;
+                      bind_args names args;
+                  | [], [] -> ()
+                  | _ -> raise (Invalid_argument "Bad param count in fn call"))
+              in bind_args arg_names args;
+              eval expr sub_env)
+    | T.List { T.value = [T.Symbol { T.value = "quote" }; ast] } -> ast
+    | T.List { T.value = [T.Symbol { T.value = "quasiquote" }; ast] } ->
+       eval (quasiquote ast) env
+    | T.List { T.value = [T.Symbol { T.value = "macroexpand" }; ast] } ->
+       macroexpand ast env
+    | T.List { T.value = [T.Symbol { T.value = "try*" }; scary ;
+                          T.List { T.value = [T.Symbol { T.value = "catch*" };
+                                              local ; handler]}]} ->
+       (try (eval scary env)
+        with exn ->
+           let value = match exn with
+             | Types.MalExn value -> value
+             | Invalid_argument msg -> T.String msg
+             | _ -> (T.String "OCaml exception") in
+           let sub_env = Env.make (Some env) in
+           Env.set sub_env local value;
+           eval handler sub_env)
+    | T.List _ as ast ->
+      (match eval_ast ast env with
+         | T.List { T.value = ((T.Fn { T.value = f }) :: args) } -> f args
+         | _ -> raise (Invalid_argument "Cannot invoke non-function"))
+    | ast -> eval_ast ast env
+
+let read str = Reader.read_str str
+let print exp = Printer.pr_str exp true
+let rep str env = print (eval (read str) env)
+
+let rec main =
+  try
+    Core.init Core.ns;
+    Env.set repl_env (Types.symbol "*ARGV*")
+            (Types.list (if Array.length Sys.argv > 1
+                         then (List.map (fun x -> T.String x) (List.tl (List.tl (Array.to_list Sys.argv))))
+                         else []));
+    Env.set repl_env (Types.symbol "eval")
+            (Types.fn (function [ast] -> eval ast repl_env | _ -> T.Nil));
+
+    ignore (rep "(def! *host-language* \"ocaml\")" repl_env);
+    ignore (rep "(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))" repl_env);
+    ignore (rep "(def! not (fn* (a) (if a false true)))" repl_env);
+    ignore (rep "(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))" repl_env);
+    ignore (rep "(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))" repl_env);
+
+    if Array.length Sys.argv > 1 then
+      ignore (rep ("(load-file \"" ^ Sys.argv.(1) ^ "\")") repl_env)
+    else begin
+        ignore (rep "(println (str \"Mal [\" *host-language* \"]\"))" repl_env);
+        while true do
+          print_string "user> ";
+          let line = read_line () in
+          try
+            print_endline (rep line repl_env);
+          with End_of_file -> ()
+             | Invalid_argument x ->
+                output_string stderr ("Invalid_argument exception: " ^ x ^ "\n");
+                flush stderr
+             | _ ->
+                output_string stderr ("Erroringness!\n");
+                flush stderr
+        done
+      end
+  with End_of_file -> ()
diff --git a/perl/Makefile b/perl/Makefile
index d8e95a0..0aed9c6 100644
--- a/perl/Makefile
+++ b/perl/Makefile
@@ -2,7 +2,7 @@ TESTS =
 
 SOURCES_BASE = readline.pm types.pm reader.pm printer.pm \
                interop.pm
-SOURCES_LISP = env.pm core.pm stepA_interop.pl
+SOURCES_LISP = env.pm core.pm stepA_mal.pl
 SOURCES = $(SOURCES_BASE) $(SOURCES_LISP)
 
 #all: mal.pl
diff --git a/perl/stepA_interop.pl b/perl/stepA_interop.pl
deleted file mode 100644
index 7993635..0000000
--- a/perl/stepA_interop.pl
+++ /dev/null
@@ -1,265 +0,0 @@
-use strict;
-use warnings FATAL => qw(all);
-no if $] >= 5.018, warnings => "experimental::smartmatch";
-use File::Basename;
-use lib dirname (__FILE__);
-use readline qw(mal_readline set_rl_mode);
-use feature qw(switch);
-use Data::Dumper;
-
-use types qw($nil $true $false _sequential_Q _symbol_Q _list_Q);
-use reader;
-use printer;
-use env;
-use core qw($core_ns);
-use interop qw(pl_to_mal);
-
-# read
-sub READ {
-    my $str = shift;
-    return reader::read_str($str);
-}
-
-# eval
-sub is_pair {
-    my ($x) = @_;
-    return _sequential_Q($x) && scalar(@{$x->{val}}) > 0;
-}
-
-sub quasiquote {
-    my ($ast) = @_;
-    if (!is_pair($ast)) {
-        return List->new([Symbol->new("quote"), $ast]);
-    } elsif (_symbol_Q($ast->nth(0)) && ${$ast->nth(0)} eq 'unquote') {
-        return $ast->nth(1);
-    } elsif (is_pair($ast->nth(0)) && _symbol_Q($ast->nth(0)->nth(0)) &&
-             ${$ast->nth(0)->nth(0)} eq 'splice-unquote') {
-        return List->new([Symbol->new("concat"),
-                          $ast->nth(0)->nth(1),
-                          quasiquote($ast->rest())]);
-    } else {
-        return List->new([Symbol->new("cons"),
-                          quasiquote($ast->nth(0)),
-                          quasiquote($ast->rest())]);
-    }
-}
-
-sub is_macro_call {
-    my ($ast, $env) = @_;
-    if (_list_Q($ast) &&
-        _symbol_Q($ast->nth(0)) &&
-        $env->find($ast->nth(0))) {
-        my ($f) = $env->get($ast->nth(0));
-        if ((ref $f) =~ /^Function/) {
-            return $f->{ismacro};
-        }
-    }
-    return 0;
-}
-
-sub macroexpand {
-    my ($ast, $env) = @_;
-    while (is_macro_call($ast, $env)) {
-        my $mac = $env->get($ast->nth(0));
-        $ast = $mac->apply($ast->rest());
-    }
-    return $ast;
-}
-
-
-sub eval_ast {
-    my($ast, $env) = @_;
-    given (ref $ast) {
-        when (/^Symbol/) {
-            $env->get($ast);
-        }
-        when (/^List/) {
-            my @lst = map {EVAL($_, $env)} @{$ast->{val}};
-            return List->new(\@lst);
-        }
-        when (/^Vector/) {
-            my @lst = map {EVAL($_, $env)} @{$ast->{val}};
-            return Vector->new(\@lst);
-        }
-        when (/^HashMap/) {
-            my $new_hm = {};
-            foreach my $k (keys($ast->{val})) {
-                $new_hm->{$k} = EVAL($ast->get($k), $env);
-            }
-            return HashMap->new($new_hm);
-        }
-        default {
-            return $ast;
-        }
-    }
-}
-
-sub EVAL {
-    my($ast, $env) = @_;
-
-    while (1) {
-
-    #print "EVAL: " . printer::_pr_str($ast) . "\n";
-    if (! _list_Q($ast)) {
-        return eval_ast($ast, $env);
-    }
-
-    # apply list
-    $ast = macroexpand($ast, $env);
-    if (! _list_Q($ast)) { return $ast; }
-
-    my ($a0, $a1, $a2, $a3) = @{$ast->{val}};
-    given ((ref $a0) =~ /^Symbol/ ? $$a0 : $a0) {
-        when (/^def!$/) {
-            my $res = EVAL($a2, $env);
-            return $env->set($a1, $res);
-        }
-        when (/^let\*$/) {
-            my $let_env = Env->new($env);
-            for(my $i=0; $i < scalar(@{$a1->{val}}); $i+=2) {
-                $let_env->set($a1->nth($i), EVAL($a1->nth($i+1), $let_env));
-            }
-            $ast = $a2;
-            $env = $let_env;
-            # Continue loop (TCO)
-        }
-        when (/^quote$/) {
-            return $a1;
-        }
-        when (/^quasiquote$/) {
-            $ast = quasiquote($a1);
-            # Continue loop (TCO)
-        }
-        when (/^defmacro!$/) {
-            my $func = EVAL($a2, $env);
-            $func->{ismacro} = 1;
-            return $env->set($a1, $func);
-        }
-        when (/^macroexpand$/) {
-            return macroexpand($a1, $env);
-        }
-        when (/^pl\*$/) {
-            return pl_to_mal(eval(${$a1}));
-        }
-        when (/^try\*$/) {
-            do {
-                local $@;
-                my $ret;
-                eval {
-                    use autodie; # always "throw" errors
-                    $ret = EVAL($a1, $env);
-                     1;
-                } or do {
-                    my $err = $@;
-                    if ($a2 && ${$a2->nth(0)} eq "catch\*") {
-                        my $exc;
-                        if (ref $err) {
-                            $exc = $err;
-                        } else {
-                            $exc = String->new(substr $err, 0, -1);
-                        }
-                        return EVAL($a2->nth(2), Env->new($env,
-                                                        List->new([$a2->nth(1)]), 
-                                                        List->new([$exc])));
-                    } else {
-                        die $err;
-                    }
-                };
-                return $ret;
-            };
-        }
-        when (/^do$/) {
-            eval_ast($ast->slice(1, $#{$ast->{val}}-1), $env);
-            $ast = $ast->nth($#{$ast->{val}});
-            # Continue loop (TCO)
-        }
-        when (/^if$/) {
-            my $cond = EVAL($a1, $env);
-            if ($cond eq $nil || $cond eq $false) {
-                $ast = $a3 ? $a3 : $nil;
-            } else {
-                $ast = $a2;
-            }
-            # Continue loop (TCO)
-        }
-        when (/^fn\*$/) {
-            return Function->new(\&EVAL, $a2, $env, $a1);
-        }
-        default {
-            my $el = eval_ast($ast, $env);
-            my $f = $el->nth(0);
-            if ((ref $f) =~ /^Function/) {
-                $ast = $f->{ast};
-                $env = $f->gen_env($el->rest());
-                # Continue loop (TCO)
-            } else {
-                return &{ $f }($el->rest());
-            }
-        }
-    }
-
-    } # TCO while loop
-}
-
-# print
-sub PRINT {
-    my $exp = shift;
-    return printer::_pr_str($exp);
-}
-
-# repl
-my $repl_env = Env->new();
-sub REP {
-    my $str = shift;
-    return PRINT(EVAL(READ($str), $repl_env));
-}
-
-# core.pl: defined using perl
-foreach my $n (%$core_ns) {
-    $repl_env->set(Symbol->new($n), $core_ns->{$n});
-}
-$repl_env->set(Symbol->new('eval'), sub { EVAL($_[0]->nth(0), $repl_env); });
-my @_argv = map {String->new($_)}  @ARGV[1..$#ARGV];
-$repl_env->set(Symbol->new('*ARGV*'), List->new(\@_argv));
-
-# core.mal: defined using the language itself
-REP("(def! *host-language* \"javascript\")");
-REP("(def! not (fn* (a) (if a false true)))");
-REP("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))");
-REP("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))");
-REP("(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))");
-
-
-if (scalar(@ARGV) > 0 && $ARGV[0] eq "--raw") {
-    set_rl_mode("raw");
-    shift @ARGV;
-}
-if (scalar(@ARGV) > 0) {
-    REP("(load-file \"" . $ARGV[0] . "\")");
-    exit 0;
-}
-REP("(println (str \"Mal [\" *host-language* \"]\"))");
-while (1) {
-    my $line = mal_readline("user> ");
-    if (! defined $line) { last; }
-    do {
-        local $@;
-        my $ret;
-        eval {
-            use autodie; # always "throw" errors
-            print(REP($line), "\n");
-            1;
-        } or do {
-            my $err = $@;
-            given (ref $err) {
-                when (/^BlankException/) {
-                    # ignore and continue
-                }
-                default {
-                    chomp $err;
-                    print "Error: $err\n";
-                }
-            }
-        };
-    };
-}
diff --git a/perl/stepA_mal.pl b/perl/stepA_mal.pl
new file mode 100644
index 0000000..7993635
--- /dev/null
+++ b/perl/stepA_mal.pl
@@ -0,0 +1,265 @@
+use strict;
+use warnings FATAL => qw(all);
+no if $] >= 5.018, warnings => "experimental::smartmatch";
+use File::Basename;
+use lib dirname (__FILE__);
+use readline qw(mal_readline set_rl_mode);
+use feature qw(switch);
+use Data::Dumper;
+
+use types qw($nil $true $false _sequential_Q _symbol_Q _list_Q);
+use reader;
+use printer;
+use env;
+use core qw($core_ns);
+use interop qw(pl_to_mal);
+
+# read
+sub READ {
+    my $str = shift;
+    return reader::read_str($str);
+}
+
+# eval
+sub is_pair {
+    my ($x) = @_;
+    return _sequential_Q($x) && scalar(@{$x->{val}}) > 0;
+}
+
+sub quasiquote {
+    my ($ast) = @_;
+    if (!is_pair($ast)) {
+        return List->new([Symbol->new("quote"), $ast]);
+    } elsif (_symbol_Q($ast->nth(0)) && ${$ast->nth(0)} eq 'unquote') {
+        return $ast->nth(1);
+    } elsif (is_pair($ast->nth(0)) && _symbol_Q($ast->nth(0)->nth(0)) &&
+             ${$ast->nth(0)->nth(0)} eq 'splice-unquote') {
+        return List->new([Symbol->new("concat"),
+                          $ast->nth(0)->nth(1),
+                          quasiquote($ast->rest())]);
+    } else {
+        return List->new([Symbol->new("cons"),
+                          quasiquote($ast->nth(0)),
+                          quasiquote($ast->rest())]);
+    }
+}
+
+sub is_macro_call {
+    my ($ast, $env) = @_;
+    if (_list_Q($ast) &&
+        _symbol_Q($ast->nth(0)) &&
+        $env->find($ast->nth(0))) {
+        my ($f) = $env->get($ast->nth(0));
+        if ((ref $f) =~ /^Function/) {
+            return $f->{ismacro};
+        }
+    }
+    return 0;
+}
+
+sub macroexpand {
+    my ($ast, $env) = @_;
+    while (is_macro_call($ast, $env)) {
+        my $mac = $env->get($ast->nth(0));
+        $ast = $mac->apply($ast->rest());
+    }
+    return $ast;
+}
+
+
+sub eval_ast {
+    my($ast, $env) = @_;
+    given (ref $ast) {
+        when (/^Symbol/) {
+            $env->get($ast);
+        }
+        when (/^List/) {
+            my @lst = map {EVAL($_, $env)} @{$ast->{val}};
+            return List->new(\@lst);
+        }
+        when (/^Vector/) {
+            my @lst = map {EVAL($_, $env)} @{$ast->{val}};
+            return Vector->new(\@lst);
+        }
+        when (/^HashMap/) {
+            my $new_hm = {};
+            foreach my $k (keys($ast->{val})) {
+                $new_hm->{$k} = EVAL($ast->get($k), $env);
+            }
+            return HashMap->new($new_hm);
+        }
+        default {
+            return $ast;
+        }
+    }
+}
+
+sub EVAL {
+    my($ast, $env) = @_;
+
+    while (1) {
+
+    #print "EVAL: " . printer::_pr_str($ast) . "\n";
+    if (! _list_Q($ast)) {
+        return eval_ast($ast, $env);
+    }
+
+    # apply list
+    $ast = macroexpand($ast, $env);
+    if (! _list_Q($ast)) { return $ast; }
+
+    my ($a0, $a1, $a2, $a3) = @{$ast->{val}};
+    given ((ref $a0) =~ /^Symbol/ ? $$a0 : $a0) {
+        when (/^def!$/) {
+            my $res = EVAL($a2, $env);
+            return $env->set($a1, $res);
+        }
+        when (/^let\*$/) {
+            my $let_env = Env->new($env);
+            for(my $i=0; $i < scalar(@{$a1->{val}}); $i+=2) {
+                $let_env->set($a1->nth($i), EVAL($a1->nth($i+1), $let_env));
+            }
+            $ast = $a2;
+            $env = $let_env;
+            # Continue loop (TCO)
+        }
+        when (/^quote$/) {
+            return $a1;
+        }
+        when (/^quasiquote$/) {
+            $ast = quasiquote($a1);
+            # Continue loop (TCO)
+        }
+        when (/^defmacro!$/) {
+            my $func = EVAL($a2, $env);
+            $func->{ismacro} = 1;
+            return $env->set($a1, $func);
+        }
+        when (/^macroexpand$/) {
+            return macroexpand($a1, $env);
+        }
+        when (/^pl\*$/) {
+            return pl_to_mal(eval(${$a1}));
+        }
+        when (/^try\*$/) {
+            do {
+                local $@;
+                my $ret;
+                eval {
+                    use autodie; # always "throw" errors
+                    $ret = EVAL($a1, $env);
+                     1;
+                } or do {
+                    my $err = $@;
+                    if ($a2 && ${$a2->nth(0)} eq "catch\*") {
+                        my $exc;
+                        if (ref $err) {
+                            $exc = $err;
+                        } else {
+                            $exc = String->new(substr $err, 0, -1);
+                        }
+                        return EVAL($a2->nth(2), Env->new($env,
+                                                        List->new([$a2->nth(1)]), 
+                                                        List->new([$exc])));
+                    } else {
+                        die $err;
+                    }
+                };
+                return $ret;
+            };
+        }
+        when (/^do$/) {
+            eval_ast($ast->slice(1, $#{$ast->{val}}-1), $env);
+            $ast = $ast->nth($#{$ast->{val}});
+            # Continue loop (TCO)
+        }
+        when (/^if$/) {
+            my $cond = EVAL($a1, $env);
+            if ($cond eq $nil || $cond eq $false) {
+                $ast = $a3 ? $a3 : $nil;
+            } else {
+                $ast = $a2;
+            }
+            # Continue loop (TCO)
+        }
+        when (/^fn\*$/) {
+            return Function->new(\&EVAL, $a2, $env, $a1);
+        }
+        default {
+            my $el = eval_ast($ast, $env);
+            my $f = $el->nth(0);
+            if ((ref $f) =~ /^Function/) {
+                $ast = $f->{ast};
+                $env = $f->gen_env($el->rest());
+                # Continue loop (TCO)
+            } else {
+                return &{ $f }($el->rest());
+            }
+        }
+    }
+
+    } # TCO while loop
+}
+
+# print
+sub PRINT {
+    my $exp = shift;
+    return printer::_pr_str($exp);
+}
+
+# repl
+my $repl_env = Env->new();
+sub REP {
+    my $str = shift;
+    return PRINT(EVAL(READ($str), $repl_env));
+}
+
+# core.pl: defined using perl
+foreach my $n (%$core_ns) {
+    $repl_env->set(Symbol->new($n), $core_ns->{$n});
+}
+$repl_env->set(Symbol->new('eval'), sub { EVAL($_[0]->nth(0), $repl_env); });
+my @_argv = map {String->new($_)}  @ARGV[1..$#ARGV];
+$repl_env->set(Symbol->new('*ARGV*'), List->new(\@_argv));
+
+# core.mal: defined using the language itself
+REP("(def! *host-language* \"javascript\")");
+REP("(def! not (fn* (a) (if a false true)))");
+REP("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))");
+REP("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))");
+REP("(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))");
+
+
+if (scalar(@ARGV) > 0 && $ARGV[0] eq "--raw") {
+    set_rl_mode("raw");
+    shift @ARGV;
+}
+if (scalar(@ARGV) > 0) {
+    REP("(load-file \"" . $ARGV[0] . "\")");
+    exit 0;
+}
+REP("(println (str \"Mal [\" *host-language* \"]\"))");
+while (1) {
+    my $line = mal_readline("user> ");
+    if (! defined $line) { last; }
+    do {
+        local $@;
+        my $ret;
+        eval {
+            use autodie; # always "throw" errors
+            print(REP($line), "\n");
+            1;
+        } or do {
+            my $err = $@;
+            given (ref $err) {
+                when (/^BlankException/) {
+                    # ignore and continue
+                }
+                default {
+                    chomp $err;
+                    print "Error: $err\n";
+                }
+            }
+        };
+    };
+}
diff --git a/perl/tests/stepA_interop.mal b/perl/tests/stepA_interop.mal
deleted file mode 100644
index 1335be4..0000000
--- a/perl/tests/stepA_interop.mal
+++ /dev/null
@@ -1,22 +0,0 @@
-;; Testing types returned from pl*
-
-(pl* "123")
-;=>123
-
-(pl* "\"abc\"")
-;=>"abc"
-
-(pl* "{'abc'=>123}")
-;=>{"abc" 123}
-
-(pl* "['abc', 123]")
-;=>("abc" 123)
-
-(pl* "2+3")
-;=>5
-
-;; Testing eval of print statement
-
-(pl* "print 'hello\n';")
-; hello
-;=>1
diff --git a/perl/tests/stepA_mal.mal b/perl/tests/stepA_mal.mal
new file mode 100644
index 0000000..1335be4
--- /dev/null
+++ b/perl/tests/stepA_mal.mal
@@ -0,0 +1,22 @@
+;; Testing types returned from pl*
+
+(pl* "123")
+;=>123
+
+(pl* "\"abc\"")
+;=>"abc"
+
+(pl* "{'abc'=>123}")
+;=>{"abc" 123}
+
+(pl* "['abc', 123]")
+;=>("abc" 123)
+
+(pl* "2+3")
+;=>5
+
+;; Testing eval of print statement
+
+(pl* "print 'hello\n';")
+; hello
+;=>1
diff --git a/php/Makefile b/php/Makefile
index d9fd2d4..659e89c 100644
--- a/php/Makefile
+++ b/php/Makefile
@@ -2,7 +2,7 @@
 TESTS =
 
 SOURCES_BASE = readline.php types.php reader.php printer.php
-SOURCES_LISP = env.php core.php stepA_interop.php
+SOURCES_LISP = env.php core.php stepA_mal.php
 SOURCES = $(SOURCES_BASE) $(SOURCES_LISP)
 
 .PHONY: stats tests $(TESTS)
diff --git a/php/stepA_interop.php b/php/stepA_interop.php
deleted file mode 100644
index 1dc3b04..0000000
--- a/php/stepA_interop.php
+++ /dev/null
@@ -1,229 +0,0 @@
-<?php
-
-require_once 'readline.php';
-require_once 'types.php';
-require_once 'reader.php';
-require_once 'printer.php';
-require_once 'env.php';
-require_once 'core.php';
-
-// read
-function READ($str) {
-    return read_str($str);
-}
-
-// eval
-function is_pair($x) {
-    return _sequential_Q($x) and count($x) > 0;
-}
-
-function quasiquote($ast) {
-    if (!is_pair($ast)) {
-        return _list(_symbol("quote"), $ast);
-    } elseif (_symbol_Q($ast[0]) && $ast[0]->value === 'unquote') {
-        return $ast[1];
-    } elseif (is_pair($ast[0]) && _symbol_Q($ast[0][0]) &&
-              $ast[0][0]->value === 'splice-unquote') {
-        return _list(_symbol("concat"), $ast[0][1],
-                     quasiquote($ast->slice(1)));
-    } else {
-        return _list(_symbol("cons"), quasiquote($ast[0]),
-                     quasiquote($ast->slice(1)));
-    }
-}
-
-function is_macro_call($ast, $env) {
-    return is_pair($ast) &&
-           _symbol_Q($ast[0]) &&
-           $env->find($ast[0]) &&
-           $env->get($ast[0])->ismacro;
-}
-
-function macroexpand($ast, $env) {
-    while (is_macro_call($ast, $env)) {
-        $mac = $env->get($ast[0]);
-        $args = array_slice($ast->getArrayCopy(),1);
-        $ast = $mac->apply($args);
-    }
-    return $ast;
-}
-
-function eval_ast($ast, $env) {
-    if (_symbol_Q($ast)) {
-        return $env->get($ast);
-    } elseif (_sequential_Q($ast)) {
-        if (_list_Q($ast)) {
-            $el = _list();
-        } else {
-            $el = _vector();
-        }
-        foreach ($ast as $a) { $el[] = MAL_EVAL($a, $env); }
-        return $el;
-    } elseif (_hash_map_Q($ast)) {
-        $new_hm = _hash_map();
-        foreach (array_keys($ast->getArrayCopy()) as $key) {
-            $new_hm[$key] = MAL_EVAL($ast[$key], $env);
-        }
-        return $new_hm;
-    } else {
-        return $ast;
-    }
-}
-
-function MAL_EVAL($ast, $env) {
-    while (true) {
-
-    #echo "MAL_EVAL: " . _pr_str($ast) . "\n";
-    if (!_list_Q($ast)) {
-        return eval_ast($ast, $env);
-    }
-
-    // apply list
-    $ast = macroexpand($ast, $env);
-    if (!_list_Q($ast)) { return $ast; }
-
-    $a0 = $ast[0];
-    $a0v = (_symbol_Q($a0) ? $a0->value : $a0);
-    switch ($a0v) {
-    case "def!":
-        $res = MAL_EVAL($ast[2], $env);
-        return $env->set($ast[1], $res);
-    case "let*":
-        $a1 = $ast[1];
-        $let_env = new Env($env);
-        for ($i=0; $i < count($a1); $i+=2) {
-            $let_env->set($a1[$i], MAL_EVAL($a1[$i+1], $let_env));
-        }
-        $ast = $ast[2];
-        $env = $let_env;
-        break; // Continue loop (TCO)
-    case "quote":
-        return $ast[1];
-    case "quasiquote":
-        $ast = quasiquote($ast[1]);
-        break; // Continue loop (TCO)
-    case "defmacro!":
-        $func = MAL_EVAL($ast[2], $env);
-        $func->ismacro = true;
-        return $env->set($ast[1], $func);
-    case "macroexpand":
-        return macroexpand($ast[1], $env);
-    case "php*":
-        $res = eval($ast[1]);
-        switch (gettype($res)) {
-        case "array":
-            if ($res !== array_values($res)) {
-                $new_res = _hash_map();
-                $new_res->exchangeArray($res);
-                return $new_res;
-            } else {
-                return call_user_func_array('_list', $res);
-            }
-        default:
-            return $res;
-        }
-    case "try*":
-        $a1 = $ast[1];
-        $a2 = $ast[2];
-        if ($a2[0]->value === "catch*") {
-            try {
-                return MAL_EVAL($a1, $env);
-            } catch (Error $e) {
-                $catch_env = new Env($env, array($a2[1]),
-                                            array($e->obj));
-                return MAL_EVAL($a2[2], $catch_env);
-            } catch (Exception $e) {
-                $catch_env = new Env($env, array($a2[1]),
-                                            array($e->getMessage()));
-                return MAL_EVAL($a2[2], $catch_env);
-            }
-        } else {
-            return MAL_EVAL($a1, $env);
-        }
-    case "do":
-        eval_ast($ast->slice(1, -1), $env);
-        $ast = $ast[count($ast)-1];
-        break; // Continue loop (TCO)
-    case "if":
-        $cond = MAL_EVAL($ast[1], $env);
-        if ($cond === NULL || $cond === false) {
-            if (count($ast) === 4) { $ast = $ast[3]; }
-            else                   { $ast = NULL; }
-        } else {
-            $ast = $ast[2];
-        }
-        break; // Continue loop (TCO)
-    case "fn*":
-        return _function('MAL_EVAL', 'native',
-                         $ast[2], $env, $ast[1]);
-    default:
-        $el = eval_ast($ast, $env);
-        $f = $el[0];
-        $args = array_slice($el->getArrayCopy(), 1);
-        if ($f->type === 'native') {
-            $ast = $f->ast;
-            $env = $f->gen_env($args);
-            // Continue loop (TCO)
-        } else {
-            return $f->apply($args);
-        }
-    }
-
-    }
-}
-
-// print
-function MAL_PRINT($exp) {
-    return _pr_str($exp, True) . "\n";
-}
-
-// repl
-$repl_env = new Env(NULL);
-function rep($str) {
-    global $repl_env;
-    return MAL_PRINT(MAL_EVAL(READ($str), $repl_env));
-}
-
-// core.php: defined using PHP
-foreach ($core_ns as $k=>$v) {
-    $repl_env->set(_symbol($k), _function($v));
-}
-$repl_env->set(_symbol('eval'), _function(function($ast) {
-    global $repl_env; return MAL_EVAL($ast, $repl_env);
-}));
-$_argv = _list();
-for ($i=2; $i < count($argv); $i++) {
-    $_argv->append($argv[$i]);
-}
-$repl_env->set(_symbol('*ARGV*'), $_argv);
-
-// core.mal: defined using the language itself
-rep("(def! *host-language* \"php\")");
-rep("(def! not (fn* (a) (if a false true)))");
-rep("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))");
-rep("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))");
-rep("(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))");
-
-if (count($argv) > 1) {
-    rep('(load-file "' . $argv[1] . '")');
-    exit(0);
-}
-
-// repl loop
-rep("(println (str \"Mal [\" *host-language* \"]\"))");
-do {
-    try {
-        $line = mal_readline("user> ");
-        if ($line === NULL) { break; }
-        if ($line !== "") {
-            print(rep($line));
-        }
-    } catch (BlankException $e) {
-        continue;
-    } catch (Exception $e) {
-        echo "Error: " . $e->getMessage() . "\n";
-        echo $e->getTraceAsString() . "\n";
-    }
-} while (true);
-
-?>
diff --git a/php/stepA_mal.php b/php/stepA_mal.php
new file mode 100644
index 0000000..1dc3b04
--- /dev/null
+++ b/php/stepA_mal.php
@@ -0,0 +1,229 @@
+<?php
+
+require_once 'readline.php';
+require_once 'types.php';
+require_once 'reader.php';
+require_once 'printer.php';
+require_once 'env.php';
+require_once 'core.php';
+
+// read
+function READ($str) {
+    return read_str($str);
+}
+
+// eval
+function is_pair($x) {
+    return _sequential_Q($x) and count($x) > 0;
+}
+
+function quasiquote($ast) {
+    if (!is_pair($ast)) {
+        return _list(_symbol("quote"), $ast);
+    } elseif (_symbol_Q($ast[0]) && $ast[0]->value === 'unquote') {
+        return $ast[1];
+    } elseif (is_pair($ast[0]) && _symbol_Q($ast[0][0]) &&
+              $ast[0][0]->value === 'splice-unquote') {
+        return _list(_symbol("concat"), $ast[0][1],
+                     quasiquote($ast->slice(1)));
+    } else {
+        return _list(_symbol("cons"), quasiquote($ast[0]),
+                     quasiquote($ast->slice(1)));
+    }
+}
+
+function is_macro_call($ast, $env) {
+    return is_pair($ast) &&
+           _symbol_Q($ast[0]) &&
+           $env->find($ast[0]) &&
+           $env->get($ast[0])->ismacro;
+}
+
+function macroexpand($ast, $env) {
+    while (is_macro_call($ast, $env)) {
+        $mac = $env->get($ast[0]);
+        $args = array_slice($ast->getArrayCopy(),1);
+        $ast = $mac->apply($args);
+    }
+    return $ast;
+}
+
+function eval_ast($ast, $env) {
+    if (_symbol_Q($ast)) {
+        return $env->get($ast);
+    } elseif (_sequential_Q($ast)) {
+        if (_list_Q($ast)) {
+            $el = _list();
+        } else {
+            $el = _vector();
+        }
+        foreach ($ast as $a) { $el[] = MAL_EVAL($a, $env); }
+        return $el;
+    } elseif (_hash_map_Q($ast)) {
+        $new_hm = _hash_map();
+        foreach (array_keys($ast->getArrayCopy()) as $key) {
+            $new_hm[$key] = MAL_EVAL($ast[$key], $env);
+        }
+        return $new_hm;
+    } else {
+        return $ast;
+    }
+}
+
+function MAL_EVAL($ast, $env) {
+    while (true) {
+
+    #echo "MAL_EVAL: " . _pr_str($ast) . "\n";
+    if (!_list_Q($ast)) {
+        return eval_ast($ast, $env);
+    }
+
+    // apply list
+    $ast = macroexpand($ast, $env);
+    if (!_list_Q($ast)) { return $ast; }
+
+    $a0 = $ast[0];
+    $a0v = (_symbol_Q($a0) ? $a0->value : $a0);
+    switch ($a0v) {
+    case "def!":
+        $res = MAL_EVAL($ast[2], $env);
+        return $env->set($ast[1], $res);
+    case "let*":
+        $a1 = $ast[1];
+        $let_env = new Env($env);
+        for ($i=0; $i < count($a1); $i+=2) {
+            $let_env->set($a1[$i], MAL_EVAL($a1[$i+1], $let_env));
+        }
+        $ast = $ast[2];
+        $env = $let_env;
+        break; // Continue loop (TCO)
+    case "quote":
+        return $ast[1];
+    case "quasiquote":
+        $ast = quasiquote($ast[1]);
+        break; // Continue loop (TCO)
+    case "defmacro!":
+        $func = MAL_EVAL($ast[2], $env);
+        $func->ismacro = true;
+        return $env->set($ast[1], $func);
+    case "macroexpand":
+        return macroexpand($ast[1], $env);
+    case "php*":
+        $res = eval($ast[1]);
+        switch (gettype($res)) {
+        case "array":
+            if ($res !== array_values($res)) {
+                $new_res = _hash_map();
+                $new_res->exchangeArray($res);
+                return $new_res;
+            } else {
+                return call_user_func_array('_list', $res);
+            }
+        default:
+            return $res;
+        }
+    case "try*":
+        $a1 = $ast[1];
+        $a2 = $ast[2];
+        if ($a2[0]->value === "catch*") {
+            try {
+                return MAL_EVAL($a1, $env);
+            } catch (Error $e) {
+                $catch_env = new Env($env, array($a2[1]),
+                                            array($e->obj));
+                return MAL_EVAL($a2[2], $catch_env);
+            } catch (Exception $e) {
+                $catch_env = new Env($env, array($a2[1]),
+                                            array($e->getMessage()));
+                return MAL_EVAL($a2[2], $catch_env);
+            }
+        } else {
+            return MAL_EVAL($a1, $env);
+        }
+    case "do":
+        eval_ast($ast->slice(1, -1), $env);
+        $ast = $ast[count($ast)-1];
+        break; // Continue loop (TCO)
+    case "if":
+        $cond = MAL_EVAL($ast[1], $env);
+        if ($cond === NULL || $cond === false) {
+            if (count($ast) === 4) { $ast = $ast[3]; }
+            else                   { $ast = NULL; }
+        } else {
+            $ast = $ast[2];
+        }
+        break; // Continue loop (TCO)
+    case "fn*":
+        return _function('MAL_EVAL', 'native',
+                         $ast[2], $env, $ast[1]);
+    default:
+        $el = eval_ast($ast, $env);
+        $f = $el[0];
+        $args = array_slice($el->getArrayCopy(), 1);
+        if ($f->type === 'native') {
+            $ast = $f->ast;
+            $env = $f->gen_env($args);
+            // Continue loop (TCO)
+        } else {
+            return $f->apply($args);
+        }
+    }
+
+    }
+}
+
+// print
+function MAL_PRINT($exp) {
+    return _pr_str($exp, True) . "\n";
+}
+
+// repl
+$repl_env = new Env(NULL);
+function rep($str) {
+    global $repl_env;
+    return MAL_PRINT(MAL_EVAL(READ($str), $repl_env));
+}
+
+// core.php: defined using PHP
+foreach ($core_ns as $k=>$v) {
+    $repl_env->set(_symbol($k), _function($v));
+}
+$repl_env->set(_symbol('eval'), _function(function($ast) {
+    global $repl_env; return MAL_EVAL($ast, $repl_env);
+}));
+$_argv = _list();
+for ($i=2; $i < count($argv); $i++) {
+    $_argv->append($argv[$i]);
+}
+$repl_env->set(_symbol('*ARGV*'), $_argv);
+
+// core.mal: defined using the language itself
+rep("(def! *host-language* \"php\")");
+rep("(def! not (fn* (a) (if a false true)))");
+rep("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))");
+rep("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))");
+rep("(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))");
+
+if (count($argv) > 1) {
+    rep('(load-file "' . $argv[1] . '")');
+    exit(0);
+}
+
+// repl loop
+rep("(println (str \"Mal [\" *host-language* \"]\"))");
+do {
+    try {
+        $line = mal_readline("user> ");
+        if ($line === NULL) { break; }
+        if ($line !== "") {
+            print(rep($line));
+        }
+    } catch (BlankException $e) {
+        continue;
+    } catch (Exception $e) {
+        echo "Error: " . $e->getMessage() . "\n";
+        echo $e->getTraceAsString() . "\n";
+    }
+} while (true);
+
+?>
diff --git a/php/tests/stepA_interop.mal b/php/tests/stepA_interop.mal
deleted file mode 100644
index 15f8a94..0000000
--- a/php/tests/stepA_interop.mal
+++ /dev/null
@@ -1,25 +0,0 @@
-;; Testing basic php interop
-
-(php* "return 7;")
-;=>7
-
-(php* "return '7';")
-;=>"7"
-
-(php* "return array(7,8,9);")
-;=>(7 8 9)
-
-(php* "return array(\"abc\" => 789);")
-;=>{"abc" 789}
-
-(php* "print \"hello\n\";")
-; hello
-;=>nil
-
-(php* "global $foo; $foo=8;")
-(php* "global $foo; return $foo;")
-;=>8
-
-(php* "global $f; $f = function($v) { return 1+$v; };")
-(php* "global $f; return array_map($f, array(1,2,3));")
-;=>(2 3 4)
diff --git a/php/tests/stepA_mal.mal b/php/tests/stepA_mal.mal
new file mode 100644
index 0000000..15f8a94
--- /dev/null
+++ b/php/tests/stepA_mal.mal
@@ -0,0 +1,25 @@
+;; Testing basic php interop
+
+(php* "return 7;")
+;=>7
+
+(php* "return '7';")
+;=>"7"
+
+(php* "return array(7,8,9);")
+;=>(7 8 9)
+
+(php* "return array(\"abc\" => 789);")
+;=>{"abc" 789}
+
+(php* "print \"hello\n\";")
+; hello
+;=>nil
+
+(php* "global $foo; $foo=8;")
+(php* "global $foo; return $foo;")
+;=>8
+
+(php* "global $f; $f = function($v) { return 1+$v; };")
+(php* "global $f; return array_map($f, array(1,2,3));")
+;=>(2 3 4)
diff --git a/process/guide.md b/process/guide.md
index 734dc32..1cae879 100644
--- a/process/guide.md
+++ b/process/guide.md
@@ -1151,15 +1151,15 @@ diff -urp ../process/step8_macros.txt ../process/step9_try.txt
 
 ### Step A: Interop and Self-hosting
 
-![stepA_interop architecture](stepA_interop.png)
+![stepA_mal architecture](stepA_mal.png)
 
 Compare the pseudocode for step 9 and step A to get a basic idea of
 the changes that will be made during this step:
 ```
-diff -urp ../process/step9_try.txt ../process/stepA_interop.txt
+diff -urp ../process/step9_try.txt ../process/stepA_mal.txt
 ```
 
-* Copy `step9_try.qx` to `stepA_interop.qx`.
+* Copy `step9_try.qx` to `stepA_mal.qx`.
 
 * TODO/TBD
 
diff --git a/process/stepA_interop.gliffy b/process/stepA_interop.gliffy
deleted file mode 100644
index 7d4920f..0000000
--- a/process/stepA_interop.gliffy
+++ /dev/null
@@ -1 +0,0 @@
-{"contentType":"application/gliffy+json","version":"1.3","stage":{"background":"#FFFFFF","width":934,"height":725,"nodeIndex":215,"autoFit":true,"exportBorder":false,"gridOn":true,"snapToGrid":true,"drawingGuidesOn":true,"pageBreaksOn":false,"printGridOn":false,"printPaper":"LETTER","printShrinkToFit":false,"printPortrait":true,"maxWidth":5000,"maxHeight":5000,"themeData":null,"viewportType":"default","fitBB":{"min":{"x":20,"y":18.5},"max":{"x":934,"y":724.5}},"objects":[{"x":264.5,"y":87.5,"rotation":0.0,"id":208,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":91,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":197,"py":0.29289321881345237,"px":1.0}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":44,"py":0.5,"px":0.0}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[-3.0,-1.4213562373095243],[12.007480555277652,-1.4213562373095243],[27.01496111055536,-1.4213562373095243],[42.022441665833014,-1.4213562373095243]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[]},{"x":31.5,"y":63.5,"rotation":0.0,"id":207,"width":225.0,"height":154.0,"uid":"com.gliffy.shape.basic.basic_v1.default.text","order":90,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:left;\"><span style=\"font-weight:bold;font-family:Arial;font-size:10px;\"><span style=\"\">&#61; </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">throw </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">nil? </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">true? </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">false? </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">symbol symbol? keyword keyword?</span></span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;text-decoration:none;font-family:Arial;font-size:10px;\"><span style=\"text-decoration:none;\"> </span></span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;font-family:Arial;font-size:10px;\"><span style=\"\">pr-str </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">str </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">prn </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">println </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">readline </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">read-string </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">slurp</span></span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;text-decoration:none;font-size:10px;\"><span style=\"text-decoration:none;\"> </span></span><span style=\"font-weight:bold;text-decoration:none;font-size:10px;\"><span style=\"text-decoration:none;\"> </span></span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;font-family:Arial;font-size:10px;\"><span style=\"\">&lt; &lt;&#61; &gt; &gt;&#61; </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">&#43; - * / </span></span><span style=\"color:#cc0000;font-weight:bold;font-size:10px;\"><span style=\"\">time-ms</span></span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;text-decoration:none;font-size:10px;\"><span style=\"text-decoration:none;\"> </span></span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">list list? vector vector? </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">hash-map map? assoc dissoc </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">get contains? keys vals</span></span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;text-decoration:none;font-size:10px;\"><span style=\"text-decoration:none;\"> </span></span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">sequential? cons concat nth </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">first rest empty? count apply </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">map conj</span></span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;text-decoration:none;font-size:10px;\"><span style=\"text-decoration:none;\"> </span></span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">with-meta meta atom atom? </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">deref reset! swap!</span></span></p><p style=\"text-align:left;\"></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"linkMap":[],"children":[]},{"x":393.5,"y":63.5,"rotation":0.0,"id":201,"width":56.0,"height":33.0,"uid":"com.gliffy.shape.basic.basic_v1.default.text","order":89,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:left;\"><span style=\"font-weight:bold;font-family:Arial;font-size:10px;\"><span style=\"\">eval</span></span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;text-decoration:none;font-family:Arial;font-size:10px;\"><span style=\"text-decoration:none;\"> </span></span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">*ARGV*</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"linkMap":[],"children":[]},{"x":479.5,"y":383.8333333333333,"rotation":0.0,"id":158,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":72,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":146,"py":0.5,"px":0.0}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":2,"py":0.0,"px":0.2928932188134524}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[2.0,-1.3333333333333144],[-76.67669529663686,-1.3333333333333144],[-76.67669529663686,-171.3333333333333],[-106.55339059327378,-171.3333333333333],[-106.55339059327378,-131.3333333333333]],"lockSegments":{"1":true},"ortho":true}},"linkMap":[],"children":[]},{"x":477.5,"y":352.5,"rotation":0.0,"id":157,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":84,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":130,"py":0.5,"px":0.0}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":2,"py":0.0,"px":0.2928932188134524}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[4.0,0.0],[-74.27669529663689,0.0],[-74.27669529663689,-139.99999999999997],[-104.55339059327378,-139.99999999999997],[-104.55339059327378,-99.99999999999997]],"lockSegments":{"1":true},"ortho":true}},"linkMap":[],"children":[{"x":0.0,"y":0.0,"rotation":0.0,"id":180,"width":30.0,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"both","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":0.5410276646970311,"linePerpValue":0.0,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">TCO</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":835.5,"y":82.5,"rotation":0.0,"id":58,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":36,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":56,"py":0.0,"px":0.9711340206185567}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":44,"py":0.0,"px":0.9200000000000002}}},"graphic":{"type":"Line","Line":{"strokeWidth":1.0,"strokeColor":"#000000","fillColor":"none","dashStyle":"1.0,1.0","startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[-120.69072164948443,5.0],[-120.69072164948443,-58.5],[-165.5999999999999,-58.5],[-165.5999999999999,-30.0]],"lockSegments":{"1":true},"ortho":true}},"linkMap":[],"children":[{"x":0.0,"y":0.0,"rotation":0.0,"id":168,"width":30.0,"height":11.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"both","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":0.6273328731976967,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:10px;\"><span style=\"\">outer</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":546.5,"y":302.5,"rotation":0.0,"id":51,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":79,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":136,"py":0.0,"px":0.2928932188134524}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":44,"py":1.0,"px":0.8227848101265823}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[85.00000000000011,70.02649212270546],[85.00000000000011,-13.315671918196358],[85.0,-96.65783595909818],[85.0,-180.0]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[{"x":0.0,"y":0.0,"rotation":0.0,"id":189,"width":68.0,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"both","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":0.6679846702072576,"linePerpValue":20.0,"cardinalityType":null,"html":"<p style=\"text-align:right;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">update env</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":306.5,"y":301.5,"rotation":0.0,"id":46,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":33,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":44,"py":1.0,"px":0.06329113924050633}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":90,"py":0.0,"px":0.8}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[25.0,-179.0],[25.0,-118.99629641060108],[25.000000000000057,-58.99259282120215],[25.000000000000057,1.0111107681967724]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[{"x":0.0,"y":0.0,"rotation":0.0,"id":112,"width":47.0,"height":28.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"both","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":0.3943470868113573,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">symbol</span></span></p><p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">lookup</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":431.5,"y":560.5,"rotation":0.0,"id":42,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":30,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":18,"py":1.0,"px":0.5}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":20,"py":1.0,"px":0.2392857142857143}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[-110.0,-28.0],[-110.0,12.0],[57.0,12.0],[57.0,-28.0]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[{"x":0.0,"y":0.0,"rotation":0.0,"id":187,"width":83.0,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"both","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":0.484414172761811,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">macroexpand</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":481.5,"y":302.5,"rotation":0.0,"id":36,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":29,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":20,"py":0.0,"px":0.26785714285714285}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":2,"py":0.0,"px":0.2928932188134524}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[15.0,0.0],[15.0,-89.99999999999997],[-108.55339059327378,-89.99999999999997],[-108.55339059327378,-49.99999999999997]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[]},{"x":836.5,"y":401.5,"rotation":0.0,"id":34,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":27,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":32,"py":0.0,"px":0.5}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":30,"py":1.0,"px":0.5}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[0.0,33.5],[0.0,2.6666666666666856],[0.0,-28.166666666666686],[0.0,-59.0]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[{"x":0.0,"y":0.0,"rotation":0.0,"id":185,"width":38.0,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"both","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":0.42162162162162165,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">string</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":0.5,"y":323.5,"rotation":0.0,"id":27,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":19,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":22,"py":0.5,"px":0.0}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[24.0,-2.0],[39.670212364724215,-2.0],[55.34042472944843,-2.0],[71.01063709417264,-2.0]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[{"x":0.0,"y":0.0,"rotation":0.0,"id":100,"width":16.0,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"both","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":0.2339895963963344,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">in</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":105.5,"y":343.5,"rotation":0.0,"id":26,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":17,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":22,"py":1.0,"px":0.5}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":24,"py":0.0,"px":0.5}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[1.0,-1.0],[1.0,15.666666666666686],[1.0,32.333333333333314],[1.0,49.0]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[{"x":0.0,"y":0.0,"rotation":0.0,"id":184,"width":38.0,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"both","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":0.44000000000000006,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">string</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":261.5,"y":302.5,"rotation":0.0,"id":18,"width":120.0,"height":230.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":10,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":2.0,"y":0.0,"rotation":0.0,"id":190,"width":116.0,"height":56.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:left;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"text-decoration:none;\">* symbol</span></span></p><p style=\"text-align:left;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"text-decoration:none;\">* list</span></span></p><p style=\"text-align:left;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"text-decoration:none;\">* vector</span></span></p><p style=\"text-align:left;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"text-decoration:none;\">* hash-map</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":670.5,"y":419.5,"rotation":0.0,"id":17,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":8,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":20,"py":0.5,"px":1.0}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":32,"py":0.5,"px":0.0}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[31.0,-2.0],[81.0,-2.0],[81.0,35.5],[131.0,35.5]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[{"x":0.0,"y":0.0,"rotation":0.0,"id":99,"width":29.0,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"both","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":0.46236810530620487,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">AST</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":833.5,"y":580.5,"rotation":0.0,"id":15,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":7,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":13,"py":1.0,"px":0.5}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":0,"py":1.0,"px":0.5}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":"8.0,8.0","startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[3.0,32.0],[3.0,128.0],[-727.0,128.0],[-727.0,32.0]],"lockSegments":{"1":true},"ortho":true}},"linkMap":[],"children":[]},{"x":218.5,"y":413.5,"rotation":0.0,"id":9,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":4,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":24,"py":0.3973684210526316,"px":1.0}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":18,"py":0.5,"px":0.0}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[-77.0,49.53289473684208],[-17.0,49.53289473684208],[-17.0,4.0],[43.0,4.0]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[{"x":0.0,"y":0.0,"rotation":0.0,"id":98,"width":29.0,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"both","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":0.488635066574355,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">AST</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":226.50000000000003,"y":252.50000000000003,"rotation":0.0,"id":2,"width":499.99999999999994,"height":359.99999999999994,"uid":"com.gliffy.shape.basic.basic_v1.default.square","order":3,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[]},{"x":51.5,"y":252.5,"rotation":0.0,"id":0,"width":110.0,"height":360.0,"uid":"com.gliffy.shape.basic.basic_v1.default.square","order":2,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[]},{"x":781.5,"y":252.5,"rotation":0.0,"id":13,"width":110.0,"height":360.0,"uid":"com.gliffy.shape.basic.basic_v1.default.square","order":6,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[]},{"x":71.5,"y":302.5,"rotation":0.0,"id":22,"width":70.0,"height":40.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":13,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":1.4000000000000001,"y":0.0,"rotation":0.0,"id":23,"width":67.2,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"text-decoration:none;\">readline</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":71.5,"y":392.5,"rotation":0.0,"id":24,"width":70.0,"height":177.5,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":15,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":1.4000000000000001,"y":0.0,"rotation":0.0,"id":25,"width":67.2,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:left;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"text-decoration:none;\">read_str</span></span></p>","tid":null,"valign":"top","vposition":"none","hposition":"none"}},"children":[]}]},{"x":801.5,"y":302.5,"rotation":0.0,"id":30,"width":70.0,"height":40.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":23,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":1.4000000000000001,"y":0.0,"rotation":0.0,"id":31,"width":67.2,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"text-decoration:none;\">printline</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":801.5,"y":435.0,"rotation":0.0,"id":32,"width":70.0,"height":40.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":25,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":1.4000000000000001,"y":0.0,"rotation":0.0,"id":33,"width":67.2,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"text-decoration:none;\">pr_str</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":321.5,"y":87.5,"rotation":0.0,"id":56,"width":405.00000000000006,"height":70.0,"uid":"com.gliffy.shape.basic.basic_v1.default.square","order":0,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":8.099999999999998,"y":0.0,"rotation":0.0,"id":57,"width":388.8000000000001,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:left;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:12px;\">ENV</span></p>","tid":null,"valign":"top","vposition":"none","hposition":"none"}},"children":[]}]},{"x":261.5,"y":302.5,"rotation":0.0,"id":90,"width":90.0,"height":28.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":40,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":3.0,"y":0.0,"rotation":0.0,"id":91,"width":84.0,"height":16.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:14px;\">eval_ast</span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":51.5,"y":252.5,"rotation":0.0,"id":92,"width":60.0,"height":28.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":42,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#c9daf8","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":2.0,"y":0.0,"rotation":0.0,"id":93,"width":55.99999999999999,"height":16.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:14px;\">READ</span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":226.5,"y":252.5,"rotation":0.0,"id":94,"width":60.0,"height":28.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":44,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#c9daf8","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":2.0,"y":0.0,"rotation":0.0,"id":95,"width":55.99999999999999,"height":16.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:14px;\">EVAL</span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":781.5,"y":252.5,"rotation":0.0,"id":96,"width":70.0,"height":28.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":46,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#c9daf8","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":2.333333333333333,"y":0.0,"rotation":0.0,"id":97,"width":65.33333333333331,"height":16.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:14px;\">PRINT</span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":914.5,"y":324.5,"rotation":0.0,"id":29,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":21,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":30,"py":0.5,"px":1.0}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[-43.0,-2.0],[-23.66666666666663,-2.0],[-4.333333333333371,-2.0],[15.0,-2.0]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[{"x":0.0,"y":0.0,"rotation":0.0,"id":109,"width":24.0,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"both","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":0.5689655172413794,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">out</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":654.5,"y":298.5,"rotation":0.0,"id":53,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":35,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[-132.0,42.00496464680543],[-132.0,-50.49751767659728],[-132.0,-50.49751767659728],[-132.0,-143.0]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[]},{"x":656.8333333333334,"y":309.83333333333337,"rotation":0.0,"id":150,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":82,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":146,"py":0.0,"px":0.85}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[-107.33333333333337,62.66666666666663],[-107.33333333333337,-45.166666666666686],[-107.33333333333337,-45.166666666666686],[-107.33333333333337,-153.0]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[{"x":0.0,"y":0.0,"rotation":0.0,"id":151,"width":64.0,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"both","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":0.7928902627511594,"linePerpValue":0.0,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">create env</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":664.8333333333334,"y":319.83333333333337,"rotation":0.0,"id":152,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":81,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[-88.66666666666674,82.66757369446611],[-88.66666666666674,-39.83287981943363],[-88.66666666666674,-39.83287981943363],[-88.66666666666674,-162.33333333333337]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[]},{"x":549.8333333333333,"y":312.5,"rotation":0.0,"id":154,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":78,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[119.66666666666663,30.01053612348437],[119.66666666666663,-79.99473193825781],[119.66666666666663,-79.99473193825781],[119.66666666666663,-190.0]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[]},{"x":472.83333333333326,"y":449.16666666666663,"rotation":0.0,"id":159,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":73,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":124,"py":0.5,"px":0.0}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":2,"py":0.0,"px":0.2928932188134524}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[8.666666666666742,-6.666666666666629],[-69.81002862997008,-6.666666666666629],[-69.81002862997008,-236.6666666666666],[-99.88672392660703,-236.6666666666666],[-99.88672392660703,-196.6666666666666]],"lockSegments":{"1":true},"ortho":true}},"linkMap":[],"children":[]},{"x":464.83333333333326,"y":481.83333333333326,"rotation":0.0,"id":160,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":74,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":126,"py":0.5,"px":0.0}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":2,"py":0.0,"px":0.2928932188134524}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[16.666666666666742,-9.333333333333258],[-61.61002862997009,-9.333333333333258],[-61.61002862997009,-269.33333333333326],[-91.88672392660703,-269.33333333333326],[-91.88672392660703,-229.33333333333323]],"lockSegments":{"1":true},"ortho":true}},"linkMap":[],"children":[]},{"x":454.1666666666665,"y":513.8333333333333,"rotation":0.0,"id":161,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":75,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":140,"py":0.5,"px":0.0}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":2,"py":0.0,"px":0.2928932188134524}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[27.333333333333485,-11.333333333333258],[-50.9433619633034,-11.333333333333258],[-50.9433619633034,-301.33333333333326],[-81.22005725994029,-301.33333333333326],[-81.22005725994029,-261.33333333333326]],"lockSegments":{"1":true},"ortho":true}},"linkMap":[],"children":[]},{"x":421.5,"y":696.5,"rotation":0.0,"id":176,"width":70.0,"height":28.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":76,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#c9daf8","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":2.333333333333333,"y":0.0,"rotation":0.0,"id":177,"width":65.33333333333331,"height":16.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:14px;\">LOOP</span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":481.5,"y":372.5,"rotation":0.0,"id":146,"width":80.0,"height":20.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":70,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":1.6000000000000005,"y":0.0,"rotation":0.0,"id":147,"width":76.80000000000001,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">&#34;apply&#34;</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":591.5,"y":492.5,"rotation":0.0,"id":142,"width":100.0,"height":20.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":68,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":2.0000000000000004,"y":0.0,"rotation":0.0,"id":143,"width":96.00000000000003,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">macroexpand</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":481.5,"y":492.5,"rotation":0.0,"id":140,"width":90.0,"height":20.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":66,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":1.800000000000001,"y":0.0,"rotation":0.0,"id":141,"width":86.40000000000003,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">quasiquote</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":629.0,"y":462.5,"rotation":0.0,"id":138,"width":62.5,"height":20.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":64,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":1.2500000000000004,"y":0.0,"rotation":0.0,"id":139,"width":60.00000000000001,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">quote</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":601.5,"y":372.5,"rotation":0.0,"id":136,"width":90.0,"height":20.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":62,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":1.8000000000000005,"y":0.0,"rotation":0.0,"id":137,"width":86.4,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">defmacro!</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":646.5,"y":342.5,"rotation":0.0,"id":134,"width":45.0,"height":20.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":60,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":0.9000000000000001,"y":0.0,"rotation":0.0,"id":135,"width":43.199999999999996,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">def!</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":481.5,"y":342.5,"rotation":0.0,"id":130,"width":50.0,"height":20.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":58,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":1.0000000000000002,"y":0.0,"rotation":0.0,"id":131,"width":48.0,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">let*</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":656.5,"y":432.5,"rotation":0.0,"id":128,"width":35.0,"height":20.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":56,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":0.7000000000000001,"y":0.0,"rotation":0.0,"id":129,"width":33.599999999999994,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">fn*</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":481.5,"y":462.5,"rotation":0.0,"id":126,"width":40.0,"height":20.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":54,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":0.8000000000000004,"y":0.0,"rotation":0.0,"id":127,"width":38.400000000000006,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">if</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":481.5,"y":432.5,"rotation":0.0,"id":124,"width":40.0,"height":20.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":52,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":0.8000000000000004,"y":0.0,"rotation":0.0,"id":125,"width":38.400000000000006,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"text-decoration:none;\">do</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":481.5,"y":402.5,"rotation":0.0,"id":122,"width":110.00000000000001,"height":20.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":50,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":2.200000000000001,"y":0.0,"rotation":0.0,"id":123,"width":105.60000000000001,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"text-decoration:none;\">try*/catch*</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":421.5,"y":302.5,"rotation":0.0,"id":87,"width":60.00000000000001,"height":28.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":38,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":2.0,"y":0.0,"rotation":0.0,"id":89,"width":56.00000000000001,"height":16.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:14px;\">apply</span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":421.5,"y":302.5,"rotation":0.0,"id":20,"width":280.0,"height":230.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":12,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[]},{"x":306.5,"y":52.5,"rotation":0.0,"id":110,"width":60.0,"height":28.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":48,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":2.0,"y":0.0,"rotation":0.0,"id":111,"width":55.99999999999999,"height":16.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:14px;\">Env</span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":306.5,"y":52.5,"rotation":0.0,"id":44,"width":395.0,"height":70.0,"uid":"com.gliffy.shape.basic.basic_v1.default.square","order":32,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[]},{"x":31.5,"y":27.5,"rotation":0.0,"id":195,"width":55.0,"height":28.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":87,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":1.833333333333333,"y":0.0,"rotation":0.0,"id":196,"width":51.333333333333314,"height":16.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:14px;\">Core</span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":31.5,"y":27.5,"rotation":0.0,"id":197,"width":230.0,"height":200.0,"uid":"com.gliffy.shape.basic.basic_v1.default.square","order":86,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[]},{"x":451.5,"y":63.5,"rotation":0.0,"id":211,"width":100.0,"height":33.0,"uid":"com.gliffy.shape.basic.basic_v1.default.text","order":92,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:left;\"><span style=\"color:rgb(204, 0, 0);font-weight:bold;font-size:10px;\">*host-language*</span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;font-size:10px;\">not</span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;font-size:10px;\">load-file</span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"linkMap":[],"children":[]},{"x":561.5,"y":63.5,"rotation":0.0,"id":212,"width":77.5,"height":22.0,"uid":"com.gliffy.shape.basic.basic_v1.default.text","order":93,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:left;\"><span style=\"font-weight:bold;font-size:10px;\">cond</span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;font-size:10px;\">or</span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"linkMap":[],"children":[]}],"shapeStyles":{"com.gliffy.shape.basic.basic_v1.default":{"fill":"#c9daf8","stroke":"#333333","strokeWidth":2}},"lineStyles":{"global":{"strokeWidth":2,"endArrow":2}},"textStyles":{"global":{"bold":true,"size":"10px","color":"#cc0000"}}},"metadata":{"title":"untitled","revision":0,"exportBorder":false,"loadPosition":"default","libraries":["com.gliffy.libraries.basic.basic_v1.default","com.gliffy.libraries.flowchart.flowchart_v1.default","com.gliffy.libraries.swimlanes.swimlanes_v1.default","com.gliffy.libraries.uml.uml_v2.class","com.gliffy.libraries.uml.uml_v2.sequence","com.gliffy.libraries.uml.uml_v2.activity","com.gliffy.libraries.erd.erd_v1.default","com.gliffy.libraries.ui.ui_v3.forms_controls","com.gliffy.libraries.images"],"autosaveDisabled":false},"embeddedResources":{"index":0,"resources":[]}}
\ No newline at end of file
diff --git a/process/stepA_interop.png b/process/stepA_interop.png
deleted file mode 100644
index 28dcb5b..0000000
Binary files a/process/stepA_interop.png and /dev/null differ
diff --git a/process/stepA_interop.txt b/process/stepA_interop.txt
deleted file mode 100644
index 8d36f31..0000000
--- a/process/stepA_interop.txt
+++ /dev/null
@@ -1,136 +0,0 @@
---- stepA_interop -------------------------------
-import types, reader, printer, env, core
-
-READ(str): return reader.read_str(str)
-
-pair?(ast): return ... // true if non-empty sequence
-quasiquote(ast): return ... // quasiquote
-
-macro?(ast, env): return ... // true if macro call
-macroexpand(ast, env): return ... // recursive macro expansion
-
-eval_ast(ast,env):
-  switch type(ast):
-    symbol:      return env.get(ast)
-    list,vector: return ast.map((x) -> EVAL(x,env))
-    hash:        return ast.map((k,v) -> list(k, EVAL(v,env)))
-    _default_:   return ast
-
-EVAL(ast,env):
-  while true:
-    if not list?(ast): return eval_ast(ast, env)
-
-    ast = macroexpand(ast, env)
-    if not list?(ast): return ast
-
-    switch ast[0]:
-      'def!:        return env.set(ast[1], EVAL(ast[2], env))
-      'let*:        env = ...; ast = ast[2] // TCO
-      'quote:       return ast[1]
-      'quasiquote:  ast = quasiquote(ast[1]) // TCO
-      'defmacro!:   return ... // like def!, but set macro property
-      'macroexpand: return macroexpand(ast[1], env)
-      'try*:        return ... // try/catch native and malval exceptions
-      'do:          ast = eval_ast(ast[1..-1], env)[-1] // TCO
-      'if:          EVAL(ast[1], env) ? ast = ast[2] : ast = ast[3] // TCO
-      'fn*:         return new MalFunc(...)
-      _default_:    f, args = eval_ast(ast, env)
-                    if malfunc?(f): ast = f.fn; env = ... // TCO
-                    else:           return apply(f, args)
-
-PRINT(exp): return printer.pr_str(exp)
-
-repl_env = new Env()
-rep(str): return PRINT(EVAL(READ(str),repl_env))
-
-;; core.EXT: defined using Racket
-core.ns.map((k,v) -> (repl_env.set(k, v)))
-repl_env.set('eval, (ast) -> EVAL(ast, repl-env))
-repl_env.set('*ARGV*, cmdline_args[1..])
-
-;; core.mal: defined using the language itself
-rep("(def! *host-language* \"racket\")")
-rep("(def! not (fn* (a) (if a false true)))")
-rep("(def! load-file (fn* (f) ...))")
-rep("(defmacro! cond (fn* (& xs) ...))")
-rep("(defmacro! or (fn* (& xs) ...))")
-
-if cmdline_args: rep("(load-file \"" + args[0] + "\")"); exit 0
-
-rep("(println (str \"Mal [\" *host-language* \"]\"))")
-main loop:
-  try:      println(rep(readline("user> ")))
-  catch e:  println("Error: ", e)
-
---- env module ----------------------------------
-class Env (outer=null,binds=[],exprs=[])
-    data = hash_map()
-    foreach b, i in binds:
-      if binds[i] == '&: data[binds[i+1]] = exprs.drop(i); break
-      else: data[binds[i]] = exprs[i]
-  set(k,v): return data.set(k,v)
-  find(k): return data.has(k) ? this : (if outer ? find(outer) : null)
-  get(k): return data.find(k).get(k) OR raise "'" + k + "' not found"
-
---- core module ---------------------------------
-ns = {'=:        equal?,
-      'throw:    throw,
-
-      'nil?:     nil?,
-      'true?:    true?,
-      'false?:   false?,
-      'symbol:   symbol,
-      'symbol?:  symbol?,
-      'keyword:  keyword,
-      'keyword?: keyword?,
-
-      'pr-str:   (a) -> a.map(|s| pr_str(e,true)).join(" ")),
-      'str:      (a) -> a.map(|s| pr_str(e,false)).join("")),
-      'prn:      (a) -> println(a.map(|s| pr_str(e,true)).join(" ")),
-      'println:  (a) -> println(a.map(|s| pr_str(e,false)).join(" ")),
-      'read-string: read_str,
-      'readline: readline,
-      'slurp     read-file,
-
-      '<:        lt,
-      '<=:       lte,
-      '>:        gt,
-      '>=:       gte,
-      '+:        add,
-      '-:        sub,
-      '*:        mult,
-      '/:        div,
-      'time-ms   cur-epoch-millis,
-
-      'list:     list,
-      'list?:    list?,
-      'vector:   vector,
-      'vector?:  vector?,
-      'hash-map: hash_map,
-      'map?:     hash_map?,
-      'assoc:    assoc,
-      'dissoc:   dissoc,
-      'get:      get,
-      'contains?: contains?,
-      'keys:     keys,
-      'vals:     vals,
-
-      'sequential? sequential?,
-      'cons:     (a) -> concat([a[0]], a[1]),
-      'concat:   (a) -> reduce(concat, [], a),
-      'nth:      (a) -> a[0][a[1]] OR raise "nth: index out of range",
-      'first:    (a) -> a[0][0] OR nil,
-      'rest:     (a) -> a[0][1..] OR list(),
-      'empty?:   empty?,
-      'count:    count,
-      'apply:    apply,
-      'map:      map,
-      'conj:     conj,
-
-      'meta:     (a) -> a[0].meta,
-      'with-meta: (a) -> a[0].with_meta(a[1]),
-      'atom:     (a) -> new Atom(a[0]),
-      'atom?:    (a) -> type(a[0]) == "atom",
-      'deref:    (a) -> a[0].val,
-      'reset!:   (a) -> a[0].val = a[1],
-      'swap!:    swap!}
diff --git a/process/stepA_mal.gliffy b/process/stepA_mal.gliffy
new file mode 100644
index 0000000..7d4920f
--- /dev/null
+++ b/process/stepA_mal.gliffy
@@ -0,0 +1 @@
+{"contentType":"application/gliffy+json","version":"1.3","stage":{"background":"#FFFFFF","width":934,"height":725,"nodeIndex":215,"autoFit":true,"exportBorder":false,"gridOn":true,"snapToGrid":true,"drawingGuidesOn":true,"pageBreaksOn":false,"printGridOn":false,"printPaper":"LETTER","printShrinkToFit":false,"printPortrait":true,"maxWidth":5000,"maxHeight":5000,"themeData":null,"viewportType":"default","fitBB":{"min":{"x":20,"y":18.5},"max":{"x":934,"y":724.5}},"objects":[{"x":264.5,"y":87.5,"rotation":0.0,"id":208,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":91,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":197,"py":0.29289321881345237,"px":1.0}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":44,"py":0.5,"px":0.0}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[-3.0,-1.4213562373095243],[12.007480555277652,-1.4213562373095243],[27.01496111055536,-1.4213562373095243],[42.022441665833014,-1.4213562373095243]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[]},{"x":31.5,"y":63.5,"rotation":0.0,"id":207,"width":225.0,"height":154.0,"uid":"com.gliffy.shape.basic.basic_v1.default.text","order":90,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:left;\"><span style=\"font-weight:bold;font-family:Arial;font-size:10px;\"><span style=\"\">&#61; </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">throw </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">nil? </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">true? </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">false? </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">symbol symbol? keyword keyword?</span></span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;text-decoration:none;font-family:Arial;font-size:10px;\"><span style=\"text-decoration:none;\"> </span></span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;font-family:Arial;font-size:10px;\"><span style=\"\">pr-str </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">str </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">prn </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">println </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">readline </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">read-string </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">slurp</span></span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;text-decoration:none;font-size:10px;\"><span style=\"text-decoration:none;\"> </span></span><span style=\"font-weight:bold;text-decoration:none;font-size:10px;\"><span style=\"text-decoration:none;\"> </span></span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;font-family:Arial;font-size:10px;\"><span style=\"\">&lt; &lt;&#61; &gt; &gt;&#61; </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">&#43; - * / </span></span><span style=\"color:#cc0000;font-weight:bold;font-size:10px;\"><span style=\"\">time-ms</span></span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;text-decoration:none;font-size:10px;\"><span style=\"text-decoration:none;\"> </span></span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">list list? vector vector? </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">hash-map map? assoc dissoc </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">get contains? keys vals</span></span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;text-decoration:none;font-size:10px;\"><span style=\"text-decoration:none;\"> </span></span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">sequential? cons concat nth </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">first rest empty? count apply </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">map conj</span></span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;text-decoration:none;font-size:10px;\"><span style=\"text-decoration:none;\"> </span></span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">with-meta meta atom atom? </span></span><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">deref reset! swap!</span></span></p><p style=\"text-align:left;\"></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"linkMap":[],"children":[]},{"x":393.5,"y":63.5,"rotation":0.0,"id":201,"width":56.0,"height":33.0,"uid":"com.gliffy.shape.basic.basic_v1.default.text","order":89,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:left;\"><span style=\"font-weight:bold;font-family:Arial;font-size:10px;\"><span style=\"\">eval</span></span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;text-decoration:none;font-family:Arial;font-size:10px;\"><span style=\"text-decoration:none;\"> </span></span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;font-size:10px;\"><span style=\"\">*ARGV*</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"linkMap":[],"children":[]},{"x":479.5,"y":383.8333333333333,"rotation":0.0,"id":158,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":72,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":146,"py":0.5,"px":0.0}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":2,"py":0.0,"px":0.2928932188134524}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[2.0,-1.3333333333333144],[-76.67669529663686,-1.3333333333333144],[-76.67669529663686,-171.3333333333333],[-106.55339059327378,-171.3333333333333],[-106.55339059327378,-131.3333333333333]],"lockSegments":{"1":true},"ortho":true}},"linkMap":[],"children":[]},{"x":477.5,"y":352.5,"rotation":0.0,"id":157,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":84,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":130,"py":0.5,"px":0.0}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":2,"py":0.0,"px":0.2928932188134524}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[4.0,0.0],[-74.27669529663689,0.0],[-74.27669529663689,-139.99999999999997],[-104.55339059327378,-139.99999999999997],[-104.55339059327378,-99.99999999999997]],"lockSegments":{"1":true},"ortho":true}},"linkMap":[],"children":[{"x":0.0,"y":0.0,"rotation":0.0,"id":180,"width":30.0,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"both","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":0.5410276646970311,"linePerpValue":0.0,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">TCO</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":835.5,"y":82.5,"rotation":0.0,"id":58,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":36,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":56,"py":0.0,"px":0.9711340206185567}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":44,"py":0.0,"px":0.9200000000000002}}},"graphic":{"type":"Line","Line":{"strokeWidth":1.0,"strokeColor":"#000000","fillColor":"none","dashStyle":"1.0,1.0","startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[-120.69072164948443,5.0],[-120.69072164948443,-58.5],[-165.5999999999999,-58.5],[-165.5999999999999,-30.0]],"lockSegments":{"1":true},"ortho":true}},"linkMap":[],"children":[{"x":0.0,"y":0.0,"rotation":0.0,"id":168,"width":30.0,"height":11.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"both","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":0.6273328731976967,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:10px;\"><span style=\"\">outer</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":546.5,"y":302.5,"rotation":0.0,"id":51,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":79,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":136,"py":0.0,"px":0.2928932188134524}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":44,"py":1.0,"px":0.8227848101265823}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[85.00000000000011,70.02649212270546],[85.00000000000011,-13.315671918196358],[85.0,-96.65783595909818],[85.0,-180.0]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[{"x":0.0,"y":0.0,"rotation":0.0,"id":189,"width":68.0,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"both","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":0.6679846702072576,"linePerpValue":20.0,"cardinalityType":null,"html":"<p style=\"text-align:right;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">update env</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":306.5,"y":301.5,"rotation":0.0,"id":46,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":33,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":44,"py":1.0,"px":0.06329113924050633}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":90,"py":0.0,"px":0.8}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[25.0,-179.0],[25.0,-118.99629641060108],[25.000000000000057,-58.99259282120215],[25.000000000000057,1.0111107681967724]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[{"x":0.0,"y":0.0,"rotation":0.0,"id":112,"width":47.0,"height":28.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"both","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":0.3943470868113573,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">symbol</span></span></p><p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">lookup</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":431.5,"y":560.5,"rotation":0.0,"id":42,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":30,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":18,"py":1.0,"px":0.5}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":20,"py":1.0,"px":0.2392857142857143}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[-110.0,-28.0],[-110.0,12.0],[57.0,12.0],[57.0,-28.0]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[{"x":0.0,"y":0.0,"rotation":0.0,"id":187,"width":83.0,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"both","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":0.484414172761811,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">macroexpand</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":481.5,"y":302.5,"rotation":0.0,"id":36,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":29,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":20,"py":0.0,"px":0.26785714285714285}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":2,"py":0.0,"px":0.2928932188134524}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[15.0,0.0],[15.0,-89.99999999999997],[-108.55339059327378,-89.99999999999997],[-108.55339059327378,-49.99999999999997]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[]},{"x":836.5,"y":401.5,"rotation":0.0,"id":34,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":27,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":32,"py":0.0,"px":0.5}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":30,"py":1.0,"px":0.5}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[0.0,33.5],[0.0,2.6666666666666856],[0.0,-28.166666666666686],[0.0,-59.0]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[{"x":0.0,"y":0.0,"rotation":0.0,"id":185,"width":38.0,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"both","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":0.42162162162162165,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">string</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":0.5,"y":323.5,"rotation":0.0,"id":27,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":19,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":22,"py":0.5,"px":0.0}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[24.0,-2.0],[39.670212364724215,-2.0],[55.34042472944843,-2.0],[71.01063709417264,-2.0]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[{"x":0.0,"y":0.0,"rotation":0.0,"id":100,"width":16.0,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"both","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":0.2339895963963344,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">in</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":105.5,"y":343.5,"rotation":0.0,"id":26,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":17,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":22,"py":1.0,"px":0.5}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":24,"py":0.0,"px":0.5}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[1.0,-1.0],[1.0,15.666666666666686],[1.0,32.333333333333314],[1.0,49.0]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[{"x":0.0,"y":0.0,"rotation":0.0,"id":184,"width":38.0,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"both","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":0.44000000000000006,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">string</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":261.5,"y":302.5,"rotation":0.0,"id":18,"width":120.0,"height":230.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":10,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":2.0,"y":0.0,"rotation":0.0,"id":190,"width":116.0,"height":56.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:left;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"text-decoration:none;\">* symbol</span></span></p><p style=\"text-align:left;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"text-decoration:none;\">* list</span></span></p><p style=\"text-align:left;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"text-decoration:none;\">* vector</span></span></p><p style=\"text-align:left;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"text-decoration:none;\">* hash-map</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":670.5,"y":419.5,"rotation":0.0,"id":17,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":8,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":20,"py":0.5,"px":1.0}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":32,"py":0.5,"px":0.0}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[31.0,-2.0],[81.0,-2.0],[81.0,35.5],[131.0,35.5]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[{"x":0.0,"y":0.0,"rotation":0.0,"id":99,"width":29.0,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"both","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":0.46236810530620487,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">AST</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":833.5,"y":580.5,"rotation":0.0,"id":15,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":7,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":13,"py":1.0,"px":0.5}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":0,"py":1.0,"px":0.5}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":"8.0,8.0","startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[3.0,32.0],[3.0,128.0],[-727.0,128.0],[-727.0,32.0]],"lockSegments":{"1":true},"ortho":true}},"linkMap":[],"children":[]},{"x":218.5,"y":413.5,"rotation":0.0,"id":9,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":4,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":24,"py":0.3973684210526316,"px":1.0}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":18,"py":0.5,"px":0.0}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[-77.0,49.53289473684208],[-17.0,49.53289473684208],[-17.0,4.0],[43.0,4.0]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[{"x":0.0,"y":0.0,"rotation":0.0,"id":98,"width":29.0,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"both","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":0.488635066574355,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">AST</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":226.50000000000003,"y":252.50000000000003,"rotation":0.0,"id":2,"width":499.99999999999994,"height":359.99999999999994,"uid":"com.gliffy.shape.basic.basic_v1.default.square","order":3,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[]},{"x":51.5,"y":252.5,"rotation":0.0,"id":0,"width":110.0,"height":360.0,"uid":"com.gliffy.shape.basic.basic_v1.default.square","order":2,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[]},{"x":781.5,"y":252.5,"rotation":0.0,"id":13,"width":110.0,"height":360.0,"uid":"com.gliffy.shape.basic.basic_v1.default.square","order":6,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[]},{"x":71.5,"y":302.5,"rotation":0.0,"id":22,"width":70.0,"height":40.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":13,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":1.4000000000000001,"y":0.0,"rotation":0.0,"id":23,"width":67.2,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"text-decoration:none;\">readline</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":71.5,"y":392.5,"rotation":0.0,"id":24,"width":70.0,"height":177.5,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":15,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":1.4000000000000001,"y":0.0,"rotation":0.0,"id":25,"width":67.2,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:left;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"text-decoration:none;\">read_str</span></span></p>","tid":null,"valign":"top","vposition":"none","hposition":"none"}},"children":[]}]},{"x":801.5,"y":302.5,"rotation":0.0,"id":30,"width":70.0,"height":40.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":23,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":1.4000000000000001,"y":0.0,"rotation":0.0,"id":31,"width":67.2,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"text-decoration:none;\">printline</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":801.5,"y":435.0,"rotation":0.0,"id":32,"width":70.0,"height":40.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":25,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":1.4000000000000001,"y":0.0,"rotation":0.0,"id":33,"width":67.2,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"text-decoration:none;\">pr_str</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":321.5,"y":87.5,"rotation":0.0,"id":56,"width":405.00000000000006,"height":70.0,"uid":"com.gliffy.shape.basic.basic_v1.default.square","order":0,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":8.099999999999998,"y":0.0,"rotation":0.0,"id":57,"width":388.8000000000001,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:left;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:12px;\">ENV</span></p>","tid":null,"valign":"top","vposition":"none","hposition":"none"}},"children":[]}]},{"x":261.5,"y":302.5,"rotation":0.0,"id":90,"width":90.0,"height":28.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":40,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":3.0,"y":0.0,"rotation":0.0,"id":91,"width":84.0,"height":16.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:14px;\">eval_ast</span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":51.5,"y":252.5,"rotation":0.0,"id":92,"width":60.0,"height":28.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":42,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#c9daf8","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":2.0,"y":0.0,"rotation":0.0,"id":93,"width":55.99999999999999,"height":16.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:14px;\">READ</span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":226.5,"y":252.5,"rotation":0.0,"id":94,"width":60.0,"height":28.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":44,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#c9daf8","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":2.0,"y":0.0,"rotation":0.0,"id":95,"width":55.99999999999999,"height":16.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:14px;\">EVAL</span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":781.5,"y":252.5,"rotation":0.0,"id":96,"width":70.0,"height":28.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":46,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#c9daf8","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":2.333333333333333,"y":0.0,"rotation":0.0,"id":97,"width":65.33333333333331,"height":16.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:14px;\">PRINT</span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":914.5,"y":324.5,"rotation":0.0,"id":29,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":21,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":30,"py":0.5,"px":1.0}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[-43.0,-2.0],[-23.66666666666663,-2.0],[-4.333333333333371,-2.0],[15.0,-2.0]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[{"x":0.0,"y":0.0,"rotation":0.0,"id":109,"width":24.0,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"both","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":0.5689655172413794,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">out</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":654.5,"y":298.5,"rotation":0.0,"id":53,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":35,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[-132.0,42.00496464680543],[-132.0,-50.49751767659728],[-132.0,-50.49751767659728],[-132.0,-143.0]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[]},{"x":656.8333333333334,"y":309.83333333333337,"rotation":0.0,"id":150,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":82,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":146,"py":0.0,"px":0.85}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[-107.33333333333337,62.66666666666663],[-107.33333333333337,-45.166666666666686],[-107.33333333333337,-45.166666666666686],[-107.33333333333337,-153.0]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[{"x":0.0,"y":0.0,"rotation":0.0,"id":151,"width":64.0,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"both","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":0.7928902627511594,"linePerpValue":0.0,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">create env</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":664.8333333333334,"y":319.83333333333337,"rotation":0.0,"id":152,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":81,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[-88.66666666666674,82.66757369446611],[-88.66666666666674,-39.83287981943363],[-88.66666666666674,-39.83287981943363],[-88.66666666666674,-162.33333333333337]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[]},{"x":549.8333333333333,"y":312.5,"rotation":0.0,"id":154,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":78,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[119.66666666666663,30.01053612348437],[119.66666666666663,-79.99473193825781],[119.66666666666663,-79.99473193825781],[119.66666666666663,-190.0]],"lockSegments":{},"ortho":true}},"linkMap":[],"children":[]},{"x":472.83333333333326,"y":449.16666666666663,"rotation":0.0,"id":159,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":73,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":124,"py":0.5,"px":0.0}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":2,"py":0.0,"px":0.2928932188134524}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[8.666666666666742,-6.666666666666629],[-69.81002862997008,-6.666666666666629],[-69.81002862997008,-236.6666666666666],[-99.88672392660703,-236.6666666666666],[-99.88672392660703,-196.6666666666666]],"lockSegments":{"1":true},"ortho":true}},"linkMap":[],"children":[]},{"x":464.83333333333326,"y":481.83333333333326,"rotation":0.0,"id":160,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":74,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":126,"py":0.5,"px":0.0}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":2,"py":0.0,"px":0.2928932188134524}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[16.666666666666742,-9.333333333333258],[-61.61002862997009,-9.333333333333258],[-61.61002862997009,-269.33333333333326],[-91.88672392660703,-269.33333333333326],[-91.88672392660703,-229.33333333333323]],"lockSegments":{"1":true},"ortho":true}},"linkMap":[],"children":[]},{"x":454.1666666666665,"y":513.8333333333333,"rotation":0.0,"id":161,"width":100.0,"height":100.0,"uid":"com.gliffy.shape.basic.basic_v1.default.line","order":75,"lockAspectRatio":false,"lockShape":false,"constraints":{"constraints":[],"startConstraint":{"type":"StartPositionConstraint","StartPositionConstraint":{"nodeId":140,"py":0.5,"px":0.0}},"endConstraint":{"type":"EndPositionConstraint","EndPositionConstraint":{"nodeId":2,"py":0.0,"px":0.2928932188134524}}},"graphic":{"type":"Line","Line":{"strokeWidth":2.0,"strokeColor":"#000000","fillColor":"none","dashStyle":null,"startArrow":0,"endArrow":2,"startArrowRotation":"auto","endArrowRotation":"auto","interpolationType":"linear","cornerRadius":10.0,"controlPath":[[27.333333333333485,-11.333333333333258],[-50.9433619633034,-11.333333333333258],[-50.9433619633034,-301.33333333333326],[-81.22005725994029,-301.33333333333326],[-81.22005725994029,-261.33333333333326]],"lockSegments":{"1":true},"ortho":true}},"linkMap":[],"children":[]},{"x":421.5,"y":696.5,"rotation":0.0,"id":176,"width":70.0,"height":28.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":76,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#c9daf8","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":2.333333333333333,"y":0.0,"rotation":0.0,"id":177,"width":65.33333333333331,"height":16.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:14px;\">LOOP</span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":481.5,"y":372.5,"rotation":0.0,"id":146,"width":80.0,"height":20.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":70,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":1.6000000000000005,"y":0.0,"rotation":0.0,"id":147,"width":76.80000000000001,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">&#34;apply&#34;</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":591.5,"y":492.5,"rotation":0.0,"id":142,"width":100.0,"height":20.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":68,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":2.0000000000000004,"y":0.0,"rotation":0.0,"id":143,"width":96.00000000000003,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">macroexpand</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":481.5,"y":492.5,"rotation":0.0,"id":140,"width":90.0,"height":20.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":66,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":1.800000000000001,"y":0.0,"rotation":0.0,"id":141,"width":86.40000000000003,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">quasiquote</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":629.0,"y":462.5,"rotation":0.0,"id":138,"width":62.5,"height":20.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":64,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":1.2500000000000004,"y":0.0,"rotation":0.0,"id":139,"width":60.00000000000001,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">quote</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":601.5,"y":372.5,"rotation":0.0,"id":136,"width":90.0,"height":20.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":62,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":1.8000000000000005,"y":0.0,"rotation":0.0,"id":137,"width":86.4,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">defmacro!</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":646.5,"y":342.5,"rotation":0.0,"id":134,"width":45.0,"height":20.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":60,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":0.9000000000000001,"y":0.0,"rotation":0.0,"id":135,"width":43.199999999999996,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">def!</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":481.5,"y":342.5,"rotation":0.0,"id":130,"width":50.0,"height":20.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":58,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":1.0000000000000002,"y":0.0,"rotation":0.0,"id":131,"width":48.0,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">let*</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":656.5,"y":432.5,"rotation":0.0,"id":128,"width":35.0,"height":20.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":56,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":0.7000000000000001,"y":0.0,"rotation":0.0,"id":129,"width":33.599999999999994,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">fn*</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":481.5,"y":462.5,"rotation":0.0,"id":126,"width":40.0,"height":20.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":54,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":0.8000000000000004,"y":0.0,"rotation":0.0,"id":127,"width":38.400000000000006,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"\">if</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":481.5,"y":432.5,"rotation":0.0,"id":124,"width":40.0,"height":20.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":52,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":0.8000000000000004,"y":0.0,"rotation":0.0,"id":125,"width":38.400000000000006,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"text-decoration:none;\">do</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":481.5,"y":402.5,"rotation":0.0,"id":122,"width":110.00000000000001,"height":20.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":50,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":2.200000000000001,"y":0.0,"rotation":0.0,"id":123,"width":105.60000000000001,"height":14.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:12px;\"><span style=\"text-decoration:none;\">try*/catch*</span></span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":421.5,"y":302.5,"rotation":0.0,"id":87,"width":60.00000000000001,"height":28.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":38,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":2.0,"y":0.0,"rotation":0.0,"id":89,"width":56.00000000000001,"height":16.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:14px;\">apply</span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":421.5,"y":302.5,"rotation":0.0,"id":20,"width":280.0,"height":230.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":12,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[]},{"x":306.5,"y":52.5,"rotation":0.0,"id":110,"width":60.0,"height":28.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":48,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":2.0,"y":0.0,"rotation":0.0,"id":111,"width":55.99999999999999,"height":16.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:14px;\">Env</span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":306.5,"y":52.5,"rotation":0.0,"id":44,"width":395.0,"height":70.0,"uid":"com.gliffy.shape.basic.basic_v1.default.square","order":32,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[]},{"x":31.5,"y":27.5,"rotation":0.0,"id":195,"width":55.0,"height":28.0,"uid":"com.gliffy.shape.basic.basic_v1.default.rectangle","order":87,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[{"x":1.833333333333333,"y":0.0,"rotation":0.0,"id":196,"width":51.333333333333314,"height":16.0,"uid":null,"order":"auto","lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":8,"paddingRight":8,"paddingBottom":8,"paddingLeft":8,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:center;\"><span style=\"text-decoration:none;font-weight:bold;font-family:Arial;font-size:14px;\">Core</span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"children":[]}]},{"x":31.5,"y":27.5,"rotation":0.0,"id":197,"width":230.0,"height":200.0,"uid":"com.gliffy.shape.basic.basic_v1.default.square","order":86,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Shape","Shape":{"tid":"com.gliffy.stencil.rectangle.basic_v1","strokeWidth":2.0,"strokeColor":"#333333","fillColor":"#FFFFFF","gradient":false,"dashStyle":null,"dropShadow":false,"state":0,"opacity":1.0,"shadowX":0.0,"shadowY":0.0}},"linkMap":[],"children":[]},{"x":451.5,"y":63.5,"rotation":0.0,"id":211,"width":100.0,"height":33.0,"uid":"com.gliffy.shape.basic.basic_v1.default.text","order":92,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:left;\"><span style=\"color:rgb(204, 0, 0);font-weight:bold;font-size:10px;\">*host-language*</span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;font-size:10px;\">not</span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;font-size:10px;\">load-file</span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"linkMap":[],"children":[]},{"x":561.5,"y":63.5,"rotation":0.0,"id":212,"width":77.5,"height":22.0,"uid":"com.gliffy.shape.basic.basic_v1.default.text","order":93,"lockAspectRatio":false,"lockShape":false,"graphic":{"type":"Text","Text":{"overflow":"none","paddingTop":2,"paddingRight":2,"paddingBottom":2,"paddingLeft":2,"outerPaddingTop":6,"outerPaddingRight":6,"outerPaddingBottom":2,"outerPaddingLeft":6,"type":"fixed","lineTValue":null,"linePerpValue":null,"cardinalityType":null,"html":"<p style=\"text-align:left;\"><span style=\"font-weight:bold;font-size:10px;\">cond</span></p><p style=\"text-align:left;\"><span style=\"font-weight:bold;font-size:10px;\">or</span></p>","tid":null,"valign":"middle","vposition":"none","hposition":"none"}},"linkMap":[],"children":[]}],"shapeStyles":{"com.gliffy.shape.basic.basic_v1.default":{"fill":"#c9daf8","stroke":"#333333","strokeWidth":2}},"lineStyles":{"global":{"strokeWidth":2,"endArrow":2}},"textStyles":{"global":{"bold":true,"size":"10px","color":"#cc0000"}}},"metadata":{"title":"untitled","revision":0,"exportBorder":false,"loadPosition":"default","libraries":["com.gliffy.libraries.basic.basic_v1.default","com.gliffy.libraries.flowchart.flowchart_v1.default","com.gliffy.libraries.swimlanes.swimlanes_v1.default","com.gliffy.libraries.uml.uml_v2.class","com.gliffy.libraries.uml.uml_v2.sequence","com.gliffy.libraries.uml.uml_v2.activity","com.gliffy.libraries.erd.erd_v1.default","com.gliffy.libraries.ui.ui_v3.forms_controls","com.gliffy.libraries.images"],"autosaveDisabled":false},"embeddedResources":{"index":0,"resources":[]}}
\ No newline at end of file
diff --git a/process/stepA_mal.png b/process/stepA_mal.png
new file mode 100644
index 0000000..28dcb5b
Binary files /dev/null and b/process/stepA_mal.png differ
diff --git a/process/stepA_mal.txt b/process/stepA_mal.txt
new file mode 100644
index 0000000..6c1e71e
--- /dev/null
+++ b/process/stepA_mal.txt
@@ -0,0 +1,136 @@
+--- stepA_mal -------------------------------
+import types, reader, printer, env, core
+
+READ(str): return reader.read_str(str)
+
+pair?(ast): return ... // true if non-empty sequence
+quasiquote(ast): return ... // quasiquote
+
+macro?(ast, env): return ... // true if macro call
+macroexpand(ast, env): return ... // recursive macro expansion
+
+eval_ast(ast,env):
+  switch type(ast):
+    symbol:      return env.get(ast)
+    list,vector: return ast.map((x) -> EVAL(x,env))
+    hash:        return ast.map((k,v) -> list(k, EVAL(v,env)))
+    _default_:   return ast
+
+EVAL(ast,env):
+  while true:
+    if not list?(ast): return eval_ast(ast, env)
+
+    ast = macroexpand(ast, env)
+    if not list?(ast): return ast
+
+    switch ast[0]:
+      'def!:        return env.set(ast[1], EVAL(ast[2], env))
+      'let*:        env = ...; ast = ast[2] // TCO
+      'quote:       return ast[1]
+      'quasiquote:  ast = quasiquote(ast[1]) // TCO
+      'defmacro!:   return ... // like def!, but set macro property
+      'macroexpand: return macroexpand(ast[1], env)
+      'try*:        return ... // try/catch native and malval exceptions
+      'do:          ast = eval_ast(ast[1..-1], env)[-1] // TCO
+      'if:          EVAL(ast[1], env) ? ast = ast[2] : ast = ast[3] // TCO
+      'fn*:         return new MalFunc(...)
+      _default_:    f, args = eval_ast(ast, env)
+                    if malfunc?(f): ast = f.fn; env = ... // TCO
+                    else:           return apply(f, args)
+
+PRINT(exp): return printer.pr_str(exp)
+
+repl_env = new Env()
+rep(str): return PRINT(EVAL(READ(str),repl_env))
+
+;; core.EXT: defined using Racket
+core.ns.map((k,v) -> (repl_env.set(k, v)))
+repl_env.set('eval, (ast) -> EVAL(ast, repl-env))
+repl_env.set('*ARGV*, cmdline_args[1..])
+
+;; core.mal: defined using the language itself
+rep("(def! *host-language* \"racket\")")
+rep("(def! not (fn* (a) (if a false true)))")
+rep("(def! load-file (fn* (f) ...))")
+rep("(defmacro! cond (fn* (& xs) ...))")
+rep("(defmacro! or (fn* (& xs) ...))")
+
+if cmdline_args: rep("(load-file \"" + args[0] + "\")"); exit 0
+
+rep("(println (str \"Mal [\" *host-language* \"]\"))")
+main loop:
+  try:      println(rep(readline("user> ")))
+  catch e:  println("Error: ", e)
+
+--- env module ----------------------------------
+class Env (outer=null,binds=[],exprs=[])
+    data = hash_map()
+    foreach b, i in binds:
+      if binds[i] == '&: data[binds[i+1]] = exprs.drop(i); break
+      else: data[binds[i]] = exprs[i]
+  set(k,v): return data.set(k,v)
+  find(k): return data.has(k) ? this : (if outer ? find(outer) : null)
+  get(k): return data.find(k).get(k) OR raise "'" + k + "' not found"
+
+--- core module ---------------------------------
+ns = {'=:        equal?,
+      'throw:    throw,
+
+      'nil?:     nil?,
+      'true?:    true?,
+      'false?:   false?,
+      'symbol:   symbol,
+      'symbol?:  symbol?,
+      'keyword:  keyword,
+      'keyword?: keyword?,
+
+      'pr-str:   (a) -> a.map(|s| pr_str(e,true)).join(" ")),
+      'str:      (a) -> a.map(|s| pr_str(e,false)).join("")),
+      'prn:      (a) -> println(a.map(|s| pr_str(e,true)).join(" ")),
+      'println:  (a) -> println(a.map(|s| pr_str(e,false)).join(" ")),
+      'read-string: read_str,
+      'readline: readline,
+      'slurp     read-file,
+
+      '<:        lt,
+      '<=:       lte,
+      '>:        gt,
+      '>=:       gte,
+      '+:        add,
+      '-:        sub,
+      '*:        mult,
+      '/:        div,
+      'time-ms   cur-epoch-millis,
+
+      'list:     list,
+      'list?:    list?,
+      'vector:   vector,
+      'vector?:  vector?,
+      'hash-map: hash_map,
+      'map?:     hash_map?,
+      'assoc:    assoc,
+      'dissoc:   dissoc,
+      'get:      get,
+      'contains?: contains?,
+      'keys:     keys,
+      'vals:     vals,
+
+      'sequential? sequential?,
+      'cons:     (a) -> concat([a[0]], a[1]),
+      'concat:   (a) -> reduce(concat, [], a),
+      'nth:      (a) -> a[0][a[1]] OR raise "nth: index out of range",
+      'first:    (a) -> a[0][0] OR nil,
+      'rest:     (a) -> a[0][1..] OR list(),
+      'empty?:   empty?,
+      'count:    count,
+      'apply:    apply,
+      'map:      map,
+      'conj:     conj,
+
+      'meta:     (a) -> a[0].meta,
+      'with-meta: (a) -> a[0].with_meta(a[1]),
+      'atom:     (a) -> new Atom(a[0]),
+      'atom?:    (a) -> type(a[0]) == "atom",
+      'deref:    (a) -> a[0].val,
+      'reset!:   (a) -> a[0].val = a[1],
+      'swap!:    swap!}
diff --git a/ps/Makefile b/ps/Makefile
index 26056a6..9131674 100644
--- a/ps/Makefile
+++ b/ps/Makefile
@@ -2,7 +2,7 @@
 TESTS =
 
 SOURCES_BASE = types.ps reader.ps printer.ps
-SOURCES_LISP = env.ps core.ps stepA_interop.ps
+SOURCES_LISP = env.ps core.ps stepA_mal.ps
 SOURCES = $(SOURCES_BASE) $(SOURCES_LISP)
 
 .PHONY: stats tests $(TESTS)
diff --git a/ps/stepA_interop.ps b/ps/stepA_interop.ps
deleted file mode 100644
index c879294..0000000
--- a/ps/stepA_interop.ps
+++ /dev/null
@@ -1,298 +0,0 @@
-/runlibfile where { pop }{ /runlibfile { run } def } ifelse % 
-(types.ps) runlibfile
-(reader.ps) runlibfile
-(printer.ps) runlibfile
-(env.ps) runlibfile
-(core.ps) runlibfile
-
-% read
-/_readline { print flush (%stdin) (r) file 99 string readline } def
-
-/READ {
-    /str exch def
-    str read_str
-} def
-
-
-% eval
-% is_pair?: ast -> is_pair? -> bool
-% return true if non-empty list, otherwise false
-/is_pair? { 
-    dup _sequential? { _count 0 gt }{ pop false } ifelse
-} def
-
-% ast -> quasiquote -> new_ast
-/quasiquote { 3 dict begin
-    /ast exch def
-    ast is_pair? not { %if not is_pair?
-        /quote ast 2 _list
-    }{ 
-        /a0 ast 0 _nth def
-        a0 /unquote eq { %if a0 unquote symbol
-            ast 1 _nth
-        }{ a0 is_pair? { %elseif a0 is_pair?
-            /a00 a0 0 _nth def
-            a00 /splice-unquote eq { %if splice-unquote
-                /concat a0 1 _nth ast _rest quasiquote 3 _list
-            }{ %else not splice-unquote
-                /cons a0 quasiquote ast _rest quasiquote 3 _list
-            } ifelse
-        }{ % else not a0 is_pair?
-            /cons a0 quasiquote ast _rest quasiquote 3 _list
-        } ifelse } ifelse
-    } ifelse
-end } def
-
-/is_macro_call? { 3 dict begin
-    /env exch def
-    /ast exch def
-    ast _list? {
-        /a0 ast 0 _nth def
-        a0 _symbol? { %if a0 is symbol
-            env a0 env_find null ne { %if a0 is in env
-                env a0 env_get _mal_function? { %if user defined function
-                    env a0 env_get /macro? get true eq %if marked as macro
-                }{ false } ifelse
-            }{ false } ifelse
-        }{ false } ifelse
-    }{ false } ifelse
-end } def
-
-/macroexpand { 3 dict begin
-    /env exch def
-    /ast exch def
-    {
-        ast env is_macro_call? {
-            /mac env   ast 0 _nth   env_get def
-            /ast ast _rest mac fload EVAL def
-        }{
-            exit
-        } ifelse
-    } loop 
-    ast
-end } def
-
-/eval_ast { 2 dict begin
-    /env exch def
-    /ast exch def
-    %(eval_ast: ) print ast ==
-    ast _symbol? { %if symbol
-        env ast env_get
-    }{ ast _sequential? { %elseif list or vector
-        [
-            ast /data get { %forall items
-                env EVAL
-            } forall
-        ] ast _list? { _list_from_array }{ _vector_from_array } ifelse
-    }{ ast _hash_map? { %elseif list or vector
-        <<
-            ast /data get { %forall entries
-                env EVAL
-            } forall
-        >> _hash_map_from_dict
-    }{ % else
-        ast
-    } ifelse } ifelse } ifelse
-end } def
-
-/EVAL { 13 dict begin
-    { %loop (TCO) 
-
-    /env exch def
-    /ast exch def
-    /loop? false def
-
-    %(EVAL: ) print ast true _pr_str print (\n) print
-    ast _list? not { %if not a list
-        ast env eval_ast
-    }{ %else apply the list
-      /ast ast env macroexpand def
-      ast _list? not { %if no longer a list
-          ast
-      }{ %else still a list
-        /a0 ast 0 _nth def
-        /def! a0 eq { %if def!
-            /a1 ast 1 _nth def
-            /a2 ast 2 _nth def
-            env a1  a2 env EVAL  env_set
-        }{ /let* a0 eq { %if let*
-            /a1 ast 1 _nth def
-            /a2 ast 2 _nth def
-            /let_env env null null env_new def
-            0 2 a1 _count 1 sub { %for each pair
-                /idx exch def
-                let_env
-                    a1 idx _nth
-                    a1 idx 1 add _nth let_env EVAL
-                    env_set
-                    pop % discard the return value
-            } for
-            a2
-            let_env
-            /loop? true def % loop
-        }{ /quote a0 eq { %if quote
-            ast 1 _nth
-        }{ /quasiquote a0 eq { %if quasiquote
-            ast 1 _nth quasiquote
-            env
-            /loop? true def % loop
-        }{ /defmacro! a0 eq { %if defmacro!
-            /a1 ast 1 _nth def
-            /a2 ast 2 _nth def
-            a2 env EVAL
-            dup /macro? true put % set macro flag
-            env exch a1 exch env_set % def! it
-        }{ /macroexpand a0 eq { %if defmacro!
-            ast 1 _nth env macroexpand
-        }{ /ps* a0 eq { %if ps*
-            count /stackcnt exch def
-            ast 1 _nth
-            {
-                token not { exit } if
-                exch
-                count stackcnt sub 1 roll % send leftover string to bottom
-                exec
-                count stackcnt sub -1 roll % bring leftover string to top
-            } loop
-            count stackcnt gt { % if new operands on stack
-                % return an list of new operands
-                count stackcnt sub array astore
-            }{
-                null % return nil
-            } ifelse
-        }{ /do a0 eq { %if do
-            ast _count 2 gt { %if ast has more than 2 elements
-                ast 1 ast _count 2 sub _slice env eval_ast pop
-            } if
-            ast ast _count 1 sub _nth % last ast becomes new ast
-            env
-            /loop? true def % loop
-        }{ /try* a0 eq { %if try*
-            { %try
-                countdictstack /dictcnt exch def
-                count /stackcnt exch def
-                ast 1 _nth env EVAL
-            } stopped { %catch
-                % clean up the dictionary stack
-                1 1 countdictstack dictcnt sub { %foreach added dict
-                    %(popping dict\n) print
-                    pop end % pop idx and pop dict
-                    %(new ast: ) print ast true _pr_str print (\n) print
-                } for
-                % clean up the operand stack
-                count 1 exch 1 exch stackcnt sub { %foreach added operand
-                    %(op stack: ) print pstack
-                    pop pop % pop idx and operand
-                    %(popped op stack\n) print pstack
-                } for
-                % get error data and reset $error dict
-                /errdata get_error_data def
-                $error /newerror false put
-                $error /errorinfo null put
-
-                ast _count 3 lt { %if no third (catch*) form
-                    errdata throw
-                } if
-                ast 2 _nth 0 _nth (catch*) eq not { %if third form not catch*
-                    (No catch* in throw form) _throw
-                } if
-                ast 2 _nth 2 _nth
-                env
-                    ast 2 _nth 1 _nth 1 _list
-                    errdata 1 _list
-                    env_new
-                EVAL
-            } if
-        }{ /if a0 eq { %if if
-            /a1 ast 1 _nth def
-            /cond a1 env EVAL def
-            cond null eq cond false eq or { % if cond is nil or false
-                ast _count 3 gt { %if false branch with a3
-                    ast 3 _nth env
-                    /loop? true def
-                }{ % else false branch with no a3
-                    null
-                } ifelse
-            }{ % true branch
-                ast 2 _nth env
-                /loop? true def
-            } ifelse
-        }{ /fn* a0 eq { %if fn*
-            /a1 ast 1 _nth def
-            /a2 ast 2 _nth def
-            a2 env a1 _mal_function
-        }{
-            /el ast env eval_ast def
-            el _rest el _first % stack: ast function
-            dup _mal_function? { %if user defined function
-                fload % stack: ast new_env
-                /loop? true def
-            }{ dup _function? { %else if builtin function
-                /data get exec
-            }{ %else (regular procedure/function)
-                (cannot apply native proc!\n) print quit
-            } ifelse } ifelse
-        } ifelse } ifelse } ifelse } ifelse } ifelse } ifelse } ifelse } ifelse } ifelse } ifelse } ifelse
-      } ifelse
-    } ifelse
-
-    loop? not { exit } if
-    } loop % TCO
-end } def
-
-
-% print
-/PRINT {
-    true _pr_str
-} def
-
-
-% repl
-/repl_env null null null env_new def
-
-/RE { READ repl_env EVAL } def
-/REP { READ repl_env EVAL PRINT } def
-
-% core.ps: defined using postscript
-/_ref { repl_env 3 1 roll env_set pop } def
-core_ns { _function _ref } forall
-(eval) { 0 _nth repl_env EVAL } _function _ref
-(*ARGV*) [ ] _list_from_array _ref
-
-% core.mal: defined using the language itself
-(\(def! *host-language* "postscript"\)) RE pop
-(\(def! not \(fn* \(a\) \(if a false true\)\)\)) RE pop
-(\(def! load-file \(fn* \(f\) \(eval \(read-string \(str "\(do " \(slurp f\) "\)"\)\)\)\)\)) RE pop
-(\(defmacro! cond \(fn* \(& xs\) \(if \(> \(count xs\) 0\) \(list 'if \(first xs\) \(if \(> \(count xs\) 1\) \(nth xs 1\) \(throw "odd number of forms to cond"\)\) \(cons 'cond \(rest \(rest xs\)\)\)\)\)\)\)) RE pop
-(\(defmacro! or \(fn* \(& xs\) \(if \(empty? xs\) nil \(if \(= 1 \(count xs\)\) \(first xs\) `\(let* \(or_FIXME ~\(first xs\)\) \(if or_FIXME or_FIXME \(or ~@\(rest xs\)\)\)\)\)\)\)\)) RE pop
-
-userdict /ARGUMENTS known { %if command line arguments
-    ARGUMENTS length 0 gt { %if more than 0 arguments
-        (*ARGV*) ARGUMENTS 1 ARGUMENTS length 1 sub getinterval
-        _list_from_array _ref
-        ARGUMENTS 0 get 
-        (\(load-file ") exch ("\)) concatenate concatenate RE pop
-        quit
-    } if
-} if
-
-% repl loop
-(\(println \(str "Mal [" *host-language* "]"\)\)) RE pop
-{ %loop
-    (user> ) _readline
-    not { exit } if  % exit if EOF
-
-    { %try
-        REP print (\n) print
-    } stopped {
-        (Error: ) print
-        get_error_data false _pr_str print (\n) print
-        $error /newerror false put
-        $error /errorinfo null put
-        clear
-        cleardictstack
-    } if
-} bind loop
-
-(\n) print  % final newline before exit for cleanliness
-quit
diff --git a/ps/stepA_mal.ps b/ps/stepA_mal.ps
new file mode 100644
index 0000000..c879294
--- /dev/null
+++ b/ps/stepA_mal.ps
@@ -0,0 +1,298 @@
+/runlibfile where { pop }{ /runlibfile { run } def } ifelse % 
+(types.ps) runlibfile
+(reader.ps) runlibfile
+(printer.ps) runlibfile
+(env.ps) runlibfile
+(core.ps) runlibfile
+
+% read
+/_readline { print flush (%stdin) (r) file 99 string readline } def
+
+/READ {
+    /str exch def
+    str read_str
+} def
+
+
+% eval
+% is_pair?: ast -> is_pair? -> bool
+% return true if non-empty list, otherwise false
+/is_pair? { 
+    dup _sequential? { _count 0 gt }{ pop false } ifelse
+} def
+
+% ast -> quasiquote -> new_ast
+/quasiquote { 3 dict begin
+    /ast exch def
+    ast is_pair? not { %if not is_pair?
+        /quote ast 2 _list
+    }{ 
+        /a0 ast 0 _nth def
+        a0 /unquote eq { %if a0 unquote symbol
+            ast 1 _nth
+        }{ a0 is_pair? { %elseif a0 is_pair?
+            /a00 a0 0 _nth def
+            a00 /splice-unquote eq { %if splice-unquote
+                /concat a0 1 _nth ast _rest quasiquote 3 _list
+            }{ %else not splice-unquote
+                /cons a0 quasiquote ast _rest quasiquote 3 _list
+            } ifelse
+        }{ % else not a0 is_pair?
+            /cons a0 quasiquote ast _rest quasiquote 3 _list
+        } ifelse } ifelse
+    } ifelse
+end } def
+
+/is_macro_call? { 3 dict begin
+    /env exch def
+    /ast exch def
+    ast _list? {
+        /a0 ast 0 _nth def
+        a0 _symbol? { %if a0 is symbol
+            env a0 env_find null ne { %if a0 is in env
+                env a0 env_get _mal_function? { %if user defined function
+                    env a0 env_get /macro? get true eq %if marked as macro
+                }{ false } ifelse
+            }{ false } ifelse
+        }{ false } ifelse
+    }{ false } ifelse
+end } def
+
+/macroexpand { 3 dict begin
+    /env exch def
+    /ast exch def
+    {
+        ast env is_macro_call? {
+            /mac env   ast 0 _nth   env_get def
+            /ast ast _rest mac fload EVAL def
+        }{
+            exit
+        } ifelse
+    } loop 
+    ast
+end } def
+
+/eval_ast { 2 dict begin
+    /env exch def
+    /ast exch def
+    %(eval_ast: ) print ast ==
+    ast _symbol? { %if symbol
+        env ast env_get
+    }{ ast _sequential? { %elseif list or vector
+        [
+            ast /data get { %forall items
+                env EVAL
+            } forall
+        ] ast _list? { _list_from_array }{ _vector_from_array } ifelse
+    }{ ast _hash_map? { %elseif list or vector
+        <<
+            ast /data get { %forall entries
+                env EVAL
+            } forall
+        >> _hash_map_from_dict
+    }{ % else
+        ast
+    } ifelse } ifelse } ifelse
+end } def
+
+/EVAL { 13 dict begin
+    { %loop (TCO) 
+
+    /env exch def
+    /ast exch def
+    /loop? false def
+
+    %(EVAL: ) print ast true _pr_str print (\n) print
+    ast _list? not { %if not a list
+        ast env eval_ast
+    }{ %else apply the list
+      /ast ast env macroexpand def
+      ast _list? not { %if no longer a list
+          ast
+      }{ %else still a list
+        /a0 ast 0 _nth def
+        /def! a0 eq { %if def!
+            /a1 ast 1 _nth def
+            /a2 ast 2 _nth def
+            env a1  a2 env EVAL  env_set
+        }{ /let* a0 eq { %if let*
+            /a1 ast 1 _nth def
+            /a2 ast 2 _nth def
+            /let_env env null null env_new def
+            0 2 a1 _count 1 sub { %for each pair
+                /idx exch def
+                let_env
+                    a1 idx _nth
+                    a1 idx 1 add _nth let_env EVAL
+                    env_set
+                    pop % discard the return value
+            } for
+            a2
+            let_env
+            /loop? true def % loop
+        }{ /quote a0 eq { %if quote
+            ast 1 _nth
+        }{ /quasiquote a0 eq { %if quasiquote
+            ast 1 _nth quasiquote
+            env
+            /loop? true def % loop
+        }{ /defmacro! a0 eq { %if defmacro!
+            /a1 ast 1 _nth def
+            /a2 ast 2 _nth def
+            a2 env EVAL
+            dup /macro? true put % set macro flag
+            env exch a1 exch env_set % def! it
+        }{ /macroexpand a0 eq { %if defmacro!
+            ast 1 _nth env macroexpand
+        }{ /ps* a0 eq { %if ps*
+            count /stackcnt exch def
+            ast 1 _nth
+            {
+                token not { exit } if
+                exch
+                count stackcnt sub 1 roll % send leftover string to bottom
+                exec
+                count stackcnt sub -1 roll % bring leftover string to top
+            } loop
+            count stackcnt gt { % if new operands on stack
+                % return an list of new operands
+                count stackcnt sub array astore
+            }{
+                null % return nil
+            } ifelse
+        }{ /do a0 eq { %if do
+            ast _count 2 gt { %if ast has more than 2 elements
+                ast 1 ast _count 2 sub _slice env eval_ast pop
+            } if
+            ast ast _count 1 sub _nth % last ast becomes new ast
+            env
+            /loop? true def % loop
+        }{ /try* a0 eq { %if try*
+            { %try
+                countdictstack /dictcnt exch def
+                count /stackcnt exch def
+                ast 1 _nth env EVAL
+            } stopped { %catch
+                % clean up the dictionary stack
+                1 1 countdictstack dictcnt sub { %foreach added dict
+                    %(popping dict\n) print
+                    pop end % pop idx and pop dict
+                    %(new ast: ) print ast true _pr_str print (\n) print
+                } for
+                % clean up the operand stack
+                count 1 exch 1 exch stackcnt sub { %foreach added operand
+                    %(op stack: ) print pstack
+                    pop pop % pop idx and operand
+                    %(popped op stack\n) print pstack
+                } for
+                % get error data and reset $error dict
+                /errdata get_error_data def
+                $error /newerror false put
+                $error /errorinfo null put
+
+                ast _count 3 lt { %if no third (catch*) form
+                    errdata throw
+                } if
+                ast 2 _nth 0 _nth (catch*) eq not { %if third form not catch*
+                    (No catch* in throw form) _throw
+                } if
+                ast 2 _nth 2 _nth
+                env
+                    ast 2 _nth 1 _nth 1 _list
+                    errdata 1 _list
+                    env_new
+                EVAL
+            } if
+        }{ /if a0 eq { %if if
+            /a1 ast 1 _nth def
+            /cond a1 env EVAL def
+            cond null eq cond false eq or { % if cond is nil or false
+                ast _count 3 gt { %if false branch with a3
+                    ast 3 _nth env
+                    /loop? true def
+                }{ % else false branch with no a3
+                    null
+                } ifelse
+            }{ % true branch
+                ast 2 _nth env
+                /loop? true def
+            } ifelse
+        }{ /fn* a0 eq { %if fn*
+            /a1 ast 1 _nth def
+            /a2 ast 2 _nth def
+            a2 env a1 _mal_function
+        }{
+            /el ast env eval_ast def
+            el _rest el _first % stack: ast function
+            dup _mal_function? { %if user defined function
+                fload % stack: ast new_env
+                /loop? true def
+            }{ dup _function? { %else if builtin function
+                /data get exec
+            }{ %else (regular procedure/function)
+                (cannot apply native proc!\n) print quit
+            } ifelse } ifelse
+        } ifelse } ifelse } ifelse } ifelse } ifelse } ifelse } ifelse } ifelse } ifelse } ifelse } ifelse
+      } ifelse
+    } ifelse
+
+    loop? not { exit } if
+    } loop % TCO
+end } def
+
+
+% print
+/PRINT {
+    true _pr_str
+} def
+
+
+% repl
+/repl_env null null null env_new def
+
+/RE { READ repl_env EVAL } def
+/REP { READ repl_env EVAL PRINT } def
+
+% core.ps: defined using postscript
+/_ref { repl_env 3 1 roll env_set pop } def
+core_ns { _function _ref } forall
+(eval) { 0 _nth repl_env EVAL } _function _ref
+(*ARGV*) [ ] _list_from_array _ref
+
+% core.mal: defined using the language itself
+(\(def! *host-language* "postscript"\)) RE pop
+(\(def! not \(fn* \(a\) \(if a false true\)\)\)) RE pop
+(\(def! load-file \(fn* \(f\) \(eval \(read-string \(str "\(do " \(slurp f\) "\)"\)\)\)\)\)) RE pop
+(\(defmacro! cond \(fn* \(& xs\) \(if \(> \(count xs\) 0\) \(list 'if \(first xs\) \(if \(> \(count xs\) 1\) \(nth xs 1\) \(throw "odd number of forms to cond"\)\) \(cons 'cond \(rest \(rest xs\)\)\)\)\)\)\)) RE pop
+(\(defmacro! or \(fn* \(& xs\) \(if \(empty? xs\) nil \(if \(= 1 \(count xs\)\) \(first xs\) `\(let* \(or_FIXME ~\(first xs\)\) \(if or_FIXME or_FIXME \(or ~@\(rest xs\)\)\)\)\)\)\)\)) RE pop
+
+userdict /ARGUMENTS known { %if command line arguments
+    ARGUMENTS length 0 gt { %if more than 0 arguments
+        (*ARGV*) ARGUMENTS 1 ARGUMENTS length 1 sub getinterval
+        _list_from_array _ref
+        ARGUMENTS 0 get 
+        (\(load-file ") exch ("\)) concatenate concatenate RE pop
+        quit
+    } if
+} if
+
+% repl loop
+(\(println \(str "Mal [" *host-language* "]"\)\)) RE pop
+{ %loop
+    (user> ) _readline
+    not { exit } if  % exit if EOF
+
+    { %try
+        REP print (\n) print
+    } stopped {
+        (Error: ) print
+        get_error_data false _pr_str print (\n) print
+        $error /newerror false put
+        $error /errorinfo null put
+        clear
+        cleardictstack
+    } if
+} bind loop
+
+(\n) print  % final newline before exit for cleanliness
+quit
diff --git a/ps/tests/stepA_mal.mal b/ps/tests/stepA_mal.mal
new file mode 100644
index 0000000..fffa178
--- /dev/null
+++ b/ps/tests/stepA_mal.mal
@@ -0,0 +1,23 @@
+;; Testing basic ps interop
+
+(ps* "7")
+;=>(7)
+
+(ps* "(7)")
+;=>("7")
+
+(ps* "7 8 9 3 array astore")
+;=>((7 8 9))
+
+(ps* "1 1 eq")
+;=>(true)
+
+(ps* "/sym")
+;=>sym
+
+(ps* "1 1 eq { (yep) }{ (nope) } ifelse")
+;=>("yep")
+
+(ps* "1 0 eq { (yep) }{ (nope) } ifelse")
+;=>("nope")
+
diff --git a/python/Makefile b/python/Makefile
index 6e51430..7842eae 100644
--- a/python/Makefile
+++ b/python/Makefile
@@ -3,7 +3,7 @@ TESTS =
 
 
 SOURCES_BASE = mal_readline.py mal_types.py reader.py printer.py
-SOURCES_LISP = env.py core.py stepA_interop.py
+SOURCES_LISP = env.py core.py stepA_mal.py
 SOURCES = $(SOURCES_BASE) $(SOURCES_LISP)
 
 
diff --git a/python/stepA_interop.py b/python/stepA_interop.py
deleted file mode 100644
index 93cdb2e..0000000
--- a/python/stepA_interop.py
+++ /dev/null
@@ -1,177 +0,0 @@
-import sys, traceback
-import mal_readline
-import mal_types as types
-import reader, printer
-from env import Env
-import core
-
-# read
-def READ(str):
-    return reader.read_str(str)
-
-# eval
-def is_pair(x):
-    return types._sequential_Q(x) and len(x) > 0
-
-def quasiquote(ast):
-    if not is_pair(ast):
-        return types._list(types._symbol("quote"),
-                           ast)
-    elif ast[0] == 'unquote':
-        return ast[1]
-    elif is_pair(ast[0]) and ast[0][0] == 'splice-unquote':
-        return types._list(types._symbol("concat"),
-                           ast[0][1],
-                           quasiquote(ast[1:]))
-    else:
-        return types._list(types._symbol("cons"),
-                           quasiquote(ast[0]),
-                           quasiquote(ast[1:]))
-
-def is_macro_call(ast, env):
-    return (types._list_Q(ast) and
-            types._symbol_Q(ast[0]) and
-            env.find(ast[0]) and
-            hasattr(env.get(ast[0]), '_ismacro_'))
-
-def macroexpand(ast, env):
-    while is_macro_call(ast, env):
-        mac = env.get(ast[0])
-        ast = macroexpand(mac(*ast[1:]), env)
-    return ast
-
-def eval_ast(ast, env):
-    if types._symbol_Q(ast):
-        return env.get(ast)
-    elif types._list_Q(ast):
-        return types._list(*map(lambda a: EVAL(a, env), ast))
-    elif types._vector_Q(ast):
-        return types._vector(*map(lambda a: EVAL(a, env), ast))
-    elif types._hash_map_Q(ast):
-        keyvals = []
-        for k in ast.keys():
-            keyvals.append(EVAL(k, env))
-            keyvals.append(EVAL(ast[k], env))
-        return types._hash_map(*keyvals)
-    else:
-        return ast  # primitive value, return unchanged
-
-def EVAL(ast, env):
-    while True:
-        #print("EVAL %s" % printer._pr_str(ast))
-        if not types._list_Q(ast):
-            return eval_ast(ast, env)
-
-        # apply list
-        ast = macroexpand(ast, env)
-        if not types._list_Q(ast): return ast
-        if len(ast) == 0: return ast
-        a0 = ast[0]
-
-        if "def!" == a0:
-            a1, a2 = ast[1], ast[2]
-            res = EVAL(a2, env)
-            return env.set(a1, res)
-        elif "let*" == a0:
-            a1, a2 = ast[1], ast[2]
-            let_env = Env(env)
-            for i in range(0, len(a1), 2):
-                let_env.set(a1[i], EVAL(a1[i+1], let_env))
-            ast = a2
-            env = let_env
-            # Continue loop (TCO)
-        elif "quote" == a0:
-            return ast[1]
-        elif "quasiquote" == a0:
-            ast = quasiquote(ast[1]);
-            # Continue loop (TCO)
-        elif 'defmacro!' == a0:
-            func = EVAL(ast[2], env)
-            func._ismacro_ = True
-            return env.set(ast[1], func)
-        elif 'macroexpand' == a0:
-            return macroexpand(ast[1], env)
-        elif "py!*" == a0:
-            if sys.version_info[0] >= 3:
-                exec(compile(ast[1], '', 'single'), globals())
-            else:
-                exec(compile(ast[1], '', 'single') in globals())
-            return None
-        elif "py*" == a0:
-            return eval(ast[1])
-        elif "." == a0:
-            el = eval_ast(ast[2:], env)
-            f = eval(ast[1])
-            return f(*el)
-        elif "try*" == a0:
-            a1, a2 = ast[1], ast[2]
-            if a2[0] == "catch*":
-                try:
-                    return EVAL(a1, env);
-                except Exception as exc:
-                    exc = exc.args[0]
-                    catch_env = Env(env, [a2[1]], [exc])
-                    return EVAL(a2[2], catch_env)
-            else:
-                return EVAL(a1, env);
-        elif "do" == a0:
-            eval_ast(ast[1:-1], env)
-            ast = ast[-1]
-            # Continue loop (TCO)
-        elif "if" == a0:
-            a1, a2 = ast[1], ast[2]
-            cond = EVAL(a1, env)
-            if cond is None or cond is False:
-                if len(ast) > 3: ast = ast[3]
-                else:            ast = None
-            else:
-                ast = a2
-            # Continue loop (TCO)
-        elif "fn*" == a0:
-            a1, a2 = ast[1], ast[2]
-            return types._function(EVAL, Env, a2, env, a1)
-        else:
-            el = eval_ast(ast, env)
-            f = el[0]
-            if hasattr(f, '__ast__'):
-                ast = f.__ast__
-                env = f.__gen_env__(el[1:])
-            else:
-                return f(*el[1:])
-
-# print
-def PRINT(exp):
-    return printer._pr_str(exp)
-
-# repl
-repl_env = Env()
-def REP(str):
-    return PRINT(EVAL(READ(str), repl_env))
-
-# core.py: defined using python
-for k, v in core.ns.items(): repl_env.set(types._symbol(k), v)
-repl_env.set(types._symbol('eval'), lambda ast: EVAL(ast, repl_env))
-repl_env.set(types._symbol('*ARGV*'), types._list(*sys.argv[2:]))
-
-# core.mal: defined using the language itself
-REP("(def! *host-language* \"python\")")
-REP("(def! not (fn* (a) (if a false true)))")
-REP("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))")
-REP("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))")
-REP("(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))")
-
-if len(sys.argv) >= 2:
-    REP('(load-file "' + sys.argv[1] + '")')
-    sys.exit(0)
-
-# repl loop
-REP("(println (str \"Mal [\" *host-language* \"]\"))")
-while True:
-    try:
-        line = mal_readline.readline("user> ")
-        if line == None: break
-        if line == "": continue
-        print(REP(line))
-    except reader.Blank: continue
-    except Exception as e:
-        print("".join(traceback.format_exception(*sys.exc_info())))
diff --git a/python/stepA_mal.py b/python/stepA_mal.py
new file mode 100644
index 0000000..93cdb2e
--- /dev/null
+++ b/python/stepA_mal.py
@@ -0,0 +1,177 @@
+import sys, traceback
+import mal_readline
+import mal_types as types
+import reader, printer
+from env import Env
+import core
+
+# read
+def READ(str):
+    return reader.read_str(str)
+
+# eval
+def is_pair(x):
+    return types._sequential_Q(x) and len(x) > 0
+
+def quasiquote(ast):
+    if not is_pair(ast):
+        return types._list(types._symbol("quote"),
+                           ast)
+    elif ast[0] == 'unquote':
+        return ast[1]
+    elif is_pair(ast[0]) and ast[0][0] == 'splice-unquote':
+        return types._list(types._symbol("concat"),
+                           ast[0][1],
+                           quasiquote(ast[1:]))
+    else:
+        return types._list(types._symbol("cons"),
+                           quasiquote(ast[0]),
+                           quasiquote(ast[1:]))
+
+def is_macro_call(ast, env):
+    return (types._list_Q(ast) and
+            types._symbol_Q(ast[0]) and
+            env.find(ast[0]) and
+            hasattr(env.get(ast[0]), '_ismacro_'))
+
+def macroexpand(ast, env):
+    while is_macro_call(ast, env):
+        mac = env.get(ast[0])
+        ast = macroexpand(mac(*ast[1:]), env)
+    return ast
+
+def eval_ast(ast, env):
+    if types._symbol_Q(ast):
+        return env.get(ast)
+    elif types._list_Q(ast):
+        return types._list(*map(lambda a: EVAL(a, env), ast))
+    elif types._vector_Q(ast):
+        return types._vector(*map(lambda a: EVAL(a, env), ast))
+    elif types._hash_map_Q(ast):
+        keyvals = []
+        for k in ast.keys():
+            keyvals.append(EVAL(k, env))
+            keyvals.append(EVAL(ast[k], env))
+        return types._hash_map(*keyvals)
+    else:
+        return ast  # primitive value, return unchanged
+
+def EVAL(ast, env):
+    while True:
+        #print("EVAL %s" % printer._pr_str(ast))
+        if not types._list_Q(ast):
+            return eval_ast(ast, env)
+
+        # apply list
+        ast = macroexpand(ast, env)
+        if not types._list_Q(ast): return ast
+        if len(ast) == 0: return ast
+        a0 = ast[0]
+
+        if "def!" == a0:
+            a1, a2 = ast[1], ast[2]
+            res = EVAL(a2, env)
+            return env.set(a1, res)
+        elif "let*" == a0:
+            a1, a2 = ast[1], ast[2]
+            let_env = Env(env)
+            for i in range(0, len(a1), 2):
+                let_env.set(a1[i], EVAL(a1[i+1], let_env))
+            ast = a2
+            env = let_env
+            # Continue loop (TCO)
+        elif "quote" == a0:
+            return ast[1]
+        elif "quasiquote" == a0:
+            ast = quasiquote(ast[1]);
+            # Continue loop (TCO)
+        elif 'defmacro!' == a0:
+            func = EVAL(ast[2], env)
+            func._ismacro_ = True
+            return env.set(ast[1], func)
+        elif 'macroexpand' == a0:
+            return macroexpand(ast[1], env)
+        elif "py!*" == a0:
+            if sys.version_info[0] >= 3:
+                exec(compile(ast[1], '', 'single'), globals())
+            else:
+                exec(compile(ast[1], '', 'single') in globals())
+            return None
+        elif "py*" == a0:
+            return eval(ast[1])
+        elif "." == a0:
+            el = eval_ast(ast[2:], env)
+            f = eval(ast[1])
+            return f(*el)
+        elif "try*" == a0:
+            a1, a2 = ast[1], ast[2]
+            if a2[0] == "catch*":
+                try:
+                    return EVAL(a1, env);
+                except Exception as exc:
+                    exc = exc.args[0]
+                    catch_env = Env(env, [a2[1]], [exc])
+                    return EVAL(a2[2], catch_env)
+            else:
+                return EVAL(a1, env);
+        elif "do" == a0:
+            eval_ast(ast[1:-1], env)
+            ast = ast[-1]
+            # Continue loop (TCO)
+        elif "if" == a0:
+            a1, a2 = ast[1], ast[2]
+            cond = EVAL(a1, env)
+            if cond is None or cond is False:
+                if len(ast) > 3: ast = ast[3]
+                else:            ast = None
+            else:
+                ast = a2
+            # Continue loop (TCO)
+        elif "fn*" == a0:
+            a1, a2 = ast[1], ast[2]
+            return types._function(EVAL, Env, a2, env, a1)
+        else:
+            el = eval_ast(ast, env)
+            f = el[0]
+            if hasattr(f, '__ast__'):
+                ast = f.__ast__
+                env = f.__gen_env__(el[1:])
+            else:
+                return f(*el[1:])
+
+# print
+def PRINT(exp):
+    return printer._pr_str(exp)
+
+# repl
+repl_env = Env()
+def REP(str):
+    return PRINT(EVAL(READ(str), repl_env))
+
+# core.py: defined using python
+for k, v in core.ns.items(): repl_env.set(types._symbol(k), v)
+repl_env.set(types._symbol('eval'), lambda ast: EVAL(ast, repl_env))
+repl_env.set(types._symbol('*ARGV*'), types._list(*sys.argv[2:]))
+
+# core.mal: defined using the language itself
+REP("(def! *host-language* \"python\")")
+REP("(def! not (fn* (a) (if a false true)))")
+REP("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))")
+REP("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))")
+REP("(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))")
+
+if len(sys.argv) >= 2:
+    REP('(load-file "' + sys.argv[1] + '")')
+    sys.exit(0)
+
+# repl loop
+REP("(println (str \"Mal [\" *host-language* \"]\"))")
+while True:
+    try:
+        line = mal_readline.readline("user> ")
+        if line == None: break
+        if line == "": continue
+        print(REP(line))
+    except reader.Blank: continue
+    except Exception as e:
+        print("".join(traceback.format_exception(*sys.exc_info())))
diff --git a/r/Makefile b/r/Makefile
index 9d1a35d..4d1ec24 100644
--- a/r/Makefile
+++ b/r/Makefile
@@ -1,7 +1,7 @@
 TESTS =
 
 SOURCES_BASE = readline.r types.r reader.r printer.r
-SOURCES_LISP = env.r core.r stepA_interop.r
+SOURCES_LISP = env.r core.r stepA_mal.r
 SOURCES = $(SOURCES_BASE) $(SOURCES_LISP)
 
 all: libs
diff --git a/r/stepA_interop.r b/r/stepA_interop.r
deleted file mode 100644
index e699048..0000000
--- a/r/stepA_interop.r
+++ /dev/null
@@ -1,198 +0,0 @@
-if(!exists("..readline..")) source("readline.r")
-if(!exists("..types..")) source("types.r")
-if(!exists("..reader..")) source("reader.r")
-if(!exists("..printer..")) source("printer.r")
-if(!exists("..env..")) source("env.r")
-if(!exists("..core..")) source("core.r")
-
-# read
-READ <- function(str) {
-    return(read_str(str))
-}
-
-# eval
-is_pair <- function(x) {
-    .sequential_q(x) && length(x) > 0
-}
-
-quasiquote <- function(ast) {
-    if (!is_pair(ast)) {
-        new.list(new.symbol("quote"),
-                 ast)
-    } else if (.symbol_q(ast[[1]]) && ast[[1]] == "unquote") {
-        ast[[2]]
-    } else if (is_pair(ast[[1]]) &&
-               .symbol_q(ast[[1]][[1]]) &&
-               ast[[1]][[1]] == "splice-unquote") {
-        new.list(new.symbol("concat"),
-                 ast[[1]][[2]],
-                 quasiquote(slice(ast, 2)))
-    } else {
-        new.list(new.symbol("cons"),
-                 quasiquote(ast[[1]]),
-                 quasiquote(slice(ast, 2)))
-    }
-}
-
-is_macro_call <- function(ast, env) {
-    if(.list_q(ast) &&
-      .symbol_q(ast[[1]]) &&
-      (!.nil_q(Env.find(env, ast[[1]])))) {
-        exp <- Env.get(env, ast[[1]])
-        return(.malfunc_q(exp) && exp$ismacro)
-    }
-    FALSE
-}
-
-macroexpand <- function(ast, env) {
-    while(is_macro_call(ast, env)) {
-        mac <- Env.get(env, ast[[1]])
-        ast <- fapply(mac, slice(ast, 2))
-    }
-    ast
-}
-
-eval_ast <- function(ast, env) {
-    if (.symbol_q(ast)) {
-        Env.get(env, ast)
-    } else if (.list_q(ast)) {
-        new.listl(lapply(ast, function(a) EVAL(a, env)))
-    } else if (.vector_q(ast)) {
-        new.vectorl(lapply(ast, function(a) EVAL(a, env)))
-    } else if (.hash_map_q(ast)) {
-        lst <- list()
-        for(k in ls(ast)) {
-            lst[[length(lst)+1]] = k
-            lst[[length(lst)+1]] = EVAL(ast[[k]], env)
-        }
-        new.hash_mapl(lst)
-    } else {
-        ast
-    }
-}
-
-EVAL <- function(ast, env) {
-    repeat {
-
-    #cat("EVAL: ", .pr_str(ast,TRUE), "\n", sep="")
-    if (!.list_q(ast)) {
-        return(eval_ast(ast, env))
-    }
-
-    # apply list
-    ast <- macroexpand(ast, env)
-    if (!.list_q(ast)) return(ast)
-
-    switch(paste("l",length(ast),sep=""),
-           l0={ return(ast) },
-           l1={ a0 <- ast[[1]]; a1 <- NULL;     a2 <- NULL },
-           l2={ a0 <- ast[[1]]; a1 <- ast[[2]]; a2 <- NULL },
-              { a0 <- ast[[1]]; a1 <- ast[[2]]; a2 <- ast[[3]] })
-    if (length(a0) > 1) a0sym <- "__<*fn*>__"
-    else                a0sym <- as.character(a0)
-    if (a0sym == "def!") {
-        res <- EVAL(a2, env)
-        return(Env.set(env, a1, res))
-    } else if (a0sym == "let*") {
-        let_env <- new.Env(env)
-        for(i in seq(1,length(a1),2)) {
-            Env.set(let_env, a1[[i]], EVAL(a1[[i+1]], let_env))
-        }
-        ast <- a2
-        env <- let_env
-    } else if (a0sym == "quote") {
-        return(a1)
-    } else if (a0sym == "quasiquote") {
-        ast <- quasiquote(a1)
-    } else if (a0sym == "defmacro!") {
-        func <- EVAL(a2, env)
-        func$ismacro = TRUE
-        return(Env.set(env, a1, func))
-    } else if (a0sym == "macroexpand") {
-        return(macroexpand(a1, env))
-    } else if (a0sym == "try*") {
-        edata <- new.env()
-        tryCatch({
-            return(EVAL(a1, env))
-        }, error=function(err) {
-            edata$exc <- get_error(err)
-        })
-        if ((!is.null(a2)) && a2[[1]] == "catch*") {
-            return(EVAL(a2[[3]], new.Env(env,
-                                         new.list(a2[[2]]),
-                                         new.list(edata$exc))))
-        } else {
-            throw(err)
-        }
-    } else if (a0sym == "do") {
-        eval_ast(slice(ast,2,length(ast)-1), env)
-        ast <- ast[[length(ast)]]
-    } else if (a0sym == "if") {
-        cond <- EVAL(a1, env)
-        if (.nil_q(cond) || identical(cond, FALSE)) {
-            if (length(ast) < 4) return(nil)
-            ast <- ast[[4]]
-        } else {
-            ast <- a2
-        }
-    } else if (a0sym == "fn*") {
-        return(malfunc(EVAL, a2, env, a1))
-    } else {
-        el <- eval_ast(ast, env)
-        f <- el[[1]]
-        if (class(f) == "MalFunc") {
-            ast <- f$ast
-            env <- f$gen_env(slice(el,2))
-        } else {
-            return(do.call(f,slice(el,2)))
-        }
-    }
-
-    }
-}
-
-# print
-PRINT <- function(exp) {
-    return(.pr_str(exp, TRUE))
-}
-
-# repl loop
-repl_env <- new.Env()
-rep <- function(str) return(PRINT(EVAL(READ(str), repl_env)))
-
-# core.r: defined using R
-for(k in names(core_ns)) { Env.set(repl_env, k, core_ns[[k]]) }
-Env.set(repl_env, "eval", function(ast) EVAL(ast, repl_env))
-Env.set(repl_env, "*ARGV*", new.list())
-
-# core.mal: defined using the language itself
-. <- rep("(def! *host-language* \"R\")")
-. <- rep("(def! not (fn* (a) (if a false true)))")
-. <- rep("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))")
-. <- rep("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))")
-. <- rep("(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))")
-
-
-args <- commandArgs(trailingOnly = TRUE)
-if (length(args) > 0) {
-    Env.set(repl_env, "*ARGV*", new.listl(slice(list(args),2)))
-    tryCatch({
-        . <- rep(concat("(load-file \"", args[[1]], "\")"))
-    }, error=function(err) {
-        cat("Error: ", get_error(err),"\n", sep="")
-    })
-    quit(save="no", status=0)
-}
-
-. <- rep("(println (str \"Mal [\" *host-language* \"]\"))")
-repeat {
-    line <- readline("user> ")
-    if (is.null(line)) { cat("\n"); break }
-    tryCatch({
-        cat(rep(line),"\n", sep="")
-    }, error=function(err) {
-        cat("Error: ", get_error(err),"\n", sep="")
-    })
-    # R debug/fatal with tracebacks:
-    #cat(rep(line),"\n", sep="")
-}
diff --git a/r/stepA_mal.r b/r/stepA_mal.r
new file mode 100644
index 0000000..e699048
--- /dev/null
+++ b/r/stepA_mal.r
@@ -0,0 +1,198 @@
+if(!exists("..readline..")) source("readline.r")
+if(!exists("..types..")) source("types.r")
+if(!exists("..reader..")) source("reader.r")
+if(!exists("..printer..")) source("printer.r")
+if(!exists("..env..")) source("env.r")
+if(!exists("..core..")) source("core.r")
+
+# read
+READ <- function(str) {
+    return(read_str(str))
+}
+
+# eval
+is_pair <- function(x) {
+    .sequential_q(x) && length(x) > 0
+}
+
+quasiquote <- function(ast) {
+    if (!is_pair(ast)) {
+        new.list(new.symbol("quote"),
+                 ast)
+    } else if (.symbol_q(ast[[1]]) && ast[[1]] == "unquote") {
+        ast[[2]]
+    } else if (is_pair(ast[[1]]) &&
+               .symbol_q(ast[[1]][[1]]) &&
+               ast[[1]][[1]] == "splice-unquote") {
+        new.list(new.symbol("concat"),
+                 ast[[1]][[2]],
+                 quasiquote(slice(ast, 2)))
+    } else {
+        new.list(new.symbol("cons"),
+                 quasiquote(ast[[1]]),
+                 quasiquote(slice(ast, 2)))
+    }
+}
+
+is_macro_call <- function(ast, env) {
+    if(.list_q(ast) &&
+      .symbol_q(ast[[1]]) &&
+      (!.nil_q(Env.find(env, ast[[1]])))) {
+        exp <- Env.get(env, ast[[1]])
+        return(.malfunc_q(exp) && exp$ismacro)
+    }
+    FALSE
+}
+
+macroexpand <- function(ast, env) {
+    while(is_macro_call(ast, env)) {
+        mac <- Env.get(env, ast[[1]])
+        ast <- fapply(mac, slice(ast, 2))
+    }
+    ast
+}
+
+eval_ast <- function(ast, env) {
+    if (.symbol_q(ast)) {
+        Env.get(env, ast)
+    } else if (.list_q(ast)) {
+        new.listl(lapply(ast, function(a) EVAL(a, env)))
+    } else if (.vector_q(ast)) {
+        new.vectorl(lapply(ast, function(a) EVAL(a, env)))
+    } else if (.hash_map_q(ast)) {
+        lst <- list()
+        for(k in ls(ast)) {
+            lst[[length(lst)+1]] = k
+            lst[[length(lst)+1]] = EVAL(ast[[k]], env)
+        }
+        new.hash_mapl(lst)
+    } else {
+        ast
+    }
+}
+
+EVAL <- function(ast, env) {
+    repeat {
+
+    #cat("EVAL: ", .pr_str(ast,TRUE), "\n", sep="")
+    if (!.list_q(ast)) {
+        return(eval_ast(ast, env))
+    }
+
+    # apply list
+    ast <- macroexpand(ast, env)
+    if (!.list_q(ast)) return(ast)
+
+    switch(paste("l",length(ast),sep=""),
+           l0={ return(ast) },
+           l1={ a0 <- ast[[1]]; a1 <- NULL;     a2 <- NULL },
+           l2={ a0 <- ast[[1]]; a1 <- ast[[2]]; a2 <- NULL },
+              { a0 <- ast[[1]]; a1 <- ast[[2]]; a2 <- ast[[3]] })
+    if (length(a0) > 1) a0sym <- "__<*fn*>__"
+    else                a0sym <- as.character(a0)
+    if (a0sym == "def!") {
+        res <- EVAL(a2, env)
+        return(Env.set(env, a1, res))
+    } else if (a0sym == "let*") {
+        let_env <- new.Env(env)
+        for(i in seq(1,length(a1),2)) {
+            Env.set(let_env, a1[[i]], EVAL(a1[[i+1]], let_env))
+        }
+        ast <- a2
+        env <- let_env
+    } else if (a0sym == "quote") {
+        return(a1)
+    } else if (a0sym == "quasiquote") {
+        ast <- quasiquote(a1)
+    } else if (a0sym == "defmacro!") {
+        func <- EVAL(a2, env)
+        func$ismacro = TRUE
+        return(Env.set(env, a1, func))
+    } else if (a0sym == "macroexpand") {
+        return(macroexpand(a1, env))
+    } else if (a0sym == "try*") {
+        edata <- new.env()
+        tryCatch({
+            return(EVAL(a1, env))
+        }, error=function(err) {
+            edata$exc <- get_error(err)
+        })
+        if ((!is.null(a2)) && a2[[1]] == "catch*") {
+            return(EVAL(a2[[3]], new.Env(env,
+                                         new.list(a2[[2]]),
+                                         new.list(edata$exc))))
+        } else {
+            throw(err)
+        }
+    } else if (a0sym == "do") {
+        eval_ast(slice(ast,2,length(ast)-1), env)
+        ast <- ast[[length(ast)]]
+    } else if (a0sym == "if") {
+        cond <- EVAL(a1, env)
+        if (.nil_q(cond) || identical(cond, FALSE)) {
+            if (length(ast) < 4) return(nil)
+            ast <- ast[[4]]
+        } else {
+            ast <- a2
+        }
+    } else if (a0sym == "fn*") {
+        return(malfunc(EVAL, a2, env, a1))
+    } else {
+        el <- eval_ast(ast, env)
+        f <- el[[1]]
+        if (class(f) == "MalFunc") {
+            ast <- f$ast
+            env <- f$gen_env(slice(el,2))
+        } else {
+            return(do.call(f,slice(el,2)))
+        }
+    }
+
+    }
+}
+
+# print
+PRINT <- function(exp) {
+    return(.pr_str(exp, TRUE))
+}
+
+# repl loop
+repl_env <- new.Env()
+rep <- function(str) return(PRINT(EVAL(READ(str), repl_env)))
+
+# core.r: defined using R
+for(k in names(core_ns)) { Env.set(repl_env, k, core_ns[[k]]) }
+Env.set(repl_env, "eval", function(ast) EVAL(ast, repl_env))
+Env.set(repl_env, "*ARGV*", new.list())
+
+# core.mal: defined using the language itself
+. <- rep("(def! *host-language* \"R\")")
+. <- rep("(def! not (fn* (a) (if a false true)))")
+. <- rep("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))")
+. <- rep("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))")
+. <- rep("(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))")
+
+
+args <- commandArgs(trailingOnly = TRUE)
+if (length(args) > 0) {
+    Env.set(repl_env, "*ARGV*", new.listl(slice(list(args),2)))
+    tryCatch({
+        . <- rep(concat("(load-file \"", args[[1]], "\")"))
+    }, error=function(err) {
+        cat("Error: ", get_error(err),"\n", sep="")
+    })
+    quit(save="no", status=0)
+}
+
+. <- rep("(println (str \"Mal [\" *host-language* \"]\"))")
+repeat {
+    line <- readline("user> ")
+    if (is.null(line)) { cat("\n"); break }
+    tryCatch({
+        cat(rep(line),"\n", sep="")
+    }, error=function(err) {
+        cat("Error: ", get_error(err),"\n", sep="")
+    })
+    # R debug/fatal with tracebacks:
+    #cat(rep(line),"\n", sep="")
+}
diff --git a/racket/Makefile b/racket/Makefile
index a472c2f..01cb12a 100644
--- a/racket/Makefile
+++ b/racket/Makefile
@@ -1,5 +1,5 @@
 SOURCES_BASE = types.rkt reader.rkt printer.rkt
-SOURCES_LISP = env.rkt core.rkt stepA_interop.rkt
+SOURCES_LISP = env.rkt core.rkt stepA_mal.rkt
 SOURCES = $(SOURCES_BASE) $(SOURCES_LISP)
 
 all:
diff --git a/racket/stepA_interop.rkt b/racket/stepA_interop.rkt
deleted file mode 100755
index 9b816cb..0000000
--- a/racket/stepA_interop.rkt
+++ /dev/null
@@ -1,163 +0,0 @@
-#!/usr/bin/env racket
-#lang racket
-
-(require "readline.rkt" "types.rkt" "reader.rkt" "printer.rkt"
-         "env.rkt" "core.rkt")
-
-;; read
-(define (READ str)
-  (read_str str))
-
-;; eval
-(define (is-pair x)
-  (and (_sequential? x) (> (_count x) 0)))
-
-(define (quasiquote ast)
-  (cond
-    [(not (is-pair ast))
-     (list 'quote ast)]
-
-    [(equal? 'unquote (_nth ast 0))
-     (_nth ast 1)]
-
-    [(and (is-pair (_nth ast 0))
-          (equal? 'splice-unquote (_nth (_nth ast 0) 0)))
-     (list 'concat (_nth (_nth ast 0) 1) (quasiquote (_rest ast)))]
-
-    [else
-     (list 'cons (quasiquote (_nth ast 0)) (quasiquote (_rest ast)))]))
-
-(define (macro? ast env)
-  (and (list? ast)
-       (symbol? (first ast))
-       (not (equal? null (send env find (first ast))))
-       (let ([fn (send env get (first ast))])
-         (and (malfunc? fn) (malfunc-macro? fn)))))
-
-(define (macroexpand ast env)
-  (if (macro? ast env)
-    (let ([mac (malfunc-fn (send env get (first ast)))])
-      (macroexpand (apply mac (rest ast)) env))
-    ast))
-
-(define (eval-ast ast env)
-  (cond
-    [(symbol? ast) (send env get ast)]
-    [(_sequential? ast) (_map (lambda (x) (EVAL x env)) ast)]
-    [(hash? ast) (make-hash
-                  (dict-map ast (lambda (k v) (cons k (EVAL v env)))))]
-    [else ast]))
-
-(define (EVAL ast env)
-  ;(printf "~a~n" (pr_str ast true))
-  (if (not (list? ast))
-    (eval-ast ast env)
-
-    (let ([ast (macroexpand ast env)])
-      (if (not (list? ast))
-        ast
-        (let ([a0 (_nth ast 0)])
-          (cond
-            [(eq? 'def! a0)
-             (send env set (_nth ast 1) (EVAL (_nth ast 2) env))]
-            [(eq? 'let* a0)
-             (let ([let-env (new Env% [outer env] [binds null] [exprs null])])
-               (_map (lambda (b_e)
-                       (send let-env set (_first b_e)
-                             (EVAL (_nth b_e 1) let-env)))
-                    (_partition 2 (_to_list (_nth ast 1))))
-               (EVAL (_nth ast 2) let-env))]
-            [(eq? 'quote a0)
-             (_nth ast 1)]
-            [(eq? 'quasiquote a0)
-             (EVAL (quasiquote (_nth ast 1)) env)]
-            [(eq? 'defmacro! a0)
-             (let* ([func (EVAL (_nth ast 2) env)]
-                    [mac (struct-copy malfunc func [macro? #t])])
-               (send env set (_nth ast 1) mac))]
-            [(eq? 'macroexpand a0)
-             (macroexpand (_nth ast 1) env)]
-            [(eq? 'try* a0)
-             (if (eq? 'catch* (_nth (_nth ast 2) 0))
-               (let ([efn (lambda (exc)
-                            (EVAL (_nth (_nth ast 2) 2)
-                                  (new Env%
-                                       [outer env]
-                                       [binds (list (_nth (_nth ast 2) 1))]
-                                       [exprs (list exc)])))])
-                 (with-handlers
-                   ([mal-exn?  (lambda (exc) (efn (mal-exn-val exc)))]
-                    [string?   (lambda (exc) (efn exc))]
-                    [exn:fail? (lambda (exc) (efn (format "~a" exc)))])
-                   (EVAL (_nth ast 1) env)))
-               (EVAL (_nth ast 1)))]
-            [(eq? 'do a0)
-             (eval-ast (drop (drop-right ast 1) 1) env)
-             (EVAL (last ast) env)]
-            [(eq? 'if a0)
-             (let ([cnd (EVAL (_nth ast 1) env)])
-               (if (or (eq? cnd nil) (eq? cnd #f))
-                 (if (> (length ast) 3)
-                   (EVAL (_nth ast 3) env)
-                   nil)
-                 (EVAL (_nth ast 2) env)))]
-            [(eq? 'fn* a0)
-             (malfunc
-               (lambda args (EVAL (_nth ast 2)
-                                  (new Env% [outer env]
-                                            [binds (_nth ast 1)]
-                                            [exprs args])))
-               (_nth ast 2) env (_nth ast 1) #f nil)]
-            [else (let* ([el (eval-ast ast env)]
-                         [f (first el)]
-                         [args (rest el)])
-                    (if (malfunc? f)
-                      (EVAL (malfunc-ast f)
-                            (new Env%
-                                 [outer (malfunc-env f)]
-                                 [binds (malfunc-params f)]
-                                 [exprs args]))
-                      (apply f args)))]))))))
-
-;; print
-(define (PRINT exp)
-  (pr_str exp true))
-
-;; repl
-(define repl-env
-  (new Env% [outer null] [binds null] [exprs null]))
-(define (rep str)
-  (PRINT (EVAL (READ str) repl-env)))
-
-(for ()  ;; ignore return values
-
-;; core.rkt: defined using Racket
-(hash-for-each core_ns (lambda (k v) (send repl-env set k v)))
-(send repl-env set 'eval (lambda [ast] (EVAL ast repl-env)))
-(send repl-env set '*ARGV* (list))
-
-;; core.mal: defined using the language itself
-(rep "(def! *host-language* \"racket\")")
-(rep "(def! not (fn* (a) (if a false true)))")
-(rep "(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))")
-(rep "(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))")
-(rep "(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))")
-
-)
-
-(define (repl-loop)
-  (let ([line (readline "user> ")])
-    (when (not (eq? nil line))
-      (with-handlers
-        ([string? (lambda (exc) (printf "Error: ~a~n" exc))]
-         [mal-exn? (lambda (exc) (printf "Error: ~a~n"
-                                         (pr_str (mal-exn-val exc) true)))]
-         [blank-exn? (lambda (exc) null)])
-        (printf "~a~n" (rep line)))
-      (repl-loop))))
-(let ([args (current-command-line-arguments)])
-  (if (> (vector-length args) 0)
-    (for () (rep (string-append "(load-file \"" (vector-ref args 0) "\")")))
-    (begin
-      (rep "(println (str \"Mal [\" *host-language* \"]\"))")
-      (repl-loop))))
diff --git a/racket/stepA_mal.rkt b/racket/stepA_mal.rkt
new file mode 100755
index 0000000..9b816cb
--- /dev/null
+++ b/racket/stepA_mal.rkt
@@ -0,0 +1,163 @@
+#!/usr/bin/env racket
+#lang racket
+
+(require "readline.rkt" "types.rkt" "reader.rkt" "printer.rkt"
+         "env.rkt" "core.rkt")
+
+;; read
+(define (READ str)
+  (read_str str))
+
+;; eval
+(define (is-pair x)
+  (and (_sequential? x) (> (_count x) 0)))
+
+(define (quasiquote ast)
+  (cond
+    [(not (is-pair ast))
+     (list 'quote ast)]
+
+    [(equal? 'unquote (_nth ast 0))
+     (_nth ast 1)]
+
+    [(and (is-pair (_nth ast 0))
+          (equal? 'splice-unquote (_nth (_nth ast 0) 0)))
+     (list 'concat (_nth (_nth ast 0) 1) (quasiquote (_rest ast)))]
+
+    [else
+     (list 'cons (quasiquote (_nth ast 0)) (quasiquote (_rest ast)))]))
+
+(define (macro? ast env)
+  (and (list? ast)
+       (symbol? (first ast))
+       (not (equal? null (send env find (first ast))))
+       (let ([fn (send env get (first ast))])
+         (and (malfunc? fn) (malfunc-macro? fn)))))
+
+(define (macroexpand ast env)
+  (if (macro? ast env)
+    (let ([mac (malfunc-fn (send env get (first ast)))])
+      (macroexpand (apply mac (rest ast)) env))
+    ast))
+
+(define (eval-ast ast env)
+  (cond
+    [(symbol? ast) (send env get ast)]
+    [(_sequential? ast) (_map (lambda (x) (EVAL x env)) ast)]
+    [(hash? ast) (make-hash
+                  (dict-map ast (lambda (k v) (cons k (EVAL v env)))))]
+    [else ast]))
+
+(define (EVAL ast env)
+  ;(printf "~a~n" (pr_str ast true))
+  (if (not (list? ast))
+    (eval-ast ast env)
+
+    (let ([ast (macroexpand ast env)])
+      (if (not (list? ast))
+        ast
+        (let ([a0 (_nth ast 0)])
+          (cond
+            [(eq? 'def! a0)
+             (send env set (_nth ast 1) (EVAL (_nth ast 2) env))]
+            [(eq? 'let* a0)
+             (let ([let-env (new Env% [outer env] [binds null] [exprs null])])
+               (_map (lambda (b_e)
+                       (send let-env set (_first b_e)
+                             (EVAL (_nth b_e 1) let-env)))
+                    (_partition 2 (_to_list (_nth ast 1))))
+               (EVAL (_nth ast 2) let-env))]
+            [(eq? 'quote a0)
+             (_nth ast 1)]
+            [(eq? 'quasiquote a0)
+             (EVAL (quasiquote (_nth ast 1)) env)]
+            [(eq? 'defmacro! a0)
+             (let* ([func (EVAL (_nth ast 2) env)]
+                    [mac (struct-copy malfunc func [macro? #t])])
+               (send env set (_nth ast 1) mac))]
+            [(eq? 'macroexpand a0)
+             (macroexpand (_nth ast 1) env)]
+            [(eq? 'try* a0)
+             (if (eq? 'catch* (_nth (_nth ast 2) 0))
+               (let ([efn (lambda (exc)
+                            (EVAL (_nth (_nth ast 2) 2)
+                                  (new Env%
+                                       [outer env]
+                                       [binds (list (_nth (_nth ast 2) 1))]
+                                       [exprs (list exc)])))])
+                 (with-handlers
+                   ([mal-exn?  (lambda (exc) (efn (mal-exn-val exc)))]
+                    [string?   (lambda (exc) (efn exc))]
+                    [exn:fail? (lambda (exc) (efn (format "~a" exc)))])
+                   (EVAL (_nth ast 1) env)))
+               (EVAL (_nth ast 1)))]
+            [(eq? 'do a0)
+             (eval-ast (drop (drop-right ast 1) 1) env)
+             (EVAL (last ast) env)]
+            [(eq? 'if a0)
+             (let ([cnd (EVAL (_nth ast 1) env)])
+               (if (or (eq? cnd nil) (eq? cnd #f))
+                 (if (> (length ast) 3)
+                   (EVAL (_nth ast 3) env)
+                   nil)
+                 (EVAL (_nth ast 2) env)))]
+            [(eq? 'fn* a0)
+             (malfunc
+               (lambda args (EVAL (_nth ast 2)
+                                  (new Env% [outer env]
+                                            [binds (_nth ast 1)]
+                                            [exprs args])))
+               (_nth ast 2) env (_nth ast 1) #f nil)]
+            [else (let* ([el (eval-ast ast env)]
+                         [f (first el)]
+                         [args (rest el)])
+                    (if (malfunc? f)
+                      (EVAL (malfunc-ast f)
+                            (new Env%
+                                 [outer (malfunc-env f)]
+                                 [binds (malfunc-params f)]
+                                 [exprs args]))
+                      (apply f args)))]))))))
+
+;; print
+(define (PRINT exp)
+  (pr_str exp true))
+
+;; repl
+(define repl-env
+  (new Env% [outer null] [binds null] [exprs null]))
+(define (rep str)
+  (PRINT (EVAL (READ str) repl-env)))
+
+(for ()  ;; ignore return values
+
+;; core.rkt: defined using Racket
+(hash-for-each core_ns (lambda (k v) (send repl-env set k v)))
+(send repl-env set 'eval (lambda [ast] (EVAL ast repl-env)))
+(send repl-env set '*ARGV* (list))
+
+;; core.mal: defined using the language itself
+(rep "(def! *host-language* \"racket\")")
+(rep "(def! not (fn* (a) (if a false true)))")
+(rep "(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))")
+(rep "(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))")
+(rep "(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))")
+
+)
+
+(define (repl-loop)
+  (let ([line (readline "user> ")])
+    (when (not (eq? nil line))
+      (with-handlers
+        ([string? (lambda (exc) (printf "Error: ~a~n" exc))]
+         [mal-exn? (lambda (exc) (printf "Error: ~a~n"
+                                         (pr_str (mal-exn-val exc) true)))]
+         [blank-exn? (lambda (exc) null)])
+        (printf "~a~n" (rep line)))
+      (repl-loop))))
+(let ([args (current-command-line-arguments)])
+  (if (> (vector-length args) 0)
+    (for () (rep (string-append "(load-file \"" (vector-ref args 0) "\")")))
+    (begin
+      (rep "(println (str \"Mal [\" *host-language* \"]\"))")
+      (repl-loop))))
diff --git a/ruby/Makefile b/ruby/Makefile
index f9792f5..2241a4e 100644
--- a/ruby/Makefile
+++ b/ruby/Makefile
@@ -1,7 +1,7 @@
 TESTS =
 
 SOURCES_BASE = mal_readline.rb types.rb reader.rb printer.rb
-SOURCES_LISP = env.rb core.rb stepA_interop.rb
+SOURCES_LISP = env.rb core.rb stepA_mal.rb
 SOURCES = $(SOURCES_BASE) $(SOURCES_LISP)
 
 #all: mal.rb
diff --git a/ruby/stepA_interop.rb b/ruby/stepA_interop.rb
deleted file mode 100644
index 1eff1f1..0000000
--- a/ruby/stepA_interop.rb
+++ /dev/null
@@ -1,184 +0,0 @@
-$: << File.expand_path(File.dirname(__FILE__))
-require "mal_readline"
-require "types"
-require "reader"
-require "printer"
-require "env"
-require "core"
-
-# read
-def READ(str)
-    return read_str(str)
-end
-
-# eval
-def pair?(x)
-    return sequential?(x) && x.size > 0
-end
-
-def quasiquote(ast)
-    if not pair?(ast)
-        return List.new [:quote, ast]
-    elsif ast[0] == :unquote
-        return ast[1]
-    elsif pair?(ast[0]) && ast[0][0] == :"splice-unquote"
-        return List.new [:concat, ast[0][1], quasiquote(ast.drop(1))]
-    else
-        return List.new [:cons, quasiquote(ast[0]), quasiquote(ast.drop(1))]
-    end
-end
-
-def macro_call?(ast, env)
-    return (ast.is_a?(List) &&
-            ast[0].is_a?(Symbol) &&
-            env.find(ast[0]) &&
-            env.get(ast[0]).is_a?(Function) &&
-            env.get(ast[0]).is_macro)
-end
-
-def macroexpand(ast, env)
-    while macro_call?(ast, env)
-        mac = env.get(ast[0])
-        ast = mac[*ast.drop(1)]
-    end
-    return ast
-end
-
-def eval_ast(ast, env)
-    return case ast
-        when Symbol
-            env.get(ast)
-        when List   
-            List.new ast.map{|a| EVAL(a, env)}
-        when Vector
-            Vector.new ast.map{|a| EVAL(a, env)}
-        when Hash
-            new_hm = {}
-            ast.each{|k,v| new_hm[EVAL(k,env)] = EVAL(v, env)}
-            new_hm
-        else 
-            ast
-    end
-end
-
-def EVAL(ast, env)
-    while true
-
-    #puts "EVAL: #{_pr_str(ast, true)}"
-
-    if not ast.is_a? List
-        return eval_ast(ast, env)
-    end
-
-    # apply list
-    ast = macroexpand(ast, env)
-    return ast if not ast.is_a? List
-
-    a0,a1,a2,a3 = ast
-    case a0
-    when :def!
-        return env.set(a1, EVAL(a2, env))
-    when :"let*"
-        let_env = Env.new(env)
-        a1.each_slice(2) do |a,e|
-            let_env.set(a, EVAL(e, let_env))
-        end
-        env = let_env
-        ast = a2 # Continue loop (TCO)
-    when :quote
-        return a1
-    when :quasiquote
-        ast = quasiquote(a1); # Continue loop (TCO)
-    when :defmacro!
-        func = EVAL(a2, env)
-        func.is_macro = true
-        return env.set(a1, func)
-    when :macroexpand
-        return macroexpand(a1, env)
-    when :"rb*"
-        res = eval(a1)
-        return case res
-            when Array; List.new res
-            else; res
-        end
-    when :"try*"
-        begin
-            return EVAL(a1, env)
-        rescue Exception => exc
-            if exc.is_a? MalException
-                exc = exc.data
-            else
-                exc = exc.message
-            end
-            if a2 && a2[0] == :"catch*"
-                return EVAL(a2[2], Env.new(env, [a2[1]], [exc]))
-            else
-                raise esc
-            end
-        end
-    when :do
-        eval_ast(ast[1..-2], env)
-        ast = ast.last # Continue loop (TCO)
-    when :if
-        cond = EVAL(a1, env)
-        if not cond
-            return nil if a3 == nil
-            ast = a3 # Continue loop (TCO)
-        else
-            ast = a2 # Continue loop (TCO)
-        end
-    when :"fn*"
-        return Function.new(a2, env, a1) {|*args|
-            EVAL(a2, Env.new(env, a1, args))
-        }
-    else
-        el = eval_ast(ast, env)
-        f = el[0]
-        if f.class == Function
-            ast = f.ast
-            env = f.gen_env(el.drop(1)) # Continue loop (TCO)
-        else
-            return f[*el.drop(1)]
-        end
-    end
-
-    end
-end
-
-# print
-def PRINT(exp)
-    return _pr_str(exp, true)
-end
-
-# repl
-repl_env = Env.new
-RE = lambda {|str| EVAL(READ(str), repl_env) }
-REP = lambda {|str| PRINT(EVAL(READ(str), repl_env)) }
-
-# core.rb: defined using ruby
-$core_ns.each do |k,v| repl_env.set(k,v) end
-repl_env.set(:eval, lambda {|ast| EVAL(ast, repl_env)})
-repl_env.set(:"*ARGV*", List.new(ARGV.slice(1,ARGV.length) || []))
-
-# core.mal: defined using the language itself
-RE["(def! *host-language* \"ruby\")"]
-RE["(def! not (fn* (a) (if a false true)))"]
-RE["(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))"]
-RE["(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))"]
-RE["(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))"]
-
-if ARGV.size > 0
-    RE["(load-file \"" + ARGV[0] + "\")"]
-    exit 0
-end
-
-# repl loop
-RE["(println (str \"Mal [\" *host-language* \"]\"))"]
-while line = _readline("user> ")
-    begin
-        puts REP[line]
-    rescue Exception => e
-        puts "Error: #{e}" 
-        puts "\t#{e.backtrace.join("\n\t")}"
-    end
-end
diff --git a/ruby/stepA_mal.rb b/ruby/stepA_mal.rb
new file mode 100644
index 0000000..1eff1f1
--- /dev/null
+++ b/ruby/stepA_mal.rb
@@ -0,0 +1,184 @@
+$: << File.expand_path(File.dirname(__FILE__))
+require "mal_readline"
+require "types"
+require "reader"
+require "printer"
+require "env"
+require "core"
+
+# read
+def READ(str)
+    return read_str(str)
+end
+
+# eval
+def pair?(x)
+    return sequential?(x) && x.size > 0
+end
+
+def quasiquote(ast)
+    if not pair?(ast)
+        return List.new [:quote, ast]
+    elsif ast[0] == :unquote
+        return ast[1]
+    elsif pair?(ast[0]) && ast[0][0] == :"splice-unquote"
+        return List.new [:concat, ast[0][1], quasiquote(ast.drop(1))]
+    else
+        return List.new [:cons, quasiquote(ast[0]), quasiquote(ast.drop(1))]
+    end
+end
+
+def macro_call?(ast, env)
+    return (ast.is_a?(List) &&
+            ast[0].is_a?(Symbol) &&
+            env.find(ast[0]) &&
+            env.get(ast[0]).is_a?(Function) &&
+            env.get(ast[0]).is_macro)
+end
+
+def macroexpand(ast, env)
+    while macro_call?(ast, env)
+        mac = env.get(ast[0])
+        ast = mac[*ast.drop(1)]
+    end
+    return ast
+end
+
+def eval_ast(ast, env)
+    return case ast
+        when Symbol
+            env.get(ast)
+        when List   
+            List.new ast.map{|a| EVAL(a, env)}
+        when Vector
+            Vector.new ast.map{|a| EVAL(a, env)}
+        when Hash
+            new_hm = {}
+            ast.each{|k,v| new_hm[EVAL(k,env)] = EVAL(v, env)}
+            new_hm
+        else 
+            ast
+    end
+end
+
+def EVAL(ast, env)
+    while true
+
+    #puts "EVAL: #{_pr_str(ast, true)}"
+
+    if not ast.is_a? List
+        return eval_ast(ast, env)
+    end
+
+    # apply list
+    ast = macroexpand(ast, env)
+    return ast if not ast.is_a? List
+
+    a0,a1,a2,a3 = ast
+    case a0
+    when :def!
+        return env.set(a1, EVAL(a2, env))
+    when :"let*"
+        let_env = Env.new(env)
+        a1.each_slice(2) do |a,e|
+            let_env.set(a, EVAL(e, let_env))
+        end
+        env = let_env
+        ast = a2 # Continue loop (TCO)
+    when :quote
+        return a1
+    when :quasiquote
+        ast = quasiquote(a1); # Continue loop (TCO)
+    when :defmacro!
+        func = EVAL(a2, env)
+        func.is_macro = true
+        return env.set(a1, func)
+    when :macroexpand
+        return macroexpand(a1, env)
+    when :"rb*"
+        res = eval(a1)
+        return case res
+            when Array; List.new res
+            else; res
+        end
+    when :"try*"
+        begin
+            return EVAL(a1, env)
+        rescue Exception => exc
+            if exc.is_a? MalException
+                exc = exc.data
+            else
+                exc = exc.message
+            end
+            if a2 && a2[0] == :"catch*"
+                return EVAL(a2[2], Env.new(env, [a2[1]], [exc]))
+            else
+                raise esc
+            end
+        end
+    when :do
+        eval_ast(ast[1..-2], env)
+        ast = ast.last # Continue loop (TCO)
+    when :if
+        cond = EVAL(a1, env)
+        if not cond
+            return nil if a3 == nil
+            ast = a3 # Continue loop (TCO)
+        else
+            ast = a2 # Continue loop (TCO)
+        end
+    when :"fn*"
+        return Function.new(a2, env, a1) {|*args|
+            EVAL(a2, Env.new(env, a1, args))
+        }
+    else
+        el = eval_ast(ast, env)
+        f = el[0]
+        if f.class == Function
+            ast = f.ast
+            env = f.gen_env(el.drop(1)) # Continue loop (TCO)
+        else
+            return f[*el.drop(1)]
+        end
+    end
+
+    end
+end
+
+# print
+def PRINT(exp)
+    return _pr_str(exp, true)
+end
+
+# repl
+repl_env = Env.new
+RE = lambda {|str| EVAL(READ(str), repl_env) }
+REP = lambda {|str| PRINT(EVAL(READ(str), repl_env)) }
+
+# core.rb: defined using ruby
+$core_ns.each do |k,v| repl_env.set(k,v) end
+repl_env.set(:eval, lambda {|ast| EVAL(ast, repl_env)})
+repl_env.set(:"*ARGV*", List.new(ARGV.slice(1,ARGV.length) || []))
+
+# core.mal: defined using the language itself
+RE["(def! *host-language* \"ruby\")"]
+RE["(def! not (fn* (a) (if a false true)))"]
+RE["(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))"]
+RE["(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))"]
+RE["(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))"]
+
+if ARGV.size > 0
+    RE["(load-file \"" + ARGV[0] + "\")"]
+    exit 0
+end
+
+# repl loop
+RE["(println (str \"Mal [\" *host-language* \"]\"))"]
+while line = _readline("user> ")
+    begin
+        puts REP[line]
+    rescue Exception => e
+        puts "Error: #{e}" 
+        puts "\t#{e.backtrace.join("\n\t")}"
+    end
+end
diff --git a/ruby/tests/stepA_interop.mal b/ruby/tests/stepA_interop.mal
deleted file mode 100644
index 2d7efb8..0000000
--- a/ruby/tests/stepA_interop.mal
+++ /dev/null
@@ -1,27 +0,0 @@
-;; Testing basic ruby interop
-
-(rb* "7")
-;=>7
-
-(rb* "'7'")
-;=>"7"
-
-(rb* "[7,8,9]")
-;=>(7 8 9)
-
-(rb* "{\"abc\" => 789}")
-;=>{"abc" 789}
-
-(rb* "print 'hello\n'")
-; hello
-;=>nil
-
-(rb* "$foo=8;")
-(rb* "$foo")
-;=>8
-
-(rb* "['a','b','c'].map{|x| 'X'+x+'Y'}.join(' ')")
-;=>"XaY XbY XcY"
-
-(rb* "[1,2,3].map{|x| 1+x}")
-;=>(2 3 4)
diff --git a/ruby/tests/stepA_mal.mal b/ruby/tests/stepA_mal.mal
new file mode 100644
index 0000000..2d7efb8
--- /dev/null
+++ b/ruby/tests/stepA_mal.mal
@@ -0,0 +1,27 @@
+;; Testing basic ruby interop
+
+(rb* "7")
+;=>7
+
+(rb* "'7'")
+;=>"7"
+
+(rb* "[7,8,9]")
+;=>(7 8 9)
+
+(rb* "{\"abc\" => 789}")
+;=>{"abc" 789}
+
+(rb* "print 'hello\n'")
+; hello
+;=>nil
+
+(rb* "$foo=8;")
+(rb* "$foo")
+;=>8
+
+(rb* "['a','b','c'].map{|x| 'X'+x+'Y'}.join(' ')")
+;=>"XaY XbY XcY"
+
+(rb* "[1,2,3].map{|x| 1+x}")
+;=>(2 3 4)
diff --git a/rust/Cargo.toml b/rust/Cargo.toml
index d382d32..daf999d 100644
--- a/rust/Cargo.toml
+++ b/rust/Cargo.toml
@@ -36,4 +36,4 @@ name = "step8_macros"
 [[bin]]
 name = "step9_try"
 [[bin]]
-name = "stepA_interop"
+name = "stepA_mal"
diff --git a/rust/Makefile b/rust/Makefile
index 6910356..da8a6c6 100644
--- a/rust/Makefile
+++ b/rust/Makefile
@@ -3,14 +3,14 @@
 SOURCES_BASE = src/types.rs src/readline.rs \
 	       src/reader.rs src/printer.rs \
 	       src/env.rs src/core.rs
-SOURCES_LISP = src/env.rs src/core.rs src/stepA_interop.rs
+SOURCES_LISP = src/env.rs src/core.rs src/stepA_mal.rs
 SOURCES = $(SOURCES_BASE) $(SOURCES_LISP)
 
 #####################
 
 SRCS = step1_read_print.rs step2_eval.rs step3_env.rs \
        step4_if_fn_do.rs step5_tco.rs step6_file.rs step7_quote.rs \
-       step8_macros.rs step9_try.rs stepA_interop.rs
+       step8_macros.rs step9_try.rs stepA_mal.rs
 BINS = $(SRCS:%.rs=target/%)
 
 #####################
diff --git a/rust/src/stepA_interop.rs b/rust/src/stepA_interop.rs
deleted file mode 100644
index 8e30867..0000000
--- a/rust/src/stepA_interop.rs
+++ /dev/null
@@ -1,479 +0,0 @@
-// support precompiled regexes in reader.rs
-#![feature(phase)]
-#[phase(plugin)]
-extern crate regex_macros;
-extern crate regex;
-
-use std::collections::HashMap;
-use std::os;
-
-use types::{MalVal,MalRet,MalError,ErrString,ErrMalVal,err_str,
-            Nil,False,Sym,List,Vector,Hash_Map,Func,MalFunc,
-            symbol,_nil,string,list,vector,hash_map,malfunc,malfuncd};
-use env::{Env,env_new,env_bind,env_root,env_find,env_set,env_get};
-mod readline;
-mod types;
-mod reader;
-mod printer;
-mod env;
-mod core;
-
-// read
-fn read(str: String) -> MalRet {
-    reader::read_str(str)
-}
-
-// eval
-fn is_pair(x: MalVal) -> bool {
-    match *x {
-        List(ref lst,_) | Vector(ref lst,_) => lst.len() > 0,
-        _ => false,
-    }
-}
-
-fn quasiquote(ast: MalVal) -> MalVal {
-    if !is_pair(ast.clone()) {
-        return list(vec![symbol("quote"), ast])
-    }
-
-    match *ast.clone() {
-        List(ref args,_) | Vector(ref args,_) => {
-            let ref a0 = args[0];
-            match **a0 {
-                Sym(ref s) => {
-                    if s.to_string() == "unquote".to_string() {
-                        let ref a1 = args[1];
-                        return a1.clone();
-                    }
-                },
-                _ => (),
-            }
-            if is_pair(a0.clone()) {
-                match **a0 {
-                    List(ref a0args,_) | Vector(ref a0args,_) => {
-                        let a00 = a0args[0].clone();
-                        match *a00 {
-                            Sym(ref s) => {
-                                if s.to_string() == "splice-unquote".to_string() {
-                                    return list(vec![symbol("concat"),
-                                                     a0args[1].clone(),
-                                                     quasiquote(list(args.slice(1,args.len()).to_vec()))])
-                                }
-                            },
-                            _ => (),
-                        }
-                    },
-                    _ => (),
-                }
-            }
-            let rest = list(args.slice(1,args.len()).to_vec());
-            return list(vec![symbol("cons"),
-                             quasiquote(a0.clone()),
-                             quasiquote(rest)])
-        },
-        _ => _nil(), // should never reach
-    }
-}
-
-fn is_macro_call(ast: MalVal, env: Env) -> bool {
-    match *ast {
-        List(ref lst,_) => {
-            match *lst[0] {
-                Sym(_) => {
-                    if env_find(env.clone(), lst[0].clone()).is_some() {
-                        match env_get(env, lst[0].clone()) {
-                            Ok(f) => {
-                                match *f {
-                                    MalFunc(ref mfd,_) => {
-                                        mfd.is_macro
-                                    },
-                                    _ => false,
-                                }
-                            },
-                            _ => false,
-                        }
-                    } else {
-                        false
-                    }
-                },
-                _ => false,
-            }
-        },
-        _ => false,
-    }
-}
-
-fn macroexpand(mut ast: MalVal, env: Env) -> MalRet {
-    while is_macro_call(ast.clone(), env.clone()) {
-        let ast2 = ast.clone();
-        let args = match *ast2 {
-            List(ref args,_) => args,
-            _ => break,
-        };
-        let ref a0 = args[0];
-        let mf = match **a0 {
-            Sym(_) => {
-                match env_get(env.clone(), a0.clone()) {
-                    Ok(mf) => mf,
-                    Err(e) => return Err(e),
-                }
-            },
-            _ => break,
-        };
-        match *mf {
-            MalFunc(_,_) => {
-                match mf.apply(args.slice(1,args.len()).to_vec()) {
-                    Ok(r) => ast = r,
-                    Err(e) => return Err(e),
-                }
-            },
-            _ => break,
-        }
-    }
-    Ok(ast)
-}
-
-fn eval_ast(ast: MalVal, env: Env) -> MalRet {
-    let ast2 = ast.clone();
-    match *ast2 {
-    //match *ast {
-        Sym(_) => {
-            env_get(env.clone(), ast)
-        },
-        List(ref a,_) | Vector(ref a,_) => {
-            let mut ast_vec : Vec<MalVal> = vec![];
-            for mv in a.iter() {
-                let mv2 = mv.clone();
-                match eval(mv2, env.clone()) {
-                    Ok(mv) => { ast_vec.push(mv); },
-                    Err(e) => { return Err(e); },
-                }
-            }
-            Ok(match *ast { List(_,_) => list(ast_vec),
-                            _         => vector(ast_vec) })
-        },
-        Hash_Map(ref hm,_) => {
-            let mut new_hm: HashMap<String,MalVal> = HashMap::new();
-            for (key, value) in hm.iter() {
-                match eval(value.clone(), env.clone()) {
-                    Ok(mv) => { new_hm.insert(key.to_string(), mv); },
-                    Err(e) => return Err(e),
-                }
-            }
-            Ok(hash_map(new_hm))
-        },
-        _ => {
-            Ok(ast)
-        }
-    }
-}
-
-fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
-    'tco: loop {
-
-    //println!("eval: {}, {}", ast, env.borrow());
-    //println!("eval: {}", ast);
-    let mut ast2 = ast.clone();
-    match *ast2 {
-        List(_,_) => (),  // continue
-        _ => return eval_ast(ast2, env),
-    }
-
-    // apply list
-    match macroexpand(ast2, env.clone()) {
-        Ok(a) => {
-            ast2 = a;
-        },
-        Err(e) => return Err(e),
-    }
-    match *ast2 {
-        List(_,_) => (),  // continue
-        _ => return Ok(ast2),
-    }
-    let ast3 = ast2.clone();
-
-    let (args, a0sym) = match *ast2 {
-        List(ref args,_) => {
-            if args.len() == 0 { 
-                return Ok(ast3);
-            }
-            let ref a0 = *args[0];
-            match *a0 {
-                Sym(ref a0sym) => (args, a0sym.as_slice()),
-                _ => (args, "__<fn*>__"),
-            }
-        },
-        _ => return err_str("Expected list"),
-    };
-
-    match a0sym {
-        "def!" => {
-            let a1 = (*args)[1].clone();
-            let a2 = (*args)[2].clone();
-            let res = eval(a2, env.clone());
-            match res {
-                Ok(r) => {
-                    match *a1 {
-                        Sym(_) => {
-                            env_set(&env.clone(), a1.clone(), r.clone());
-                            return Ok(r);
-                        },
-                        _ => {
-                            return err_str("def! of non-symbol")
-                        }
-                    }
-                },
-                Err(e) => return Err(e),
-            }
-        },
-        "let*" => {
-            let let_env = env_new(Some(env.clone()));
-            let a1 = (*args)[1].clone();
-            let a2 = (*args)[2].clone();
-            match *a1 {
-                List(ref binds,_) | Vector(ref binds,_) => {
-                    let mut it = binds.iter();
-                    while it.len() >= 2 {
-                        let b = it.next().unwrap();
-                        let exp = it.next().unwrap();
-                        match **b {
-                            Sym(_) => {
-                                match eval(exp.clone(), let_env.clone()) {
-                                    Ok(r) => {
-                                        env_set(&let_env, b.clone(), r);
-                                    },
-                                    Err(e) => {
-                                        return Err(e);
-                                    },
-                                }
-                            },
-                            _ => {
-                                return err_str("let* with non-symbol binding");
-                            },
-                        }
-                    }
-                },
-                _ => return err_str("let* with non-list bindings"),
-            }
-            ast = a2;
-            env = let_env.clone();
-            continue 'tco;
-        },
-        "quote" => {
-            return Ok((*args)[1].clone());
-        },
-        "quasiquote" => {
-            let a1 = (*args)[1].clone();
-            ast = quasiquote(a1);
-            continue 'tco;
-        },
-        "defmacro!" => {
-            let a1 = (*args)[1].clone();
-            let a2 = (*args)[2].clone();
-            match eval(a2, env.clone()) {
-                Ok(r) => {
-                    match *r {
-                        MalFunc(ref mfd,_) => {
-                            match *a1 {
-                                Sym(_) => {
-                                    let mut new_mfd = mfd.clone();
-                                    new_mfd.is_macro = true;
-                                    let mf = malfuncd(new_mfd,_nil());
-                                    env_set(&env.clone(), a1.clone(), mf.clone());
-                                    return Ok(mf);
-                                },
-                                _ => return err_str("def! of non-symbol"),
-                            }
-                        },
-                        _ => return err_str("def! of non-symbol"),
-                    }
-                },
-                Err(e) => return Err(e),
-            }
-        },
-        "macroexpand" => {
-            let a1 = (*args)[1].clone();
-            return macroexpand(a1, env.clone())
-        },
-        "try*" => {
-            let a1 = (*args)[1].clone();
-            match eval(a1, env.clone()) {
-                Ok(res) => return Ok(res),
-                Err(err) => {
-                    if args.len() < 3 { return Err(err); }
-                    let a2 = (*args)[2].clone();
-                    let cat = match *a2 {
-                        List(ref cat,_) => cat,
-                        _ => return err_str("invalid catch* clause"),
-                    };
-                    if cat.len() != 3 {
-                        return err_str("wrong arity to catch* clause");
-                    }
-                    let c1 = (*cat)[1].clone();
-                    match *c1 {
-                        Sym(_) => {},
-                        _ => return err_str("invalid catch* binding"),
-                    };
-                    let exc = match err {
-                        ErrMalVal(mv) => mv,
-                        ErrString(s) => string(s),
-                    };
-                    let bind_env = env_new(Some(env.clone()));
-                    env_set(&bind_env, c1.clone(), exc);
-                    let c2 = (*cat)[2].clone();
-                    return eval(c2, bind_env);
-                },
-            };
-        }
-        "do" => {
-            let el = list(args.slice(1,args.len()-1).to_vec());
-            match eval_ast(el, env.clone()) {
-                Err(e) => return Err(e),
-                Ok(_) => {
-                    let ref last = args[args.len()-1];
-                    ast = last.clone();
-                    continue 'tco;
-                },
-            }
-        },
-        "if" => {
-            let a1 = (*args)[1].clone();
-            let cond = eval(a1, env.clone());
-            match cond {
-                Err(e) => return Err(e),
-                Ok(c) => match *c {
-                    False | Nil => {
-                        if args.len() >= 4 {
-                            let a3 = (*args)[3].clone();
-                            ast = a3;
-                            env = env.clone();
-                            continue 'tco;
-                        } else {
-                            return Ok(_nil());
-                        }
-                    },
-                    _ => {
-                        let a2 = (*args)[2].clone();
-                        ast = a2;
-                        env = env.clone();
-                        continue 'tco;
-                    },
-                }
-            }
-        },
-        "fn*" => {
-            let a1 = (*args)[1].clone();
-            let a2 = (*args)[2].clone();
-            return Ok(malfunc(eval, a2, env.clone(), a1, _nil()));
-        },
-        "eval" => {
-            let a1 = (*args)[1].clone();
-            match eval(a1, env.clone()) {
-                Ok(exp) => {
-                    ast = exp;
-                    env = env_root(&env);
-                    continue 'tco;
-                },
-                Err(e) => return Err(e),
-            }
-        },
-        _ => { // function call
-            return match eval_ast(ast3, env.clone()) {
-                Err(e) => Err(e),
-                Ok(el) => {
-                    let args = match *el {
-                        List(ref args,_) => args,
-                        _ => return err_str("Invalid apply"),
-                    };
-                    match *args.clone()[0] {
-                        Func(f,_) => f(args.slice(1,args.len()).to_vec()),
-                        MalFunc(ref mf,_) => {
-                            let mfc = mf.clone();
-                            let alst = list(args.slice(1,args.len()).to_vec());
-                            let new_env = env_new(Some(mfc.env.clone()));
-                            match env_bind(&new_env, mfc.params, alst) {
-                                Ok(_) => {
-                                    ast = mfc.exp;
-                                    env = new_env;
-                                    continue 'tco;
-                                },
-                                Err(e) => err_str(e.as_slice()),
-                            }
-                        },
-                        _ => err_str("attempt to call non-function"),
-                    }
-                }
-            }
-        },
-    }
-
-    }
-}
-
-// print
-fn print(exp: MalVal) -> String {
-    exp.pr_str(true)
-}
-
-fn rep(str: &str, env: Env) -> Result<String,MalError> {
-    match read(str.to_string()) {
-        Err(e) => Err(e),
-        Ok(ast) => {
-            //println!("read: {}", ast);
-            match eval(ast, env) {
-                Err(e)  => Err(e),
-                Ok(exp) => Ok(print(exp)),
-            }
-        }
-    }
-}
-
-fn main() {
-    // core.rs: defined using rust
-    let repl_env = env_new(None);
-    for (k, v) in core::ns().into_iter() {
-        env_set(&repl_env, symbol(k.as_slice()), v);
-    }
-    // see eval() for definition of "eval"
-    env_set(&repl_env, symbol("*ARGV*".as_slice()), list(vec![]));
-
-    // core.mal: defined using the language itself
-    let _ = rep("(def! *host-language* \"rust\")", repl_env.clone());
-    let _ = rep("(def! not (fn* (a) (if a false true)))", repl_env.clone());
-    let _ = rep("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))", repl_env.clone());
-    let _ = rep("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))", repl_env.clone());
-    let _ = rep("(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))", repl_env.clone());
-
-    // Invoked with command line arguments
-    let args = os::args();
-    if args.len() > 1 {
-        let mv_args = args.slice(2,args.len()).iter()
-            .map(|a| string(a.to_string()))
-            .collect::<Vec<MalVal>>();
-        env_set(&repl_env, symbol("*ARGV*".as_slice()), list(mv_args));
-        let lf = "(load-file \"".to_string() + args[1] + "\")".to_string();
-        match rep(lf.as_slice(), repl_env.clone()) {
-            Ok(_) => {
-                os::set_exit_status(0);
-                return;
-            },
-            Err(str) => {
-                println!("Error: {}", str);
-                os::set_exit_status(1);
-                return;
-            },
-        }
-    }
-
-    // repl loop
-    let _  = rep("(println (str \"Mal [\" *host-language* \"]\"))", repl_env.clone());
-    loop {
-        let line = readline::mal_readline("user> ");
-        match line { None => break, _ => () }
-        match rep(line.unwrap().as_slice(), repl_env.clone()) {
-            Ok(str)  => println!("{}", str),
-            Err(ErrMalVal(_)) => (),  // Blank line
-            Err(ErrString(s)) => println!("Error: {}", s),
-        }
-    }
-}
diff --git a/rust/src/stepA_mal.rs b/rust/src/stepA_mal.rs
new file mode 100644
index 0000000..8e30867
--- /dev/null
+++ b/rust/src/stepA_mal.rs
@@ -0,0 +1,479 @@
+// support precompiled regexes in reader.rs
+#![feature(phase)]
+#[phase(plugin)]
+extern crate regex_macros;
+extern crate regex;
+
+use std::collections::HashMap;
+use std::os;
+
+use types::{MalVal,MalRet,MalError,ErrString,ErrMalVal,err_str,
+            Nil,False,Sym,List,Vector,Hash_Map,Func,MalFunc,
+            symbol,_nil,string,list,vector,hash_map,malfunc,malfuncd};
+use env::{Env,env_new,env_bind,env_root,env_find,env_set,env_get};
+mod readline;
+mod types;
+mod reader;
+mod printer;
+mod env;
+mod core;
+
+// read
+fn read(str: String) -> MalRet {
+    reader::read_str(str)
+}
+
+// eval
+fn is_pair(x: MalVal) -> bool {
+    match *x {
+        List(ref lst,_) | Vector(ref lst,_) => lst.len() > 0,
+        _ => false,
+    }
+}
+
+fn quasiquote(ast: MalVal) -> MalVal {
+    if !is_pair(ast.clone()) {
+        return list(vec![symbol("quote"), ast])
+    }
+
+    match *ast.clone() {
+        List(ref args,_) | Vector(ref args,_) => {
+            let ref a0 = args[0];
+            match **a0 {
+                Sym(ref s) => {
+                    if s.to_string() == "unquote".to_string() {
+                        let ref a1 = args[1];
+                        return a1.clone();
+                    }
+                },
+                _ => (),
+            }
+            if is_pair(a0.clone()) {
+                match **a0 {
+                    List(ref a0args,_) | Vector(ref a0args,_) => {
+                        let a00 = a0args[0].clone();
+                        match *a00 {
+                            Sym(ref s) => {
+                                if s.to_string() == "splice-unquote".to_string() {
+                                    return list(vec![symbol("concat"),
+                                                     a0args[1].clone(),
+                                                     quasiquote(list(args.slice(1,args.len()).to_vec()))])
+                                }
+                            },
+                            _ => (),
+                        }
+                    },
+                    _ => (),
+                }
+            }
+            let rest = list(args.slice(1,args.len()).to_vec());
+            return list(vec![symbol("cons"),
+                             quasiquote(a0.clone()),
+                             quasiquote(rest)])
+        },
+        _ => _nil(), // should never reach
+    }
+}
+
+fn is_macro_call(ast: MalVal, env: Env) -> bool {
+    match *ast {
+        List(ref lst,_) => {
+            match *lst[0] {
+                Sym(_) => {
+                    if env_find(env.clone(), lst[0].clone()).is_some() {
+                        match env_get(env, lst[0].clone()) {
+                            Ok(f) => {
+                                match *f {
+                                    MalFunc(ref mfd,_) => {
+                                        mfd.is_macro
+                                    },
+                                    _ => false,
+                                }
+                            },
+                            _ => false,
+                        }
+                    } else {
+                        false
+                    }
+                },
+                _ => false,
+            }
+        },
+        _ => false,
+    }
+}
+
+fn macroexpand(mut ast: MalVal, env: Env) -> MalRet {
+    while is_macro_call(ast.clone(), env.clone()) {
+        let ast2 = ast.clone();
+        let args = match *ast2 {
+            List(ref args,_) => args,
+            _ => break,
+        };
+        let ref a0 = args[0];
+        let mf = match **a0 {
+            Sym(_) => {
+                match env_get(env.clone(), a0.clone()) {
+                    Ok(mf) => mf,
+                    Err(e) => return Err(e),
+                }
+            },
+            _ => break,
+        };
+        match *mf {
+            MalFunc(_,_) => {
+                match mf.apply(args.slice(1,args.len()).to_vec()) {
+                    Ok(r) => ast = r,
+                    Err(e) => return Err(e),
+                }
+            },
+            _ => break,
+        }
+    }
+    Ok(ast)
+}
+
+fn eval_ast(ast: MalVal, env: Env) -> MalRet {
+    let ast2 = ast.clone();
+    match *ast2 {
+    //match *ast {
+        Sym(_) => {
+            env_get(env.clone(), ast)
+        },
+        List(ref a,_) | Vector(ref a,_) => {
+            let mut ast_vec : Vec<MalVal> = vec![];
+            for mv in a.iter() {
+                let mv2 = mv.clone();
+                match eval(mv2, env.clone()) {
+                    Ok(mv) => { ast_vec.push(mv); },
+                    Err(e) => { return Err(e); },
+                }
+            }
+            Ok(match *ast { List(_,_) => list(ast_vec),
+                            _         => vector(ast_vec) })
+        },
+        Hash_Map(ref hm,_) => {
+            let mut new_hm: HashMap<String,MalVal> = HashMap::new();
+            for (key, value) in hm.iter() {
+                match eval(value.clone(), env.clone()) {
+                    Ok(mv) => { new_hm.insert(key.to_string(), mv); },
+                    Err(e) => return Err(e),
+                }
+            }
+            Ok(hash_map(new_hm))
+        },
+        _ => {
+            Ok(ast)
+        }
+    }
+}
+
+fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
+    'tco: loop {
+
+    //println!("eval: {}, {}", ast, env.borrow());
+    //println!("eval: {}", ast);
+    let mut ast2 = ast.clone();
+    match *ast2 {
+        List(_,_) => (),  // continue
+        _ => return eval_ast(ast2, env),
+    }
+
+    // apply list
+    match macroexpand(ast2, env.clone()) {
+        Ok(a) => {
+            ast2 = a;
+        },
+        Err(e) => return Err(e),
+    }
+    match *ast2 {
+        List(_,_) => (),  // continue
+        _ => return Ok(ast2),
+    }
+    let ast3 = ast2.clone();
+
+    let (args, a0sym) = match *ast2 {
+        List(ref args,_) => {
+            if args.len() == 0 { 
+                return Ok(ast3);
+            }
+            let ref a0 = *args[0];
+            match *a0 {
+                Sym(ref a0sym) => (args, a0sym.as_slice()),
+                _ => (args, "__<fn*>__"),
+            }
+        },
+        _ => return err_str("Expected list"),
+    };
+
+    match a0sym {
+        "def!" => {
+            let a1 = (*args)[1].clone();
+            let a2 = (*args)[2].clone();
+            let res = eval(a2, env.clone());
+            match res {
+                Ok(r) => {
+                    match *a1 {
+                        Sym(_) => {
+                            env_set(&env.clone(), a1.clone(), r.clone());
+                            return Ok(r);
+                        },
+                        _ => {
+                            return err_str("def! of non-symbol")
+                        }
+                    }
+                },
+                Err(e) => return Err(e),
+            }
+        },
+        "let*" => {
+            let let_env = env_new(Some(env.clone()));
+            let a1 = (*args)[1].clone();
+            let a2 = (*args)[2].clone();
+            match *a1 {
+                List(ref binds,_) | Vector(ref binds,_) => {
+                    let mut it = binds.iter();
+                    while it.len() >= 2 {
+                        let b = it.next().unwrap();
+                        let exp = it.next().unwrap();
+                        match **b {
+                            Sym(_) => {
+                                match eval(exp.clone(), let_env.clone()) {
+                                    Ok(r) => {
+                                        env_set(&let_env, b.clone(), r);
+                                    },
+                                    Err(e) => {
+                                        return Err(e);
+                                    },
+                                }
+                            },
+                            _ => {
+                                return err_str("let* with non-symbol binding");
+                            },
+                        }
+                    }
+                },
+                _ => return err_str("let* with non-list bindings"),
+            }
+            ast = a2;
+            env = let_env.clone();
+            continue 'tco;
+        },
+        "quote" => {
+            return Ok((*args)[1].clone());
+        },
+        "quasiquote" => {
+            let a1 = (*args)[1].clone();
+            ast = quasiquote(a1);
+            continue 'tco;
+        },
+        "defmacro!" => {
+            let a1 = (*args)[1].clone();
+            let a2 = (*args)[2].clone();
+            match eval(a2, env.clone()) {
+                Ok(r) => {
+                    match *r {
+                        MalFunc(ref mfd,_) => {
+                            match *a1 {
+                                Sym(_) => {
+                                    let mut new_mfd = mfd.clone();
+                                    new_mfd.is_macro = true;
+                                    let mf = malfuncd(new_mfd,_nil());
+                                    env_set(&env.clone(), a1.clone(), mf.clone());
+                                    return Ok(mf);
+                                },
+                                _ => return err_str("def! of non-symbol"),
+                            }
+                        },
+                        _ => return err_str("def! of non-symbol"),
+                    }
+                },
+                Err(e) => return Err(e),
+            }
+        },
+        "macroexpand" => {
+            let a1 = (*args)[1].clone();
+            return macroexpand(a1, env.clone())
+        },
+        "try*" => {
+            let a1 = (*args)[1].clone();
+            match eval(a1, env.clone()) {
+                Ok(res) => return Ok(res),
+                Err(err) => {
+                    if args.len() < 3 { return Err(err); }
+                    let a2 = (*args)[2].clone();
+                    let cat = match *a2 {
+                        List(ref cat,_) => cat,
+                        _ => return err_str("invalid catch* clause"),
+                    };
+                    if cat.len() != 3 {
+                        return err_str("wrong arity to catch* clause");
+                    }
+                    let c1 = (*cat)[1].clone();
+                    match *c1 {
+                        Sym(_) => {},
+                        _ => return err_str("invalid catch* binding"),
+                    };
+                    let exc = match err {
+                        ErrMalVal(mv) => mv,
+                        ErrString(s) => string(s),
+                    };
+                    let bind_env = env_new(Some(env.clone()));
+                    env_set(&bind_env, c1.clone(), exc);
+                    let c2 = (*cat)[2].clone();
+                    return eval(c2, bind_env);
+                },
+            };
+        }
+        "do" => {
+            let el = list(args.slice(1,args.len()-1).to_vec());
+            match eval_ast(el, env.clone()) {
+                Err(e) => return Err(e),
+                Ok(_) => {
+                    let ref last = args[args.len()-1];
+                    ast = last.clone();
+                    continue 'tco;
+                },
+            }
+        },
+        "if" => {
+            let a1 = (*args)[1].clone();
+            let cond = eval(a1, env.clone());
+            match cond {
+                Err(e) => return Err(e),
+                Ok(c) => match *c {
+                    False | Nil => {
+                        if args.len() >= 4 {
+                            let a3 = (*args)[3].clone();
+                            ast = a3;
+                            env = env.clone();
+                            continue 'tco;
+                        } else {
+                            return Ok(_nil());
+                        }
+                    },
+                    _ => {
+                        let a2 = (*args)[2].clone();
+                        ast = a2;
+                        env = env.clone();
+                        continue 'tco;
+                    },
+                }
+            }
+        },
+        "fn*" => {
+            let a1 = (*args)[1].clone();
+            let a2 = (*args)[2].clone();
+            return Ok(malfunc(eval, a2, env.clone(), a1, _nil()));
+        },
+        "eval" => {
+            let a1 = (*args)[1].clone();
+            match eval(a1, env.clone()) {
+                Ok(exp) => {
+                    ast = exp;
+                    env = env_root(&env);
+                    continue 'tco;
+                },
+                Err(e) => return Err(e),
+            }
+        },
+        _ => { // function call
+            return match eval_ast(ast3, env.clone()) {
+                Err(e) => Err(e),
+                Ok(el) => {
+                    let args = match *el {
+                        List(ref args,_) => args,
+                        _ => return err_str("Invalid apply"),
+                    };
+                    match *args.clone()[0] {
+                        Func(f,_) => f(args.slice(1,args.len()).to_vec()),
+                        MalFunc(ref mf,_) => {
+                            let mfc = mf.clone();
+                            let alst = list(args.slice(1,args.len()).to_vec());
+                            let new_env = env_new(Some(mfc.env.clone()));
+                            match env_bind(&new_env, mfc.params, alst) {
+                                Ok(_) => {
+                                    ast = mfc.exp;
+                                    env = new_env;
+                                    continue 'tco;
+                                },
+                                Err(e) => err_str(e.as_slice()),
+                            }
+                        },
+                        _ => err_str("attempt to call non-function"),
+                    }
+                }
+            }
+        },
+    }
+
+    }
+}
+
+// print
+fn print(exp: MalVal) -> String {
+    exp.pr_str(true)
+}
+
+fn rep(str: &str, env: Env) -> Result<String,MalError> {
+    match read(str.to_string()) {
+        Err(e) => Err(e),
+        Ok(ast) => {
+            //println!("read: {}", ast);
+            match eval(ast, env) {
+                Err(e)  => Err(e),
+                Ok(exp) => Ok(print(exp)),
+            }
+        }
+    }
+}
+
+fn main() {
+    // core.rs: defined using rust
+    let repl_env = env_new(None);
+    for (k, v) in core::ns().into_iter() {
+        env_set(&repl_env, symbol(k.as_slice()), v);
+    }
+    // see eval() for definition of "eval"
+    env_set(&repl_env, symbol("*ARGV*".as_slice()), list(vec![]));
+
+    // core.mal: defined using the language itself
+    let _ = rep("(def! *host-language* \"rust\")", repl_env.clone());
+    let _ = rep("(def! not (fn* (a) (if a false true)))", repl_env.clone());
+    let _ = rep("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))", repl_env.clone());
+    let _ = rep("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))", repl_env.clone());
+    let _ = rep("(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))", repl_env.clone());
+
+    // Invoked with command line arguments
+    let args = os::args();
+    if args.len() > 1 {
+        let mv_args = args.slice(2,args.len()).iter()
+            .map(|a| string(a.to_string()))
+            .collect::<Vec<MalVal>>();
+        env_set(&repl_env, symbol("*ARGV*".as_slice()), list(mv_args));
+        let lf = "(load-file \"".to_string() + args[1] + "\")".to_string();
+        match rep(lf.as_slice(), repl_env.clone()) {
+            Ok(_) => {
+                os::set_exit_status(0);
+                return;
+            },
+            Err(str) => {
+                println!("Error: {}", str);
+                os::set_exit_status(1);
+                return;
+            },
+        }
+    }
+
+    // repl loop
+    let _  = rep("(println (str \"Mal [\" *host-language* \"]\"))", repl_env.clone());
+    loop {
+        let line = readline::mal_readline("user> ");
+        match line { None => break, _ => () }
+        match rep(line.unwrap().as_slice(), repl_env.clone()) {
+            Ok(str)  => println!("{}", str),
+            Err(ErrMalVal(_)) => (),  // Blank line
+            Err(ErrString(s)) => println!("Error: {}", s),
+        }
+    }
+}
diff --git a/scala/Makefile b/scala/Makefile
index 10c2e11..29dd8aa 100644
--- a/scala/Makefile
+++ b/scala/Makefile
@@ -1,7 +1,7 @@
 TESTS =
 
 SOURCES_BASE = types.scala reader.scala printer.scala
-SOURCES_LISP = env.scala core.scala stepA_interop.scala
+SOURCES_LISP = env.scala core.scala stepA_mal.scala
 SOURCES = $(SOURCES_BASE) $(SOURCES_LISP)
 
 #all: mal.scala
diff --git a/scala/stepA_interop.scala b/scala/stepA_interop.scala
deleted file mode 100644
index 2ba6b5a..0000000
--- a/scala/stepA_interop.scala
+++ /dev/null
@@ -1,229 +0,0 @@
-import types.{MalList, _list, _list_Q, MalVector, MalHashMap,
-              Func, MalFunction}
-import env.Env
-
-object stepA_interop {
-  // read
-  def READ(str: String): Any = {
-    reader.read_str(str)
-  }
-
-  // eval
-  def is_pair(x: Any): Boolean = {
-    types._sequential_Q(x) && x.asInstanceOf[MalList].value.length > 0
-  }
-
-  def quasiquote(ast: Any): Any = {
-    if (!is_pair(ast)) {
-      return _list(Symbol("quote"), ast)
-    } else {
-      val a0 = ast.asInstanceOf[MalList](0)
-      if (types._symbol_Q(a0) &&
-          a0.asInstanceOf[Symbol].name == "unquote") {
-        return ast.asInstanceOf[MalList](1)
-      } else if (is_pair(a0)) {
-        val a00 = a0.asInstanceOf[MalList](0)
-        if (types._symbol_Q(a00) &&
-            a00.asInstanceOf[Symbol].name == "splice-unquote") {
-          return _list(Symbol("concat"),
-                       a0.asInstanceOf[MalList](1),
-                       quasiquote(ast.asInstanceOf[MalList].drop(1)))
-        }
-      }
-      return _list(Symbol("cons"),
-                   quasiquote(a0),
-                   quasiquote(ast.asInstanceOf[MalList].drop(1)))
-    }
-  }
-
-  def is_macro_call(ast: Any, env: Env): Boolean = {
-    ast match {
-      case ml: MalList => {
-        if (types._symbol_Q(ml(0)) &&
-            env.find(ml(0).asInstanceOf[Symbol]) != null) {
-          env.get(ml(0).asInstanceOf[Symbol]) match {
-            case f: MalFunction => return f.ismacro
-            case _ => return false
-          }
-        }
-        return false
-      }
-      case _ => return false
-    }
-  }
-
-  def macroexpand(orig_ast: Any, env: Env): Any = {
-    var ast = orig_ast;
-    while (is_macro_call(ast, env)) {
-      ast.asInstanceOf[MalList].value match {
-        case f :: args => {
-          val mac = env.get(f.asInstanceOf[Symbol])
-          ast = mac.asInstanceOf[MalFunction](args)
-        }
-        case _ => throw new Exception("macroexpand: invalid call")
-      }
-    }
-    ast
-  }
-
-  def eval_ast(ast: Any, env: Env): Any = {
-    ast match {
-      case s : Symbol    => env.get(s)
-      case v: MalVector  => v.map(EVAL(_, env))
-      case l: MalList    => l.map(EVAL(_, env))
-      case m: MalHashMap => {
-        m.map{case (k: String,v: Any) => (k, EVAL(v, env))}
-      }
-      case _             => ast
-    }
-  }
-
-  def EVAL(orig_ast: Any, orig_env: Env): Any = {
-   var ast = orig_ast; var env = orig_env;
-   while (true) {
-
-    //println("EVAL: " + printer._pr_str(ast,true))
-    if (!_list_Q(ast))
-      return eval_ast(ast, env)
-
-    // apply list
-    ast = macroexpand(ast, env)
-    if (!_list_Q(ast)) return ast
-
-    ast.asInstanceOf[MalList].value match {
-      case Symbol("def!") :: a1 :: a2 :: Nil => {
-        return env.set(a1.asInstanceOf[Symbol], EVAL(a2, env))
-      }
-      case Symbol("let*") :: a1 :: a2 :: Nil => {
-        val let_env = new Env(env)
-        for (g <- a1.asInstanceOf[MalList].value.grouped(2)) {
-          let_env.set(g(0).asInstanceOf[Symbol],EVAL(g(1),let_env))
-        }
-        env = let_env
-        ast = a2   // continue loop (TCO)
-      }
-      case Symbol("quote") :: a1 :: Nil => {
-        return a1
-      }
-      case Symbol("quasiquote") :: a1 :: Nil => {
-        ast = quasiquote(a1)  // continue loop (TCO)
-      }
-      case Symbol("defmacro!") :: a1 :: a2 :: Nil => {
-        val f = EVAL(a2, env)
-        f.asInstanceOf[MalFunction].ismacro = true
-        return env.set(a1.asInstanceOf[Symbol], f)
-      }
-      case Symbol("macroexpand") :: a1 :: Nil => {
-        return macroexpand(a1, env)
-      }
-      case Symbol("try*") :: a1 :: rest => {
-        try {
-          return EVAL(a1, env)
-        } catch {
-          case t: Throwable => {
-            rest(0).asInstanceOf[MalList].value match {
-              case List(Symbol("catch*"), a21, a22) => {
-                val exc: Any = t match {
-                  case mex: types.MalException => mex.value
-                  case _ => t.getMessage
-                }
-                return EVAL(a22, new Env(env,
-                                         List(a21).iterator,
-                                         List(exc).iterator))
-              }
-            }
-            throw t
-          }
-        }
-      }
-      case Symbol("do") :: rest => {
-        eval_ast(_list(rest.slice(0,rest.length-1):_*), env)
-        ast = ast.asInstanceOf[MalList].value.last  // continue loop (TCO)
-      }
-      case Symbol("if") :: a1 :: a2 :: rest => {
-        val cond = EVAL(a1, env)
-        if (cond == null || cond == false) {
-          if (rest.length == 0) return null
-          ast = rest(0)  // continue loop (TCO)
-        } else {
-          ast = a2  // continue loop (TCO)
-        }
-      }
-      case Symbol("fn*") :: a1 :: a2 :: Nil => {
-        return new MalFunction(a2, env, a1.asInstanceOf[MalList],
-          (args: List[Any]) => {
-            EVAL(a2, new Env(env, types._toIter(a1), args.iterator))
-          }
-        )
-      }
-      case _ => {
-        // function call
-        eval_ast(ast, env).asInstanceOf[MalList].value match {
-          case f :: el => {
-            f match {
-              case fn: MalFunction => {
-                env = fn.gen_env(el) 
-                ast = fn.ast  // continue loop (TCO)
-              }
-              case fn: Func => {
-                return fn(el)
-              }
-              case _ => {
-                throw new Exception("attempt to call non-function: " + f)
-              }
-            }
-          }
-          case _ => throw new Exception("invalid apply")
-        }
-      }
-    }
-   }
-  }
-
-  // print
-  def PRINT(exp: Any): String = {
-    printer._pr_str(exp, true)
-  }
-
-  // repl
-  def main(args: Array[String]) = {
-    val repl_env: Env = new Env()
-    val REP = (str: String) => PRINT(EVAL(READ(str), repl_env))
-
-    // core.scala: defined using scala
-    core.ns.map{case (k: String,v: Any) => {
-      repl_env.set(Symbol(k), new Func(v))
-    }}
-    repl_env.set(Symbol("eval"), new Func((a: List[Any]) => EVAL(a(0), repl_env)))
-    repl_env.set(Symbol("*ARGV*"), _list(args.slice(1,args.length):_*))
-
-    // core.mal: defined using the language itself
-    REP("(def! *host-language* \"scala\")")
-    REP("(def! not (fn* (a) (if a false true)))")
-    REP("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))")
-    REP("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))")
-    REP("(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))")
-
-
-    if (args.length > 0) {
-      REP("(load-file \"" + args(0) + "\")")
-      System.exit(0)
-    }
-
-    // repl loop
-    REP("(println (str \"Mal [\" *host-language* \"]\"))")
-    var line:String = null
-    while ({line = readLine("user> "); line != null}) {
-      try {
-        println(REP(line))
-      } catch {
-        case e : Throwable => {
-          println("Error: " + e.getMessage)
-          println("    " + e.getStackTrace.mkString("\n    "))
-        }
-      }
-    }
-  }
-}
-
-// vim: ts=2:sw=2
diff --git a/scala/stepA_mal.scala b/scala/stepA_mal.scala
new file mode 100644
index 0000000..5230cb1
--- /dev/null
+++ b/scala/stepA_mal.scala
@@ -0,0 +1,229 @@
+import types.{MalList, _list, _list_Q, MalVector, MalHashMap,
+              Func, MalFunction}
+import env.Env
+
+object stepA_mal {
+  // read
+  def READ(str: String): Any = {
+    reader.read_str(str)
+  }
+
+  // eval
+  def is_pair(x: Any): Boolean = {
+    types._sequential_Q(x) && x.asInstanceOf[MalList].value.length > 0
+  }
+
+  def quasiquote(ast: Any): Any = {
+    if (!is_pair(ast)) {
+      return _list(Symbol("quote"), ast)
+    } else {
+      val a0 = ast.asInstanceOf[MalList](0)
+      if (types._symbol_Q(a0) &&
+          a0.asInstanceOf[Symbol].name == "unquote") {
+        return ast.asInstanceOf[MalList](1)
+      } else if (is_pair(a0)) {
+        val a00 = a0.asInstanceOf[MalList](0)
+        if (types._symbol_Q(a00) &&
+            a00.asInstanceOf[Symbol].name == "splice-unquote") {
+          return _list(Symbol("concat"),
+                       a0.asInstanceOf[MalList](1),
+                       quasiquote(ast.asInstanceOf[MalList].drop(1)))
+        }
+      }
+      return _list(Symbol("cons"),
+                   quasiquote(a0),
+                   quasiquote(ast.asInstanceOf[MalList].drop(1)))
+    }
+  }
+
+  def is_macro_call(ast: Any, env: Env): Boolean = {
+    ast match {
+      case ml: MalList => {
+        if (types._symbol_Q(ml(0)) &&
+            env.find(ml(0).asInstanceOf[Symbol]) != null) {
+          env.get(ml(0).asInstanceOf[Symbol]) match {
+            case f: MalFunction => return f.ismacro
+            case _ => return false
+          }
+        }
+        return false
+      }
+      case _ => return false
+    }
+  }
+
+  def macroexpand(orig_ast: Any, env: Env): Any = {
+    var ast = orig_ast;
+    while (is_macro_call(ast, env)) {
+      ast.asInstanceOf[MalList].value match {
+        case f :: args => {
+          val mac = env.get(f.asInstanceOf[Symbol])
+          ast = mac.asInstanceOf[MalFunction](args)
+        }
+        case _ => throw new Exception("macroexpand: invalid call")
+      }
+    }
+    ast
+  }
+
+  def eval_ast(ast: Any, env: Env): Any = {
+    ast match {
+      case s : Symbol    => env.get(s)
+      case v: MalVector  => v.map(EVAL(_, env))
+      case l: MalList    => l.map(EVAL(_, env))
+      case m: MalHashMap => {
+        m.map{case (k: String,v: Any) => (k, EVAL(v, env))}
+      }
+      case _             => ast
+    }
+  }
+
+  def EVAL(orig_ast: Any, orig_env: Env): Any = {
+   var ast = orig_ast; var env = orig_env;
+   while (true) {
+
+    //println("EVAL: " + printer._pr_str(ast,true))
+    if (!_list_Q(ast))
+      return eval_ast(ast, env)
+
+    // apply list
+    ast = macroexpand(ast, env)
+    if (!_list_Q(ast)) return ast
+
+    ast.asInstanceOf[MalList].value match {
+      case Symbol("def!") :: a1 :: a2 :: Nil => {
+        return env.set(a1.asInstanceOf[Symbol], EVAL(a2, env))
+      }
+      case Symbol("let*") :: a1 :: a2 :: Nil => {
+        val let_env = new Env(env)
+        for (g <- a1.asInstanceOf[MalList].value.grouped(2)) {
+          let_env.set(g(0).asInstanceOf[Symbol],EVAL(g(1),let_env))
+        }
+        env = let_env
+        ast = a2   // continue loop (TCO)
+      }
+      case Symbol("quote") :: a1 :: Nil => {
+        return a1
+      }
+      case Symbol("quasiquote") :: a1 :: Nil => {
+        ast = quasiquote(a1)  // continue loop (TCO)
+      }
+      case Symbol("defmacro!") :: a1 :: a2 :: Nil => {
+        val f = EVAL(a2, env)
+        f.asInstanceOf[MalFunction].ismacro = true
+        return env.set(a1.asInstanceOf[Symbol], f)
+      }
+      case Symbol("macroexpand") :: a1 :: Nil => {
+        return macroexpand(a1, env)
+      }
+      case Symbol("try*") :: a1 :: rest => {
+        try {
+          return EVAL(a1, env)
+        } catch {
+          case t: Throwable => {
+            rest(0).asInstanceOf[MalList].value match {
+              case List(Symbol("catch*"), a21, a22) => {
+                val exc: Any = t match {
+                  case mex: types.MalException => mex.value
+                  case _ => t.getMessage
+                }
+                return EVAL(a22, new Env(env,
+                                         List(a21).iterator,
+                                         List(exc).iterator))
+              }
+            }
+            throw t
+          }
+        }
+      }
+      case Symbol("do") :: rest => {
+        eval_ast(_list(rest.slice(0,rest.length-1):_*), env)
+        ast = ast.asInstanceOf[MalList].value.last  // continue loop (TCO)
+      }
+      case Symbol("if") :: a1 :: a2 :: rest => {
+        val cond = EVAL(a1, env)
+        if (cond == null || cond == false) {
+          if (rest.length == 0) return null
+          ast = rest(0)  // continue loop (TCO)
+        } else {
+          ast = a2  // continue loop (TCO)
+        }
+      }
+      case Symbol("fn*") :: a1 :: a2 :: Nil => {
+        return new MalFunction(a2, env, a1.asInstanceOf[MalList],
+          (args: List[Any]) => {
+            EVAL(a2, new Env(env, types._toIter(a1), args.iterator))
+          }
+        )
+      }
+      case _ => {
+        // function call
+        eval_ast(ast, env).asInstanceOf[MalList].value match {
+          case f :: el => {
+            f match {
+              case fn: MalFunction => {
+                env = fn.gen_env(el) 
+                ast = fn.ast  // continue loop (TCO)
+              }
+              case fn: Func => {
+                return fn(el)
+              }
+              case _ => {
+                throw new Exception("attempt to call non-function: " + f)
+              }
+            }
+          }
+          case _ => throw new Exception("invalid apply")
+        }
+      }
+    }
+   }
+  }
+
+  // print
+  def PRINT(exp: Any): String = {
+    printer._pr_str(exp, true)
+  }
+
+  // repl
+  def main(args: Array[String]) = {
+    val repl_env: Env = new Env()
+    val REP = (str: String) => PRINT(EVAL(READ(str), repl_env))
+
+    // core.scala: defined using scala
+    core.ns.map{case (k: String,v: Any) => {
+      repl_env.set(Symbol(k), new Func(v))
+    }}
+    repl_env.set(Symbol("eval"), new Func((a: List[Any]) => EVAL(a(0), repl_env)))
+    repl_env.set(Symbol("*ARGV*"), _list(args.slice(1,args.length):_*))
+
+    // core.mal: defined using the language itself
+    REP("(def! *host-language* \"scala\")")
+    REP("(def! not (fn* (a) (if a false true)))")
+    REP("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))")
+    REP("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))")
+    REP("(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))")
+
+
+    if (args.length > 0) {
+      REP("(load-file \"" + args(0) + "\")")
+      System.exit(0)
+    }
+
+    // repl loop
+    REP("(println (str \"Mal [\" *host-language* \"]\"))")
+    var line:String = null
+    while ({line = readLine("user> "); line != null}) {
+      try {
+        println(REP(line))
+      } catch {
+        case e : Throwable => {
+          println("Error: " + e.getMessage)
+          println("    " + e.getStackTrace.mkString("\n    "))
+        }
+      }
+    }
+  }
+}
+
+// vim: ts=2:sw=2
diff --git a/vb/Makefile b/vb/Makefile
index d9ce097..25d9b96 100644
--- a/vb/Makefile
+++ b/vb/Makefile
@@ -5,14 +5,14 @@ DEBUG =
 TESTS =
 
 SOURCES_BASE = readline.vb types.vb reader.vb printer.vb
-SOURCES_LISP = env.vb core.vb stepA_interop.vb
+SOURCES_LISP = env.vb core.vb stepA_mal.vb
 SOURCES = $(SOURCES_BASE) $(SOURCES_LISP)
 
 #####################
 
 SRCS = step0_repl.vb step1_read_print.vb step2_eval.vb \
        step3_env.vb step4_if_fn_do.vb step5_tco.vb step6_file.vb \
-       step7_quote.vb step8_macros.vb step9_try.vb stepA_interop.vb
+       step7_quote.vb step8_macros.vb step9_try.vb stepA_mal.vb
 
 LIB_CS_SRCS = getline.cs
 LIB_VB_SRCS = $(filter-out step%,$(filter %.vb,$(SOURCES)))
diff --git a/vb/stepA_interop.vb b/vb/stepA_interop.vb
deleted file mode 100644
index f9af038..0000000
--- a/vb/stepA_interop.vb
+++ /dev/null
@@ -1,317 +0,0 @@
-Imports System
-Imports System.IO
-Imports System.Collections.Generic
-Imports Mal
-Imports MalVal = Mal.types.MalVal
-Imports MalInt = Mal.types.MalInt
-Imports MalString = Mal.types.MalString
-Imports MalSymbol = Mal.types.MalSymbol
-Imports MalList = Mal.types.MalList
-Imports MalVector = Mal.types.MalVector
-Imports MalHashMap = Mal.types.MalHashMap
-Imports MalFunc = Mal.types.MalFunc
-Imports MalEnv = Mal.env.Env
-
-Namespace Mal
-    Class stepA_interop
-        ' read
-        Shared Function READ(str As String) As MalVal
-            Return reader.read_str(str)
-        End Function
-
-        ' eval
-        Shared Function is_pair(x As MalVal) As Boolean
-            return TypeOf x Is MalList AndAlso _
-                   DirectCast(x,MalList).size() > 0
-        End Function
-
-        Shared Function quasiquote(ast As MalVal) As MalVal
-            If not is_pair(ast) Then
-                return New MalList(New MalSymbol("quote"), ast)
-            Else
-                Dim a0 As MalVal = DirectCast(ast,MalList)(0)
-                If TypeOf a0 Is MalSymbol AndAlso _
-                    DirectCast(a0,MalSymbol).getName() = "unquote" Then
-                    return DirectCast(ast,MalList)(1)
-                Else If is_pair(a0) Then
-                    Dim a00 As MalVal = DirectCast(a0,MalList)(0)
-                    If TypeOf a00 is MalSymbol AndAlso _
-                        DirectCast(a00,MalSymbol).getName() = "splice-unquote" Then
-                        return New MalList(New MalSymbol("concat"),
-                                           DirectCast(a0,MalList)(1),
-                                           quasiquote(DirectCast(ast,MalList).rest()))
-                    End If
-                End If
-                return New MalList(New MalSymbol("cons"),
-                                   quasiquote(a0),
-                                   quasiquote(DirectCast(ast,MalList).rest()))
-            End If
-        End Function
-
-        Shared Function is_macro_call(ast As MalVal, env As MalEnv) As Boolean
-            If TypeOf ast Is MalList Then
-                Dim a0 As MalVal = DirectCast(ast,MalList)(0)
-                If TypeOf a0 Is MalSymbol AndAlso _
-                    env.find(DirectCast(a0,MalSymbol)) IsNot Nothing Then
-                    Dim mac As MalVal = env.do_get(DirectCast(a0,MalSymbol))
-                    If TypeOf mac Is MalFunc AndAlso _
-                        DirectCast(mac,MalFunc).isMacro() Then
-                        return True
-                    End If
-                End If
-            End If
-            return False
-        End Function
-
-        Shared Function macroexpand(ast As MalVal, env As MalEnv) As MalVal
-            While is_macro_call(ast, env)
-                Dim a0 As MalSymbol = DirectCast(DirectCast(ast,MalList)(0),MalSymbol)
-                Dim mac As MalFunc = DirectCast(env.do_get(a0),MalFunc)
-                ast = mac.apply(DirectCast(ast,MalList).rest())
-            End While
-            return ast
-        End Function
-
-        Shared Function eval_ast(ast As MalVal, env As MalEnv) As MalVal
-            If TypeOf ast Is MalSymbol Then
-                return env.do_get(DirectCast(ast, MalSymbol))
-            Else If TypeOf ast Is MalList Then
-                Dim old_lst As MalList = DirectCast(ast, MalList)
-                Dim new_lst As MalList
-                If ast.list_Q() Then
-                    new_lst = New MalList
-                Else
-                    new_lst = DirectCast(New MalVector, MalList)
-                End If
-                Dim mv As MalVal
-                For Each mv in old_lst.getValue()
-                    new_lst.conj_BANG(EVAL(mv, env))
-                Next
-                return new_lst
-            Else If TypeOf ast Is MalHashMap Then
-                Dim new_dict As New Dictionary(Of String, MalVal)
-                Dim entry As KeyValuePair(Of String, MalVal)
-                For Each entry in DirectCast(ast,MalHashMap).getValue()
-                    new_dict.Add(entry.Key, EVAL(DirectCast(entry.Value,MalVal), env))
-                Next
-                return New MalHashMap(new_dict)
-            Else
-                return ast
-            End If
-            return ast
-        End Function
-
-        ' TODO: move to types.vb when it is ported
-        Class FClosure
-            Public ast As MalVal
-            Public params As MalList
-            Public env As MalEnv
-            Function fn(args as MalList) As MalVal
-                return EVAL(ast, new MalEnv(env, params, args))
-            End Function
-        End Class
-
-        Shared Function EVAL(orig_ast As MalVal, env As MalEnv) As MalVal
-            Do
-
-            'Console.WriteLine("EVAL: {0}", printer._pr_str(orig_ast, true))
-            If not orig_ast.list_Q() Then
-                return eval_ast(orig_ast, env)
-            End If
-
-            ' apply list
-            Dim expanded As MalVal = macroexpand(orig_ast, env)
-            if not expanded.list_Q() Then
-                return expanded
-            End If
-            Dim ast As MalList = DirectCast(expanded, MalList)
-
-            If ast.size() = 0  Then
-                return ast
-            End If
-            Dim a0 As MalVal = ast(0)
-            Dim a0sym As String
-            If TypeOf a0 is MalSymbol Then
-                a0sym = DirectCast(a0,MalSymbol).getName()
-            Else
-                a0sym = "__<*fn*>__"
-            End If
-
-            Select a0sym
-            Case "def!"
-                Dim a1 As MalVal = ast(1)
-                Dim a2 As MalVal = ast(2)
-                Dim res As MalVal = EVAL(a2, env)
-                env.do_set(DirectCast(a1,MalSymbol), res)
-                return res
-            Case "let*"
-                Dim a1 As MalVal = ast(1)
-                Dim a2 As MalVal = ast(2)
-                Dim key As MalSymbol
-                Dim val as MalVal
-                Dim let_env As new MalEnv(env)
-                For i As Integer = 0 To (DirectCast(a1,MalList)).size()-1 Step 2
-                    key = DirectCast(DirectCast(a1,MalList)(i),MalSymbol)
-                    val = DirectCast(a1,MalList)(i+1)
-                    let_env.do_set(key, EVAL(val, let_env))
-                Next
-                orig_ast = a2
-                env = let_env
-            Case "quote"
-                return ast(1)
-            Case "quasiquote"
-                orig_ast = quasiquote(ast(1))
-            Case "defmacro!"
-                Dim a1 As MalVal = ast(1)
-                Dim a2 As MalVal = ast(2)
-                Dim res As MalVal = EVAL(a2, env)
-                DirectCast(res,MalFunc).setMacro()
-                env.do_set(DirectCast(a1,MalSymbol), res)
-                return res
-            Case "macroexpand"
-                Dim a1 As MalVal = ast(1)
-                return macroexpand(a1, env)
-            Case "try*"
-                Try
-                    return EVAL(ast(1), env)
-                Catch e As Exception
-                    If ast.size() > 2 Then
-                        Dim exc As MalVal
-                        Dim a2 As MalVal = ast(2)
-                        Dim a20 As MalVal = DirectCast(a2,MalList)(0)
-                        If DirectCast(a20,MalSymbol).getName() = "catch*" Then
-                            If TypeOf e Is Mal.types.MalException Then
-                                exc = DirectCast(e,Mal.types.MalException).getValue()
-                            Else
-                                exc = New MalString(e.StackTrace)
-                            End If
-                            return EVAL(
-                                DirectCast(a2,MalList)(2),
-                                New MalEnv(env,
-                                           DirectCast(a2,MalList).slice(1,2),
-                                           New MalList(exc)))
-                        End If
-                        Throw e
-                    End If
-                End Try
-            Case "do"
-                eval_ast(ast.slice(1, ast.size()-1), env)
-                orig_ast = ast(ast.size()-1)
-            Case "if"
-                Dim a1 As MalVal = ast(1)
-                Dim cond As MalVal = EVAL(a1, env)
-                If cond Is Mal.types.Nil or cond Is Mal.types.MalFalse Then
-                    ' eval false slot form
-                    If ast.size() > 3 Then
-                        orig_ast = ast(3)
-                    Else
-                        return Mal.types.Nil
-                    End If
-                Else
-                    ' eval true slot form
-                    orig_ast = ast(2)
-
-                End If
-            Case "fn*"
-                Dim fc As New FClosure()
-                fc.ast = ast(2)
-                fc.params = DirectCast(ast(1),MalLIst)
-                fc.env = env
-                Dim f As Func(Of MalList, MalVal) = AddressOf fc.fn
-                Dim mf As new MalFunc(ast(2), env,
-                                      DirectCast(ast(1),MalList), f)
-                return DirectCast(mf,MalVal)
-            Case Else
-                Dim el As MalList = DirectCast(eval_ast(ast, env), MalList)
-                Dim f As MalFunc = DirectCast(el(0), MalFunc)
-                Dim fnast As MalVal = f.getAst()
-                If not fnast Is Nothing
-                    orig_ast = fnast
-                    env = f.genEnv(el.rest())
-                Else
-                    Return f.apply(el.rest())
-                End If
-            End Select
-
-            Loop While True
-        End Function
-        
-        ' print
-        Shared Function PRINT(exp As MalVal) As String
-            return printer._pr_str(exp, TRUE)
-        End Function
-
-        ' repl
-        Shared repl_env As MalEnv
-
-        Shared Function REP(str As String) As String
-            Return PRINT(EVAL(READ(str), repl_env))
-        End Function
-
-        Shared Function do_eval(args As MalList) As MalVal
-            Return EVAL(args(0), repl_env)
-        End Function
-
-        Shared Function Main As Integer
-            Dim args As String() = Environment.GetCommandLineArgs()
-
-            repl_env = New MalEnv(Nothing)
-
-            ' core.vb: defined using VB.NET
-            For Each entry As KeyValuePair(Of String,MalVal) In core.ns()
-                repl_env.do_set(new MalSymbol(entry.Key), entry.Value)
-            Next
-            repl_env.do_set(new MalSymbol("eval"), new MalFunc(AddressOf do_eval))
-            Dim fileIdx As Integer = 1
-            If args.Length > 1 AndAlso args(1) = "--raw" Then
-                Mal.readline.SetMode(Mal.readline.Modes.Raw)
-                fileIdx = 2
-            End If
-            Dim argv As New MalList()
-            For i As Integer = fileIdx+1 To args.Length-1
-                argv.conj_BANG(new MalString(args(i)))
-            Next
-            repl_env.do_set(new MalSymbol("*ARGV*"), argv)
-
-            ' core.mal: defined using the language itself
-            REP("(def! *host-language* ""VB.NET"")")
-            REP("(def! not (fn* (a) (if a false true)))")
-            REP("(def! load-file (fn* (f) (eval (read-string (str ""(do "" (slurp f) "")"")))))")
-            REP("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw ""odd number of forms to cond"")) (cons 'cond (rest (rest xs)))))))")
-            REP("(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))")
-
-            If args.Length > fileIdx Then
-                REP("(load-file """ & args(fileIdx) & """)")
-                return 0
-            End If
-
-            ' repl loop
-            Dim line As String
-            REP("(println (str ""Mal ["" *host-language* ""]""))")
-            Do
-                Try
-                    line = Mal.readline.Readline("user> ")
-                    If line is Nothing Then
-                        Exit Do
-                    End If
-                    If line = "" Then
-                        Continue Do
-                    End If
-                Catch e As IOException
-                    Console.WriteLine("IOException: " & e.Message)
-                End Try
-                Try
-                    Console.WriteLine(REP(line))
-                Catch e As Mal.types.MalException
-                    Console.WriteLine("Error: " & _
-                        printer._pr_str(e.getValue(), False))
-                    Continue Do
-                Catch e As Exception
-                    Console.WriteLine("Error: " & e.Message)
-                    Console.WriteLine(e.StackTrace)
-                    Continue Do
-                End Try
-            Loop While True
-        End function
-    End Class
-End Namespace
diff --git a/vb/stepA_mal.vb b/vb/stepA_mal.vb
new file mode 100644
index 0000000..6778e0a
--- /dev/null
+++ b/vb/stepA_mal.vb
@@ -0,0 +1,317 @@
+Imports System
+Imports System.IO
+Imports System.Collections.Generic
+Imports Mal
+Imports MalVal = Mal.types.MalVal
+Imports MalInt = Mal.types.MalInt
+Imports MalString = Mal.types.MalString
+Imports MalSymbol = Mal.types.MalSymbol
+Imports MalList = Mal.types.MalList
+Imports MalVector = Mal.types.MalVector
+Imports MalHashMap = Mal.types.MalHashMap
+Imports MalFunc = Mal.types.MalFunc
+Imports MalEnv = Mal.env.Env
+
+Namespace Mal
+    Class stepA_mal
+        ' read
+        Shared Function READ(str As String) As MalVal
+            Return reader.read_str(str)
+        End Function
+
+        ' eval
+        Shared Function is_pair(x As MalVal) As Boolean
+            return TypeOf x Is MalList AndAlso _
+                   DirectCast(x,MalList).size() > 0
+        End Function
+
+        Shared Function quasiquote(ast As MalVal) As MalVal
+            If not is_pair(ast) Then
+                return New MalList(New MalSymbol("quote"), ast)
+            Else
+                Dim a0 As MalVal = DirectCast(ast,MalList)(0)
+                If TypeOf a0 Is MalSymbol AndAlso _
+                    DirectCast(a0,MalSymbol).getName() = "unquote" Then
+                    return DirectCast(ast,MalList)(1)
+                Else If is_pair(a0) Then
+                    Dim a00 As MalVal = DirectCast(a0,MalList)(0)
+                    If TypeOf a00 is MalSymbol AndAlso _
+                        DirectCast(a00,MalSymbol).getName() = "splice-unquote" Then
+                        return New MalList(New MalSymbol("concat"),
+                                           DirectCast(a0,MalList)(1),
+                                           quasiquote(DirectCast(ast,MalList).rest()))
+                    End If
+                End If
+                return New MalList(New MalSymbol("cons"),
+                                   quasiquote(a0),
+                                   quasiquote(DirectCast(ast,MalList).rest()))
+            End If
+        End Function
+
+        Shared Function is_macro_call(ast As MalVal, env As MalEnv) As Boolean
+            If TypeOf ast Is MalList Then
+                Dim a0 As MalVal = DirectCast(ast,MalList)(0)
+                If TypeOf a0 Is MalSymbol AndAlso _
+                    env.find(DirectCast(a0,MalSymbol)) IsNot Nothing Then
+                    Dim mac As MalVal = env.do_get(DirectCast(a0,MalSymbol))
+                    If TypeOf mac Is MalFunc AndAlso _
+                        DirectCast(mac,MalFunc).isMacro() Then
+                        return True
+                    End If
+                End If
+            End If
+            return False
+        End Function
+
+        Shared Function macroexpand(ast As MalVal, env As MalEnv) As MalVal
+            While is_macro_call(ast, env)
+                Dim a0 As MalSymbol = DirectCast(DirectCast(ast,MalList)(0),MalSymbol)
+                Dim mac As MalFunc = DirectCast(env.do_get(a0),MalFunc)
+                ast = mac.apply(DirectCast(ast,MalList).rest())
+            End While
+            return ast
+        End Function
+
+        Shared Function eval_ast(ast As MalVal, env As MalEnv) As MalVal
+            If TypeOf ast Is MalSymbol Then
+                return env.do_get(DirectCast(ast, MalSymbol))
+            Else If TypeOf ast Is MalList Then
+                Dim old_lst As MalList = DirectCast(ast, MalList)
+                Dim new_lst As MalList
+                If ast.list_Q() Then
+                    new_lst = New MalList
+                Else
+                    new_lst = DirectCast(New MalVector, MalList)
+                End If
+                Dim mv As MalVal
+                For Each mv in old_lst.getValue()
+                    new_lst.conj_BANG(EVAL(mv, env))
+                Next
+                return new_lst
+            Else If TypeOf ast Is MalHashMap Then
+                Dim new_dict As New Dictionary(Of String, MalVal)
+                Dim entry As KeyValuePair(Of String, MalVal)
+                For Each entry in DirectCast(ast,MalHashMap).getValue()
+                    new_dict.Add(entry.Key, EVAL(DirectCast(entry.Value,MalVal), env))
+                Next
+                return New MalHashMap(new_dict)
+            Else
+                return ast
+            End If
+            return ast
+        End Function
+
+        ' TODO: move to types.vb when it is ported
+        Class FClosure
+            Public ast As MalVal
+            Public params As MalList
+            Public env As MalEnv
+            Function fn(args as MalList) As MalVal
+                return EVAL(ast, new MalEnv(env, params, args))
+            End Function
+        End Class
+
+        Shared Function EVAL(orig_ast As MalVal, env As MalEnv) As MalVal
+            Do
+
+            'Console.WriteLine("EVAL: {0}", printer._pr_str(orig_ast, true))
+            If not orig_ast.list_Q() Then
+                return eval_ast(orig_ast, env)
+            End If
+
+            ' apply list
+            Dim expanded As MalVal = macroexpand(orig_ast, env)
+            if not expanded.list_Q() Then
+                return expanded
+            End If
+            Dim ast As MalList = DirectCast(expanded, MalList)
+
+            If ast.size() = 0  Then
+                return ast
+            End If
+            Dim a0 As MalVal = ast(0)
+            Dim a0sym As String
+            If TypeOf a0 is MalSymbol Then
+                a0sym = DirectCast(a0,MalSymbol).getName()
+            Else
+                a0sym = "__<*fn*>__"
+            End If
+
+            Select a0sym
+            Case "def!"
+                Dim a1 As MalVal = ast(1)
+                Dim a2 As MalVal = ast(2)
+                Dim res As MalVal = EVAL(a2, env)
+                env.do_set(DirectCast(a1,MalSymbol), res)
+                return res
+            Case "let*"
+                Dim a1 As MalVal = ast(1)
+                Dim a2 As MalVal = ast(2)
+                Dim key As MalSymbol
+                Dim val as MalVal
+                Dim let_env As new MalEnv(env)
+                For i As Integer = 0 To (DirectCast(a1,MalList)).size()-1 Step 2
+                    key = DirectCast(DirectCast(a1,MalList)(i),MalSymbol)
+                    val = DirectCast(a1,MalList)(i+1)
+                    let_env.do_set(key, EVAL(val, let_env))
+                Next
+                orig_ast = a2
+                env = let_env
+            Case "quote"
+                return ast(1)
+            Case "quasiquote"
+                orig_ast = quasiquote(ast(1))
+            Case "defmacro!"
+                Dim a1 As MalVal = ast(1)
+                Dim a2 As MalVal = ast(2)
+                Dim res As MalVal = EVAL(a2, env)
+                DirectCast(res,MalFunc).setMacro()
+                env.do_set(DirectCast(a1,MalSymbol), res)
+                return res
+            Case "macroexpand"
+                Dim a1 As MalVal = ast(1)
+                return macroexpand(a1, env)
+            Case "try*"
+                Try
+                    return EVAL(ast(1), env)
+                Catch e As Exception
+                    If ast.size() > 2 Then
+                        Dim exc As MalVal
+                        Dim a2 As MalVal = ast(2)
+                        Dim a20 As MalVal = DirectCast(a2,MalList)(0)
+                        If DirectCast(a20,MalSymbol).getName() = "catch*" Then
+                            If TypeOf e Is Mal.types.MalException Then
+                                exc = DirectCast(e,Mal.types.MalException).getValue()
+                            Else
+                                exc = New MalString(e.StackTrace)
+                            End If
+                            return EVAL(
+                                DirectCast(a2,MalList)(2),
+                                New MalEnv(env,
+                                           DirectCast(a2,MalList).slice(1,2),
+                                           New MalList(exc)))
+                        End If
+                        Throw e
+                    End If
+                End Try
+            Case "do"
+                eval_ast(ast.slice(1, ast.size()-1), env)
+                orig_ast = ast(ast.size()-1)
+            Case "if"
+                Dim a1 As MalVal = ast(1)
+                Dim cond As MalVal = EVAL(a1, env)
+                If cond Is Mal.types.Nil or cond Is Mal.types.MalFalse Then
+                    ' eval false slot form
+                    If ast.size() > 3 Then
+                        orig_ast = ast(3)
+                    Else
+                        return Mal.types.Nil
+                    End If
+                Else
+                    ' eval true slot form
+                    orig_ast = ast(2)
+
+                End If
+            Case "fn*"
+                Dim fc As New FClosure()
+                fc.ast = ast(2)
+                fc.params = DirectCast(ast(1),MalLIst)
+                fc.env = env
+                Dim f As Func(Of MalList, MalVal) = AddressOf fc.fn
+                Dim mf As new MalFunc(ast(2), env,
+                                      DirectCast(ast(1),MalList), f)
+                return DirectCast(mf,MalVal)
+            Case Else
+                Dim el As MalList = DirectCast(eval_ast(ast, env), MalList)
+                Dim f As MalFunc = DirectCast(el(0), MalFunc)
+                Dim fnast As MalVal = f.getAst()
+                If not fnast Is Nothing
+                    orig_ast = fnast
+                    env = f.genEnv(el.rest())
+                Else
+                    Return f.apply(el.rest())
+                End If
+            End Select
+
+            Loop While True
+        End Function
+        
+        ' print
+        Shared Function PRINT(exp As MalVal) As String
+            return printer._pr_str(exp, TRUE)
+        End Function
+
+        ' repl
+        Shared repl_env As MalEnv
+
+        Shared Function REP(str As String) As String
+            Return PRINT(EVAL(READ(str), repl_env))
+        End Function
+
+        Shared Function do_eval(args As MalList) As MalVal
+            Return EVAL(args(0), repl_env)
+        End Function
+
+        Shared Function Main As Integer
+            Dim args As String() = Environment.GetCommandLineArgs()
+
+            repl_env = New MalEnv(Nothing)
+
+            ' core.vb: defined using VB.NET
+            For Each entry As KeyValuePair(Of String,MalVal) In core.ns()
+                repl_env.do_set(new MalSymbol(entry.Key), entry.Value)
+            Next
+            repl_env.do_set(new MalSymbol("eval"), new MalFunc(AddressOf do_eval))
+            Dim fileIdx As Integer = 1
+            If args.Length > 1 AndAlso args(1) = "--raw" Then
+                Mal.readline.SetMode(Mal.readline.Modes.Raw)
+                fileIdx = 2
+            End If
+            Dim argv As New MalList()
+            For i As Integer = fileIdx+1 To args.Length-1
+                argv.conj_BANG(new MalString(args(i)))
+            Next
+            repl_env.do_set(new MalSymbol("*ARGV*"), argv)
+
+            ' core.mal: defined using the language itself
+            REP("(def! *host-language* ""VB.NET"")")
+            REP("(def! not (fn* (a) (if a false true)))")
+            REP("(def! load-file (fn* (f) (eval (read-string (str ""(do "" (slurp f) "")"")))))")
+            REP("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw ""odd number of forms to cond"")) (cons 'cond (rest (rest xs)))))))")
+            REP("(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))")
+
+            If args.Length > fileIdx Then
+                REP("(load-file """ & args(fileIdx) & """)")
+                return 0
+            End If
+
+            ' repl loop
+            Dim line As String
+            REP("(println (str ""Mal ["" *host-language* ""]""))")
+            Do
+                Try
+                    line = Mal.readline.Readline("user> ")
+                    If line is Nothing Then
+                        Exit Do
+                    End If
+                    If line = "" Then
+                        Continue Do
+                    End If
+                Catch e As IOException
+                    Console.WriteLine("IOException: " & e.Message)
+                End Try
+                Try
+                    Console.WriteLine(REP(line))
+                Catch e As Mal.types.MalException
+                    Console.WriteLine("Error: " & _
+                        printer._pr_str(e.getValue(), False))
+                    Continue Do
+                Catch e As Exception
+                    Console.WriteLine("Error: " & e.Message)
+                    Console.WriteLine(e.StackTrace)
+                    Continue Do
+                End Try
+            Loop While True
+        End function
+    End Class
+End Namespace
-- 
cgit v1.2.3


From 90ab31710e9a495ba3aebf7948e366093896d6d7 Mon Sep 17 00:00:00 2001
From: Joel Martin <github@martintribe.org>
Date: Sat, 28 Feb 2015 11:18:18 -0600
Subject: JS: fix https://github.com/kanaka/mal/issues/9

---
 tests/step2_eval.mal | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/step2_eval.mal b/tests/step2_eval.mal
index aaf1a7d..e975910 100644
--- a/tests/step2_eval.mal
+++ b/tests/step2_eval.mal
@@ -11,8 +11,8 @@
 (/ (- (+ 5 (* 2 3)) 3) 4)
 ;=>2
 
-(/ (- (+ 515 (* 222 311)) 300) 41)
-;=>1689
+(/ (- (+ 515 (* 222 311)) 302) 27)
+;=>2565
 
 (abc 1 2 3)
 ; .*\'abc\' not found.*
-- 
cgit v1.2.3


From 943f21c4220400e8c2c10a25c12537694d868e9b Mon Sep 17 00:00:00 2001
From: Thomas Coopman <thomas.coopman@gmail.com>
Date: Sat, 28 Feb 2015 22:27:53 +0100
Subject: small typo

---
 process/guide.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/process/guide.md b/process/guide.md
index c91c81a..6c6887c 100644
--- a/process/guide.md
+++ b/process/guide.md
@@ -352,7 +352,7 @@ and each step will give progressively more bang for the buck.
 * Add support for the other basic data type to your reader and printer
   functions: string, nil, true, and false. These become mandatory at
   step 4. When a string is read, a slash followed by a doublequote is
-  translatd into a plain doublequote character and a slash followed by
+  translated into a plain doublequote character and a slash followed by
   "n" is translated into a newline. To properly print a string (for
   step 4 string functions), the `pr_str` function needs another
   parameter called `print_readably`. When `print_readably` is true,
-- 
cgit v1.2.3


From 7907cd904a12c542529b27b0517a609e9cc4bb08 Mon Sep 17 00:00:00 2001
From: Joel Martin <github@martintribe.org>
Date: Sat, 28 Feb 2015 15:41:18 -0600
Subject: runtest.py: order of magnitude faster.

C#, VB and Lua tests are broken though.
---
 Makefile       |  11 +++--
 docs/TODO      |   4 +-
 runtest-old.py | 134 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 runtest.py     |  86 +++++++++++++++++++++++++-----------
 4 files changed, 205 insertions(+), 30 deletions(-)
 create mode 100755 runtest-old.py

diff --git a/Makefile b/Makefile
index 674ad71..6405422 100644
--- a/Makefile
+++ b/Makefile
@@ -29,18 +29,21 @@ stepA = stepA_mal
 EXCLUDE_TESTS += test^bash^step5 # no stack exhaustion or completion
 EXCLUDE_TESTS += test^c^step5    # segfault
 EXCLUDE_TESTS += test^cs^step5   # fatal stack overflow fault
+EXCLUDE_TESTS += test^haskell^step5 # test completes
 EXCLUDE_TESTS += test^make^step5 # no TCO capability/step
 EXCLUDE_TESTS += test^mal^step5  # no TCO capability/step
 EXCLUDE_TESTS += test^go^step5   # test completes, even at 100,000
 EXCLUDE_TESTS += test^php^step5  # test completes, even at 100,000
+EXCLUDE_TESTS += test^racket^step5 # test completes
 EXCLUDE_TESTS += test^ruby^step5 # test completes, even at 100,000
 EXCLUDE_TESTS += test^rust^step5 # no catching stack overflows
 EXCLUDE_TESTS += test^ocaml^step5 # test completes, even at 1,000,000
 
 # interop tests now implemented yet
-EXCLUDE_TESTS += test^cs^stepA test^java^stepA test^mal^stepA \
-		 test^mal^step0 test^php^stepA test^ps^stepA \
-		 test^python^stepA test^ruby^stepA
+EXCLUDE_TESTS += test^cs^stepA test^go^stepA test^haskell^stepA \
+		 test^java^stepA test^mal^stepA test^mal^step0 \
+		 test^php^stepA test^ps^stepA test^python^stepA \
+		 test^ruby^stepA
 
 EXCLUDE_PERFS = perf^mal  # TODO: fix this
 
@@ -112,7 +115,7 @@ vb_RUNSTEP =      mono ../$(2) --raw $(3)
 
 # Extra options to pass to runtest.py
 cs_TEST_OPTS =  --redirect
-mal_TEST_OPTS = --redirect --start-timeout 60 --test-timeout 120
+mal_TEST_OPTS = --start-timeout 60 --test-timeout 120
 vb_TEST_OPTS =  --redirect
 
 
diff --git a/docs/TODO b/docs/TODO
index e5a4fc1..0452fe0 100644
--- a/docs/TODO
+++ b/docs/TODO
@@ -9,8 +9,8 @@ All:
       of iterations per second
     - redefine (defmacro!) as (def! (macro*))
     - runtest expect fixes:
-        - stop using expect, so we can drop --raw option
-        - fix long lines in runtext/expect
+        * stop using expect, so we can drop --raw option
+        - fix long line splitting in runtest
     - regular expression matching in runtest
     - add re (use in rep) everywhere and use that (to avoid printing)
     - Implement/fix interop
diff --git a/runtest-old.py b/runtest-old.py
new file mode 100755
index 0000000..aacd770
--- /dev/null
+++ b/runtest-old.py
@@ -0,0 +1,134 @@
+#!/usr/bin/env python
+
+import os, sys, re
+import argparse
+
+# http://pexpect.sourceforge.net/pexpect.html
+from pexpect import spawn, EOF, TIMEOUT
+
+# TODO: do we need to support '\n' too
+sep = "\r\n"
+rundir = None
+
+parser = argparse.ArgumentParser(
+        description="Run a test file against a Mal implementation")
+parser.add_argument('--rundir',
+        help="change to the directory before running tests")
+parser.add_argument('--start-timeout', default=10, type=int,
+        help="default timeout for initial prompt")
+parser.add_argument('--test-timeout', default=20, type=int,
+        help="default timeout for each individual test action")
+parser.add_argument('--pre-eval', default=None, type=str,
+        help="Mal code to evaluate prior to running the test")
+parser.add_argument('--redirect', action='store_true',
+        help="Run implementation in bash and redirect output to /dev/null")
+
+parser.add_argument('test_file', type=argparse.FileType('r'),
+        help="a test file formatted as with mal test data")
+parser.add_argument('mal_cmd', nargs="*",
+        help="Mal implementation command line. Use '--' to "
+             "specify a Mal command line with dashed options.")
+
+args = parser.parse_args(sys.argv[1:])
+test_data = args.test_file.read().split('\n')
+
+if args.rundir: os.chdir(args.rundir)
+
+if args.redirect:
+    # Redirect to try and force raw mode (no ASCII codes)
+    p = spawn('/bin/bash -c "' + " ".join(args.mal_cmd) + ' |tee /dev/null"')
+else:
+    p = spawn(args.mal_cmd[0], args.mal_cmd[1:])
+
+
+test_idx = 0
+def read_test(data):
+    global test_idx
+    form, output, ret = None, "", None
+    while data:
+        test_idx += 1
+        line = data.pop(0)
+        if re.match(r"^\s*$", line):   # blank line
+            continue
+        elif line[0:3] == ";;;":       # ignore comment
+            continue
+        elif line[0:2] == ";;":        # output comment
+            print line[3:]
+            continue
+        elif line[0:2] == ";":         # unexpected comment
+            print "Test data error at line %d:\n%s" % (test_idx, line)
+            return None, None, None, test_idx
+        form = line   # the line is a form to send
+
+        # Now find the output and return value
+        while data:
+            line = data[0]
+            if line[0:3] == ";=>":
+                ret = line[3:].replace('\\r', '\r').replace('\\n', '\n')
+                test_idx += 1
+                data.pop(0)
+                break
+            elif line[0:2] == "; ":
+                output = output + line[2:] + sep
+                test_idx += 1
+                data.pop(0)
+            else:
+                ret = "*"
+                break
+        if ret: break
+
+    return form, output, ret, test_idx
+
+def assert_prompt(timeout):
+    # Wait for the initial prompt
+    idx = p.expect(['user> ', 'mal-user> ', EOF, TIMEOUT],
+                timeout=timeout)
+    if idx not in [0,1]:
+        print "Did not get 'user> ' or 'mal-user> ' prompt"
+        print "    Got      : %s" % repr(p.before)
+        sys.exit(1)
+
+
+# Wait for the initial prompt
+assert_prompt(args.start_timeout)
+
+# Send the pre-eval code if any
+if args.pre_eval:
+    sys.stdout.write("RUNNING pre-eval: %s" % args.pre_eval)
+    p.sendline(args.pre_eval)
+    assert_prompt(args.test_timeout)
+
+fail_cnt = 0
+
+while test_data:
+    form, out, ret, line_num = read_test(test_data)
+    if form == None:
+        break
+    sys.stdout.write("TEST: %s -> [%s,%s]" % (form, repr(out), repr(ret)))
+    sys.stdout.flush()
+    expected = "%s%s%s%s" % (form, sep, out, ret)
+
+    p.sendline(form)
+    try:
+        idx = p.expect(['\r\nuser> ', '\nuser> ',
+                        '\r\nmal-user> ', '\nmal-user> '],
+                       timeout=args.test_timeout)
+        #print "%s,%s,%s" % (idx, repr(p.before), repr(p.after))
+        if ret == "*" or p.before == expected:
+            print " -> SUCCESS"
+        else:
+            print " -> FAIL (line %d):" % line_num
+            print "    Expected : %s" % repr(expected)
+            print "    Got      : %s" % repr(p.before)
+            fail_cnt += 1
+    except EOF:
+        print "Got EOF"
+        sys.exit(1)
+    except TIMEOUT:
+        print "Got TIMEOUT, received: %s" % repr(p.before)
+        sys.exit(1)
+
+if fail_cnt > 0:
+    print "FAILURES: %d" % fail_cnt
+    sys.exit(2)
+sys.exit(0)
diff --git a/runtest.py b/runtest.py
index aacd770..858c634 100755
--- a/runtest.py
+++ b/runtest.py
@@ -1,13 +1,15 @@
 #!/usr/bin/env python
 
 import os, sys, re
-import argparse
+import argparse, time
 
-# http://pexpect.sourceforge.net/pexpect.html
-from pexpect import spawn, EOF, TIMEOUT
+import pty
+from subprocess import Popen, STDOUT, PIPE
+from select import select
 
 # TODO: do we need to support '\n' too
 sep = "\r\n"
+#sep = "\n"
 rundir = None
 
 parser = argparse.ArgumentParser(
@@ -29,16 +31,53 @@ parser.add_argument('mal_cmd', nargs="*",
         help="Mal implementation command line. Use '--' to "
              "specify a Mal command line with dashed options.")
 
+class Runner():
+    def __init__(self, args, redirect=False):
+        print "args: %s" % repr(args)
+        if redirect:
+            print "using redirect"
+            self.p = Popen(args, bufsize=0, stdin=PIPE, stdout=PIPE, stderr=STDOUT)
+            self.stdin = self.p.stdin
+            self.stdout = self.p.stdout
+        else:
+            # provide tty to get 'interactive' readline to work
+            master, slave = pty.openpty()
+            self.p = Popen(args, bufsize=0, stdin=slave, stdout=slave, stderr=STDOUT)
+            self.stdin = os.fdopen(master, 'r+b', 0)
+            self.stdout = self.stdin
+
+        #print "started"
+        self.buf = ""
+        self.last_prompt = ""
+
+    def read_to_prompt(self, prompts, timeout):
+        end_time = time.time() + timeout
+        while time.time() < end_time:
+            [outs,_,_] = select([self.stdin], [], [], 1)
+            if self.stdin in outs:
+                new_data = self.stdin.read(1)
+                #print "new_data: '%s'" % new_data
+                self.buf += new_data
+                for prompt in prompts:
+                    regexp = re.compile(prompt)
+                    match = regexp.search(self.buf)
+                    if match:
+                        end = match.end()
+                        buf = self.buf[0:end-len(prompt)]
+                        self.buf = self.buf[end:]
+                        self.last_prompt = prompt
+                        return buf
+        return None
+
+    def write(self, str):
+        self.stdout.write(str)
+
 args = parser.parse_args(sys.argv[1:])
 test_data = args.test_file.read().split('\n')
 
 if args.rundir: os.chdir(args.rundir)
 
-if args.redirect:
-    # Redirect to try and force raw mode (no ASCII codes)
-    p = spawn('/bin/bash -c "' + " ".join(args.mal_cmd) + ' |tee /dev/null"')
-else:
-    p = spawn(args.mal_cmd[0], args.mal_cmd[1:])
+r = Runner(args.mal_cmd, redirect=args.redirect)
 
 
 test_idx = 0
@@ -81,11 +120,13 @@ def read_test(data):
 
 def assert_prompt(timeout):
     # Wait for the initial prompt
-    idx = p.expect(['user> ', 'mal-user> ', EOF, TIMEOUT],
-                timeout=timeout)
-    if idx not in [0,1]:
+    header = r.read_to_prompt(['user> ', 'mal-user> '], timeout=timeout)
+    if not header == None:
+        if header:
+            print "Started with:\n%s" % header
+    else:
         print "Did not get 'user> ' or 'mal-user> ' prompt"
-        print "    Got      : %s" % repr(p.before)
+        print "    Got      : %s" % repr(r.buf)
         sys.exit(1)
 
 
@@ -95,7 +136,7 @@ assert_prompt(args.start_timeout)
 # Send the pre-eval code if any
 if args.pre_eval:
     sys.stdout.write("RUNNING pre-eval: %s" % args.pre_eval)
-    p.sendline(args.pre_eval)
+    p.write(args.pre_eval)
     assert_prompt(args.test_timeout)
 
 fail_cnt = 0
@@ -108,24 +149,21 @@ while test_data:
     sys.stdout.flush()
     expected = "%s%s%s%s" % (form, sep, out, ret)
 
-    p.sendline(form)
+    r.write(form + "\n")
     try:
-        idx = p.expect(['\r\nuser> ', '\nuser> ',
-                        '\r\nmal-user> ', '\nmal-user> '],
-                       timeout=args.test_timeout)
+        res = r.read_to_prompt(['\r\nuser> ', '\nuser> ',
+                                '\r\nmal-user> ', '\nmal-user> '],
+                                timeout=args.test_timeout)
         #print "%s,%s,%s" % (idx, repr(p.before), repr(p.after))
-        if ret == "*" or p.before == expected:
+        if ret == "*" or res == expected:
             print " -> SUCCESS"
         else:
             print " -> FAIL (line %d):" % line_num
             print "    Expected : %s" % repr(expected)
-            print "    Got      : %s" % repr(p.before)
+            print "    Got      : %s" % repr(res)
             fail_cnt += 1
-    except EOF:
-        print "Got EOF"
-        sys.exit(1)
-    except TIMEOUT:
-        print "Got TIMEOUT, received: %s" % repr(p.before)
+    except:
+        print "Got Exception"
         sys.exit(1)
 
 if fail_cnt > 0:
-- 
cgit v1.2.3


From 3e0b36dcee99ddfd7ea0e04a382c1ad3858fc45f Mon Sep 17 00:00:00 2001
From: Joel Martin <github@martintribe.org>
Date: Sat, 28 Feb 2015 15:58:35 -0600
Subject: Lua: fix with new runtest.py

---
 Makefile                 |  2 +-
 docs/TODO                |  1 +
 lua/core.lua             |  2 ++
 lua/readline.lua         |  9 ++++++++-
 lua/step1_read_print.lua |  4 ++++
 lua/step2_eval.lua       |  4 ++++
 lua/step3_env.lua        |  4 ++++
 lua/step4_if_fn_do.lua   |  4 ++++
 lua/step5_tco.lua        |  4 ++++
 lua/step6_file.lua       |  5 +++++
 lua/step7_quote.lua      |  5 +++++
 lua/step8_macros.lua     |  5 +++++
 lua/step9_try.lua        | 31 +++++++++++++++++++------------
 lua/stepA_mal.lua        |  5 +++++
 14 files changed, 71 insertions(+), 14 deletions(-)

diff --git a/Makefile b/Makefile
index 6405422..85652a6 100644
--- a/Makefile
+++ b/Makefile
@@ -95,7 +95,7 @@ go_RUNSTEP =      ../$(2) $(3)
 haskell_RUNSTEP = ../$(2) $(3)
 java_RUNSTEP =    mvn -quiet exec:java -Dexec.mainClass="mal.$($(1))" -Dexec.args="--raw$(if $(3), $(3),)"
 js_RUNSTEP =      node ../$(2) $(3)
-lua_RUNSTEP =     ../$(2) $(3)
+lua_RUNSTEP =     ../$(2) --raw $(3)
 make_RUNSTEP =    make -f ../$(2) $(3)
 mal_RUNSTEP =     $(call $(MAL_IMPL)_RUNSTEP,$(1),$(call $(MAL_IMPL)_STEP_TO_PROG,stepA),../$(2),")  #"
 ocaml_RUNSTEP =   ../$(2) $(3)
diff --git a/docs/TODO b/docs/TODO
index 0452fe0..8abbf6c 100644
--- a/docs/TODO
+++ b/docs/TODO
@@ -9,6 +9,7 @@ All:
       of iterations per second
     - redefine (defmacro!) as (def! (macro*))
     - runtest expect fixes:
+        - fix C#, VB and Lua
         * stop using expect, so we can drop --raw option
         - fix long line splitting in runtest
     - regular expression matching in runtest
diff --git a/lua/core.lua b/lua/core.lua
index 3f46aeb..279a6d6 100644
--- a/lua/core.lua
+++ b/lua/core.lua
@@ -23,12 +23,14 @@ end
 function prn(...)
     print(table.concat(
         utils.map(function(e) return _pr_str(e, true) end, arg), " "))
+    io.flush()
     return Nil
 end
 
 function println(...)
     print(table.concat(
         utils.map(function(e) return _pr_str(e, false) end, arg), " "))
+    io.flush()
     return Nil
 end
 
diff --git a/lua/readline.lua b/lua/readline.lua
index a75f4ff..5acdb54 100644
--- a/lua/readline.lua
+++ b/lua/readline.lua
@@ -5,6 +5,8 @@ local M = {}
 local history_loaded = false
 local history_file = os.getenv("HOME") .. "/.mal-history"
 
+M.raw = false
+
 function M.readline(prompt)
     if not history_loaded then
         history_loaded = true
@@ -13,7 +15,12 @@ function M.readline(prompt)
         end
     end
 
-    line = LN.linenoise(prompt)
+    if M.raw then
+        io.write(prompt); io.flush();
+        line = io.read()
+    else
+        line = LN.linenoise(prompt)
+    end
     if line then
         LN.historyadd(line)
         local f = io.open(history_file, "a")
diff --git a/lua/step1_read_print.lua b/lua/step1_read_print.lua
index abd555d..46d71f5 100755
--- a/lua/step1_read_print.lua
+++ b/lua/step1_read_print.lua
@@ -25,6 +25,10 @@ function rep(str)
     return PRINT(EVAL(READ(str),""))
 end
 
+if #arg > 0 and arg[1] == "--raw" then
+    readline.raw = true
+end
+
 while true do
     line = readline.readline("user> ")
     if not line then break end
diff --git a/lua/step2_eval.lua b/lua/step2_eval.lua
index 7487064..22ac8cf 100755
--- a/lua/step2_eval.lua
+++ b/lua/step2_eval.lua
@@ -58,6 +58,10 @@ function rep(str)
     return PRINT(EVAL(READ(str),repl_env))
 end
 
+if #arg > 0 and arg[1] == "--raw" then
+    readline.raw = true
+end
+
 while true do
     line = readline.readline("user> ")
     if not line then break end
diff --git a/lua/step3_env.lua b/lua/step3_env.lua
index ed2e62a..dbdb879 100755
--- a/lua/step3_env.lua
+++ b/lua/step3_env.lua
@@ -71,6 +71,10 @@ repl_env:set(types.Symbol:new('-'), function(a,b) return a-b end)
 repl_env:set(types.Symbol:new('*'), function(a,b) return a*b end)
 repl_env:set(types.Symbol:new('/'), function(a,b) return math.floor(a/b) end)
 
+if #arg > 0 and arg[1] == "--raw" then
+    readline.raw = true
+end
+
 while true do
     line = readline.readline("user> ")
     if not line then break end
diff --git a/lua/step4_if_fn_do.lua b/lua/step4_if_fn_do.lua
index e211973..65b3a0a 100755
--- a/lua/step4_if_fn_do.lua
+++ b/lua/step4_if_fn_do.lua
@@ -89,6 +89,10 @@ end
 -- core.mal: defined using mal
 rep("(def! not (fn* (a) (if a false true)))")
 
+if #arg > 0 and arg[1] == "--raw" then
+    readline.raw = true
+end
+
 while true do
     line = readline.readline("user> ")
     if not line then break end
diff --git a/lua/step5_tco.lua b/lua/step5_tco.lua
index fa4e41f..237f5ea 100755
--- a/lua/step5_tco.lua
+++ b/lua/step5_tco.lua
@@ -97,6 +97,10 @@ end
 -- core.mal: defined using mal
 rep("(def! not (fn* (a) (if a false true)))")
 
+if #arg > 0 and arg[1] == "--raw" then
+    readline.raw = true
+end
+
 while true do
     line = readline.readline("user> ")
     if not line then break end
diff --git a/lua/step6_file.lua b/lua/step6_file.lua
index b109a90..7992888 100755
--- a/lua/step6_file.lua
+++ b/lua/step6_file.lua
@@ -101,6 +101,11 @@ repl_env:set(types.Symbol:new('*ARGV*'), types.List:new(types.slice(arg,2)))
 rep("(def! not (fn* (a) (if a false true)))")
 rep("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))")
 
+if #arg > 0 and arg[1] == "--raw" then
+    readline.raw = true
+    table.remove(arg,1)
+end
+
 if #arg > 0 then
     rep("(load-file \""..arg[1].."\")")
     os.exit(0)
diff --git a/lua/step7_quote.lua b/lua/step7_quote.lua
index 974e342..32bf60c 100755
--- a/lua/step7_quote.lua
+++ b/lua/step7_quote.lua
@@ -127,6 +127,11 @@ repl_env:set(types.Symbol:new('*ARGV*'), types.List:new(types.slice(arg,2)))
 rep("(def! not (fn* (a) (if a false true)))")
 rep("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))")
 
+if #arg > 0 and arg[1] == "--raw" then
+    readline.raw = true
+    table.remove(arg,1)
+end
+
 if #arg > 0 then
     rep("(load-file \""..arg[1].."\")")
     os.exit(0)
diff --git a/lua/step8_macros.lua b/lua/step8_macros.lua
index 46a5881..25a9238 100755
--- a/lua/step8_macros.lua
+++ b/lua/step8_macros.lua
@@ -156,6 +156,11 @@ rep("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\"))
 rep("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))")
 rep("(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))")
 
+if #arg > 0 and arg[1] == "--raw" then
+    readline.raw = true
+    table.remove(arg,1)
+end
+
 if #arg > 0 then
     rep("(load-file \""..arg[1].."\")")
     os.exit(0)
diff --git a/lua/step9_try.lua b/lua/step9_try.lua
index f3d8cce..315d698 100755
--- a/lua/step9_try.lua
+++ b/lua/step9_try.lua
@@ -174,23 +174,30 @@ rep("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\"))
 rep("(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw \"odd number of forms to cond\")) (cons 'cond (rest (rest xs)))))))")
 rep("(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) `(let* (or_FIXME ~(first xs)) (if or_FIXME or_FIXME (or ~@(rest xs))))))))")
 
+function print_exception(exc)
+    if exc then
+        if types._malexception_Q(exc) then
+            exc = printer._pr_str(exc.val, true)
+        end
+        print("Error: " .. exc)
+        print(debug.traceback())
+    end
+end
+
+if #arg > 0 and arg[1] == "--raw" then
+    readline.raw = true
+    table.remove(arg,1)
+end
+
 if #arg > 0 then
-    rep("(load-file \""..arg[1].."\")")
+    xpcall(function() rep("(load-file \""..arg[1].."\")") end,
+           print_exception)
     os.exit(0)
 end
 
 while true do
     line = readline.readline("user> ")
     if not line then break end
-    xpcall(function()
-        print(rep(line))
-    end, function(exc)
-        if exc then
-            if types._malexception_Q(exc) then
-                exc = printer._pr_str(exc.val, true)
-            end
-            print("Error: " .. exc)
-            print(debug.traceback())
-        end
-    end)
+    xpcall(function() print(rep(line)) end,
+           print_exception)
 end
diff --git a/lua/stepA_mal.lua b/lua/stepA_mal.lua
index 430fffc..db31789 100755
--- a/lua/stepA_mal.lua
+++ b/lua/stepA_mal.lua
@@ -185,6 +185,11 @@ function print_exception(exc)
     end
 end
 
+if #arg > 0 and arg[1] == "--raw" then
+    readline.raw = true
+    table.remove(arg,1)
+end
+
 if #arg > 0 then
     xpcall(function() rep("(load-file \""..arg[1].."\")") end,
            print_exception)
-- 
cgit v1.2.3


From f6c83b2b802ef540afcdeccdee76f006629737bd Mon Sep 17 00:00:00 2001
From: Joel Martin <github@martintribe.org>
Date: Sat, 28 Feb 2015 16:25:00 -0600
Subject: runtest.py: cleanup orphan test processes.

---
 docs/TODO  | 2 +-
 runtest.py | 9 +++++++++
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/docs/TODO b/docs/TODO
index 8abbf6c..e586f52 100644
--- a/docs/TODO
+++ b/docs/TODO
@@ -9,8 +9,8 @@ All:
       of iterations per second
     - redefine (defmacro!) as (def! (macro*))
     - runtest expect fixes:
-        - fix C#, VB and Lua
         * stop using expect, so we can drop --raw option
+        - fix C#, VB
         - fix long line splitting in runtest
     - regular expression matching in runtest
     - add re (use in rep) everywhere and use that (to avoid printing)
diff --git a/runtest.py b/runtest.py
index 858c634..e90fc68 100755
--- a/runtest.py
+++ b/runtest.py
@@ -72,6 +72,12 @@ class Runner():
     def write(self, str):
         self.stdout.write(str)
 
+    def cleanup(self):
+        if self.p:
+            self.p.terminate()
+            self.p = None
+
+
 args = parser.parse_args(sys.argv[1:])
 test_data = args.test_file.read().split('\n')
 
@@ -127,6 +133,7 @@ def assert_prompt(timeout):
     else:
         print "Did not get 'user> ' or 'mal-user> ' prompt"
         print "    Got      : %s" % repr(r.buf)
+        r.cleanup()
         sys.exit(1)
 
 
@@ -164,7 +171,9 @@ while test_data:
             fail_cnt += 1
     except:
         print "Got Exception"
+        r.cleanup()
         sys.exit(1)
+r.cleanup()
 
 if fail_cnt > 0:
     print "FAILURES: %d" % fail_cnt
-- 
cgit v1.2.3