Calling .Sequence on a left state Either<L, Task<R>> is returning bottom value

Example code:

var before = Left<string, Task<int>>("Failed");
var after = await before.Sequence();

I’m expecting after to be a left value of the type Either<string, int>, but in reality it is a bottom value.

Nuget version: 3.1.15

[louthy]

Isn’t that because it isn’t a monad that has a “zero” but a monoid?

No, that’s ‘Empty’. Monads in language-ext follow the MonadPlus type-class design. But, it’s not valid for all monads, so things like this happens. It’s just a limitation that I’ve had to deal with when trying to formalise the type-class/class-instance system. I think there’s a better approach (via code-gen), but it takes time to get all this into my head (then implementing it is a whole other bundle of joy)

-- | Monads that also support choice and failure.
class (Alternative m, Monad m) => MonadPlus m where
   -- | The identity of 'mplus'.  It should also satisfy the equations
   --
   -- > mzero >>= f  =  mzero
   -- > v >> mzero   =  mzero
   --
   -- The default definition is
   --
   -- @
   -- mzero = 'empty'
   -- @
   mzero :: m a
   mzero = empty

   -- | An associative operation. The default definition is
   --
   -- @
   -- mplus = ('<|>')
   -- @
   mplus :: m a -> m a -> m a
   mplus = (<|>)

[louthy]

The latest beta has the issues in this thread fixed:

var before = Left<string, Task<int>>("Failed");
var after = await before.Sequence();  // Left("Failed")

Either<string, Seq<int>> r1 = Prelude.Seq(1,2,3);
Seq<Either<string, int>> r2 = r1.Sequence(); // [Right(1), Right(2), Right(3)]
Either<string, Seq<int>> r3 = r2.Sequence(); // Right(Seq(1,2,3))

Either<string, Seq<int>> l1 = "left";
Seq<Either<string, int>> l2 = l1.Sequence(); // []
Either<string, Seq<int>> l3 = l2.Sequence(); // Right([])

The notion of symmetry when calling Sequence twice isn’t a contract of the function, and couldn’t possibly be maintained for all pairs of monads. Traverse and Sequence both work by applying the monad rules of the inner and outer type repeatedly for the all of the items in the transformer type; that can be destructive in the case of monad can short-cut an operation (Option, Either, etc.), and so data can be lost in the operation, that obviously means it can’t be recovered by calling Sequence again.