循环先前定义的功能

Question

My goal is to iterate a function that I wrote, arbitrarily called gorilla, j times. Gorilla takes sequences as arguments. However, the code is riddled with errors (not on purpose), and returns key must be an integer.

Here is a copy of the code:

(defn gen-gorilla [seq j]
  (loop [level j gorilla seq]
    (if (= level 0)
      seq
      (if (> level 0)
        (recur (- level 1) (gorilla seq))))))  

Answer 1

This kind of thing is what iterate is most useful for.

(last (take 5 (iterate inc 0))) => 4

so for this case you would want:

(nth (iterate gorilla seq) j)

Answer 2

The problem in your code is that you are binding the name gorilla in your loop, but this means calling gorilla refers to the latest sequence, not the function.

This can actually be quite nicely written with reduce

 (defn apply-gorilla [n s]
    (reduce (fn [s _] (gorilla s)) s (range n)))

This basically loops up to n and ignores n as it goes, simply repeatedly applying gorilla repeatedly.

If you really want explicit recursion

 (defn apply-gorilla [n s]
   (if (zero? n)
       s
       (recur (dec n) (gorilla s))))

Answer 3

The issue is in your use of gorilla in the recur call. gorilla in this case is a collection, defined in the loop statement, which, when you use them as functions is equivalent to indexing into them.

([1 2 3] 0) ;; => 1

But, you are passing a sequence as the index into the collection.

([1 2 3] [1 2 3]) ;; => Exception: Key must be integer

From your description, you are trying to call your function, gorilla , defined elsewhere. You would need to rename the var defined in the loop statement to something like the following:

(defn gen-gorilla [seq j]
  (loop [level j s seq]
    (if (= level 0)
      s
      (if (> level 0)
        (recur (- level 1) (gorilla s))))))