Higher-Order Functions in F#

Analogy categoryAnalogies

What Are Higher-Order Functions?

Higher-order functions in F# are functions that either accept other functions as parameters, return a function as their result, or both. Because F# treats functions as first-class values, you can store them in variables, pass them into other functions, and build new functions dynamically at runtime. This capability is central to F#'s functional style, letting you express transformations like 'apply this operation to every item' or 'combine these values' without writing explicit loops.

🏏

Cricket analogy: A cricket captain who plugs different bowlers (fast, spin, medium-pace) into the same over slot is treating bowlers like first-class values — the over structure stays fixed while the bowler function passed in changes the outcome, just as List.map takes any transformation function you hand it.

Passing Functions as Arguments

Many core F# library functions are higher-order functions themselves. List.map applies a transformation function to every element of a list, producing a new list of the same length. List.filter applies a predicate function to decide which elements to keep. List.fold walks the list left-to-right, applying an accumulator function to combine each element with a running state, producing a single final value.

🏏

Cricket analogy: List.map applying a run-conversion function to every ball of an over is like a scorer who runs each delivery's outcome through the same 'runs scored' rule — every element transforms via one shared function, the way MS Dhoni's finishing overs get logged ball by ball through a consistent scoring function.

fsharp

let numbers = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]

// map: transform every element
let squares = List.map (fun x -> x * x) numbers

// filter: keep elements matching a predicate
let evens = List.filter (fun x -> x % 2 = 0) numbers

// fold: accumulate a single result
let sum = List.fold (fun acc x -> acc + x) 0 numbers

// choose: filter + transform in one pass
let evenSquaresText =
    numbers
    |> List.choose (fun x ->
        if x % 2 = 0 then Some (sprintf "%d^2=%d" x (x*x))
        else None)

// A function that returns a function (closure)
let makeMultiplier factor =
    fun x -> x * factor

let triple = makeMultiplier 3
printfn "%d" (triple 7)   // 21

Returning Functions and Building Closures

F# functions can also return other functions as their result, which is how closures are built. A closure is a function value that captures variables from its enclosing scope, remembering them even after that scope has finished executing. This lets you write function factories — functions like makeAdder that take a configuration value and return a specialized function tailored to that value, without repeating logic.

🏏

Cricket analogy: A bowling-machine calibration function that takes a target speed and returns a 'deliver ball at that speed' function is a closure — the returned function remembers the calibrated speed just as Jasprit Bumrah's yorker-throwing machine setting persists across every ball fired after configuration.

Common Higher-Order Functions in the Core Library

F#'s core collection modules — List, Array, and Seq — are built almost entirely from higher-order functions. Beyond map, filter, and fold, you'll frequently use List.iter for side effects, List.choose to filter and transform in one pass (returning Some to keep, None to drop), List.sortBy to order elements by a derived key, and List.exists / List.forall to test predicates across a whole collection. Seq is the lazy counterpart to List, evaluating elements on demand, which matters when composing several higher-order operations over large or infinite sequences.

🏏

Cricket analogy: List.sortBy ordering batsmen by strike rate rather than raw runs is like a captain reordering a T20 batting lineup using a derived key (strike rate) instead of the obvious total, letting the higher-order sort function decide the order.

F# functions are curried by default, so a two-argument function like let add x y = x + y is really int -> int -> int — a function that takes x and returns a new function waiting for y. This is why partial application (add 5) works without any special syntax.

List.fold and List.foldBack process elements in opposite directions and take their accumulator/element arguments in a different order. Mixing them up silently produces a result built in the wrong order rather than an error — always check whether you need left-to-right (fold) or right-to-left (foldBack) folding.

Higher-order functions accept functions as arguments, return functions as results, or both.
F# functions are first-class values, curried by default, enabling partial application.
List.map transforms, List.filter selects, and List.fold accumulates — the three foundational higher-order operations.
List.choose combines filtering and transforming into a single pass using option values.
Closures capture variables from their enclosing scope, letting you build specialized functions with makeX-style factories.
Seq is the lazy counterpart to List, evaluating elements only as needed.