Learn: Functional & Parallel Thinking on tristancode

Build Map and Filter

Mon, 01 Jan 0001 00:00:00 +0000

You hand-built transform (Lesson 9) and keep (Lesson 10) using recursion. In this lesson you formalise them as my_map and my_filter, and then try something harder: can filter be built from map?

Terms used here (standalone):

Map: apply a function f to every element of a list, producing a new list of the same length. map(f, [a, b, c]) → [f(a), f(b), f(c)].
Filter: keep only the elements for which a predicate pred returns True. filter(pred, [a, b, c]) → a sub-list of elements where pred holds.
Predicate: a function that takes a value and returns True or False.
Pure function: output depends only on inputs; no side effects.

Part 1 — `my_map`

Write my_map(f, xs) recursively. No built-in map, no list comprehensions.

Build the Fold

Mon, 01 Jan 0001 00:00:00 +0000

foldl (also called reduce or foldLeft) is the single most powerful list combinator. Every list operation you have written — sum, length, reverse, map, filter — can be re-expressed as a fold. This lesson builds it from scratch, and then puts it under stress.

Terms used here (standalone):

Fold (foldl): consumes a list by combining elements one-at-a-time with an accumulator. Takes three arguments: a combining function f, an initial accumulator value init, and a list xs. Processes from left to right:
```
foldl(f, init, [a, b, c]) = f(f(f(init, a), b), c)
```
Accumulator: a value carried forward through each step, updated by the combining function.
Combining function: f(acc, x) takes the current accumulator and the current element, returns the new accumulator.

Part 1 — Implement `foldl`

Write foldl(f, init, xs) recursively. Base case: empty list → return init. Recursive case: apply f to the accumulator and the head, recurse on the tail with the new accumulator.

Closures Capture Variables, Not Values

Mon, 01 Jan 0001 00:00:00 +0000

A closure is a function that captures variables from the scope where it was defined — not just their values at the moment of creation, but the variables themselves. When the function is called later, it reads the variable as it exists at call time, not at definition time.

Terms used here (standalone):

Scope: the region of code where a name is visible. In Python, a function body has its own local scope; the enclosing function’s variables are in the enclosing scope.
Closure: a function bundled with the environment (set of captured variables) from its defining scope. The function “closes over” those variables.
Late binding: the value of a captured variable is looked up when the function is called, not when it is defined.

Consider this code:

Count the List

Mon, 01 Jan 0001 00:00:00 +0000

Count how many elements are in a list — recursively, no len, no loop.

Recap so it stands alone. Recursion = a function that calls itself on a smaller piece, with a base case (smallest input, answered directly, stops the recursion) and a recursive case (call yourself on something smaller, then use the result). A list is a first element xs[0] followed by the rest xs[1:]; the empty list is written [].

Curry, Partial, Compose

Mon, 01 Jan 0001 00:00:00 +0000

Three tools. Each is a single concept; together they form the vocabulary of functional plumbing.

Terms used here (standalone):

Currying: converting a function that takes multiple arguments into a chain of functions that each take one argument. f(a, b) becomes curried_f(a)(b).
Partial application: fixing some of a function’s arguments in advance, returning a function that takes the remaining arguments. add(3, _) fixed at 3 becomes a “add 3 to anything” function.
Function composition: combining two functions into one. compose(f, g)(x) = f(g(x)) — g runs first, f runs second.
Closure (from Lesson 16): a function that captures variables from its defining scope.

Part 1 — Curry `add` by hand

The two-argument add below takes both arguments at once. Write a curried version add_c that takes one argument and returns a function that takes the second.

Find It, Then Transform It

Mon, 01 Jan 0001 00:00:00 +0000

Two exercises. Both use pure recursion — no built-in in, no map, no list comprehensions.

Recursion recap (standing alone): a function is recursive when it calls itself on a smaller version of its input. The base case handles the smallest possible input directly; the recursive case breaks the input down one step and uses the result of the smaller call. For lists, the base case is usually the empty list [], and the recursive case peels off the first element xs[0] and recurses on the rest xs[1:].

Find the Last Element

Mon, 01 Jan 0001 00:00:00 +0000

Get the last element of a list, recursively — no loops, no indexing tricks like xs[-1]. Just a function that calls itself.

Quick recap of the tool, so this stands alone. Recursion means solving a problem by calling a function on a smaller piece of itself. Every recursive function needs a base case (the smallest input, answered outright, which stops the recursion) and a recursive case (call yourself on something smaller, then use the result). We’ll treat a list as a first element xs[0] followed by the rest xs[1:].

Flatten the Nesting

Mon, 01 Jan 0001 00:00:00 +0000

Every recursion you’ve written so far has had this shape: peel the head, do something with it, then recurse only on the tail. This puzzle breaks that pattern.

Flatten a nested list: given a list that may contain elements or other lists (nested to any depth), produce a single flat list of all the leaf elements in order.

flatten([1, [2, 3], [4, [5, 6]], 7]) # [1, 2, 3, 4, 5, 6, 7]
flatten([[[[1]]]]) # [1]
flatten([]) # []
flatten([1, 2, 3]) # [1, 2, 3] (already flat — works too)

Recursion recap (standalone): a recursive function calls itself on a smaller input until it reaches a base case answered directly. A list is either empty [] or has a first element xs[0] and a rest xs[1:]. In Python, isinstance(x, list) is True when x is a list.

Functions Are Values

Mon, 01 Jan 0001 00:00:00 +0000

In most languages a function is just a value — you can assign it to a variable, put it in a list, pass it to another function, and return it from a function. These are called higher-order functions (HOFs): functions that operate on other functions.

Terms used here (standalone):

First-class function: a function that can be stored, passed, and returned like any other value.
Higher-order function: a function that takes a function as an argument or returns one.
compose(f, g)(x) returns f(g(x)) — g runs first, f runs second.

Read this code carefully and trace it by hand:

Keep, Drop, and Slice

Mon, 01 Jan 0001 00:00:00 +0000

Four functions. No loops, no filter, no slicing, no built-ins except comparison. All return new lists; the original is never mutated.

Recursion recap (standalone): a recursive function calls itself on a smaller input. For lists the base case is the empty list []; the recursive case peels off the first element xs[0] and recurses on the rest xs[1:]. A predicate is a function that takes a value and returns a boolean (True/False).

Push the Effects to the Edge

Mon, 01 Jan 0001 00:00:00 +0000

Side effects — printing, reading input, writing files, talking to a database — are unavoidable. Real programs must do them. The question isn’t whether to have them; it’s where to put them.

Recap of terms used here:

A pure function produces an output that depends only on its inputs and has no side effects. It can be called any number of times, in any order, without changing the world.
Referential transparency (Lesson 7): a pure call can always be replaced by its result.
Side effect: anything a function does besides returning a value — printing, mutating global state, making network requests, generating random numbers, reading the clock, etc.

The functional strategy is “effects at the edges”: write a pure core that does all the interesting computation, wrap it with a thin shell that handles I/O. The core stays fully testable, reusable, and safe to parallelize. The shell knows how to talk to the outside world.

Reduce Reconstructs Everything

Mon, 01 Jan 0001 00:00:00 +0000

This is the payoff for Stage 2. You will re-derive every list operation you’ve written — using only foldl as the engine.

foldl recap (standalone): consumes a list by updating an accumulator left-to-right.

def foldl(f, init, xs):
 if xs == []:
 return init
 return foldl(f, f(init, xs[0]), xs[1:])

foldl(f, init, [a, b, c]) expands to f(f(f(init, a), b), c). The combining function f takes (acc, element) and returns the new accumulator. The init is the starting accumulator.

Reverse a List — Twice

Mon, 01 Jan 0001 00:00:00 +0000

Reverse a list recursively: reverse([1, 2, 3]) should give [3, 2, 1]. No loops, no built-in reversed.

Standing on its own: recursion is a function that calls itself on a smaller piece, with a base case (smallest input, answered directly) and a recursive case (call yourself on something smaller, then combine). A list is a first element xs[0] followed by the rest xs[1:]. In Python pseudocode, a + b on two lists concatenates them into a new list: [1] + [2, 3] is [1, 2, 3].

Solution: Build Map and Filter

Mon, 01 Jan 0001 00:00:00 +0000

Part 1 — `my_map`

def my_map(f, xs):
 if xs == []:
 return []
 return [f(xs[0])] + my_map(f, xs[1:])

Identical to transform from Lesson 9 — you already built this. map is just the canonical name.

Part 2 — `my_filter`

def my_filter(pred, xs):
 if xs == []:
 return []
 elif pred(xs[0]):
 return [xs[0]] + my_filter(pred, xs[1:])
 else:
 return my_filter(pred, xs[1:])

Same as keep from Lesson 10.

Part 3 — Why filter cannot be written in terms of map alone

You cannot implement my_filter using only my_map. Here’s why:

Solution: Build the Fold

Mon, 01 Jan 0001 00:00:00 +0000

Part 1 — `foldl`

def foldl(f, init, xs):
 if xs == []:
 return init
 return foldl(f, f(init, xs[0]), xs[1:])

Each recursive call passes the updated accumulator f(init, xs[0]) as the new init. The recursive call is in tail position — this is already tail-recursive and runs in constant stack space in a TCO-capable runtime.

Part 2 — Trace

foldl(lambda acc, x: acc - x, 100, [10, 20, 5]):

foldl(sub, 100, [10, 20, 5])
 = foldl(sub, 100-10, [20, 5]) = foldl(sub, 90, [20, 5])
 = foldl(sub, 90-20, [5]) = foldl(sub, 70, [5])
 = foldl(sub, 70-5, []) = foldl(sub, 65, [])
 = 65

Equivalent to ((100 - 10) - 20) - 5 = 65. Left-associative — parentheses nest to the left.

Solution: Closures Capture Variables, Not Values

Mon, 01 Jan 0001 00:00:00 +0000

The answer is [12, 12, 12].

Why

After for i in range(3) the loop variable i holds 2 — the last value it was assigned. All three lambdas close over the same variable i (not a copy of its value at creation time). When you call them, they all read i = 2 and return 10 + 2 = 12.

fns = []
for i in range(3): # i = 0, then 1, then 2
 fns.append(lambda x: x + i) # captures the VARIABLE i, not its current value

# after the loop: i == 2

results = [f(10) for f in fns]
# each f(10) reads i at call time → i==2 → 10+2 = 12
# results = [12, 12, 12]

This surprises many developers who expect [10, 11, 12] — they imagine the lambda “froze” i’s value at creation time. It doesn’t. Closures in Python (and most languages) capture the binding — the variable itself — not a snapshot of its value.

Solution: Count the List

Mon, 01 Jan 0001 00:00:00 +0000

B is the correct recursive length:

def length(xs):
 return 0 if xs == [] else 1 + length(xs[1:])

Empty list → 0. Otherwise, count the first element as 1 and add the length of the rest. For ["a", "b", "c"]:

length(["a","b","c"]) = 1 + length(["b","c"])
 = 1 + (1 + length(["c"]))
 = 1 + (1 + (1 + length([])))
 = 1 + (1 + (1 + 0)) = 3

The bugs in the others:

Solution: Curry, Partial, Compose

Mon, 01 Jan 0001 00:00:00 +0000

Part 1 — Currying `add`

def add_c(x):
 def inner(y):
 return x + y
 return inner

# or, more compactly:
add_c = lambda x: lambda y: x + y

add_c(3)(4) # 7

add10 = add_c(10)
add10(5) # 15
add10(100) # 110

add_c(10) returns the inner closure with x=10 captured. Every subsequent call just adds 10. This is make_adder(10) from Lesson 13 — currying is the general pattern behind all those factories.

Part 2 — `functools.partial`

from functools import partial

square = partial(power, exponent=2) # or: partial(power, 2) for positional
cube = partial(power, exponent=3)
powers_of_2 = partial(power, 2)

square(5) # 25
cube(3) # 27
powers_of_2(8) # 256

Note: partial(power, 2) fixes the first positional argument (base=2). partial(power, exponent=2) uses a keyword argument to fix the second. Both work; keyword form is clearer for non-first args.

Solution: Find It, Then Transform It

Mon, 01 Jan 0001 00:00:00 +0000

Part 1 — `contains`

def contains(xs, target):
 if xs == []:
 return False
 elif xs[0] == target:
 return True
 else:
 return contains(xs[1:], target)

Three branches: empty list → definitely not there; head matches → found it; otherwise → the answer is the same as whether target is in the rest. Trace:

contains([3,7,1], 7)
 = contains([7,1], 7) # 3 ≠ 7
 = True # 7 == 7 ✓

Short-circuits as soon as it finds a match — it doesn’t scan the rest of the list.

Solution: Find the Last Element

Mon, 01 Jan 0001 00:00:00 +0000

def last(xs):
 if len(xs) == 1:
 return xs[0] # base case: the only element IS the last
 else:
 return last(xs[1:]) # recursive case: last of the rest

Base case: a one-element list [x] — its last element is xs[0], the element itself.

Recursive case: the last element of [3, 1, 2] is exactly the last element of [1, 2], which is the last element of [2]. Each step throws away the first element and asks the same question of a shorter list. Notice the difference from summing a list: there we combined xs[0] with the recursive result (xs[0] + total(xs[1:])); here we discard xs[0] and just pass the answer straight up (last(xs[1:])). The first element does no work — it’s only along for the ride until we reach the last one.

Solution: Flatten the Nesting

Mon, 01 Jan 0001 00:00:00 +0000

def flatten(xs):
 if xs == []:
 return []
 elif isinstance(xs[0], list):
 return flatten(xs[0]) + flatten(xs[1:])
 else:
 return [xs[0]] + flatten(xs[1:])

Trace flatten([1, [2, 3], 4]):

flatten([1, [2,3], 4])
 = [1] + flatten([[2,3], 4]) # head is 1 (leaf)
 = [1] + (flatten([2,3]) + flatten([4])) # head is [2,3] (list)
 = [1] + ([2,3] + [4]) # flatten([2,3]) = [2]+flatten([3])
 = [1, 2, 3, 4] # = [2]+[3]==[2,3]

Two recursive calls: flatten(xs[0]) drills into the head, flatten(xs[1:]) advances along the rest. That’s the new pattern — recursive on both dimensions at once.

Solution: Functions Are Values

Mon, 01 Jan 0001 00:00:00 +0000

The answer is 42.

Trace

add5 ≡ λx. x + 5
double ≡ λx. x * 2
triple ≡ λx. x * 3
steps = [add5, double, triple]

The loop composes step-by-step:

before loop: pipeline = add5 # x → x+5

iteration 1: step = double
 pipeline = compose(double, add5)
 # pipeline(x) = double(add5(x)) = 2*(x+5)

iteration 2: step = triple
 pipeline = compose(triple, compose(double, add5))
 # pipeline(x) = triple(double(add5(x))) = 3 * 2 * (x+5) = 6*(x+5)

So pipeline(2) = 6 * (2+5) = 6 * 7 = 42.

Solution: Keep, Drop, and Slice

Mon, 01 Jan 0001 00:00:00 +0000

Part 1 — `keep`

def keep(xs, pred):
 if xs == []:
 return []
 elif pred(xs[0]):
 return [xs[0]] + keep(xs[1:], pred)
 else:
 return keep(xs[1:], pred)

When the head passes the predicate, include it; otherwise discard it and recurse. Notice that keep(xs[1:], pred) appears in both branches — the only difference is whether xs[0] is prepended.

Part 2 — `take`

def take(n, xs):
 if n == 0 or xs == []:
 return []
 else:
 return [xs[0]] + take(n - 1, xs[1:])

Two base cases joined by or: we stop when we’ve taken enough or when the list runs out. Both matter — one guards the count, the other guards the list. Miss either and you get an infinite loop or an index error.

Solution: Push the Effects to the Edge

Mon, 01 Jan 0001 00:00:00 +0000

The split

def compute(n):
 total = 0
 for i in range(1, n + 1):
 if i % 2 == 0:
 total += i * i
 else:
 total -= i
 return total

def run():
 n = int(input("Enter a positive integer: "))
 result = compute(n)
 print(f"Result for {n}: {result}")

compute(4) → 2² + 4² − 1 − 3 = 4 + 16 − 1 − 3 = 16.

compute is pure: same input, same output, always, no matter how many times you call it. run is the only place that touches I/O.

Solution: Reduce Reconstructs Everything

Mon, 01 Jan 0001 00:00:00 +0000

Part 1 — `my_sum` and `my_product`

my_sum = lambda xs: foldl(lambda acc, x: acc + x, 0, xs)
my_product = lambda xs: foldl(lambda acc, x: acc * x, 1, xs)

init=0 for sum: adding nothing to an empty list gives 0 (the additive identity). init=1 for product: the multiplicative identity — multiplying nothing gives 1. Use 0 and my_product([]) = 0 instead of 1, which would be wrong.

Part 2 — `my_map_via_fold`

def my_map_via_fold(f, xs):
 return foldl(lambda acc, x: acc + [f(x)], [], xs)

init=[] (empty output). At each step, apply f to the element and append it to the right of the accumulator. The list grows in order — first to last — because foldl processes left-to-right and we append to the right.

Solution: Reverse a List — Twice

Mon, 01 Jan 0001 00:00:00 +0000

Part 1 — the obvious version

def reverse(xs):
 if xs == []:
 return [] # reverse of nothing is nothing
 else:
 return reverse(xs[1:]) + [xs[0]]

The idea: reverse the rest of the list, then stick the first element on the end — because in the reversed result, the original first element must come last. Trace it:

reverse([1,2,3]) = reverse([2,3]) + [1]
 = (reverse([3]) + [2]) + [1]
 = ((reverse([]) + [3]) + [2]) + [1]
 = (([] + [3]) + [2]) + [1]
 = [3,2,1]

Correct — and pure: a new list out, the original untouched.

Solution: Spot the Pure Function

Mon, 01 Jan 0001 00:00:00 +0000

The pure one is A, add_tax.

Run it with add_tax(100) and you get 108.0 — today, tomorrow, on any machine, no matter what else the program is doing. It reads its input (price), reads a constant (TAX), and returns a value. It touches nothing else and changes nothing else. That’s purity.

Here’s why each of the others fails:

B — add_to_cart has a side effect. cart.append(item) mutates a list that lives outside the function. Call it twice with the same item and the world is different each time — the cart keeps growing. The return value also depends on history, not just the argument.
C — now_plus depends on more than its inputs. time.time() returns the current clock, so now_plus(10) gives a different answer every time you call it. Same input, different output → impure.
D — greet has a side effect and returns nothing. print pushes text to the screen (the outside world). Its “result” is the act of printing, not a returned value.

Why this is the foundation

Pure functions buy you three things that this whole path keeps cashing in:

Solution: Sum a List Without a Loop

Mon, 01 Jan 0001 00:00:00 +0000

Here’s the function:

def total(xs):
 if xs == []:
 return 0 # base case
 else:
 return xs[0] + total(xs[1:]) # recursive case

The empty list sums to 0. That’s the right base case for two reasons: it’s the true answer (an empty list has nothing to add), and 0 is the value that doesn’t disturb a sum — adding it changes nothing. Every recursion needs a base case like this, or it would call itself forever.

Solution: Tail Calls and the Accumulator Pattern

Mon, 01 Jan 0001 00:00:00 +0000

Part 1 — Answers

A — sum_list: NOT a tail call.

return xs[0] + sum_list(xs[1:])

After sum_list(xs[1:]) returns, you still have to add xs[0] to it. The + is pending work. The call is wrapped inside another operation — not in tail position.

B — sum_tail: IS a tail call.

return sum_tail(xs[1:], acc + xs[0])

The result of the recursive call is returned directly — no further operation. acc + xs[0] is computed before the call, as the new argument. After the call completes, the caller just hands back what it received. That’s tail position.

Solution: The List That Wouldn't Change

Mon, 01 Jan 0001 00:00:00 +0000

The answer is B: return xs + [4].

xs + [4] evaluates to a new list. The original xs is read but never touched, so the caller’s scores stays [10, 20, 30] and result becomes [10, 20, 30, 4]. Two separate values, exactly as the caller expected.

The other three all mutate the original in place:

A — xs.append(4) tacks 4 onto the very list the caller passed in. scores becomes [10, 20, 30, 4] too. Surprise side effect.
D — xs += [4] looks like “make a new list,” but for a Python list += is in-place extension — the same object the caller holds is modified.
C — xs[len(xs):] = [4] is slice assignment, another in-place edit of the original.

The trap in B-vs-D is worth remembering: xs = xs + [4] rebinds a name to a new list, but xs += [4] mutates the existing one. They look almost identical and behave oppositely.

Solution: The Substitution Game

Mon, 01 Jan 0001 00:00:00 +0000

D is the only referentially transparent option.

def f(x): return x * 2

f(5) is always 10, period. You can swap every f(5) in your code for 10 and the program behaves identically. Nothing else changes — no side channel is disturbed, no hidden state updates, no output appears on the terminal.

Why A, B, and C break the substitution

Option A — hidden output:

def f(x):
 print(x)
 return x * 2

The return value is 10, but printing 5 to the terminal is a side effect. A program with two calls to f(5) prints 5 twice. Replace those calls with 10 and nothing is printed at all. The two programs are observable differently — the substitution changed behaviour.

Spot the Pure Function

Mon, 01 Jan 0001 00:00:00 +0000

Almost everything in this path rests on one idea, so we start there: the pure function.

A function is pure when both of these hold:

Its output depends only on its inputs. Same arguments in → same answer out, every single time.
It has no side effects. It doesn’t change anything outside itself — no writing to a global, a file, a database, or the screen; and it doesn’t modify the arguments it was handed. It just takes values and returns a value.

A function that breaks either rule is called impure.

Sum a List Without a Loop

Mon, 01 Jan 0001 00:00:00 +0000

Here’s a challenge with a rule: add up all the numbers in a list, but you may not use a loop (no for, no while) and no built-in sum. Your only tool is the function calling itself. That tool is recursion.

A recursive function is one that solves a problem by calling itself on a smaller piece of the same problem. Every recursive function needs two parts:

A base case — the smallest input, simple enough to answer outright with no further calls. It’s what stops the recursion.
A recursive case — solve a smaller version of the problem by calling yourself, then combine that result with the current piece.

Think about a list as a first element followed by the rest of the list. For example [3, 1, 2] is 3 followed by [1, 2]. We’ll write the answer in Python-flavored pseudocode, where xs[0] is the first element and xs[1:] is “everything after the first”:

Tail Calls and the Accumulator Pattern

Mon, 01 Jan 0001 00:00:00 +0000

You’ve used accumulators in Lessons 5 and 6 to make counting and reversing O(n). This lesson makes the underlying principle explicit.

Terms used here (standalone):

Tail call: a call where the return value of the recursive call is immediately returned — nothing is left to do with the result once it comes back. Formally, the call is in tail position.
Non-tail call: a call where there’s still work to do with the result before returning (like adding 1 + to it, or prepending [x] +).
Tail-recursive function: one whose recursive calls are all tail calls.
TCO (tail-call optimisation): an optimisation some runtimes perform — if a call is in tail position, reuse the current stack frame instead of pushing a new one. The recursion becomes as cheap as a loop, with constant stack depth.

Part 1 — Spot the tail call (or lack thereof)

Label each recursive call as tail or not-tail:

The List That Wouldn't Change

Mon, 01 Jan 0001 00:00:00 +0000

A value is immutable when it can’t be changed after it’s created. Instead of modifying it, you build a new value from it and leave the original alone. (The opposite — changing a value in place — is called mutation.)

This pairs naturally with last lesson’s idea of a pure function: a function whose output depends only on its inputs and which changes nothing outside itself. A function can’t very well “change nothing” if it mutates the list you handed it.

The Substitution Game

Mon, 01 Jan 0001 00:00:00 +0000

In algebra, you can replace an expression with its value without changing anything. If y = 3 + 4, you can substitute 7 for 3 + 4 anywhere it appears, and the math stays the same. Functions in most programming languages look like algebra — but they aren’t always.

Referential transparency is the property that makes the substitution safe. A function call is referentially transparent if you can always replace it with its return value and the surrounding program behaves identically.

Learn: Functional & Parallel Thinking on tristancode

Build Map and Filter

Part 1 — my_map

Build the Fold

Part 1 — Implement foldl

Closures Capture Variables, Not Values

Count the List

Curry, Partial, Compose

Part 1 — Curry add by hand

Find It, Then Transform It

Find the Last Element

Flatten the Nesting

Functions Are Values

Keep, Drop, and Slice

Push the Effects to the Edge

Reduce Reconstructs Everything

Reverse a List — Twice

Solution: Build Map and Filter

Part 1 — my_map

Part 2 — my_filter

Part 3 — Why filter cannot be written in terms of map alone

Solution: Build the Fold

Part 1 — foldl

Part 2 — Trace

Solution: Closures Capture Variables, Not Values

Why

Solution: Count the List

Solution: Curry, Partial, Compose

Part 1 — Currying add

Part 2 — functools.partial

Solution: Find It, Then Transform It

Part 1 — contains

Solution: Find the Last Element

Solution: Flatten the Nesting

Solution: Functions Are Values

Trace

Solution: Keep, Drop, and Slice

Part 1 — keep

Part 2 — take

Solution: Push the Effects to the Edge

The split

Solution: Reduce Reconstructs Everything

Part 1 — my_sum and my_product

Part 2 — my_map_via_fold

Solution: Reverse a List — Twice

Part 1 — the obvious version

Solution: Spot the Pure Function

Why this is the foundation

Solution: Sum a List Without a Loop

Solution: Tail Calls and the Accumulator Pattern

Part 1 — Answers

Solution: The List That Wouldn't Change

Solution: The Substitution Game

Why A, B, and C break the substitution

Spot the Pure Function

Sum a List Without a Loop

Tail Calls and the Accumulator Pattern

Part 1 — Spot the tail call (or lack thereof)

The List That Wouldn't Change

The Substitution Game

Part 1 — `my_map`

Part 1 — Implement `foldl`

Part 1 — Curry `add` by hand

Part 1 — `my_map`

Part 2 — `my_filter`

Part 1 — `foldl`

Part 1 — Currying `add`

Part 2 — `functools.partial`

Part 1 — `contains`

Part 1 — `keep`

Part 2 — `take`

Part 1 — `my_sum` and `my_product`

Part 2 — `my_map_via_fold`