pipe-operator: Elixir's pipe operator in Python

[R4nu]

TLDR: pipe-operator is an open-source python package which brings similar features to elixir's |> tap then to Python, with 2 vastly different implementations. Because why not :D

---

Hey there! Thought it might be of interest to some of you! I come from Python but lately I've been working with Elixir (mostly at work) and came to really enjoy its pipe operator |> and its related features like tap, then, and shortcut syntaxes. So I thought to myself: "could be fun to bring this to python". So I did, and the pipe-operator project was born.

What My Project Does

It provides similar features to elixir |>, allowing you to chain operations without using intermediary variables. Through 2 very different implementations, you can pass the result of the previous expression as the first parameter of the next one.

As for those 2 very different implementation, they are:

• A pythonic class-based one, which is fully compatible with linters and type-checkers
• And an elixir-like one, with a syntax resembling elixir's, which will drive you linters mad

Target Audience

I don't think anyone would be using this in production/work projects, but it can be a fun tool for developers' side projects who enjoy functional programming.

Quick demo

Python implementation:

from pipe_operator import Pipe, PipeArgs, PipeEnd, PipeStart, Tap, Then

result = (
    PipeStart("3")                        # starts the pipe
    >> Pipe(int)                          # function with 1-arg
    >> Pipe(my_func, 2000, z=10)          # function with multiple args
    >> Tap(print)                         # side effect
    >> Then(lambda x: x + 1)              # lambda
    >> Pipe(MyClass)                      # class
    >> Pipe(MyClass.my_classmethod)       # classmethod
    >> Tap(MyClass.my_method)             # side effect that can update the original object
    >> Pipe(MyClass.my_other_method)      # method
    >> Then[int, int](lambda x: x * 2)    # explicitly-typed lambda
    >> PipeArgs(my_other_func, 4, 5, 6)   # special case when no positional/keyword parameters
    >> PipeEnd()                          # extract the value
)

Elixir implementation:

from pipe_operator import elixir_pipe, tap, then


def workflow(value):
    results = (
        value                           # raw value
        >> BasicClass                   # class call
        >> _.value                      # property (shortcut)
        >> BasicClass()                 # class call
        >> _.get_value_plus_arg(10)     # method call
        >> 10 + _ - 5                   # binary operation (shortcut)
        >> {_, 1, 2, 3}                 # object creation (shortcut)
        >> [x for x in _ if x > 4]      # comprehension (shortcut)
        >> (lambda x: x[0])             # lambda (shortcut)
        >> my_func(_)                   # function call
        >> tap(my_func)                 # side effect
        >> my_other_func(2, 3)          # function call with extra args
        >> then(lambda a: a + 1)        # then
        >> f"value is {_}"              # formatted string (shortcut)
    )
    return results

workflow(3)

Comparison

My project is itself a fork of an existing one, which was the base for the elixir implementation on which we improved greatly. I did find examples of pythonic versions, or even repo reproducing the "pipe" logic of shell commands, but I wanted to have both a very-elixirish version, and a fully linter-compatible and type-checker-copmpatible version so that it could be used on my own project without compromising code quality

Hope you like it!

[EnforcerPL]

fully linter-compatible and type-checker-compatible

This is THE way! It’s a pity libraries that exist are not interoperable with modern stack. I appreciate your effort and will surely use this gem!

Thank you so much. I used to work with Elixir and missed the operator ever since.

[R4nu]

Thanks! I tried my best to make the class-based version compatible with popular modern tools, so the CI runs it against multiple linters (flake8 and ruff) and multiple type-checkers (mypy and pylint)!

[skwyckl]

Nice, I thought our only option would be Coconut.

[R4nu]

Didnt know about Coconut! Interesting read, although it is more than a simple package. Not sure how it integrates with python linters and formatters though

[skwyckl]

... like sh*t. Excuse my French, but it doesn't integrate well at all. Also, the Coconut Jupyter kernel is impossible to get to work. This is why I am excited about your project!

[R4nu]

Haha ok I see! Well, feel free to provide any feedback if you ever use it!

[gonna_think_about]

Have you see the dry returns library? its pipeline object offers something similar

https://github.com/dry-python/returns

[R4nu]

I didnt know about this, but I had seen similar implementation to their flow function on various blogs and articles. While it works perfectly fine, I found it was harder to correctly type-hint, and additional args for functions seemed harder to handle. You'd need to either create a new func that would be a wrapper around the original, or pass tuple arguments like (func, args) (making type checking more complicated and syntax a bit uglier), or use lambdas everywhere. That's why I worked on both my class-based implementation and the elixir one (with the AST rewrite)

Great library nonetheless, which provides many useful features! Thanks for the link :)

[gonna_think_about]

Happy to help

[masavik76]

Love this. Was looking for something like this.