Loading…
Free A-Level Computer Science guide
Use original Python examples to explore the functional paradigm, with explicit connections to AQA's mathematical notation. A language supporting several paradigms can still be used to write a functional solution.
Content owner: Michael Print · Written for A-Level learners · Checked against official specifications
Functional programming describes a calculation through functions and their composition. A function can be a value: assign it to a name, pass it to another function or return it. A higher-order function receives a function, returns one, or does both.
Map transforms each element, filter keeps elements satisfying a predicate, and fold combines elements into an accumulated result. Partial application fixes some inputs and produces a function for the remaining inputs; composition feeds one function's result into the next.
AQA 7517 · 4.12.1.1–4.12.1.5, 4.12.2.1, 4.12.3.1
Useful foundations
By the end, you should be able to
Write f: A → B for a function with inputs in domain A and outputs in co-domain B. For f(n) = 2n, let A = {0, 1, 2} and B = {0, 1, 2, 3, 4}.
The actual outputs are {0, 2, 4}. The co-domain names permitted outputs; every permitted value need not be produced. Function application supplies an input: f(2) gives the output 4.
In Python, double refers to a function object; double(5) applies it and returns a number. Assigning operation = double creates another name for the callable, without evaluating it or copying a result.
A higher-order helper can receive operation and apply it to several values without knowing the particular transformation in advance. Functions can also be returned, as make_adder demonstrates below.
A two-input calculation can have type add: Integer × Integer → Integer, with an ordered pair as input. The curried type Integer → (Integer → Integer) instead takes one integer and returns a function waiting for another.
Arrow types associate to the right when brackets are omitted. Supplying the only input to a one-argument function gives a result; supplying just some inputs to a multi-input calculation can produce another function.
For volume: Number → Number → Number → Number, fixing length 2 leaves width and height to supply. Also fixing width 3 leaves a function taking height and returning six times that height.
make_adder(amount) returns a function that adds the captured amount to its later input. add_three = make_adder(3) fixes one addition input; add_three(7) returns 10. The nested function supplies currying behaviour explicitly: ordinary Python functions are not automatically curried.
If f maps A to B and g maps B to C, g ∘ f maps A to C and applies f first. The intermediate output must be acceptable to the next function; a string cannot silently feed an integer-only calculation.
Reversing the functions changes the result: with f(x) = x + 3 and g(x) = 2x, (f ∘ g)(5) doubles first, then adds 3, giving 13.
Prefer functions whose results depend on their inputs and which do not modify outside state. Python supports this style but also permits side effects: using lambda or map alone does not establish purity.
Input 5
Supply 5 to f(x) = x + 3.
Apply f first
f(5) = 8. This intermediate value becomes the input to g.
Apply g second
g(8) = 2 × 8 = 16. The composed result is 16.
The three operations answer different questions: filter decides which elements to keep, map transforms each retained element, and fold combines elements into an accumulated result. None requires changing the source list.
In Python 3, map and filter return iterators; this example uses list to display and reuse their values. Other functional languages may return lists directly. functools.reduce provides the combining operation.
Here the combining arguments are accumulator first, next element second. The explicit initial value defines empty-input behaviour. Addition starts at 0, then becomes 6, then 30.
Direction can matter. Left-fold subtraction of [3, 2] from initial 10 gives (10 − 3) − 2 = 5. A combining function need not be associative, so changing the fold direction can change its result.
Start: [2, 5, 8, 11]
These are the original readings; the pipeline preserves this list.
Filter: [2, 8]
Keep the readings satisfying the even-number predicate.
Map: [6, 24]
Triple each surviving reading.
Fold: 30
Start at 0 and add each transformed reading: 0 + 6 + 24.
For [6, 24, 9], head is the element 6 and tail is the list [24, 9]. A singleton [6] has tail []; an empty list has no head. Check non-emptiness instead of inventing an element.
The second example constructs []; tests emptiness; obtains length, head and tail; and prepends or appends an element. Each transformation constructs a new list, leaving the original unchanged.
Python slicing and concatenation copy list contents. They demonstrate the required behaviour, without promising the constant-time operations that a persistent linked-list implementation might provide.
Worked example
| Line | Output |
|---|---|
| 1 | [2, 8] |
| 2 | [6, 24] 30 |
| 3 | 16 |
| 4 | [2, 5, 8, 11] |
from functools import reduce
def make_adder(amount):
return lambda value: value + amount
def compose(after, before):
return lambda value: after(before(value))
readings = [2, 5, 8, 11]
even = list(filter(lambda value: value % 2 == 0, readings))
tripled = list(map(lambda value: value * 3, even))
total = reduce(lambda acc, value: acc + value, tripled, 0)
add_three = make_adder(3)
double_after_add = compose(lambda value: value * 2, add_three)
print(even)
print(tripled, total)
print(double_after_add(5))
print(readings)Worked example
| Line | Output |
|---|---|
| 1 | 6 [24, 9] 3 |
| 2 | [1, 6, 24, 9] [6, 24, 9, 1] |
| 3 | True [] |
| 4 | [6, 24, 9] |
def empty_list():
return []
def is_empty(values):
return len(values) == 0
def length(values):
return len(values)
def head(values):
if is_empty(values):
raise ValueError("empty list has no head")
return values[0]
def tail(values):
if is_empty(values):
raise ValueError("tail requires a non-empty list")
return values[1:]
def prepend(value, values):
return [value] + values
def append(value, values):
return values + [value]
values = [6, 24, 9]
print(head(values), tail(values), length(values))
print(prepend(1, values), append(1, values))
print(is_empty(empty_list()), tail([6]))
print(values)6 original questions total 24 marks. Attempt each before opening the independently written indicative marking guidance.
For f(n) = 3n, domain {0, 1, 2} and co-domain {0, 1, 2, 3, 4, 5, 6}, give the actual outputs and explain why the co-domain can contain other values.
Indicative answer
Explain two ways functions are first-class values in make_adder and compose. State why each helper is higher-order.
make_adder(amount) returns lambda value: value + amount. The statement add_three = make_adder(3) stores what the helper returns.
compose(after, before) returns lambda value: after(before(value)). A caller supplies two functions as after and before.
Indicative answer
Let f(x) = x + 4 and g(x) = 3x. Calculate (g composed with f)(2) and (f composed with g)(2), showing the order.
Indicative answer
Filter [1, 4, 6, 9] for values greater than 4, map squaring over the result, then left-fold addition with initial 0. Give each intermediate result and the fold accumulator values.
Indicative answer
A curried volume function has type Number → Number → Number → Number. Explain the result of fixing length 2 and width 5, then applying height 3. Distinguish partial application from the final application.
Indicative answer
For [8], give head, tail and length using these functions. State the result of head([]), and explain why append leaves its input unchanged.
head(values) and tail(values) first raise ValueError if values is empty. Otherwise head returns values[0], while tail returns values[1:].
length(values) returns len(values). append(value, values) returns values + [value].
Indicative answer
This guide addresses AQA 7517 4.12.1.1–4.12.1.5, 4.12.2.1, 4.12.3.1. Check your examination year and the complete specification for the assessment scope.
These are independently written explanations and practice questions. CompSciTutoring.co.uk is not affiliated with or endorsed by an examination board. The marking guidance is indicative; always check the syllabus for your examination year.
Found an error? Email a correction.
Use the free examples first, then explore one-to-one tuition if guided practice would help.