Functional Python and Lambdas

Lambda and Lines of Code

A Python lambda has a single expression. This precludes any statements.

An expression must be complete on a single logical line of code. Because of the way ( and ) must balance, it can span multiple physical lines of code.

a = list(
    map(
        lambda x: (
            (
                3 * x + 1
            )
            if
            (
                x % 2 == 1
            )
            else
            (
                x // 2
            )
        ),
        range(10)
    )
)

A lambda can be quite long. Use ( and ) to enclose it.

Design Choices

The Ruby foo.map(m).filter(f).reduce(r) has two renderings in Python.

• Nested functions. This is bad, but we'll look at it.
• Chains of generator expressions. I call them stacks. This is good.

Let's take a concrete example, one that we can unit test. We'll look at it first as nested functions to see how bad it can be.

Nested Functions

Here's are two functions to generate some complicated data.

hotpo = (
    lambda x:
        (x * 3 + 1) if (x % 2 == 1)
        else (x // 2)
)
hotpo_run = (
    lambda x, r:
        r + [x] if x == 1
        else hotpo_run(hotpo(x), r + [x])
)

These are two functions that we've defined as lambdas for no particularly good reason.

Let's use a mapping to compute a range of values. This is a bit like range(1, 11).map(lambda...) in Ruby.

list(
    map(
        lambda n: hotpo_run(n, []),
        range(1, 11)
    )
)

We don't want the lists. We want the lengths of the lists.

list(
    map(len,
        map(
            lambda n: hotpo_run(n, []),
            range(1, 11)
        )
    )
)

Not that it matters much, but let's add a filter.

list(
    filter(
        lambda x: x > 0,
        map(len,
            map(
                lambda n: hotpo_run(n, []),
                range(1, 11)
            )
        )
    )
)

Let's reduce this to find the largest value.

Clearly max() will work, but, for the sake of matching the Ruby, let's build max() as a reduce().

from functools import reduce
reduce(
    lambda a, b: a if a > b else b,
    filter(
        lambda x: x > 0,
        map(len,
            map(
                lambda n: hotpo_run(n, []),
                range(1, 11)
            )
        )
    )
)

The answer is 20. What's important is the function-application version of the Ruby.

foo.map(m).filter(f).reduce(r)

reduce(r, filter(f, map(m, source)))

Folks don't like reading the Python right-to-left. When you spread it into multiple lines it has to be read from bottom-to-top. Or maybe from inside to outside. This nested function version is not widely used.

We can do better with a stack of generator expressions.

Stacked Generators

We'll start with the original two lambdas, hotpo() and hotpo_run().

runs = map(
        lambda n: hotpo_run(n, []),
        range(1, 11)
    )
lengths = map(len, runs)
positive = filter(lambda x: x > 0, lengths)
maximum = reduce(
    lambda a, b: a if a > b else b,
    positive
)

This reads from start to finish in an understandable fashion.

We can easily add steps in the middle of this.

The downside of adding steps is the intermediate results have names.

When we want to insert a step, we have to also modify the step after to use the new intermediate results.

The upside is the intermediate results have names. These describe what's going on. I really like this approach.

Hey, Wait

Yes, this is related to the Collatz Conjecture. See https://projecteuler.net/problem=14.

The definition of the hotpo_run() function isn't conducive to creating a cache. We can rewrite it, easily, into a function that builds a list from a single argument value. This works better with a cache.

from functools import cache
hotpo_run = cache(
    lambda x: [1] if x == 1 else [x] + hotpo_run(hotpo(x))
)

This necessitates a change to the pipeline to deal with the slightly different parameter signature for the hotpo_run() function.

runs = map(
        hotpo_run,
        range(1, 11)
    )

The rest is the same. Second verse same as the first verse.

lengths = map(len, runs)
positive = filter(lambda x: x > 0, lengths)
maximum = reduce(
    lambda a, b: a if a > b else b,
    positive
)

This computes almost instantly.

What's important is the sequence of map()-filter()-reduce() functional operations is better expressed as a sequence of generator expression statements. I like to call it the "Stack of Generators" design pattern. It has much of the expressive power of Ruby, with all of the flexibility we desire.

runs = ((hotpo_run(n), n) for n in range(1, 11))

runs = map(lambda n: (hotpo_run(n), n), range(1, 11))