Implement -cond-> and -cond->> macros.

README.md

@@ -1,8 +1,4 @@
-![GitHub Workflow Status](https://img.shields.io/github/workflow/status/magnars/dash.el/CI)
-[![MELPA](https://melpa.org/packages/dash-badge.svg)](https://melpa.org/#/dash)
-[![MELPA Stable](https://stable.melpa.org/packages/dash-badge.svg)](https://stable.melpa.org/#/dash)
-
-# <img align="right" src="https://raw.github.com/magnars/dash.el/master/rainbow-dash.png"> dash.el
+# <img align="right" src="https://raw.github.com/magnars/dash.el/master/rainbow-dash.png"> dash.el ![GitHub Workflow Status](https://img.shields.io/github/workflow/status/magnars/dash.el/CI)
 
 A modern list api for Emacs. No 'cl required.
 
@@ -282,6 +278,8 @@ Functions pretending lists are trees.
 * [-some->](#-some--x-optional-form-rest-more) `(x &optional form &rest more)`
 * [-some->>](#-some--x-optional-form-rest-more) `(x &optional form &rest more)`
 * [-some-->](#-some---x-optional-form-rest-more) `(x &optional form &rest more)`
+* [-cond->](#-cond--x-rest-clauses) `(x &rest clauses)`
+* [-cond->>](#-cond--x-rest-clauses) `(x &rest clauses)`
 
 ### Binding
 
@@ -2225,7 +2223,7 @@ and when that result is non-nil, through the next form, etc.
 
 #### -some--> `(x &optional form &rest more)`
 
-When expr in non-nil, thread it through the first form (via [`-->`](#---x-rest-forms)),
+When expr is non-nil, thread it through the first form (via [`-->`](#---x-rest-forms)),
 and when that result is non-nil, through the next form, etc.
 
 ```el
@@ -2234,6 +2232,38 @@ and when that result is non-nil, through the next form, etc.
 (-some--> '(1 3 5) (-filter 'even? it) (append it it) (-map 'square it)) ;; => nil
 ```
 
+#### -cond-> `(x &rest clauses)`
+
+Conditionally thread `x` through `clauses`.
+Threads x (via [`->`](#--x-optional-form-rest-more)) through each form for which the
+corresponding test expression is true.  Note that, unlike cond
+branching, [`-cond->`](#-cond--x-rest-clauses) threading does not short circuit after the
+first true test expression.
+Given some elisp details, current value is exposed as the symbol
+`it`.
+
+```el
+(-cond-> "abc" (stringp it) (concat "def" "ghi")) ;; => "abcdefghi"
+(-cond-> 10 (even? it) (/ 2) (odd? it) list) ;; => '(5)
+(-cond-> '(:name "John" :age 24) (not (plist-get it :name)) (plist-put :name "Owen") (not (plist-get it :age)) (plist-put :age 40) (not (plist-get it :address)) (plist-put :address "123, Saint St.")) ;; => '(:name "John" :age 24 :address "123, Saint St.")
+```
+
+#### -cond->> `(x &rest clauses)`
+
+Conditionally thread `x` through `clauses`.
+Threads x (via [`->>`](#--x-optional-form-rest-more)) through each form for which the
+corresponding test expression is true.  Note that, unlike cond
+branching, [`-cond->>`](#-cond--x-rest-clauses) threading does not short circuit after the
+first true test expression.
+Given some elisp details, current value is exposed as the symbol
+`it`.
+
+```el
+(-cond->> "abc" (stringp it) (concat "def" "ghi")) ;; => "defghiabc"
+(-cond->> '(1 2 3) nil (+ 10 100 1000) t (-filter 'even?)) ;; => '(2)
+(-cond->> "ghi" (= 1 1) (concat "abc" "def") (= 0 1) (split-string)) ;; => "abcdefghi"
+```
+
 
 ## Binding
 
@@ -2658,8 +2688,8 @@ These combinators require Emacs 24 for its lexical scope. So they are offered in
 
 #### -partial `(fn &rest args)`
 
-Takes a function `fn` and fewer than the normal arguments to `fn`,
-and returns a fn that takes a variable number of additional `args`.
+Take a function `fn` and fewer than the normal arguments to `fn`,
+and return a fn that takes a variable number of additional `args`.
 When called, the returned function calls `fn` with `args` first and
 then additional args.
 

dash.el

@@ -1591,6 +1591,54 @@ and when that result is non-nil, through the next form, etc."
                    (--> ,result ,form))
                  ,@more))))
 
+(defmacro -cond-> (x &rest clauses)
+  "Conditionally thread X through CLAUSES.
+Threads x (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."
+  (declare (debug (form body))
+           (indent 1))
+  (when (-> clauses length (% 2) (= 1))
+    (error "Wrong number of arguments"))
+  (-let* ((g (dash--match-make-source-symbol))
+          (steps (-map
+                  (-lambda ((test step))
+                    `(if ,test
+                         (-> ,g ,step)
+                       ,g))
+                  (-partition 2 clauses))))
+    `(-let* ((,g ,x)
+             ,@(-zip-lists (-cycle (list g))
+                           (butlast steps)))
+       ,@(if (null steps)
+             g
+           (last steps)))))
+
+(defmacro -cond->> (x &rest clauses)
+  "Conditionally thread X through CLAUSES.
+Threads x (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."
+  (declare (debug (form body))
+           (indent 1))
+  (when (-> clauses length (% 2) (= 1))
+    (error "Wrong number of arguments."))
+  (-let* ((g (dash--match-make-source-symbol))
+          (steps (-map
+                  (-lambda ((test step))
+                    `(if ,test
+                         (->> ,g ,step)
+                       ,g))
+                  (-partition 2 clauses))))
+    `(-let* ((,g ,x)
+             ,@(-zip-lists (-cycle (list g))
+                           (butlast steps)))
+       ,@(if (null steps)
+            g
+           (last steps)))))
+
 (defun -grade-up (comparator list)
   "Grade elements of LIST using COMPARATOR relation, yielding a
 permutation vector such that applying this permutation to LIST