Functional Programming

Reading the clock inside the decision turns time into an undeclared input: the same subscription record can produce two different answers, and no test can pin the answer down. Pass the instant in as a parameter.

A pure lookup returns the same distance for the same pair of stops every time, so a stored result can never disagree with a fresh call. Invalidation exists to catch drift between cache and source; purity removes the drift.

Either order is safe exactly when neither formula reads the cell the other writes. Purity closes every other channel — no shared counters, no clock, no files — so only declared data dependencies constrain the schedule.

A clock read, a counter bump and a log write are all side effects. Purity needs two things at once: the result depends only on the arguments, and the call changes nothing observable outside itself.

It means the call is referentially transparent: anywhere the call appears, writing the value it returned instead leaves the meaning of the program unchanged, and putting the call back is equally safe.

A persistent structure never destroys the version an update was applied to. The edit returns a new version, and a reference taken earlier still reads exactly the document it read before, with no copy having been taken.

Fixing a field fixes the binding, not the object it points at. The tier rows are separate objects; anyone holding a reference to one can write its amount in place, without ever touching the price list's field.

A value that never changes has no intermediate state to hide, so concurrent readers have nothing to exclude each other from. Locks guard transitions, and this value makes exactly one: from unbuilt to finished, before anybody can see it.

Only the nodes along the route from the root to the changed leaf are rebuilt; every subtree the change never touched is pointed at by both versions. The copy is one path deep, not one tree wide.

You build a new line that copies every field except quantity, which takes the new value. The original object is untouched, so any code already holding it keeps seeing the old quantity.

Functions have to be ordinary values: storable in a variable, a field or a map entry, and passable and returnable like a number. The table then holds behaviour itself rather than a code that some conditional must interpret.

The entry stored the result of calling save, not the function itself: the parentheses invoked it while the table was being built. Writing table[key] = save stores the function value and leaves the call for key-press time.

The caller gives up control of invocation: the send routine now decides whether the acknowledgement handler runs at all, when it runs, how many times, with what arguments, and on which execution context. That reversal is inversion of control.

A function type fixes arity plus what stands in each parameter position and in the result position. A supplied formatter must accept the one argument the renderer will pass and hand back something the renderer can print.

The invocation contract: how many times the handler may run, whether it can run before the registering call returns, on which execution context, how failures are delivered to it, and what the routine does if the handler itself throws.

A list of lists: one inner list of sessions per course, in course order, with an empty inner list wherever a course scheduled nothing. Flattening one level concatenates those inner lists into a single list of sessions.

The seed is the accumulator's starting value and the result returned for an empty day. The combining step takes the accumulator so far plus one transaction and returns the next accumulator. A fold threads that accumulator through every element.

A mapping stage produces exactly one output per input, so count and order are unchanged and only element values or types change. A filtering stage keeps a subset in the original relative order, so its count can only shrink.

Keeping the same parameters and return type makes the wrapper a drop-in: every existing call site keeps working, the wrapper goes in and comes out at one wiring line, and other wrappers can stack around it.

Currying reshapes the check itself into a chain of one-argument functions, one per parameter, and mentions no argument values. Partial application supplies actual values for some parameters and hands back a single function that still needs the rest.

Resize sees it first. A right-to-left combinator applies the last-listed function to the argument and feeds each result leftwards, so the stages are listed in the reverse of the order they run.

Another predicate. A combinator builds a condition rather than evaluating one: nothing is tested until the assembled predicate is finally applied to a candidate, and then it asks both questions and combines the answers.

Composition is associative but not commutative. Regrouping only changes which adjacent stages get bracketed together, so every stage still receives the same input; swapping two changes what the later one is handed, and therefore the result.

Give each comparator one key and one direction, then chain them: the next comparator is consulted only when the previous one reports a tie. Each returns a three-way verdict - before, equal, after - and 'equal' is the signal that hands control to the tiebreaker.

A stage returning its input unchanged is the identity function: composing it changes nothing. It earns its place as a neutral default - what an optional stage falls back to, and the starting point when a list of stages is combined into one.

An expression evaluates to a value, so it can sit anywhere a value is expected and nest inside a larger expression. A statement is run for its effect and denotes nothing, so nothing can be built around it.

Stating the result instead of the steps hands the runtime the choice of strategy: the order of the work, chunk sizes, placement and passes. You describe what; it decides how, and can change how without you editing anything.

The chain removes the index and its bounds, the mutable counter and its half-built intermediate states, and the advance-and-test mechanism; what is left is three named stages - keep the well-formed lines, take each status, count them.

An eagerly evaluated chain runs every stage over every record before anything is picked out, so it pays for the whole batch even when the answer was settled at record three. The loop returns the moment it knows.

Make the choice itself denote a value and bind the result once: each arm yields a band instead of assigning one. The name is then initialised at its declaration, never reassigned, and no path can leave it empty.

An unbounded sequence is a recipe, not a collection: a seed plus a rule for the next element, computed only when something demands it. Building it stores the rule; taking five runs the rule four times.

A short-circuiting AND evaluates its right operand only when the left one is true, so the left test can establish the precondition the right test needs - presence, a non-empty collection, a valid index - instead of hoping it holds.

Call-by-value evaluates every argument at the call site, before the check's body starts. The expensive diagnostic is built on every call, including the calls where the check discards it unused.

Forcing runs the stored computation once: the thunk evaluates its body, replaces itself with the resulting value and returns it. Every later force returns that cached value without running anything, so the work is paid for at most once.

The eager chain walks the data once per stage and builds a complete collection at every stage boundary. The fused lazy chain walks it once and holds one element in flight, so no collection exists at a boundary - only the final result is built.

The stored function itself keeps them alive. Captured state is moved out of the short-lived call frame into storage the function value owns, so it lives exactly as long as that function value stays reachable.

Capture mode decides. A by-value capture copied the status when the entry was created and reports the old value; a capture of the binding itself reads the variable at call time and reports the new one.

Lexical scoping resolves a free name in the text surrounding the helper's definition - innermost enclosing region first, then outward. The call site is never consulted, so the helper means the same thing everywhere it is used.

Every handler captured the same loop variable rather than a copy of that pass's value. The loop reassigned that one binding on each pass, so by the time any handler ran it read whatever the loop had left behind.

The returned function captured that variable, so the variable lives as long as the function value does instead of ending with the call that created it. No code outside can name it, so the returned function is the only way in.

The data definition lists the ways a value can be built, and each way becomes one case. A reply list is either empty or a comment plus the rest, so the walker has exactly those two cases.

It moves across the call, into the argument expression. The combining step is applied to the running result first, and the updated value is passed down, so the recursive call becomes the last thing the function does.

Guardedness: every recursive call must sit behind a step that has already handed back one date, so each turn of the definition delivers output. A path that recurses without delivering anything is the real failure to look for.

That rewrite is local: it turns a call to the enclosing function into reassigned parameters and a jump to the top of the same body. A mutual call's target is a different body, so no such jump exists.

Every recursive call receives a part of the value it was given, so the argument is strictly smaller each time and the descent runs out of thread. Termination comes from the data, not from a number someone picked.

Binding in the pattern makes one construct do two jobs: it tests that the value has the case's shape and names the parts of that shape at the same time. The branch body starts with named parts instead of shape checks and accessor calls.

An exhaustiveness check proves at compile time that a match handles every variant its type can hold. The payoff comes later: add a variant and every match with a gap fails the build instead of falling through at run time.

A sum type holds exactly one of its variants, tagged so you can tell which; a product type holds a value of every component at once. The payment is a sum, the record of all three is a product.

The case is rejected as a whole and matching continues with the cases below it, exactly as if the pattern had not fitted. A failed guard is not an error and does not abort the match.

A catch-all makes the match total for every variant, including ones that do not exist yet, so the compiler reports nothing when a state is added. The new state silently takes a branch written for the variants of a year ago.

Every caller must handle the failure case to reach the success value, because the two outcomes are alternative shapes of one returned value. A failure that is thrown instead puts no such obligation at the call site.

An empty-or-one-value context puts the missing case in the return type, so a caller cannot reach the employee without opening the container: transform the value inside it, or supply a fallback. The possibility of nothing stops being a convention.

Building the plan performs no effects, so the code that assembles fetch, unpack and link can be tested, inspected, combined and rewritten as ordinary data. Nothing reaches the network or the disk until a runner is handed the value.

The three checks stop being a chain and become independent parts combined together. A chain abandons the remaining checks at the first failure; combining runs all three and merges their failures into one description the response can render.

Mapping a function that itself returns a wrapped value gives you a wrapper nested inside a wrapper. Chaining is the operation you needed: it runs the step and hands back one layer, absorbing the step's own context instead of stacking it.