Foundations: Solutions

# exercise_1.py
balance = 100

def deposit(amount: int) -> int:
    global balance
    balance += amount
    return balance

print(deposit(30), deposit(30))
#: 130 160

deposit() reads and mutates balance, a name outside its own scope. A pure function reads nothing that can change and changes nothing outside itself, so deposit() breaks both halves of that definition. What deposit(30) returns depends on how many times deposit() (or withdraw()) has run: the two identical calls deposit(30) and deposit(30) return 130 and then 160, where a pure function returns the same value both times. To predict either result you must track the history of every prior call, and that tracking is the problem the chapter raises for withdraw().

# exercise_2.py
from collections.abc import Callable
from operator import mod
from exceptions import expected

def add(a: int, b: int) -> int:
    return a + b
def sub(a: int, b: int) -> int:
    return a - b
def mul(a: int, b: int) -> int:
    return a * b
def floordiv(a: int, b: int) -> int:
    return a // b

operations: dict[str, Callable[[int, int], int]] = {
    "+": add,
    "-": sub,
    "*": mul,
    "//": floordiv,
}
operations["%"] = mod
print(operations["+"](6, 4), operations["-"](6, 4),
      operations["*"](6, 4), operations["//"](6, 4),
      operations["%"](6, 4))
#: 10 2 24 1 2
with expected(KeyError):
    operations["^"](6, 4)
#: [KeyError] '^'

You call operations["*"](6, 4) the way you call the other four entries, and the calling code stays as it was. Supporting the new operator takes one function and one row in the table. expected() from the shared exceptions helper catches the missing-key KeyError, as it does in the chapter’s dispatch.py.

# exercise_3.py
from collections.abc import Callable

def multiplier(factor: int) -> Callable[[int], int]:
    def multiply(n: int) -> int:
        return n * factor
    return multiply

double = multiplier(2)
triple = multiplier(3)
quadruple = multiplier(4)
print(double(10), triple(10), quadruple(10))
#: 20 30 40

Each call to multiplier() creates a new multiply closure with its own private factor. quadruple remembers 4 independently of double’s 2 and triple’s 3, the same way double and triple are independent of each other. The three closures share nothing, because each factor is reachable only through the one function that captured it.

# exercise_4.py
from collections.abc import Callable

def compose[T, U, V](
    f: Callable[[U], V], g: Callable[[T], U]
) -> Callable[[T], V]:
    def composed(x: T) -> V:
        return f(g(x))
    return composed

def increment(n: int) -> int:
    return n + 1
def double(n: int) -> int:
    return n * 2
def square(n: int) -> int:
    return n * n

increment_then_double = compose(double, increment)
increment_then_double_then_square = compose(
    square, increment_then_double)
print(increment_then_double_then_square(3))
#: 64

increment_then_double_then_square(3) runs increment_then_double(3) first, which computes (3 + 1) * 2 = 8, then feeds that 8 into square, giving 8 * 8 = 64. compose() needs no change to support a third stage: wrapping one composed function inside another compose() call extends the pipeline.

If you build at_least_ten as partial(clamp, 10, Placeholder, Placeholder), the partial() call raises a TypeError, “trailing Placeholders are not allowed,” before you call the result. A placeholder at the end does nothing, because partial() appends the call’s arguments after the bound ones, so the library rejects it, as the chapter says. The solution passes 10 alone, with no Placeholder.

# exercise_5.py
from functools import partial
from exceptions import expect

def clamp(low: int, value: int, high: int, /) -> int:
    return max(low, min(value, high))

at_least_ten = partial(clamp, 10)
print(at_least_ten(3, 100), at_least_ten(50, 100))
#: 10 50
expect(TypeError, partial(clamp, high=100), 0, 5)  # type: ignore
#: [TypeError] clamp() got some positional-only arguments
#: passed as keyword arguments: 'high'

Preset the leading argument. at_least_ten needs no Placeholder. low is the first parameter, and partial() fills positional arguments from the left, so the two remaining parameters stay open in order.

Show where the keyword fails. Presetting high alone is the case that needs a Placeholder. partial() does not inspect the signature, so building partial(clamp, high=100) succeeds. The call is where the partial fails: high is positional-only, so it cannot arrive by name. Passing high positionally means passing low and value first, which is the opposite of leaving them to the caller. partial(clamp, Placeholder, Placeholder, 100) is the version that works, and Placeholder exists for that case.

Suppress the type checker’s report. The # type: ignore is there because ty finds the mistake earlier than the runtime does. ty reports positional-only-parameter-as-kwarg on partial(clamp, high=100), the line that builds the partial, where the runtime waits for the call.

# exercise_8.py
from collections.abc import Callable

def make_counter(step: int = 1) -> Callable[[], int]:
    count = 0
    def increment() -> int:
        nonlocal count
        count += step
        return count
    return increment

tally = make_counter(10)
print(tally(), tally(), tally())
#: 10 20 30

Declare the name you assign. increment() captures two names, and only one of them needs the nonlocal declaration. It reads step without assigning it, the way multiply() reads factor in multiplier(), and reading a captured name needs no declaration. increment() assigns count, and assignment is how Python decides a name is local. Without nonlocal, the count += step line creates a fresh local and reads it before any value exists.

Deleting the nonlocal line draws two complaints, in order. ty reports Name 'count' used when not defined on the count += step line before the program runs. Running the program raises an UnboundLocalError at the first tally() call: “cannot access local variable ‘count’ where it is not associated with a value.” The type checker points at the assignment that went wrong. The runtime message complains about an unintended local variable in increment().

# exercise_9.py
from collections.abc import Sequence
from functools import partial
from record import record

@record
class Reading:
    sensor: str
    celsius: float

def warmer_than(limit: float, r: Reading) -> bool:
    return r.celsius > limit

def colder_than(limit: float, r: Reading) -> bool:
    return r.celsius < limit

def to_fahrenheit(r: Reading) -> Reading:
    return Reading(r.sensor, r.celsius * 9 / 5 + 32)

def report(readings: Sequence[Reading]) -> list[str]:
    warm = filter(partial(warmer_than, 20.0), readings)
    band = filter(partial(colder_than, 30.0), warm)
    return [f"{r.sensor} {r.celsius:.1f}"
            for r in map(to_fahrenheit, band)]

def converted_first(
    readings: Sequence[Reading],
) -> list[str]:
    hot = map(to_fahrenheit, readings)
    warm = filter(partial(warmer_than, 20.0), hot)
    band = filter(partial(colder_than, 30.0), warm)
    return [f"{r.sensor} {r.celsius:.1f}" for r in band]

data = [Reading("a", 18.0), Reading("b", 25.0),
        Reading("c", 30.5)]
print(report(data))
#: ['b 77.0']
print(converted_first(data))
#: []
print([r.celsius for r in data])
#: [18.0, 25.0, 30.5]

Add the upper bound. colder_than() mirrors warmer_than(), and partial() turns each into the one-argument callable filter() requires.

Narrow to the band. Chaining the two filters keeps b, whose 25.0 Celsius sits inside the band: a is too cold and c is too warm. The two filters commute, because each one tests the same untouched Celsius value, so swapping the warm and band lines reports the same reading.

Reorder the stages. The empty list from converted_first() shows that the map() does not commute with the filters. Once to_fahrenheit() has run, every reading carries a Fahrenheit number, and 64.4, 77.0, and 86.9 all pass warmer_than(20.0) and all fail colder_than(30.0). The predicates still read r.celsius, so they now compare a Fahrenheit number against a Celsius limit and quietly answer the wrong question. Nothing raises an exception, because to_fahrenheit() and each predicate are correct on their own. The unit lives only in the field name. A stage that changes what a value means must run after every stage that reads the old meaning.

Show the input untouched. The last print() repeats the chapter’s point. report() and converted_first() both read data and neither writes it, so the Celsius values stay the same after three traversals, and you can run either function again and get the same answer.