Functional Python "threading" pattern

2025-03-26T00:00:00+00:00
Consider this code in Python:</p>
import</span> re</span></span>
</span>
from</span> functools</span> import</span> partial</span>,</span> reduce</span></span>
</span>
</span>
def</span> enumify</span>(</span>s</span>:</span> str</span>) -></span> str</span>:</span></span>
    return</span> reduce</span>(</span></span>
        lambda</span> x</span>,</span> f</span>:</span> f</span>(</span>x</span>),</span></span>
        [</span>partial</span>(</span>re</span>.</span>sub</span>,</span> r</span>"</span>[</span>\(\)\.\,\!</span>]</span>"</span>,</span> ""</span>),</span> partial</span>(</span>re</span>.</span>sub</span>,</span> r</span>"</span>[</span>\s</span>\-\/</span>]</span>"</span>,</span> "_"</span>),</span> str</span>.</span>upper</span>],</span></span>
        s</span>,</span></span>
    )</span></span></code></pre>
The enumify</code> function applies some transformations to a string, returning a string suitable for deserializing into an enum value.</p>
enumify</span>(</span>"Hello, world!"</span>)</span></span></code></pre>HELLO_WORLD</span></span></code></pre>enumify</span>(</span>"some-kebab-var"</span>)</span></span></code></pre>SOME_KEBAB_VAR</span></span></code></pre>
These transformations are just pure functions that modify a string. Python's functools.reduce</code> is used to apply these pure functions sequentially, with each function producing the input for the next.</p>
The arguments to functools.reduce</code> are a reducing function, which itself accepts an accumulator and a value, an iterable to supply the value in the reducing function, and optionally an initial value for the accumulator. To create the enumify</code> function, we supply our aguments:</p>


The first argument to functools.reduce</code> a generic lambda whose accumulator argument is possibly the result of one of the pure functions, and the value argument is a function to be applied.</p>
</li>

The second argument — a sequence of pure functions to apply to the accumulating result. Note the use of functools.partial</code> with re.sub</code> to produce a fucntion of singular arity.</p>
</li>

Lastly, we pass in the initial accumulator value; here it is the input to our “pipeline”. However, an initial value which is of type expected by the sequence of input functions is mandatory for this pattern.</p>
</li>
</ul>
Generalizing this pattern, we get something like the following.</p>
def</span> thread</span>(</span>input</span>,</span> *</span>fs</span>):</span></span>
    return</span> reduce</span>(</span>lambda</span> x</span>,</span> f</span>:</span> f</span>(</span>x</span>),</span> fs</span>,</span> input</span>)</span></span>
</span>
</span>
def</span> enumify</span>(</span>s</span>:</span> str</span>) -></span> str</span>:</span></span>
    return</span> thread</span>(</span></span>
        s</span>,</span> partial</span>(</span>re</span>.</span>sub</span>,</span> r</span>"</span>[</span>\(\)\.\,\!</span>]</span>"</span>,</span> ""</span>),</span> partial</span>(</span>re</span>.</span>sub</span>,</span> r</span>"</span>[</span>\s</span>\-\/</span>]</span>"</span>,</span> "_"</span>),</span> str</span>.</span>upper</span></span>
    )</span></span></code></pre>
Refactoring the function even makes it easier to reason about. This pattern is inspired by Clojure's threading macros</a>.</p>
Python is regarded as a highly readable programming language with a syntax that resembles psuedo-code or even natural language, but this is to demonstrate that taking advantage of Python's functional features can make it into a very expressive language.</p>
add_b</span> =</span> lambda</span> x</span>: {</span>**</span>x</span>,</span> "b"</span>:</span> "hello"</span>}</span></span>
capitalize_vals</span> =</span> lambda</span> x</span>: {</span>k</span>:</span> v</span>.</span>upper</span>()</span> for</span> k</span>,</span> v</span> in</span> x</span>.</span>items</span>()}</span></span>
</span>
thread</span>({</span>"a"</span>:</span> "value1"</span>},</span></span>
       add_b</span>,</span></span>
       capitalize_vals</span>)</span></span></code></pre>{'a': 'VALUE1', 'b': 'HELLO'}</span></span></code></pre>thread</span>({</span>"x-some-header"</span>:</span> "header value"</span>,</span> "x-other-header"</span>:</span> "other value"</span>},</span></span>
       add_b</span>,</span></span>
       capitalize_vals</span>)</span></span></code></pre>{'x-some-header': 'HEADER VALUE', 'x-other-header': 'OTHER VALUE', 'b': 'HELLO'}</span></span></code></pre>
So far, these examples attempt to mimic Clojure's -></code> macro. Let's go a step further and try to replicate the cond-></code> macro.</p>
def</span> thread_cond</span>(</span>input</span>,</span> *</span>pftups</span>):</span></span>
    def</span> thread_cond_reduce_helper</span>(</span>acc</span>,</span> pftup</span>):</span></span>
        pred</span>,</span> f</span> =</span> pftup</span></span>
        return</span> f</span>(</span>acc</span>)</span> if</span> pred</span>()</span> else</span> acc</span></span>
    return</span> reduce</span>(</span>thread_cond_reduce_helper</span>,</span> pftups</span>,</span> input</span>)</span></span></code></pre>
As you can see, this is very similar to our thread</code> function, but instead of a variable number of pure functions, thread_cond</code> accepts a variable number of predicate and function tuples. The predicate is a simple supplier function.</p>
def</span> describe_num</span>(</span>n</span>:</span> int</span>) -></span> str</span>:</span></span>
    return</span> thread_cond</span>(</span>""</span>,</span></span>
                       (</span>lambda</span>:</span> n</span> <</span> 0</span>,</span> lambda</span> x</span>:</span> x</span> +</span> "NEGATIVE "</span>),</span></span>
                       (</span>lambda</span>:</span> n</span> >=</span> 0</span>,</span> lambda</span> x</span>:</span> x</span> +</span> "POSITIVE "</span>),</span></span>
                       (</span>lambda</span>:</span> n</span> %</span> 2</span> !=</span> 0</span>,</span> lambda</span> x</span>:</span> x</span> +</span> "ODD "</span>),</span></span>
                       (</span>lambda</span>:</span> n</span> %</span> 2</span> ==</span> 0</span>,</span> lambda</span> x</span>:</span> x</span> +</span> "EVEN "</span>),</span></span>
                       (</span>lambda</span>:</span> True</span>,</span> str</span>.</span>strip</span>))</span></span>
</span>
describe_num</span>(</span>11</span>)</span></span></code></pre>POSITIVE ODD</span></span></code></pre>describe_num</span>(</span>26</span>)</span></span></code></pre>POSITIVE EVEN</span></span></code></pre>describe_num</span>(</span>-</span>3</span>)</span></span></code></pre>NEGATIVE ODD</span></span></code></pre>describe_num</span>(</span>-</span>14</span>)</span></span></code></pre>NEGATIVE EVEN</span></span></code></pre>
The predicate being a simple supplier function allows us to define concise closures; in this last example we created a predicate that closes over the variable n</code>. Compare this to the if</code> ladder version.</p>
def</span> describe_num_other</span>(</span>n</span>:</span> int</span>) -></span> str</span>:</span></span>
    res</span> =</span> ""</span></span>
    if</span> n</span> <</span> 0</span>:</span></span>
        x</span> +=</span> "NEGATIVE "</span></span>
    if</span> n</span> >=</span> 0</span>:</span></span>
        x</span> +=</span> "POSITIVE"</span></span>
    if</span> n</span> %</span> 2</span> !=</span> 0</span>:</span></span>
        x</span> +=</span> "ODD "</span></span>
    if</span> n</span> %</span> 2</span> ==</span> 0</span>:</span></span>
        x</span> +=</span> "EVEN "</span></span>
    return</span> res</span>.</span>strip</span>()</span></span></code></pre>
Which version you think is better is really a matter of preference and familiarity — and maybe taste.</p>
Marcos Martinez's Website

Functional Python "threading" pattern
