Package better_functools
Better functools improves functional programming ergonomics in Python
Installation
$ pip install better-functools
Background
The library introduces 2 different operators for use with functions:
- | which we'll call "pipe"
- @ which we'll call "apply"
The following is an example:
Pipeline(inputs)
| func(itertools.combinations @ func.arg(Iterable[int]) @ bind(2))
| filter @ bind(sum @ compose(eq @ bind(2020)))
| map @ bind(prod)
| sum
| Pipeline.unwrap
This may look strange but we can break this down.
better_functools.pipe
Pipeline wraps inputs and enables unix like pipes.
So Pipeline(v) | fn is equal to Pipeline(fn(v)).
| Pipeline.unwrap is finally used to unwrap the Pipeline and extract the value.
better_functools.apply
better_functools.apply includes a number of functions that implements @.
For example, map @ bind(prod) means bind prod to the first arg of map.
More apply functions can be called directly too, the above expression is equivalent to
bind(prod)(map).
The usual pattern is: some_value @ some_operator(args)
The @ operator takes some getting used to, but the main benefit is how chainable operators are.
add @ bind(1) @ bind(2)
reads left to right fairly well, but if we were to call directly:
bind(2)(bind(1)(add))
It's just a lot harder to read and we need more brackets.
Putting @ and | together
You can see that @ and | both facilitate some sort of "function chaining". So why add 2
different operators?
@ is higher precedence than | so it can be used in each stage of a better_functools.pipe without brackets.
Generally the idea is to use @ operators to build the function for each stage of a |.
Without @ functions are a lot harder to build inline and often must be defined explicitly
elsewhere.
General Tips
Type Checking
- The typing here is built for Pyright.
- Mypy compatibility is okay, specific issues with mypy are highlighted in function docs.
- Other type checkers simply lack the popularity for me to support actively.
functools.partial
Feel free to use functools.partial to create partial functions in place of bind and func.
Both MyPy and Pyright has a custom type checking handler for partial. This is the best way to
bind keyword arguments right now.
partial(itertools.combinations, r=2)
Sub-modules
better_functools.applybetter_functools.helpersbetter_functools.pipebetter_functools.strict-
Stricter copies of builtins and standard library functions …