Clojure：使用输出作为下一个操作的输入执行n次操作（a-la reduce）

Question

I want to execute a given amount of time a certain operation (eg, generating a tribe). Each time I would like to use the output of the previous iteration as input of the next one.

I am achieving it by doing a dummy reduce on collection of n elements, I then consider only the accumulator and throw away the element from the collection.

(defn generate-game [world n-tribes]
  (let [ game (create-game world)
         game (reduce (fn [acc, _] (:game (generate-tribe acc))) game (repeat n-tribes :just_something))]
    game))

I assume there is a much better way to do that. Can you help me finding it?

Answer 1

If it's the same function repeated n-tribes times, then using iterate and getting the n-tribes 'th element should work:

(defn generate-game [world n-tribes]
  (let [ game (create-game world)
         game (nth (iterate generate-tribe game) n-tribes)]
         game))

Remember that iterate creates a lazy sequence so nothing will be calculated until you request it.

Another option is applying comp to the list of functions, after all it's a simple function composition:

 (generate-tribe (generate-tribe .... (generate-tribe game) ....))

                                 n-tribes times

So something like:

(defn generate-game [world n-tribes]
  (let [ game (create-game world)
         game ((apply comp (repeat n-tribes generate-tribe)) game)]
         game))

expresses exactly that idea.

Answer 2

Not a Clojure expert, but I would expect

(defn generate-game [world n-tribes]
    (nth (iterate generate-tribe (create-game world)) n-tribes))

or (less terse)

(defn generate-game [world n-tribes]
  (let [game (create-game world)]
    (nth (iterate generate-tribe game) n-tribes)))

to work

Answer 3

The method used in the question is fine, but use range instead

(defn generate-game [world n-tribes]
  (reduce (fn [acc _] (:game (generate-tribe acc)))
          (create-game world)
          (range n-tribes)))

Since range objects know how to intelligently reduce themselves, this will get turned into a loop. This is the reduce method of range:

public Object reduce(IFn f, Object start) {
    Object ret = f.invoke(start,n);
    for(int x = n+1;x < end;x++)
            ret = f.invoke(ret, x);
    return ret;
}

If your game state is going to wind up in an atom anyway then you could also consider dotimes to update it.

(defn generate-game [world n-tribes]
  (let [game (atom (create-game world))]
    (dotimes [_ n-tribes] (swap! game (comp :game generate-tribe)))
    game))

Iterate is also a fine solution. More discussion at Iteratively apply function to its result without generating a seq .