Higher-order functions

Definition

A higher-order function takes a function as an argument, returns a function, or both.

Read the arrows

• Int => Int — one integer in, one integer out.
• (A, A) => Boolean — two values of the same type, then a decision.
• A => B => C — an A produces a function that accepts B and produces C.

Reusable traversal

def isSorted[A](as: Array[A], ordered: (A, A) => Boolean): Boolean = {
  @annotation.tailrec
  def go(n: Int): Boolean =
    if (n >= as.length - 1) true
    else if (!ordered(as(n), as(n + 1))) false
    else go(n + 1)

  go(0)
}

The loop is stable; the ordering policy is supplied by the caller.

Follow the types

def partial1[A, B, C](a: A, f: (A, B) => C): B => C =
  b => f(a, b)

def compose[A, B, C](f: B => C, g: A => B): A => C =
  a => f(g(a))

• partial1 captures the value already known and waits for the missing value.
• compose runs g first, because its output has the type required by f.

Design rule

• Keep the traversal or pipeline in one pure function.
• Pass policy, comparison, formatting, or transformation as a function.
• Use type parameters when the algorithm does not care about the concrete element type.
• Test the pure core with multiple policies before adding I/O.

Rust translation

Think of this as passing a closure into a generic Rust function. The important move is the same: the algorithm owns the structure, while the caller supplies behavior.