我可以在 Clojure 中的函数组合实现中使用“recur”吗？

Question

Consider this simple-minded recursive implementation of comp in Clojure:

(defn my-comp
  ([f]
   (fn [& args]
     (apply f args)))
  ([f & funcs]
   (fn [& args]
     (f (apply (apply my-comp funcs) args)))))

The right way to do this, I am told, is using recur , but I am unsure how recur works. In particular: is there a way to coax the code above into being recur able?

Answer 1

a way to do this, is to rearrange this code to pass some intermediate function back up to the definition with recur.

the model would be something like this:

(my-comp #(* 10 %) - +)

(my-comp (fn [& args] (#(* 10 %) (apply - args)))
           +)

(my-comp (fn [& args]
             ((fn [& args] (#(* 10 %) (apply - args)))
              (apply + args))))

the last my-comp would use the first my-comp overload (which is (my-comp [f])

here's how it could look like:

(defn my-comp
  ([f] f)
  ([f & funcs]
   (if (seq funcs)
     (recur (fn [& args]
              (f (apply (first funcs) args)))
            (rest funcs))
     (my-comp f))))

notice that despite of not being the possible apply target, the recur form can still accept variadic params being passed as a sequence.

user> ((my-comp (partial repeat 3) #(* 10 %) - +) 1 2 3)
;;=> (-60 -60 -60)

notice, though, that in practice this implementation isn't really better than yours: while recur saves you from stack overflow on function creation, it would still overflow on application (somebody, correct me if i'm wrong):

(apply my-comp (repeat 1000000 inc)) ;; ok

((apply my-comp (repeat 1000000 inc)) 1) ;; stack overflow

so it would probably be better to use reduce or something else:

(defn my-comp-reduce [f & fs]
  (let [[f & fs] (reverse (cons f fs))]
    (fn [& args]
      (reduce (fn [acc curr-f] (curr-f acc))
               (apply f args)
               fs))))

user> ((my-comp-reduce (partial repeat 3) #(* 10 %) - +) 1 2 3)
;;=> (-60 -60 -60)

user> ((apply my-comp-reduce (repeat 1000000 inc)) 1)
;;=> 1000001

Answer 2

There is already a good answer above, but I think the original suggestion to use recur may have been thinking of a more manual accumulation of the result. In case you haven't seen it, reduce is just a very specific usage of loop/recur :

(ns tst.demo.core
  (:use demo.core tupelo.core  tupelo.test))

(defn my-reduce
  [step-fn init-val data-vec]
  (loop [accum init-val
         data  data-vec]
    (if (empty? data)
      accum
      (let [accum-next (step-fn accum (first data))
            data-next  (rest data)]
        (recur accum-next data-next)))))

(dotest
  (is=  10 (my-reduce + 0 (range 5)))    ; 0..4
  (is= 120 (my-reduce * 1 (range 1 6)))  ; 1..5 )

In general, there can be any number of loop variables (not just 2 like for reduce). Using loop/recur gives you a more "functional" way of looping with accumulated state instead of using and atom and a doseq or something. As the name suggests, from the outside the effect is quite similar to a normal recursion w/o any stack size limits (ie tail-call optimization).

---

PS As this example shows, I like to use a let form to very explicitly name the values being generated for the next iteration.

PPS While the compiler will allow you to type the following w/o confusion:

(ns tst.demo.core
  (:use demo.core tupelo.core  tupelo.test))

(defn my-reduce
  [step-fn accum data]
  (loop [accum accum
         data  data]
     ...))

it can be a bit confusing and/or sloppy to re-use variable names (esp. for people new to Clojure or your particular program).

---

Also

I would be remiss if I didn't point out that the function definition itself can be a recur target (ie you don't need to use loop ). Consider this version of the factorial:

(ns tst.demo.core
  (:use demo.core tupelo.core  tupelo.test))

(defn fact-impl
  [cum x]
  (if (= x 1)
    cum
    (let [cum-next (* cum x)
          x-next   (dec x)]
      (recur cum-next x-next))))

(defn fact [x] (fact-impl 1 x))

(dotest
  (is= 6 (fact 3))
  (is= 120 (fact 5)))

Answer 3

evaluation 1

First let's visualize the problem. my-comp as it is written in the question will create a deep stack of function calls, each waiting on the stack to resolve, blocked until the the deepest call returns -

((my-comp inc inc inc) 1)
((fn [& args]
     (inc (apply (apply my-comp '(inc inc)) args))) 1)

(inc (apply (fn [& args]
                (inc (apply (apply my-comp '(inc)) args))) '(1)))

(inc (inc (apply (apply my-comp '(inc)) '(1))))

(inc (inc (apply (fn [& args]
                     (apply inc args)) '(1))))

(inc (inc (apply inc '(1)))) ; ⚠️ deep in the hole we go...
(inc (inc 2))
(inc 3)
4

tail-recursive my-comp

Rather than creating a long sequence of functions, this my-comp is refactored to return a single function, which when called, runs a loop over the supplied input functions -

(defn my-comp [& fs]
  (fn [init]
    (loop [acc init [f & more] fs]
      (if (nil? f)
          acc
          (recur (f acc) more))))) ; 🐍 tail recursion

((my-comp inc inc inc) 1)
;; 4

((apply my-comp (repeat 1000000 inc)) 1)
;; 1000001

evaluation 2

With my-comp rewritten to use loop and recur , we can see linear iterative evaluation of the composition -

((my-comp inc inc inc) 1)
(loop 1 (list inc inc inc))
(loop 2 (list inc inc))
(loop 3 (list inc))
(loop 4 nil)
4

multiple input args

Did you notice ten (10) apply calls at the beginning of this post? This is all in service to support multiple arguments for the first function in the my-comp sequence. It is a mistake to tangle this complexity with my-comp itself. The caller has control to do this if it is the desired behavior.

Without any additional changes to the refactored my-comp -

((my-comp #(apply * %) inc inc inc) '(3 4)) ; ✅ multiple input args

Which evaluates as -

(loop '(3 4) (list #(apply * %) inc inc inc))
(loop 12 (list inc inc inc))
(loop 13 (list inc inc))
(loop 14 (list inc))
(loop 15 nil)
15

right-to-left order

Above (my-comp abc) will apply a first, then b , and finally c . If you want to reverse that order, a naive solution would be to call reverse at the loop call site -

(defn my-comp [& fs]
  (fn [init]
    (loop [acc init [f & more] (reverse fs)] ; ⚠️ naive
      (if (nil? f)
          acc
          (recur (f acc) more)))))

Each time the returned function is called, (reverse fs) will be recomputed. To avoid this, use a let binding to compute the reversal just once -

(defn my-comp [& fs]
  (let [fs (reverse fs)] ; ✅ reverse once
    (fn [init]
      (loop [acc init [f & more] fs]
        (if (nil? f)
            acc
            (recur (f acc) more))))))