Merge pull request #412 from mpenet/feature/arrows

add *-> threading macros

Author: heyLu

pixie/stdlib.pxi

@@ -226,7 +226,6 @@
     ([val coll]
        (transduce (interpose val) conj coll))))
 
-
 (def preserving-reduced
   (fn preserving-reduced [rf]
     (fn pr-inner [a b]
@@ -480,38 +479,6 @@
   (let [nm (with-meta nm (assoc (meta nm) :private true))]
     (cons `defn (cons nm rest))))
 
-(defmacro ->
-  {:doc "Threads `x` through `forms`, passing the result of one step as the first argument of the next."
-   :examples [["(-> 3 inc inc)" nil 5]
-              ["(-> \"James\" (str \" is \" \"awesome \") (str \"(and stuff)\" \"!\"))" nil "James is awesome (and stuff)!"]]
-   :signatures [[x & forms]]
-   :added "0.1"}
-  [x & forms]
-  (loop [x x, forms forms]
-    (if forms
-      (let [form (first forms)
-            threaded (if (seq? form)
-                       (with-meta `(~(first form) ~x ~@(next form)) (meta form))
-                       (list form x))]
-        (recur threaded (next forms)))
-      x)))
-
-(defmacro ->>
-  {:doc "Threads `x` through `forms`, passing the result of one step as the last argument of the next."
-   :examples [["(->> \"James\" (str \"we \" \"like \") (str \"you \" \"know \" \"what? \"))" nil "you know what? we like James"]
-              ["(->> 5 (range) (map inc) seq)" nil (1 2 3 4 5)]]
-   :signatures [[x & forms]]
-   :added "0.1"}
-  [x & forms]
-  (loop [x x, forms forms]
-    (if forms
-      (let [form (first forms)
-            threaded (if (seq? form)
-                       (with-meta `(~(first form) ~@(next form)  ~x) (meta form))
-                       (list form x))]
-        (recur threaded (next forms)))
-      x)))
-
 (defn not
   {:doc "Inverts the input, if a truthy value is supplied, returns false, otherwise
 returns true"
@@ -2640,6 +2607,117 @@ Calling this function on something that is not ISeqable returns a seq with that
   [x]
   (instance? Bool x))
 
+(defmacro ->
+  {:doc "Threads `x` through `forms`, passing the result of one step as the first argument of the next."
+   :examples [["(-> 3 inc inc)" nil 5]
+              ["(-> \"James\" (str \" is \" \"awesome \") (str \"(and stuff)\" \"!\"))" nil "James is awesome (and stuff)!"]]
+   :signatures [[x & forms]]
+   :added "0.1"}
+  [x & forms]
+  (loop [x x, forms forms]
+    (if forms
+      (let [form (first forms)
+            threaded (if (seq? form)
+                       (with-meta `(~(first form) ~x ~@(next form)) (meta form))
+                       (list form x))]
+        (recur threaded (next forms)))
+      x)))
+
+(defmacro ->>
+  {:doc "Threads `x` through `forms`, passing the result of one step as the last argument of the next."
+   :examples [["(->> \"James\" (str \"we \" \"like \") (str \"you \" \"know \" \"what? \"))" nil "you know what? we like James"]
+              ["(->> 5 (range) (map inc) seq)" nil (1 2 3 4 5)]]
+   :signatures [[x & forms]]
+   :added "0.1"}
+  [x & forms]
+  (loop [x x, forms forms]
+    (if forms
+      (let [form (first forms)
+            threaded (if (seq? form)
+                       (with-meta `(~(first form) ~@(next form)  ~x) (meta form))
+                       (list form x))]
+        (recur threaded (next forms)))
+      x)))
+
+(defmacro some->
+  {:doc "When expr is not nil, threads it into the first form (via ->),
+    and when that result is not nil, through the next etc"
+   :signatures [[expr & forms]]
+   :added "0.1"}
+  [expr & forms]
+  (let [g (gensym)
+        steps (map (fn [step] `(if (nil? ~g) nil (-> ~g ~step)))
+                   forms)]
+    `(let [~g ~expr
+           ~@(interleave (repeat g) (butlast steps))]
+       ~(if (empty? steps)
+          g
+          (last steps)))))
+
+(defmacro some->>
+  {:doc "When expr is not nil, threads it into the first form (via ->>),
+  and when that result is not nil, through the next etc"
+   :signatures [[x & forms]]
+   :added "0,1"}
+  [expr & forms]
+  (let [g (gensym)
+        steps (map (fn [step] `(if (nil? ~g) nil (->> ~g ~step)))
+                   forms)]
+    `(let [~g ~expr
+           ~@(interleave (repeat g) (butlast steps))]
+       ~(if (empty? steps)
+          g
+          (last steps)))))
+
+(defmacro cond->
+  {:added "0.1"
+   :signatures [[expr & clauses]]
+   :doc "Takes an expression and a set of test/form pairs. Threads expr (via ->)
+  through each form for which the corresponding test
+  expression is true. Note that, unlike cond branching, cond-> threading does
+  not short circuit after the first true test expression."}
+  [expr & clauses]
+  (assert (even? (count clauses)))
+  (let [g (gensym)
+        steps (map (fn [[test step]] `(if ~test (-> ~g ~step) ~g))
+                   (partition 2 clauses))]
+    `(let [~g ~expr
+           ~@(interleave (repeat g) (butlast steps))]
+       ~(if (empty? steps)
+          g
+          (last steps)))))
+
+(defmacro cond->>
+  {:doc "Takes an expression and a set of test/form pairs. Threads expr (via ->>)
+  through each form for which the corresponding test expression
+  is true.  Note that, unlike cond branching, cond->> threading does not short circuit
+  after the first true test expression."
+   :signatures [[expr & clauses]]
+   :added "0.1"}
+  [expr & clauses]
+  (assert (even? (count clauses)))
+  (let [g (gensym)
+        steps (map (fn [[test step]] `(if ~test (->> ~g ~step) ~g))
+                   (partition 2 clauses))]
+    `(let [~g ~expr
+           ~@(interleave (repeat g) (butlast steps))]
+       ~(if (empty? steps)
+          g
+          (last steps)))))
+
+(defmacro as->
+  {:doc "Binds name to expr, evaluates the first form in the lexical context
+  of that binding, then binds name to that result, repeating for each
+  successive form, returning the result of the last form."
+   :signatures [[expr name & forms]]
+   :added "0,1"}
+  [expr name & forms]
+  `(let [~name ~expr
+         ~@(interleave (repeat name) (butlast forms))]
+     ~(if (empty? forms)
+        name
+        (last forms))))
+
 (defprotocol IComparable
   (-compare [x y]
     "Compare to objects returing 0 if the same -1 with x is logically smaller than y and 1 if x is logically larger"))

tests/pixie/tests/test-macros.pxi

@@ -5,4 +5,48 @@
   (let [x 10 k :boop]
     (t/assert= (-eq `{:x ~x} {:x 10}) true)
     (t/assert= (-eq `{~k ~x} {:boop 10}) true)
-    (t/assert= (-eq `{:x {:y ~x}} {:x {:y 10}}) true)))
+    (t/assert= (-eq `{:x {:y ~x}} {:x {:y 10}}) true)))
+
+(def constantly-nil (constantly nil))
+
+(t/deftest some->test
+  (t/assert (nil? (some-> nil)))
+  (t/assert (= 0 (some-> 0)))
+  (t/assert (= -1 (some-> 1 (- 2))))
+  (t/assert (nil? (some-> 1 constantly-nil (- 2)))))
+
+(t/deftest some->>test
+  (t/assert (nil? (some->> nil)))
+  (t/assert (= 0 (some->> 0)))
+  (t/assert (= 1 (some->> 1 (- 2))))
+  (t/assert (nil? (some->> 1 constantly-nil (- 2)))))
+
+(t/deftest cond->test
+  (t/assert (= 0 (cond-> 0)))
+  (t/assert (= -1 (cond-> 0 true inc true (- 2))))
+  (t/assert (= 0 (cond-> 0 false inc)))
+  (t/assert (= -1 (cond-> 1 true (- 2) false inc))))
+
+(t/deftest cond->>test
+  (t/assert (= 0 (cond->> 0)))
+  (t/assert (= 1 (cond->> 0 true inc true (- 2))))
+  (t/assert (= 0 (cond->> 0 false inc)))
+  (t/assert (= 1 (cond->> 1 true (- 2) false inc))))
+
+(t/deftest as->test
+  (t/assert (= 0 (as-> 0 x)))
+  (t/assert (= 1 (as-> 0 x (inc x))))
+  (t/assert (= 2 (as-> [0 1] x
+             (map inc x)
+             (reverse x)
+             (first x)))))
+
+(t/deftest threading-loop-recur
+  (t/assert (nil? (loop []
+              (as-> 0 x
+                (when-not (zero? x)
+                  (recur))))))
+  (t/assert (nil? (loop [x nil] (some-> x recur))))
+  (t/assert (nil? (loop [x nil] (some->> x recur))))
+  (t/assert (= 0 (loop [x 0] (cond-> x false recur))))
+  (t/assert (= 0 (loop [x 0] (cond->> x false recur)))))