CODEWITHSUNDEEP
clojurefunctional-programminghigher-order-functions
octopusgrabbus
octopusgrabbus

Reputation: 10695

Correct Syntax For Anonymous Function

The first of the following two functions, fn-apply-cmp-vals, returns a partial function that is used in the second function, apply-cmp-vals.

What is the correct syntax to embed fn-apply-cmp-vals as an anonymous function in apply-cmp-vals?

(defn fn-apply-cmp-vals
    [fn cmp-sos cmp-idx]
    (partial fn cmp-sos cmp-idx))

(defn apply-cmp-vals
    [cmp-vec cmp-vals cmp-vec-idx]
    (let [fn-cmp (fn-apply-cmp-vals ret-non-match-rows cmp-vec cmp-vec-idx)]
        (map #(fn-cmp %1) cmp-vals)))

Specifically, I want to replace fn-apply-cmp-vals ret-non-match-rows cmp-vec cmp-vec-idx) with an anonymous function instead of a function call. Thank You.

Upvotes: 2

Views: 240

Answers (2)

Jeremy
Jeremy

Reputation: 22425

Lets take a look at this, in detail, one step at a time.

Your goal is to inline fn-apply-cmp-vals as an anonymous function in apply-cmp-vals. So lets do that first. Here is what your function looks like with no other changes:

(defn apply-cmp-vals
  [cmp-vec cmp-vals cmp-vec-idx]
  (let [fn-cmp ((fn [f cmp-sos cmp-idx] (partial f cmp-sos cmp-idx))
                  ret-non-match-rows cmp-vec cmp-vec-idx)]
    (map #(fn-cmp %1) cmp-vals)))

This accomplishes your goal, but there is room for improvement. Since your function simply calls partial with the given arguments, lets replace the anonymous function with a direct call to partial with the correct arguments. This works because partial returns a partially applied function.

(defn apply-cmp-vals
  [cmp-vec cmp-vals cmp-vec-idx]
  (let [fn-cmp (partial ret-non-match-rows cmp-vec cmp-vec-idx)]
    (map #(fn-cmp %1) cmp-vals)))

Now, lets look where fn-cmp is used. It is being called in its own anonymous function with a single argument. Since your partial function satisfies this requirement, you could instead just pass fn-cmp into the map function directly.

(defn apply-cmp-vals
  [cmp-vec cmp-vals cmp-vec-idx]
  (let [fn-cmp (partial ret-non-match-rows cmp-vec cmp-vec-idx)]
    (map fn-cmp cmp-vals)))

Finally, if you desire, you can completely remove the let form:

(defn apply-cmp-vals
  [cmp-vec cmp-vals cmp-vec-idx]
  (map (partial ret-non-match-rows cmp-vec cmp-vec-idx) cmp-vals)))

So it turns out you didn't need an anonymous function at all!

Upvotes: 3

dbyrne
dbyrne

Reputation: 61031

I think what you are looking for is:

(defn apply-cmp-vals
  [cmp-vec cmp-vals cmp-vec-idx]
    (let [fn-cmp (partial ret-non-match-rows cmp-vec cmp-vec-idx)]
      (map fn-cmp cmp-vals)))

fn-apply-cmp-vals wasn't doing anything other than passing its arguments to partial.

(partial ret-non-match-rows cmp-vec cmp-vec-idx) will return an anonymous function.

fn-cmp is a function, so replace (map #(fn-cmp %1) cmp-vals) with (map fn-cmp com-vals).

Upvotes: 2

Related Questions