Feature request: `.pipe`, and possibly `.fpipe`

[james-pcdr]

Hello again,
What is your opinion on adding...

1. a pipe method that simply applies a function, and
2. a fpipe method that additionally wraps the result in a flu?

The benefit IMO is that it preserves the top-to-bottom readability of the fluent approach.

1. pipe example:

from statistics import mean

avg_of_small_nums = (flu([10, 30])
  .map(lambda x: x*10)
  .pipe(mean)
)

assert avg_of_small_nums == 200

2. fpipe example:

from itertools import starmap as starmap_original
from functools import partial

def starmap(f):
    return partial(starmap_original, f)

names_and_ages = ["bob:50", "sue:44"]
introductions = (flu(names_and_ages)
  .map(lambda x: x.split(":"))
  .fpipe(starmap(lambda name, age: f"{name} is {age} years old"))
  .to_list()
)

assert introductions == ["bob is 50 years old", "sue is 44 years old"]

Notes:

• I have no opinion on the name choices. I picked pipe because I've seen it in similar projects.
• I'm happy to submit a PR if you like the suggestion.

EDITED: fixed a parenthesis

[olirice]

The concept of the pipe example makes a lot of sense

Currently, if the aggregation method you want isn't available (like mean) you'd have to:

from statistics import mean

mean(
  flu([10, 30])
  .map(lambda x: x*10)
)

which definitely breaks the builder continuity

The benefit IMO is that it preserves the top-to-bottom readability of the fluent approach.

agree!

I picked pipe because I've seen it in similar projects

The term pipe feels a bit overloaded imo. I wasn't familiar with the term in this context and my first thought was about unix pipes. Could you link me to where you've seen it before?

Some places that might have a similar implementation worth referencing are:

• pyspark
• moreitertools
• toolz
• scala's array type
• rust's itertools crate

[olirice]

It feels like things you'd pass to pipe would any aggregate method that doesn't have first class support

I'm not as sure about fpipe. I'm probably going to land on the side of "not a frequent enough need" for that one. Could you give me a real world example of when that would be helpful?

[james-pcdr]

Regarding fpipe: Sure, omitting sounds fine. I don't have a strong opinion on that one. 👍

Regarding the naming convention for pipe:

• toolz pipe
• scala pipe
• expression pipe (you didn't ask for this one, but including for good measure 🙂 )

[olirice]

Thanks for digging into it

In contrast to those, flu operates on iterables rather than any value. Given that, I think apply might be a better fit, since the result would break out of the builder pattern

Something like

flu.apply(func: Callable[[Iterable[T]], _T1]) → _T1

[james-pcdr]

Ok. I'll submit a PR after I finish my current one.