[elpa] externals/dash 5232399 238/439: Merge pull request #50 from kurisuwhyte/master

[Phillip Lord]

branch: externals/dash
commit 52323996bf99de25d04e59b66aa130a04605878f
Merge: 6d43c4f 20eb331
Author: Magnar Sveen <address@hidden>
Commit: Magnar Sveen <address@hidden>

    Merge pull request #50 from kurisuwhyte/master
    
    Provides `-compose` for function composition
---
 README.md          |   15 +++++++++++++++
 dash-functional.el |   10 ++++++++++
 dev/examples.el    |    8 +++++++-
 3 files changed, 32 insertions(+), 1 deletions(-)

diff --git a/README.md b/README.md
index d4431e4..3611b7b 100644
--- a/README.md
+++ b/README.md
@@ -164,6 +164,7 @@ These combinators require Emacs 24 for its lexical scope. 
So they are offered in
 * [-partial](#-partial-fn-rest-args) `(fn &rest args)`
 * [-rpartial](#-rpartial-fn-rest-args) `(fn &rest args)`
 * [-juxt](#-juxt-rest-fns) `(&rest fns)`
+* [-compose](#-compose-rest-fns) `(&rest fns)`
 * [-applify](#-applify-fn) `(fn)`
 * [-on](#-on-operator-transformer) `(operator transformer)`
 * [-flip](#-flip-func) `(func)`
@@ -1134,6 +1135,20 @@ applying each fn to the args (left-to-right).
 (-map (-juxt 'identity 'square) '(1 2 3)) ;; => '((1 1) (2 4) (3 9))
 ```
 
+#### -compose `(&rest fns)`
+
+Takes a list of functions and returns a fn that is the
+composition of those fns. The returned fn takes a variable
+number of arguments, and returns the result of applying
+each fn to the result of applying the previous fn to
+the arguments (right-to-left).
+
+```cl
+(funcall (-compose 'square '+) 2 3) ;; => (square (+ 2 3))
+(funcall (-compose 'identity 'square) 3) ;; => (square 3)
+(funcall (-compose 'square 'identity) 3) ;; => (square 3)
+```
+
 #### -applify `(fn)`
 
 Changes an n-arity function `fn` to a 1-arity function that
diff --git a/dash-functional.el b/dash-functional.el
index e7f5b20..4a00720 100644
--- a/dash-functional.el
+++ b/dash-functional.el
@@ -52,6 +52,16 @@ number of args, and returns a list containing the result of
 applying each fn to the args (left-to-right)."
   (lambda (&rest args) (mapcar (lambda (x) (apply x args)) fns)))
 
+(defun -compose (&rest fns)
+  "Takes a list of functions and returns a fn that is the
+composition of those fns. The returned fn takes a variable
+number of arguments, and returns the result of applying
+each fn to the result of applying the previous fn to
+the arguments (right-to-left)."
+  (lambda (&rest args)
+    (car (-reduce-r-from (lambda (fn xs) (list (apply fn xs)))
+                        args fns))))
+
 (defun -applify (fn)
   "Changes an n-arity function FN to a 1-arity function that
 expects a list with n items as arguments"
diff --git a/dev/examples.el b/dev/examples.el
index 6c3868e..b0756dc 100644
--- a/dev/examples.el
+++ b/dev/examples.el
@@ -422,7 +422,13 @@
 
     (defexamples -juxt
       (funcall (-juxt '+ '-) 3 5) => '(8 -2)
-      (-map (-juxt 'identity 'square) '(1 2 3)) => '((1 1) (2 4) (3 9))))
+      (-map (-juxt 'identity 'square) '(1 2 3)) => '((1 1) (2 4) (3 9)))
+
+    (defexamples -compose
+      (funcall (-compose 'square '+) 2 3) => (square (+ 2 3))
+      (funcall (-compose 'identity 'square) 3) => (square 3)
+      (funcall (-compose 'square 'identity) 3) => (square 3)
+      (funcall (-compose (-compose 'not 'even?) 'square) 3) => (funcall 
(-compose 'not (-compose 'even? 'square)) 3)))
 
   (defexamples -applify
     (-map (-applify '+) '((1 1 1) (1 2 3) (5 5 5))) => '(3 6 15)