Python Lambda & Functional Programming Exercises with Solutions

square = lambda x: x ** 2

print(square(4))   # 16
print(square(9))   # 81Code language: Python (python)

Explanation:

• lambda x: x ** 2: Creates an anonymous function that takes one parameter x and returns x ** 2. The entire expression to the right of the colon is the implicit return value.
• Assigning to a variable: Storing a lambda in a named variable like square makes it callable exactly like a regular def function. The result is functionally identical to def square(x): return x ** 2.
• When to use lambda vs. def: The Python style guide (PEP 8) recommends against assigning lambdas to variables at module level – use def for named functions. Lambdas shine as inline, one-off callables passed directly to another function, as the following exercises demonstrate.
• Limitations: A lambda body must be a single expression. It cannot contain statements, assignments, loops, or multiple lines. For anything more complex, a regular def function is the right tool.

people = [("Alice", 30), ("Bob", 25), ("Charlie", 35), ("Diana", 28)]

ascending  = sorted(people, key=lambda person: person[1])
descending = sorted(people, key=lambda person: person[1], reverse=True)

print("Ascending: ", ascending)
print("Descending:", descending)Code language: Python (python)

Explanation:

• key=lambda person: person[1]: The key parameter accepts any callable. Python calls it once per element and uses the returned value for comparison. Here, person[1] extracts the age from each tuple, so the list is sorted by age rather than by the default tuple comparison (which would sort by name first).
• sorted() vs. .sort(): sorted() returns a new list and leaves the original unchanged. list.sort() sorts in place and returns None. Both accept the same key and reverse parameters.
• reverse=True: Reverses the sort direction without requiring a separate lambda. It is more efficient than sorting ascending and then reversing the list afterwards.
• Alternative – operator.itemgetter: from operator import itemgetter followed by key=itemgetter(1) is slightly faster than a lambda for simple index extraction because it avoids Python function call overhead. For most use cases the difference is negligible, and the lambda is more readable.

celsius = [0, 20, 37, 100]

fahrenheit = list(map(lambda c: (c * 9 / 5) + 32, celsius))

print(fahrenheit)   # [32.0, 68.0, 98.6, 212.0]Code language: Python (python)

Explanation:

• map(function, iterable): Applies function to each element of iterable lazily. The function is not called until the iterator is consumed – either by list(), a for loop, or another consuming operation.
• list(map(...)): Forces evaluation of the lazy iterator and collects all results into a list. Without wrapping in list(), printing the result would show something like <map object at 0x...> rather than the values.
• Lambda as the transform: The lambda lambda c: (c * 9 / 5) + 32 encodes the conversion formula in a single expression. Because it has no name and is used in exactly one place, a lambda is more appropriate here than a separate def.
• List comprehension equivalent: [(c * 9 / 5) + 32 for c in celsius] produces exactly the same result. Many Python developers prefer list comprehensions for their readability, but map() is more composable when chaining multiple transformations or working with very large datasets where lazy evaluation matters.

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

evens = list(filter(lambda n: n % 2 == 0, numbers))

print(evens)   # [2, 4, 6, 8, 10]Code language: Python (python)

Explanation:

• filter(function, iterable): Calls function on each element and yields only those for which it returns a truthy value. Passing None as the function is also valid – it then keeps all elements that are truthy themselves.
• n % 2 == 0: The modulo operator % returns the remainder after division. A remainder of 0 when dividing by 2 means the number is even. The expression evaluates directly to True or False, which is exactly what a predicate needs to return.
• Lazy evaluation: Like map(), filter() does not process any elements until iterated. This makes it memory-efficient for large datasets – wrapping in list() forces full evaluation only when you actually need all results at once.
• List comprehension equivalent: [n for n in numbers if n % 2 == 0] is the idiomatic Python alternative. As with map(), prefer filter() when composing multiple functional operations in a pipeline, and list comprehensions for simple one-off filtering where readability is the priority.

from functools import reduce

numbers = [1, 2, 3, 4, 5]

product = reduce(lambda acc, n: acc * n, numbers)

print(product)   # 120Code language: Python (python)

Explanation:

• reduce(function, iterable): Applies function cumulatively. It starts by calling function(iterable[0], iterable[1]), then calls function(result, iterable[2]), and so on until the iterable is exhausted. The final return value is a single scalar.
• lambda acc, n: acc * n: The two-argument lambda represents the binary operation being folded across the list. On the first call acc = 1 and n = 2, returning 2. On the second, acc = 2 and n = 3, returning 6. This continues until the product of all five numbers – 120 – is produced.
• Optional initial value: reduce() accepts an optional third argument as the starting accumulator: reduce(lambda acc, n: acc * n, numbers, 1). This is useful when the list might be empty – without an initial value, reduce() raises TypeError on an empty iterable.
• Why not math.prod()?: Python 3.8 added math.prod(numbers) as a built-in for exactly this case. Use it in production. The reduce() approach is taught here because it generalises to any binary operation and demonstrates the fold pattern that underpins many functional programming concepts.

parity = lambda n: "even" if n % 2 == 0 else "odd"

print(parity(4))   # even
print(parity(7))   # odd
print(parity(0))   # evenCode language: Python (python)

Explanation:

• "even" if n % 2 == 0 else "odd": This is Python’s ternary (conditional) expression. It evaluates to the value before if when the condition is true, and the value after else when it is false. Because it is a single expression, it fits naturally inside a lambda body.
• parity(0) returns "even": Zero is divisible by 2 with no remainder (0 % 2 == 0), so it correctly classifies as even. This is consistent with the mathematical definition of even numbers.
• Composing with map(): Because parity is a callable, it can be passed directly to map(): list(map(parity, [1, 2, 3, 4])) produces ['odd', 'even', 'odd', 'even']. This illustrates how named lambdas become reusable building blocks for functional pipelines.
• Readability note: Nested ternary expressions inside a lambda (e.g., deciding between three outcomes) quickly become hard to read. If the logic requires more than one condition, use a def function with explicit if/elif/else branches instead.

ops = {
    "add": lambda a, b: a + b,
    "sub": lambda a, b: a - b,
    "mul": lambda a, b: a * b,
    "div": lambda a, b: a / b,
}

a, b = 10, 3

for name, func in ops.items():
    print(f"{name}: {func(a, b)}")Code language: Python (python)

Explanation:

• Lambdas as dictionary values: In Python, functions are first-class objects – they can be stored in variables, lists, and dictionaries just like integers or strings. Each lambda here is a value associated with a string key, retrievable and callable at any time.
• ops["add"](10, 3): The lookup ops["add"] returns the lambda object itself. Appending (10, 3) immediately calls it with those arguments. This is identical to calling a function stored in any other variable.
• Dispatch table pattern: Iterating over ops.items() applies every operation in one loop without any if/elif branching. Adding a new operation requires only a new dictionary entry – no changes to the loop or calling code. This open-closed design makes dispatch tables easy to extend.
• Extending the calculator: You can add operations like "mod": lambda a, b: a % b or "pow": lambda a, b: a ** b without modifying any existing code. For a user-facing calculator, you would look up the key from user input: op = input("Operation: "); result = ops[op](a, b) – adding a KeyError check for unknown operations.

numbers = [-3, -1, 0, 2, 4, -2, 5, 7]

result = list(
    map(lambda n: n ** 2,
        filter(lambda n: n >= 0, numbers))
)

print(result)   # [0, 4, 16, 25, 49]Code language: Python (python)

Explanation:

• Evaluation order: Python evaluates arguments from the inside out. filter() runs first and produces a lazy iterator of non-negative values. That iterator is passed directly to map(), which wraps it in another lazy iterator that squares each value. list() at the outermost level triggers full evaluation.
• Zero is kept: The predicate n >= 0 includes zero, so 0 passes the filter and 0 ** 2 = 0 appears in the output. If you want to exclude zero as well, change the condition to n > 0.
• Single-pass efficiency: Because both filter() and map() are lazy, each element is processed only once as list() pulls values through the chain. There is no intermediate list allocated between the two steps, which matters for large datasets.
• List comprehension equivalent: [n ** 2 for n in numbers if n >= 0] is the idiomatic Python alternative and is often preferred for its readability. The map()/filter() chain is worth knowing because it mirrors the functional style used in languages like Haskell and Scala, and it composes cleanly when you need more than two stages.

employees = [
    {"name": "Alice",   "salary": 70000},
    {"name": "Bob",     "salary": 90000},
    {"name": "Charlie", "salary": 70000},
    {"name": "Diana",   "salary": 90000},
]
sorted_employees = sorted(
    employees,
    key=lambda e: (-e["salary"], e["name"])
)
for emp in sorted_employees:
    print(f"{emp['name']:<10} ${emp['salary']}")Code language: Python (python)

Explanation:

• Tuple key: When the key function returns a tuple, Python compares tuples lexicographically: it compares the first element, and only moves to the second if the first elements are equal. Returning (-salary, name) means salary is the primary sort criterion and name is the tiebreaker.
• Negating for descending order: Negating a numeric key (-e["salary"]) inverts the sort direction for that field only. A higher salary becomes a more negative number, so it sorts to the front. This technique works for any numeric field and avoids the complication of reverse=True, which would flip all sort levels simultaneously.
• Stability of Python’s sort: Python’s sorted() is a stable sort (Timsort). Elements that compare equal under the key function retain their original relative order. The tuple key makes equal-salary ties explicit, but stability would preserve insertion order even without the name component.
• Negation limitation: The negation trick only works for numeric fields. To sort a string field descending, you would need a different approach – such as using functools.cmp_to_key with a custom comparator, or sorting twice (Python’s stable sort guarantees correctness when you do a secondary sort first and a primary sort second).

from functools import partial

def multiply(x, n):
    return x * n

double = partial(multiply, n=2)
triple = partial(multiply, n=3)

print(f"double(5) = {double(5)}")   # 10
print(f"double(9) = {double(9)}")   # 18
print(f"triple(4) = {triple(4)}")   # 12
print(f"triple(7) = {triple(7)}")   # 21Code language: Python (python)

Explanation:

• partial(func, *args, **kwargs): Returns a new callable that behaves like func called with the given arguments pre-filled. Any additional arguments passed when calling the partial are appended to (or merged with) the pre-filled ones.
• Keyword vs. positional pre-filling: Using partial(multiply, n=2) pre-fills n by name, leaving x to be provided at call time. You could also use positional pre-filling: partial(multiply, 5) would lock x=5 and leave n free — the direction depends on argument order and which parameter you want to specialise.
• Practical use cases: partial() shines when passing callbacks to APIs that expect a fixed signature. For example, map(partial(multiply, n=10), numbers) scales every number in a list by 10 without needing a dedicated lambda or def.
• Inspecting a partial: The resulting object exposes double.func (the original function), double.args (pre-filled positional arguments), and double.keywords (pre-filled keyword arguments), making it straightforward to introspect or log what a partial was built from.

def compose(f, g):
    return lambda x: f(g(x))

double    = lambda x: x * 2
add_three = lambda x: x + 3

double_after_add = compose(double, add_three)

print(f"double(add_three(5)) = {double_after_add(5)}")   # 16

# Reverse order for comparison
add_after_double = compose(add_three, double)
print(f"add_three(double(5)) = {add_after_double(5)}")   # 13Code language: Python (python)

Explanation:

• return lambda x: f(g(x)): The inner lambda closes over f and g from the enclosing compose call. Each time the returned function is called with a value x, it evaluates g(x) first, then passes that result to f.
• Order matters: compose(double, add_three)(5) computes double(add_three(5)): add 3 to get 8, then double to get 16. Reversing to compose(add_three, double)(5) gives add_three(double(5)): double to get 10, then add 3 to get 13. Composition is not commutative.
• Extending to multiple functions: A variadic composer can chain any number of functions using reduce(): from functools import reduce; def compose_many(*fns): return reduce(compose, fns). This applies the rightmost function first and works its way left, matching standard mathematical notation.
• Real-world relevance: Function composition appears in data transformation pipelines, middleware stacks, and decorator chains. Python’s own decorator syntax (@decorator) is essentially syntactic sugar for a specific kind of function composition where the outer function wraps the inner one.

from functools import reduce

nested = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]

flat = reduce(lambda acc, sublist: acc + sublist, nested, [])

print(flat)   # [1, 2, 3, 4, 5, 6, 7, 8, 9]Code language: Python (python)

Explanation:

• lambda acc, sublist: acc + sublist: On each step, acc holds the flattened list built so far and sublist is the next inner list. The + operator creates a new concatenated list, which becomes the next acc. After all three sublists are processed, acc holds the fully flattened result.
• Initial value []: Providing an empty list as the third argument guarantees the accumulator starts as a list even if nested is empty. Without it, reduce() would raise TypeError on an empty input because there is no first element to use as the starting value.
• Performance note: Each acc + sublist creates a brand-new list, copying all elements accumulated so far. For a large number of sublists this results in O(n²) copies. A more efficient approach is reduce(lambda acc, s: acc.__iadd__(s) or acc, nested, []) using in-place extension, or simply list(itertools.chain.from_iterable(nested)) in production code.
• Accumulator type flexibility: This exercise illustrates that reduce() is not limited to numbers. The accumulator can be a list, dictionary, string, or any other type — whatever your binary function returns. This makes reduce() a general-purpose fold over any data structure.

words = ["banana", "apple", "cherry", "date", "fig", "kiwi"]

sorted_words = sorted(words, key=lambda s: s[-1])

print(sorted_words)
# ['banana', 'apple', 'date', 'fig', 'cherry', 'kiwi']Code language: Python (python)

Explanation:

• lambda s: s[-1]: Extracts the last character of each string. The last characters of the input words are: a (banana), e (apple), y (cherry), e (date), g (fig), i (kiwi). Sorting these alphabetically gives a, e, e, g, i, y, which maps back to the output order.
• Stable sort handles ties: Both "apple" and "date" end with "e". Because Python’s Timsort is stable, their relative order from the original list is preserved: "apple" came before "date", so it stays before it in the output.
• Key function called once per element: Python computes the key for each element exactly once before comparing. This means even an expensive key function is not repeatedly called during comparisons — making it safe to use key with slow operations like database lookups or regex matches.
• Beyond last character: The same pattern generalises to any positional extraction: sort by second character with s[1], by last two characters with s[-2:], or by file extension with s.rsplit(".", 1)[-1]. The lambda is just a projection function — it can express any transformation that produces a comparable value.

import time
from functools import lru_cache
@lru_cache(maxsize=None)
def fib_cached(n):
    if n < 2:
        return n
    return fib_cached(n - 1) + fib_cached(n - 2)
def fib_uncached(n):
    if n < 2:
        return n
    return fib_uncached(n - 1) + fib_uncached(n - 2)
n = 35
start = time.perf_counter()
result = fib_cached(n)
elapsed = time.perf_counter() - start
print(f"Cached   fib({n}) = {result}  in {elapsed:.6f}s")
start = time.perf_counter()
result = fib_uncached(n)
elapsed = time.perf_counter() - start
print(f"Uncached fib({n}) = {result}  in {elapsed:.6f}s")Code language: Python (python)

Explanation:

• @lru_cache(maxsize=None): Wraps the function with a Least Recently Used cache. On each call, Python checks whether the arguments are already in the cache. If they are, the stored result is returned immediately without executing the function body. maxsize=None disables the eviction policy so every computed value is kept indefinitely — appropriate for a pure function like Fibonacci where results never change.
• Why the uncached version is slow: Computing fib_uncached(35) calls fib_uncached(34) and fib_uncached(33). Each of those branches calls two more, and so on, producing a call tree with roughly 2³⁵ (about 34 billion) nodes — though many are duplicates. The cached version computes each of the 36 unique inputs (fib(0) through fib(35)) exactly once.
• time.perf_counter(): Returns a high-resolution timer value in seconds. Taking the difference before and after a function call gives wall-clock elapsed time. It is more precise than time.time() for short durations and is the recommended choice for benchmarking.
• Python 3.9 shorthand: From Python 3.9 onwards you can use @lru_cache without parentheses (equivalent to maxsize=128) or @functools.cache (equivalent to maxsize=None). The explicit lru_cache(maxsize=None) form used here works on all Python 3 versions and makes the unlimited-cache intent clear.

def curry(func):
    """Curry a two-argument function into f(a)(b)."""
    return lambda a: lambda b: func(a, b)

def add(a, b):
    return a + b

curried_add = curry(add)
print(f"curry(add)(2)(3)  = {curried_add(2)(3)}")    # 5
print(f"curry(add)(10)(7) = {curried_add(10)(7)}")   # 17

# Manually curried three-argument function
def volume(l, w, h):
    return l * w * h

curried_volume = lambda l: lambda w: lambda h: volume(l, w, h)

print(f"volume(2)(3)(4)         = {curried_volume(2)(3)(4)}")    # 24

box_with_height_4 = curried_volume(2)   # l is fixed at 2... wait, fix height
make_box = lambda h: lambda l: lambda w: volume(l, w, h)
box_with_height_4 = make_box(4)
print(f"box_with_height_4(2)(3) = {box_with_height_4(2)(3)}")   # 24Code language: Python (python)

Explanation:

• lambda a: lambda b: func(a, b): The outer lambda captures func via closure and returns a new function waiting for a. When called with a, it returns another lambda waiting for b. Only when b is supplied does the original function execute. Each step in the chain is a closure that carries the arguments collected so far.
• Partial application via currying: add5 = curried_add(5) produces a reusable function that adds 5 to any number. This is the same result as functools.partial(add, 5) but achieved through the currying structure itself, without any library support.
• Argument order matters: In the make_box(4) example, the height is fixed first so the returned function accepts length and width in sequence. Designing curried functions with the most-stable argument first and the most-varying argument last is a functional programming convention that maximises reuse.
• General-arity currying: The curry() here handles exactly two arguments. A fully general solution inspects func.__code__.co_argcount or uses inspect.signature() to determine how many arguments to collect before calling the original function. Libraries such as toolz provide this as toolz.curry.

from functools import reduce

def pipeline(*funcs):
    return lambda x: reduce(lambda value, f: f(value), funcs, x)

# Build a text-processing pipeline
process = pipeline(
    str.strip,
    str.title,
    lambda s: s.replace(",", ""),
    lambda s: s.rstrip("!") + "!",
)

result = process("  hello, world!  ")
print(result)   # Hello World!Code language: Python (python)

Explanation:

• reduce(lambda value, f: f(value), funcs, x): The accumulator starts as x. On each step, the current function f is called with the running value and the result becomes the new value. After all functions have been applied, the final value is returned. This is a left fold where the data flows left to right through the function list.
• Functions as first-class values: str.strip and str.title are passed as unbound method references without calling them. Each one is a callable that takes a string and returns a string, satisfying the single-argument contract the pipeline requires.
• Pipeline vs. compose: pipeline(f, g, h) applies f first, then g, then h — left to right. The compose(f, g) from Exercise 11 applies right to left (g first, then f), matching mathematical function composition notation. Both are useful; the choice depends on which reading direction feels more natural for the use case.
• Reusability: The pipeline object process can be called as many times as needed on different input strings. Steps can be added, removed, or reordered simply by editing the argument list to pipeline(), making the transformation logic easy to adjust without touching calling code.

from functools import reduce

# Base reducer: appends a value to the accumulator list
append = lambda acc, x: acc + [x]

# Transducer factories
def mapping(transform):
    return lambda reducer: lambda acc, x: reducer(acc, transform(x))

def filtering(predicate):
    return lambda reducer: lambda acc, x: reducer(acc, x) if predicate(x) else acc

# Compose: filter evens, then square
xf = filtering(lambda n: n % 2 == 0)(
         mapping(lambda n: n ** 2)(append)
     )

numbers = list(range(1, 11))
result = reduce(xf, numbers, [])

print(result)   # [4, 16, 36, 64, 100]Code language: Python (python)

Explanation:

• What a transducer is: A transducer is a higher-order function with the signature reducer -> reducer. It transforms a reducing function into a new one that applies an extra step (a map or filter operation) before delegating to the inner reducer. Composing two transducers stacks those steps without ever materialising an intermediate collection.
• Composition order: filtering(...)(mapping(...)(append)) reads inside-out. The innermost call wraps append with the squaring step, producing a reducer that squares and then appends. The outer call wraps that with the even-check step: only even numbers reach the squaring reducer. The overall data flow is: filter first, square second, append third.
• Single-pass guarantee: reduce(xf, numbers, []) iterates over numbers exactly once. For each element, xf decides whether to include it and how to transform it in a single function call chain. No intermediate list is created between the filtering and mapping steps.
• When this matters: For small lists the performance difference is negligible. For pipelines processing millions of records or infinite streams, eliminating intermediate allocations can reduce memory usage dramatically. The transducer pattern also makes the transformation stack inspectable and reusable across different collection types.

import itertools

def naturals():
    n = 1
    while True:
        yield n
        n += 1

# Lazy pipeline using generator expressions
evens   = (n      for n in naturals() if n % 2 == 0)
squared = (n ** 2 for n in evens)

result = list(itertools.islice(squared, 5))
print(result)   # [4, 16, 36, 64, 100]Code language: Python (python)

Explanation:

• Infinite generator: naturals() uses while True combined with yield to produce an unbounded stream. Control returns to the caller after each yield and resumes at the next line when next() is called again. The generator itself never finishes — it relies on the consumer to stop pulling values.
• Layered generator expressions: Each generator expression wraps the previous one without consuming it. Writing (n ** 2 for n in evens) creates a new generator object that, when iterated, pulls from evens, which pulls from naturals(). The entire chain is wired up but idle until a value is requested.
• itertools.islice(iterable, n): Takes at most n items from any iterable and then stops. It is the standard tool for safely consuming a finite prefix of an infinite stream. Without it, calling list(squared) would loop forever.
• Memory usage: At any point in time, only one value exists in memory as it flows through the pipeline. Contrast this with a list-based approach where filter() and map() over a large pre-built list would require storing all intermediate values. Generator pipelines scale to arbitrarily large or infinite data sources with O(1) memory overhead.

def my_map(func, lst):
    if not lst:
        return []
    return [func(lst[0])] + my_map(func, lst[1:])

def my_filter(pred, lst):
    if not lst:
        return []
    head = lst[0]
    rest = my_filter(pred, lst[1:])
    return [head] + rest if pred(head) else rest

def my_reduce(func, lst, initial):
    if not lst:
        return initial
    return my_reduce(func, lst[1:], func(initial, lst[0]))

# Test callables
square   = lambda x: x ** 2
is_even  = lambda x: x % 2 == 0
multiply = lambda acc, x: acc * x

numbers = [1, 2, 3, 4, 5]

print(f"my_map    (square, numbers)      = {my_map(square, numbers)}")
print(f"my_filter (is_even, numbers)     = {my_filter(is_even, numbers)}")
print(f"my_reduce (multiply, numbers, 1) = {my_reduce(multiply, numbers, 1)}")Code language: Python (python)

Explanation:

• Recursive structure: Each function follows the same two-branch pattern. The base case (if not lst: return [] or return initial) terminates the recursion when the list is exhausted. The recursive case processes the head element and delegates the rest of the work to the same function called on the tail, one element shorter each time.
• my_map – transform and prepend: [func(lst[0])] + my_map(func, lst[1:]) applies func to the first element, wraps the result in a single-element list, and concatenates it with the recursively mapped tail. The final result is assembled as the call stack unwinds.
• my_filter – conditional inclusion: The ternary expression [head] + rest if pred(head) else rest includes the head only when the predicate is true. Either way, the recursion continues on the tail so all elements are visited.
• my_reduce – tail-recursive accumulation: The accumulator is updated at each call rather than on the way back up, making this tail-recursive in structure. Python does not optimise tail calls, so a list of more than a few thousand elements would hit the default recursion limit. In production, use the built-in functools.reduce() which uses an iterative implementation internally.

import math

class Maybe:
    def __init__(self, value):
        self.value = value

    def bind(self, func):
        if self.value is None:
            return Maybe(None)
        return Maybe(func(self.value))

    def __repr__(self):
        return f"Maybe({self.value})"

# Transformation lambdas
double    = lambda x: x * 2
add_three = lambda x: x + 3
safe_sqrt = lambda x: math.sqrt(x) if x >= 0 else None

# Chain starting from a real value
result_a = (Maybe(10)
            .bind(double)
            .bind(add_three)
            .bind(safe_sqrt))
print(result_a)   # Maybe(4.69...)

# Chain starting from None - all steps are skipped
result_b = (Maybe(None)
            .bind(double)
            .bind(add_three)
            .bind(safe_sqrt))
print(result_b)   # Maybe(None)

# Mid-chain short-circuit: safe_sqrt returns None for negatives
result_c = (Maybe(-4)
            .bind(double)       # -8
            .bind(safe_sqrt)    # None (negative input)
            .bind(add_three))   # skipped
print(result_c)   # Maybe(None)Code language: Python (python)

Explanation:

• bind(self, func): This is the core monad operation (called flatMap or >>= in other languages). It checks the wrapped value before applying the function. If the value is None, the function is never called and the None propagates. If the value is present, the function runs and its result is wrapped in a new Maybe.
• Short-circuit propagation: Once None appears anywhere in the chain, every subsequent bind call returns Maybe(None) immediately without executing the lambda. The entire chain runs to completion without raising exceptions or requiring any conditional checks in the calling code.
• Returning None from a lambda: When safe_sqrt returns None for a negative input, bind wraps that None in a Maybe. The next bind sees self.value is None and short-circuits. This demonstrates that the monad handles failures originating anywhere in the chain, not just at the start.
• Comparison to exception handling: The Maybe monad and try/except both deal with operations that can fail, but in different styles. Exceptions use control flow that jumps out of the normal execution path. Maybe keeps everything in a linear chain and encodes the failure as data inside the wrapper. The monadic approach is easier to compose and reason about when the entire pipeline is built from pure functions.