如何将已定义的函数函数转换为匿名函数

Question

I want to turn a defined function into an anonymous one. How do I do that? The following function returns the last element from a sequence:

(defn lastt [l]
    (cond
        (nil? (next l)) l
        :else
            (lastt (next l))))

How do I turn it into fn form?

PS: I know about last function, this is just an exercise.

Answer 1

First of all, that function returns a list with the last item in it. I'd change your definition so that it returns just the last item:

(defn lastt [l]
  (cond
   (nil? (next l)) (first l)
   :else (lastt (next l))))

To simplify, I'd use a let binding since you're calling next twice on l :

(defn lastt [l]
  (let [n (next l)]
    (cond
     (nil? n) (first l)
     :else (lastt n))))

The next thing I'd do is replace the final call to lastt to use recur instead

(defn lastt [l]
  (let [n (next l)]
    (cond
     (nil? n) (first l)
     :else (recur n))))

And then I'd replace that with

#(let [n (next %)]
   (cond
    (nil? n) (first %)
    :else (recur n)))

And just realised that it could be simplified even more using destructuring :)

#(let [[h & t] %]
   (cond
    (nil? t) h
    :else (recur t)))

Updated

No need for the cond , since there's only two branches, and using fn instead of the # shorthand will allow the destructuring to happen in the fn 's parameters, making the whole function a little bit more concise:

(fn [[h & t]]
  (if (empty? t) h
      (recur t)))

Answer 2

I'm more of a schemer/CLer than a clojer, but (defn f [args] body) looks to be mostly syntactic sugar for (def f (fn f ([args] body))) , in which case lastt could be written as an anonymous function by leaving out the def :

(fn lastt 
    ([l] (cond
           (nil? (next l))
             l
           :else
             (lastt (next l)))))

Since lastt recurses, you need to provide a name to bind it to within the body.