 
 
 
-; ;;;; Push types and instructions
-
-
-; ;; recognizers work for routing
-
-; (def test-interpreter
-;   (core/register-types 
-;     (owe/make-everything-interpreter)
-;     [push-point push-line push-circle]))
-
-
-; (def point-class (class (make-point 0.0 0.0)))
-
-
-; (def line-class (class (make-line (make-point 0.0 0.0) (make-point 1 2))))
-
-
-; (def circle-class (class (make-circle (make-point 0.0 0.0) (make-point 1 2))))
-
-; (fact "the stacks are already there (though it doesn't really matter)"
-;   (keys (:stacks test-interpreter)) => (contains [:circle :line :point] :gaps-ok :any-order))
-
-
-; (fact "items can be routed to those stacks correctly"
-;   (u/get-stack
-;     (core/handle-item test-interpreter (make-point 3 9))
-;     :point) => (list (map->Point {:x 3, :y 9}))
-
-;   (u/get-stack
-;     (core/handle-item test-interpreter (make-line (make-point 2 9) (make-point 2 1)))
-;     :line) => (list (map->Line { :p1 (map->Point {:x 2, :y 9})
-;                                  :p2 (map->Point {:x 2, :y 1}) }))
-
-;   (u/get-stack
-;     (core/handle-item test-interpreter (make-circle (make-point 2 9) (make-point 2 1)))
-;     :circle) => (list (map->Circle {
-;                     :origin
-;                       (map->Point {:x 2, :y 9})
-;                     :edgepoint
-;                       (map->Point {:x 2, :y 1})})))
-
-
-; ;; interpreter executes instructions
-
-
-; (fact "test-interpreter knows :line-intersection"
-;   (keys (:instructions test-interpreter)) => (contains :line-intersection))
-
-
-; (fact "the intersection ends up on the :point stack"
-;   (let [prepped (core/recycle-interpreter
-;                 test-interpreter
-;                 [line1 line2 :line-intersection])]
-;     (:stacks prepped) =>
-;     `{:boolean (), :booleans (), :char (), :chars (), :circle (), :code (), :environment (), :error (), :exec (~line1 ~line2 :line-intersection), :float (), :floats (), :integer (), :integers (), :line (), :log (), :point (), :print (), :return (), :set (), :string (), :strings (), :unknown (), :vector ()}
+;;;; Push types and instructions
+
+
+;; recognizers work for routing
+
+(def test-interpreter
+  (core/register-types 
+    (owe/make-everything-interpreter)
+    [push-point push-line push-circle]))
+
+
+(def point-class (class (make-point 0.0 0.0)))
+
+
+(def line-class (class (make-line (make-point 0.0 0.0) (make-point 1 2))))
+
+
+(def circle-class (class (make-circle (make-point 0.0 0.0) (make-point 1 2))))
+
+(fact "the stacks are already there (though it doesn't really matter)"
+  (keys (:stacks test-interpreter)) => (contains [:circle :line :point] :gaps-ok :any-order))
+
+
+(fact "items can be routed to those stacks correctly"
+  (u/get-stack
+    (core/handle-item test-interpreter (make-point 3 9))
+    :point) => (list (map->Point {:x 3, :y 9}))
+
+  (u/get-stack
+    (core/handle-item test-interpreter (make-line (make-point 2 9) (make-point 2 1)))
+    :line) => (list (map->Line { :p1 (map->Point {:x 2, :y 9})
+                                 :p2 (map->Point {:x 2, :y 1}) }))
+
+  (u/get-stack
+    (core/handle-item test-interpreter (make-circle (make-point 2 9) (make-point 2 1)))
+    :circle) => (list (map->Circle {
+                    :origin
+                      (map->Point {:x 2, :y 9})
+                    :edgepoint
+                      (map->Point {:x 2, :y 1})})))
+
+
+;; interpreter executes instructions
+
+
+(fact "test-interpreter knows :line-intersection"
+  (keys (:instructions test-interpreter)) => (contains :line-intersection))
+
+
+(fact "the intersection ends up on the :point stack"
+  (let [prepped (core/recycle-interpreter
+                test-interpreter
+                [line1 line2 :line-intersection])]
+    (:stacks prepped) =>
+    `{:boolean (), :booleans (), :char (), :chars (), :circle (), :code (), :environment (), :error (), :exec (~line1 ~line2 :line-intersection), :float (), :floats (), :integer (), :integers (), :line (), :log (), :point (), :print (), :return (), :set (), :string (), :strings (), :unknown (), :vector ()}
     
-;     (u/get-stack (core/run prepped 1000) :point) => (list (make-point 3.0 4.0))))
-
-
+    (u/get-stack (core/run prepped 1000) :point) => (list (make-point 3.0 4.0))))
+
+

  (pretty-much-equal?
    (intercept (make-line (make-point 3.3 9.9) (make-point 0 0)))
    (intercept (make-line (make-point 0 0) (make-point 3.3 9.9)))) => true)


; ;; lines-coincide?




;; rounding

(fact "I can use ApfloatMath/round successfully"
