What does it mean to compose two functions in Kotlin, and how would you write an `andThen` helper that runs one function and feeds its result into another?
answer
- andThen = receiver first; compose = receiver last
- Returns a new lambda { x -> g(this(x)) }
- Extension on a function type, marked infix
- Three generics A, B, C thread the intermediate type
- Lazy: nothing runs until you invoke the result
basics
~10 sComposing means chaining functions so one's output becomes the next's input. An andThen helper takes function f, then g, and returns a new function that does g(f(x)) for any input x.
solid answer
~40 sComposition combines two function values into a single new function. In Kotlin you write it as an extension on a function type, usually `infix`. `andThen` applies the receiver first, then the argument: `fun <A,B,C> ((A)->B).andThen(g:(B)->C):(A)->C = { x -> g(this(x)) }`. The returned lambda captures both functions and defers execution until called. `compose` is the mirror image: `f.compose(g)` returns `{ x -> f(g(x)) }`, running g first. The key idea is that the helpers don't run anything immediately; they build and return a brand-new `(A)->C` lambda. You then invoke it like any function: `val pipeline = parse andThen validate andThen save; pipeline(input)`. Generic type parameters thread the intermediate type B so the compiler checks the wiring.
code
kotlin · 7 linesinfix fun <A, B, C> ((A) -> B).andThen(g: (B) -> C): (A) -> C =
{ x -> g(this(x)) }
val trim: (String) -> String = String::trim
val len: (String) -> Int = String::length
val trimmedLength = trim andThen len
println(trimmedLength(" hi ")) // 2go deeper
Can state that composition chains output-to-input and write a simple andThen returning g(f(x)).
Distinguishes andThen vs compose order, uses infix + generics, and knows it returns a lazy new lambda.
Explains receiver-as-function, closure capture, and when a fluent pipeline beats nested calls for readability.
Frames composition as a building block for declarative pipelines and weighs it against existing collection/sequence operators in real code.
## What composition means **Function composition** takes two functions and produces a third that, when called, runs them in sequence. If `f: (A) -> B` and `g: (B) -> C`, the composition is a function `(A) -> C` defined by `x -> g(f(x))`. The two directions have conventional names: - **`andThen`**: receiver runs **first**. `f.andThen(g)` == `{ x -> g(f(x)) }`. Reads left-to-right like a pipeline. - **`compose`**: receiver runs **last** (math convention). `g.compose(f)` == `{ x -> g(f(x)) }`. Reads right-to-left. ## Writing the helper Kotlin has no built-in `andThen` for plain function types, so you define an **extension function** on the function type. Marking it `infix` lets you write `a andThen b` without dots/parens. ```kotlin infix fun <A, B, C> ((A) -> B).andThen(g: (B) -> C): (A) -> C = { x -> g(this(x)) } infix fun <A, B, C> ((B) -> C).compose(g: (A) -> B): (A) -> C = { x -> this(g(x)) } ``` - `((A) -> B)` is the **receiver type** — the function you call the helper on. Inside the body, `this` refers to it. - The three **generic type parameters** `A, B, C` thread the types: input `A`, intermediate `B`, output `C`. The compiler infers them and rejects mismatched wiring. - The body returns a **lambda** `{ x -> g(this(x)) }`. Nothing executes yet — composition is **lazy**; the captured functions only run when you invoke the result. ## Using it ```kotlin val toLength: (String) -> Int = { it.length } val isEven: (Int) -> Boolean = { it % 2 == 0 } val lengthIsEven = toLength andThen isEven println(lengthIsEven("hello")) // 5 -> false ``` ## Key keywords - `infix` — enables `a andThen b` syntax. - extension function on a **function type** — the receiver is itself a function. - the returned **lambda captures** both functions (a closure).
- What is the difference between `f andThen g` and `f compose g`?`f andThen g` runs f first then g (g(f(x))). `f compose g` runs g first then f (f(g(x))). They are mirror images of each other.
- Does `andThen` run the functions immediately?No. It returns a new function and runs nothing. The composed functions only execute when you invoke the returned function with an argument.
Like an assembly line: andThen bolts the next station onto the end, so a part flows through each step in order.
saying these in an interview costs you the question
- Says andThen executes the functions right away instead of returning a new function
- Confuses the order: thinking compose runs the receiver first
- Writes it as a top-level function taking two args instead of an extension on a function type
- Forgets the generic type parameters so the intermediate type isn't threaded
- Thinks Kotlin's standard library already provides andThen for (A)->B