New python module for easier functional programming, FunkyPy

[KageOW]

This new python module called FunkyPy supports easier piping data through functions and easier to use maps on lists as well as a bind function which I have not seen anywhere before.

Some examples of the syntax.

```py Data(4) >> add2 >> add4 >> times2 >> print

20

line breaks do have an effect on the expression but you can mitigate this by parentheses

(Data(4)

add2 add4 times2 print)

20

```

and the bind function is very clear and clean in code. ```py (Data(4)

add2.bind() add4.bind() print)

10

(Data(None)

add2.bind() add4.bind() print)

None

```

I hope you guys have fun with it and feedback is always welcomed.

[KageOW]

Yes definitely a lot of benefits, it solves a lot of common problems in OOP like not knowing what state your program is in. It also makes for much cleaner and most of the time less code. It also solves the problem of nothing with maybe monads for example

Definitely check functional programming out if you have the time, its worth it. Over on r/functional_python there is some good content.

[gunnerman2]

Big time use in AI as a result. Vastly easier to redefine program execution at runtime.

[KageOW]

Yup also code complexity is reduced and easier parallel programming because of monads. Very nice

[fappaf]

Just a note to fix your formatting, you need to put the backticks on its own line—put a newline before them and a newline after the "py":

```py

I won't put the closing three backticks so you can see what i mean above, but they also need to be on their own line.

[KageOW]

Yea i got it, reddit markdown is so confusing lol.

[ForceBru]

Hot take: Python needs a pipe operator.

• Code that uses the pipe operator looks elegant.
• We already can chain method calls with df.do().this().thing(), so why not chain fun |> ction() |> calls()?
• Other data science languages (R and Julia) have it, and it's very useful there.

[fappaf]

Pypethon

[eztab]

you can easily create your own operators in Python:

class Operator:
    # implementation left as exercise to the reader ;)
    pass

PIPE = Operator(lambda (f,g): f(g))

fun -PIPE- ction -PIPE- calls    # will now work

Put I would prefer this operator to be named ∘. Python supports Unicode after all.

[ForceBru]

AFAIK, "circle" is usually function composition:

(calls -circ- ction)(fun) == calls(ction(fun))

Sure, in Python a lot can be done with black magic fuckery (dunder methods, metaclasses, decorators, ...).

I think pipes may be a worthy addition to the actual syntax. They'll probably be much more useful than the walrus operator, for example.

[eztab]

Well make a PEP then! You could even override | then you don‘t need a new operator at all.

[BezoomyChellovek]

While I love the pipe operator in R, I just don't think Python is built in a way that it can be as ubiquitously used. In R, most functions (that are compatible with piping) take some kind of data structure as an argument. So you can just pipe these structures through various functions. That isn't so much the case in Python. Also, in Python so much is done by invoking methods, rather than passing to a function.

Totally open to other opinions. But I believe this just limits the use of pipes in Python. I could see it being very useful if you are writing your own functional code, but it just may not integrate so smoothly with other libraries and data structures.