*Function* **COMPOSE**

**Syntax:**

**compose** * &rest functions* =>

*composite-function*

**Arguments and Values:**

*functions*---a list of *designators* for *function*s.

*composite-function*---a function created by composing *functions*.

**Description:**

**compose** returns a *function* which is created by composing *functions* right-associatively.

**Examples:**

*defun*2* (x) (* 2 x)) (funcall (compose #'1+ #'1+) 1) => 3 (funcall (compose '1+ '2*) 5) => 11 (funcall (compose #'1+ '2* '1+) 6) => 15

**Reference implementation:**

*defun*compose (&rest functions) "Compose FUNCTIONS right-associatively, returning a function" #'(

*lambda*(x) (reduce #'funcall functions :initial-value x :from-end t)))

This implementation is fairly straightforward, but very inefficient. In my benchmarks, I found it to be orders of magnitude slower than writing out an equivalent lambda function. However, a compiler macro speeds up some common cases immensely:

*define-compiler-macro*compose (&rest functions) (

*labels*((sharp-quoted-p (x) (and (listp x) (eql (first x) '

*function*) (symbolp (second x))))) `(

*lambda*(x) ,(reduce #'(

*lambda*(fun arg) (

*if*(sharp-quoted-p fun) (list (second fun) arg) (list 'funcall fun arg))) functions :initial-value 'x :from-end t))))

This compiler macro shouldn't be considered part of the reference implementation, but it may be useful anyway. I, Peter Scott, place this code in the public domain.

This version allows composition of functions with multiple arguments and return values.

*defun*compose2 (f1 f2) (

*lambda*(&rest args) (

*multiple-value-call*f1 (apply f2 args)))) (

*defun*compose (&rest functions) (

*if*functions (reduce #'compose2 functions) #'values))

Alexandria contains this function. (likely nonexhaustive)