Higher-Order Functions and Function Composition

Higher-order functions are not an advanced corner of Clojure. They are one of the reasons everyday Clojure code stays small and expressive. Instead of building behavior into objects, Clojure often passes behavior around directly as functions.

Higher-order function: A function that takes functions as arguments, returns functions as results, or both.

Once that idea feels normal, many idiomatic patterns make more sense: map, filter, reduce, function composition, strategy selection through function values, and small data pipelines built from reusable pieces.

Why Higher-Order Functions Matter in Clojure

In Clojure, functions are regular values. You can:

• store them in maps
• pass them into other functions
• return them from factories
• combine them into pipelines

That means behavior can stay explicit instead of being hidden in class hierarchies or global switches.

1(defn apply-discount [discount-fn total]
2  (discount-fn total))
3
4(defn percent-off [pct]
5  (fn [total]
6    (* total (- 1.0 pct))))
7
8(apply-discount (percent-off 0.10) 200)
9;; => 180.0

The logic stays flexible without needing inheritance or a registry of strategy objects.

Data Flows Better When Behavior Is Explicit

Many core Clojure functions are higher-order:

• map
• filter
• remove
• reduce
• sort-by
• group-by
• update
• comp

That means you can define small transformations once and reuse them in many contexts.

1(defn normalize-email [email]
2  (-> email
3      clojure.string/trim
4      clojure.string/lower-case))
5
6(map normalize-email [" Alice@EXAMPLE.com " "Bob@Example.com"])
7;; => ("alice@example.com" "bob@example.com")

The idea is simple but important: the function becomes a unit of reuse, not just the surrounding data structure.

Higher-Order Design Does Not Mean Abstraction for Its Own Sake

Passing functions around is useful when it clarifies variation points. It becomes noise when the variation is not real.

This is a good fit:

1(defn retrying [attempts f]
2  (loop [remaining attempts]
3    (try
4      (f)
5      (catch Exception e
6        (if (= remaining 1)
7          (throw e)
8          (recur (dec remaining)))))))

The caller provides behavior, and the helper provides control policy.

This is a weaker fit:

1(defn add-user [notify-fn user]
2  ;; only one real notification behavior ever exists
3  ...)

If there is no genuine variability, higher-order design can become ceremony.

Composition Is What Makes Small Functions Scale

Higher-order code becomes especially powerful when small functions compose into larger ones.

1(def trim-and-keyword
2  (comp keyword
3        clojure.string/lower-case
4        clojure.string/trim))
5
6(trim-and-keyword "  Admin ")
7;; => :admin

The point is not just terseness. Composition helps you:

• isolate small rules
• test steps independently
• reuse the same steps in different pipelines
• keep state transformation explicit

In Clojure, composition often appears alongside thread macros. The two are complementary:

• comp is excellent for building a reusable function
• -> and ->> are excellent for reading one concrete flow left to right

Returning Functions Is Often Better Than Configuring Globals

Higher-order functions also let you create focused behavior without leaking global state.

1(defn make-threshold-checker [limit]
2  (fn [n]
3    (> n limit)))
4
5(def over-100? (make-threshold-checker 100))
6(filter over-100? [10 50 125 200])
7;; => (125 200)

That style is more explicit and easier to test than sprinkling threshold lookups across the system.

Design Pressure Moves from Classes to Contracts

In object-oriented code, behavior variation often pushes you toward interfaces or inheritance. In Clojure, the same pressure often resolves into:

• plain functions
• maps of functions
• protocols when type-based dispatch is needed
• multimethods when value-based dispatch is needed

Higher-order functions are the first stop because they are direct. If you can express the variation by passing behavior explicitly, that is often the simplest solution.

A Useful Mental Model

    graph TD;
	    A["Data"] --> B["Higher-order function"]
	    C["Behavior function"] --> B
	    B --> D["New transformed data or new function"]

The diagram below captures the heart of idiomatic Clojure: data stays separate from behavior, and higher-order functions give you clean ways to combine the two.

Quiz