Allow marshaling of more functions for core.

Fix indentation in some files.

examples/3sum.dst

@@ -1,13 +1,13 @@
 (defn sum3
- "Solve the 3SUM problem in O(n^2) time."
- [s]
- (def tab @{})
- (def solutions @{})
- (def len (length s))
- (loop [k :range [0 len]]
-  (put tab (get s k) k))
- (loop [i :range [0 len], j :range [0 len]]
-  (def k (get tab (- 0 (get s i) (get s j))))
-  (when (and k (not= k i) (not= k j) (not= i j))
-   (put solutions {i true j true k true} true)))
- (map keys (keys solution)))
+  "Solve the 3SUM problem in O(n^2) time."
+  [s]
+  (def tab @{})
+  (def solutions @{})
+  (def len (length s))
+  (loop [k :range [0 len]]
+    (put tab (get s k) k))
+  (loop [i :range [0 len], j :range [0 len]]
+    (def k (get tab (- 0 (get s i) (get s j))))
+    (when (and k (not= k i) (not= k j) (not= i j))
+      (put solutions {i true j true k true} true)))
+  (map keys (keys solution)))

examples/fizzbuzz.dst

@@ -1,13 +1,13 @@
 # A simple fizz buzz example
 
 (defn fizzbuzz
- "Prints the fizzbuzz problem."
- []
- (loop [i :range [1 101]]
-  (let [fizz (zero? (% i 3))
-        buzz (zero? (% i 5))]
-    (print (cond
-        (and fizz buzz) "fizzbuzz"
-        fizz "fizz"
-        buzz "buzz"
-        i)))))
+  "Prints the fizzbuzz problem."
+  []
+  (loop [i :range [1 101]]
+    (let [fizz (zero? (% i 3))
+          buzz (zero? (% i 5))]
+      (print (cond
+               (and fizz buzz) "fizzbuzz"
+               fizz "fizz"
+               buzz "buzz"
+               i)))))

examples/iterators.dst

@@ -5,105 +5,103 @@
 ###
 
 (def iter (do
-  (defn array-iter [x]
-    (def len (length x))
-    (var i 0)
-    {
-      :more (fn [] (< i len))
-      :next (fn []
-        (def ret (get x i))
-        (:= i (+ i 1))
-        ret)
-    })
-  (def iters {
-    :array array-iter
-    :tuple array-iter
-    :struct identity})
-  (fn [x]
-   (def makei (get iters (type x)))
-   (if makei (makei x) (error "expected sequence")))))
+            (defn array-iter [x]
+              (def len (length x))
+              (var i 0)
+              {:more (fn [] (< i len))
+               :next (fn []
+                       (def ret (get x i))
+                       (:= i (+ i 1))
+                       ret)})
+            (def iters {
+                        :array array-iter
+                        :tuple array-iter
+                        :struct identity})
+            (fn [x]
+              (def makei (get iters (type x)))
+              (if makei (makei x) (error "expected sequence")))))
 
 (defn range2 [bottom top]
   (var i bottom)
   {
-    :more (fn [] (< i top))
-    :next (fn []
-      (def ret i)
-      (:= i (+ i 1))
-      ret)
-  })
+   :more (fn [] (< i top))
+   :next (fn []
+           (def ret i)
+           (:= i (+ i 1))
+           ret)
+   })
 
 (defn range [top] (range2 0 top))
 
 (defn doiter [itr]
- (def {:more more :next next} (iter itr))
- (while (more) (next)))
+  (def {:more more :next next} (iter itr))
+  (while (more) (next)))
 
 (defn foreach [itr f]
- (def {:more more :next next} (iter itr))
- (while (more) (f (next))))
+  (def {:more more :next next} (iter itr))
+  (while (more) (f (next))))
 
 (defn iter2array [itr]
- (def {:more more :next next} (iter itr))
- (def a @[])
- (while (more) (array.push a (next)))
- a)
+  (def {:more more :next next} (iter itr))
+  (def a @[])
+  (while (more) (array.push a (next)))
+  a)
 
 (defn map [f itr]
- (def {:more more :next next} (iter itr))
- {:more more :next (fn [] (f (next)))})
+  (def {:more more :next next} (iter itr))
+  {:more more :next (fn [] (f (next)))})
 
 (defn reduce [f start itr]
   (def itr (iter itr))
   (def {:more more :next next} itr)
   (if (more)
-   (reduce f (f start (next)) itr)
-   start))
+    (reduce f (f start (next)) itr)
+    start))
 
 (defn filter [pred itr]
- (def itr (iter itr))
- (def {:more more :next next} itr)
- (var alive true)
- (var temp nil)
- (var isnew true)
- (defn nextgood []
-   (if alive
-    (if (more)
-     (do
-      (def n (next))
-      (if (pred n) n (nextgood)))
-     (:= alive false))))
- (defn nnext [] (def ret temp) (:= temp (nextgood)) ret)
- (defn nmore [] (when isnew (:= isnew false) (nnext)) alive)
- {:more nmore :next nnext})
+  (def itr (iter itr))
+  (def {:more more :next next} itr)
+  (var alive true)
+  (var temp nil)
+  (var isnew true)
+  (defn nextgood []
+    (if alive
+      (if (more)
+        (do
+          (def n (next))
+          (if (pred n) n (nextgood)))
+        (:= alive false))))
+  (defn nnext [] (def ret temp) (:= temp (nextgood)) ret)
+  (defn nmore [] (when isnew (:= isnew false) (nnext)) alive)
+  {:more nmore :next nnext})
 
 (defn pairs [x]
- (var lastkey (next x nil))
- {
-    :more (fn [] lastkey)
-    :next (fn []
-        (def ret (tuple lastkey (get x lastkey)))
-        (:= lastkey (next x lastkey))
-        ret)
- })
+  (var lastkey (next x nil))
+  {
+   :more (fn [] lastkey)
+   :next (fn []
+           (def ret (tuple lastkey (get x lastkey)))
+           (:= lastkey (next x lastkey))
+           ret)
+   })
 
 (defn keys [x]
- (var lastkey (next x nil))
- {
-    :more (fn [] lastkey)
-    :next (fn []
-        (def ret lastkey)
-        (:= lastkey (next x lastkey))
-        ret)
- })
+  (var lastkey (next x nil))
+  {
+   :more (fn [] lastkey)
+   :next (fn []
+           (def ret lastkey)
+           (:= lastkey (next x lastkey))
+           ret)
+   })
 
 (defn values [x]
- (var lastkey (next x nil))
- {
-    :more (fn [] lastkey)
-    :next (fn []
-        (def ret (get x lastkey))
-        (:= lastkey (next x lastkey))
-        ret)
- })
+  (var lastkey (next x nil))
+  {
+   :more (fn [] lastkey)
+   :next (fn []
+           (def ret (get x lastkey))
+           (:= lastkey (next x lastkey))
+           ret)
+   })
 

examples/maxtriangle.dst

@@ -1,6 +1,6 @@
 # Find the maximum path from the top (root)
 # of the triangle to the leaves of the triangle.
-  
+
 (defn myfold [xs ys]
   (let [xs1 (tuple.prepend xs 0)
         xs2 (tuple.append xs 0)
@@ -9,16 +9,16 @@
     (map max m1 m2)))
 
 (defn maxpath [t]
- (extreme > (reduce myfold () t)))
+  (extreme > (reduce myfold () t)))
 
 # Test it
 # Maximum path is 3 -> 10 -> 3 -> 9 for a total of 25
 
-(def triangle '[
- [3]
- [7 10]
- [4 3 7]
- [8 9 1 3]
-])
+(def triangle 
+  '[[3]
+    [7 10]
+    [4 3 7]
+    [8 9 1 3]
+    ])
 
 (print (maxpath triangle))

examples/primes.dst

@@ -1,14 +1,14 @@
 # Return an array of primes. This is a trivial and extremely naive algorithm.
 
 (defn primes
- "Returns a list of prime numbers less than n."
- [n]
- (def list @[])
- (loop [i :range [2 n]]
-  (var isprime? true)
-  (def len (length list))
-  (loop [j :range [0 len]]
-   (def trial (get list j))
-   (if (zero? (% i trial)) (:= isprime? false)))
-  (if isprime? (array.push list i)))
- list)
+  "Returns a list of prime numbers less than n."
+  [n]
+  (def list @[])
+  (loop [i :range [2 n]]
+    (var isprime? true)
+    (def len (length list))
+    (loop [j :range [0 len]]
+      (def trial (get list j))
+      (if (zero? (% i trial)) (:= isprime? false)))
+    (if isprime? (array.push list i)))
+  list)