@graingert can you give an example of how would you like it to look like ?

const helloWorld = putStr("Hello")
  .flatMap(putStr(" "))
  .flatMap(putStr("world!"))
  .flatMap(putStr("\n"));

const helloWorld = moent.Do(function* () {
  yield putStr("Hello");
  yield putStr(" ");
  yield putStr("world!");
  yield putStr("\n");
});

you can also get values out too:

const hamSpam = monet.Do(function* () {
  const x = yield reader();
  const y = x.toLowerCase();
  yield putStr(y);
});

Example from RxJS:
https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/spawn.md

it would have to crash for monads with more than 1 element.

see also: https://github.com/pelotom/burrido and https://github.com/pelotom/immutagen

sadly it's really slow: https://github.com/pelotom/burrido#caveats

Despite the limitations, I do think it would be useful for a limited set Monads where there's only one value, like Maybe and Either. Those who want to use it with streams despite the performance penalty can use burrido instead.

@graingert @sevcsik sorry for not being responsive. This seems to be quite an interesting feature, yet there is still a lot of work to make 'monet' stable and equipped with all needed/requested basic features. So probably it'll not appear in the library in some short time. I'm thinking also how to make it work without crashing lib for ES5 limited environments…

Anyway:

1. PRs are welcome
2. Maybe we should add Just another lib like @monet/generators and put all generator centric features there?

PS
I would love to see working do notation in JS/TS :)

I sketched an implementation for the do notation (unfortunately do is a reserved word so I went with run). The first one is Monet-specific and the second one is more generic:

https://repl.it/@sevcsik/monet-monad-comprehension
https://repl.it/@sevcsik/generic-monad-comprehension

The library itself should only contain the run function which itself doesn't contain a generator expression (a generator expression just yields a function which returns an iterator), so it will work fine in ES5. Of course, to use it, you'll need ES6 generator support.

My concern about writing a separate library is about determining the unit method which we should use to wrap the result. Now, I worked it around with optionally accepting the object which holds the unit function as the first argument; if the argument isn't supplied, the result won't be wrapped.

But if we would add it to every monadic type, like Maybe.do and Either.do, this wouldn't be an issue as the run function could just use this.unit (and the do word is not reserved for object keys, so there's that :))

it would have to crash for monads with more than 1 element.

I agree. Do you know any way to detect that in a generic way? I couldn't think of anything... Of course, we could whitelist monads which are known to work if we only support Monet's monads.

Opened a PR. I'm yet to figure out how to make the do function optional in TS, so it doesn't bring in an ES6 requirement.