Higher Order functions

Functions can be used as an arguments to other functions as we have seen in function composition. This is possible because a function always evaluates to a value. This is the basis of function composition.

Higher Order functions can also return a function definition, as when that function definition is evaluated it to will return a value.

You could have a function that returns a function definition which in turn returns a function definition, but at some point this will get very confusing for the developers (yes, that means you).

<!--sec data-title="Return the even numbers between 1 and 10" data-id="answer002" data-collapse=true ces-->

(filter even? (range 1 10))

<!--endsec-->



> #### Note::Create a named function as a higher order function called `twice`
> The function twice which takes a function and value as arguments.
>
> The twice function should call the function passed as an argument on the value passed as an argument.
>
> The result should be then used as an argument to calling the function passed as an argument again.
>
> Call the twice function with an inline function which takes a number as an argument and adds it to Pi, `3.14`.
```eval-clojure
(defn twice [f]
  ,,,)

;; Our higher order function

(defn twice [function x]
  (function (function x)))

(twice
  (fn [arg]
    (* 3.14 arg))
  21)
;; => 207.0516

;; using the short syntax for a function definition

(twice #(+ 3.14 %) 21)
;; => 207.0516

(defn calculation [f]
  ,,,)

(defn calculation [f]
  (fn [& args]
    (reduce f args)))

((calculation +) 1 1 2 3 5 8 13)

;; The result of `(calculation +)` is also in a list,
;; so it will be called as a function, with the arguments 1 1 2 3 5 8 13

References

• Writing Elegant Clojure code using Higher Order functions