Understand the functional programming paradigm, functions as first-class objects, function application, partial application and composition, and the higher-order functions map, filter and reduce.

What this dot point is asking

AQA wants you to describe the functional programming paradigm, explain that functions are first-class objects, describe function application, partial application and composition, and use the higher-order functions map, filter and reduce (fold).

The functional paradigm

The avoidance of mutable state is the heart of the paradigm and the source of its advantages. Because a pure function cannot alter anything outside itself, its behaviour depends only on its arguments, so it can be tested in isolation, its result can be cached, and several pure functions can run on different processors at once without interfering. This contrasts sharply with the imperative paradigm covered in the languages topic, where the program proceeds by changing the values of variables step by step.

First-class functions, application, partial application and composition

These ideas build on one another. First-class status is the foundation, because only if functions are values can you pass them around to build higher-order functions, compose them, or partially apply them. Partial application and composition are two different ways of making new functions from existing ones: partial application fixes arguments, while composition wires outputs into inputs. Keeping the two clearly apart is a frequent exam discriminator.

Higher-order functions: map, filter and reduce

map(double, [1,2,3])        -> [2,4,6]
filter(isEven, [1,2,3,4])   -> [2,4]
reduce(add, [1,2,3,4], 0)   -> 10

These three higher-order functions replace many of the explicit loops of imperative programming with a declarative description of what should happen to the data. Instead of writing a loop that mutates an accumulator, you state that you want every element transformed (map), or the matching ones kept (filter), or all of them combined (reduce). They are often chained: filter the even numbers, then map them to their squares, then reduce by addition, expressing a whole pipeline without a single mutable variable.