Discussion on: Improving Javascript functional programming with Polyethylene

View post

That's an interesting take, thanks for sharing! Out of curiosity, why did you choose chaining methods instead of piping functions? (approach taken by Rambda and RxJS 6, for instance)

Here's an example of what I mean.

const averageSpaniards = Poly.pipe(
  Poly.filter(({ country }) => country === 'ES'),
  Poly.map(({ age }) => age),
  Poly.reduce(({ age, num }, x) => ({ age: age + x, num: num + 1 }))
)

averageSpaniards(worldPopulation)

Daniel Escoz • Jan 25 '19

Hm... I hadn't though about this, and it's interesting to me. The main reason to use chainable methods was to mimic arrays, as extending array functions to generators is how this idea started.

For what you propose,

how would you discriminate between sync and async iterators?
what would the pipeline stages receive and return?

Avalander • Jan 25 '19

The main reason to use chainable methods was to mimic arrays, as extending array functions to generators is how this idea started.

Fair enough, familiarity is always a bonus :)

how would you discriminate between sync and async iterators?

Either take MojiScript's idea and make all pipelines async anyway, or provide a pipeAsync function that would be equivalent to your .async().

what would the pipeline stages receive and return?

I'd say there wouldn't be any intermediate stages. The pipe would be created with a list of functions, and then it would be given and array and apply all operations to each element of the array at once, effectively iterating over the array only once.

But I think that's more a matter of API ergonomics than actual differences in behaviour, you can probably achieve similar results either way.