How to use Option and Writer together with LINQ syntax?

I understand that with Option type, step 3 from c in SomeC(b) will be “skipped” due to NoneB(a) returns type of None.

//pseudo code
from a in SomeA(0) //returns Some<int>
from b in NoneB(a) //returns None
from c in SomeC(b) //returns Some<int>
select c //c is of None type

If I’m trying to combine Option with Writer. Is it possible to achieve the same “skipping” behaviour?

//pseudo code
from a in WriterSomeA(0) //returns Writer<Option<int>, string[]>
from _1 in Tell("Done A")
from b in WriterNoneBB(a) //returns None
from _2 in Tell("Done B")
from c in WriterSomeC(b)
from _3 in Tell("Done C")
select c

And should I be expecting c to be of type Writer<None<int>, string[]> as well as skipping step from c in WriterSomeC(b)?

[louthy]

@HistoricallyCorrect Mixing of monad types is a bad idea and special-case SelectMany implementations leads to real inference problems for the C# compiler. It would also wipe out the writer log for stages which don’t support it (the Option stages).

However the Writer has an IsBottom state, which you could use for None:

     public static Writer<MonoidW, W, A> WriterNone<MonoidW, W, A>() 
        where MonoidW : struct, Monoid<W> => () => 
            (default, default, true);

But some better advice might be to use the code-gen system for wrapping up the RWS monad (Reader/Writer/State):

    [RWS(WriterMonoid: typeof(MSeq<string>), Env: typeof(Unit), State: typeof(Unit), 
         Constructor: "Pure", Fail: "WriterNone")]
    public partial struct Subsys<T>
    {
        // This is here to wrap up the call to the generation of a single item `Seq`
        public static Subsys<Unit> tell(string what) =>
            tell(Seq1(what));
    }

By making the Env and State into Unit you effectively have a Writer which is easier to use than the default one. So you can see that by using WriterNone it effectively gives you a short-cut out of the monad.

The Constructor and Fail parameters are used to give names to the constructor an failure functions.

You can then do this:

using static Subsys;

from a  in Pure(0)
from _1 in tell("Done A")
from b  in WriterNone<Unit>()
from _2 in tell("Done B")
from c  in Pure(b)
from _3 in tell("Done C")
select c

I updated the Reader a few weeks back to support better error handling, and will update the RWS to have a similar error handling mode in the next few days. So you’ll be able to provide an Error type that can take exceptions, strings, and error codes.

[TysonMN]

I think you meant OptionAsync ?

Yep, just fixed that typo. Thanks 😃