generator

I find straight forward, dedicated, precisely typed combinators much more readable and practical to use ie. for iterables (context where it makes a lot of sense) [0] example [1], runtime assertions (through refutations, which are much faster than combinators over assertions) [2], parser combinators for smallish grammars [3] etc. In many cases vanilla/imperative js is more readable and terse, no need to bring functional fanaticism everywhere, just in places where it gives true benefits and in form that can be understood by peers. Functional code can be beautiful and can also be unreadable/undebugable. Same with imperative code. It's great in js/ts you can pick approach where the problem is expressed more naturally and mix those paradigms at will. [0] https://github.com/preludejs/generator [1] https://observablehq.com/@mirek/project-euler [

You may be interested in: - https://github.com/preludejs/async-generator - https://github.com/preludejs/generator ...and example usage https://observablehq.com/@mirek/project-euler

Mine is a bit more complicated, unfortunately (me from 6 years ago had so much ambition, and implemented all the things) Also this: https://github.com/preludejs/generator/blob/master/src/pipe.... Wait, what? :)) I'm not ready to deal with something like that (just to make sure it doesn't come as arrogant, I mean I just don't trust myself)

You can type it, take a look at pipe and pipe1 in [0]. [0] https://github.com/preludejs/generator/tree/master/src

Parser combinators are great ie. in TypeScript [0]. Combinators in general are concise and practical ie. runtime type assertions [1] or generators [2] etc. We use them in several places in production. [0] https://github.com/preludejs/parser [1] https://github.com/appliedblockchain/assert-combinators [2] https://github.com/preludejs/generator/tree/master/src

Loops are great if your programming languages supports iterables/iterators/generators (also async generators) like in js/ts for example. Especially generator-to-generator combinators ie. [0] gives terse, transducer expressiveness over computation on finite/infinite streams, arrays, etc. (all iterables). It's easy to compose, jump into/out-of for-loops if needed for arbitrary yielding (ie. conditionally yielding multiple items, skipping some, halting etc); `continue`, `break`, nesting, yield, yield from (yield*), normal code in for-loops is very intuitive and terse, creating pleasant, understandable code. Recently I had a chance to break down complex pipeline in finance project into small steps as generator-to-generator transducer functions (can you call generator-to-generator functor a trasducer?), higher order for steps that require extr