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)))