Usage of monad transformers

[wujido]

I am new to FP and I have been following article series on paullouth.com and some of the discusions in here 1, 2. Since the final code that use monad transformers look elegant I have dicide to give it a try and create a simple CRUD api using this library and following the principles I learned as closely as possible. But I feel like I am still missing somehthing. Here is what I have done.

Since I need Db I tried to create a wrapper around EF that is using ReaderT<DbEnv, IO, A>. The environment is jsut public record DbEnv(DbContext DbContext). The wrapper looks like this:

public record Db<A>(ReaderT<DbEnv, IO, A> RunDb) : K<Db, A>
{
    public Db<B> Select<B>(Func<A, B> m) => this.Kind().Select(m).As();
    public Db<C> SelectMany<B, C>(Func<A, K<Db, B>> b, Func<A, B, C> p) => this.Kind().SelectMany(b, p).As();
    public Db<C> SelectMany<B, C>(Func<A, K<IO, B>> b, Func<A, B, C> p) => this.Kind().SelectMany(b, p).As();
}

with this trait implementation:

public abstract partial class Db : Monad<Db>, Readable<Db, DbEnv>
{
    public static K<Db, B> Map<A, B>(Func<A, B> mapFunc, K<Db, A> db)
        => new Db<B>(db.As().RunDb.Map(mapFunc).As());

    public static K<Db, A> Pure<A>(A value)
        => new Db<A>(ReaderT<DbEnv, IO, A>.Pure(value));

    public static K<Db, B> Apply<A, B>(K<Db, Func<A, B>> applyFunc, K<Db, A> db)
        => new Db<B>(applyFunc.As().RunDb.Apply(db.As().RunDb));

    public static K<Db, B> Bind<A, B>(K<Db, A> db, Func<A, K<Db, B>> bindFunc)
        => new Db<B>(db.Run().Bind(x => bindFunc(x).Run()).As());

    public static K<Db, A> Asks<A>(Func<DbEnv, A> f)
        => new Db<A>(ReaderT.asks<IO, A, DbEnv>(f));

    public static K<Db, A> Local<A>(Func<DbEnv, DbEnv> f, K<Db, A> db)
        => new Db<A>(ReaderT.local(f, db.Run().As()));

    public static K<Db, A> LiftIO<A>(IO<A> ma)
        => new Db<A>(ReaderT.liftIO<DbEnv, IO, A>(ma));
}

And some other convinience functions:

public abstract partial class Db
{
    public static Db<A> Lift<A>(IO<A> io)
        => new(ReaderT<DbEnv, IO, A>.LiftIO(io).As());

    public static Db<DbEnv> Ask()
        => Readable.ask<Db, DbEnv>().As();

    public static Db<Context> Ctx<Context>()
        where Context : DbContext
        => from env in Ask()
           select (Context)env.DbContext;

    public static Db<Unit> Save() =>
        from env in Ask()
        from _ in liftIO(() => env.DbContext.SaveChangesAsync())
        select unit;
}
public static class DbExtensions
{
    public static Db<A> As<A>(this K<Db, A> kind)
        => (Db<A>)kind;

    public static K<ReaderT<DbEnv, IO>, A> Run<A>(this K<Db, A> db)
        => db.As().RunDb;

    public static IO<A> Run<A>(this K<Db, A> db, DbEnv env)
        => db.Run().Run(env).As();

    public static Db<A> ToDb<A>(this ValueTask<A> task)
        => Db.Lift(liftIO(async () => await task));

    public static Db<A> ToDb<A>(this Task<A> task)
        => Db.Lift(liftIO(() => task));
}

This allows me to write code like this:

public static class ProductRepository
{
    public static Db<List<Product>> List() =>
        from ctx in Db.Ctx<AppDbContext>()
        from ps in ctx.Products.ToListAsync().ToDb()
        select ps;

    public static Db<Unit> Add(Product product) =>
        from ctx in Db.Ctx<AppDbContext>()
        from _ in ctx.AddAsync(product).ToDb()
        select unit;
}

And use it like this:

var listProducts =
    from products in ProductRepository.List()
    from _ in Printer.PrintProducts(products)
    select _;

So far so good. Everything looks clear and I can run listProducts which is Db<Unit> by just pluging in correct environment.

The problem I have starts to appear when I want to implement Get(int id) in the repository. It may fail to find the product based on id so it should return Option<Product>:

    public static Db<Option<Product>> Get(int id) =>
        from ctx in Db.Ctx<AppDbContext>()
        from p in liftIO(async () => Optional(await ctx.Products.FindAsync(id)))
        select p;

And now the usage is a bit ruined:

var getProduct =
    from product in ProductRepository.Get(1)
    from _ in Printer.PrintProduct(product) // won't work since `product` is `Option<Product>` and not `Product`
    select _;

The solution I can think of is to create another monad transformer stack OptDb<A>(ReaderT<DbEnv, OptionT<IO>, A> RunOptDb)
But what about update operation. It should load the item form db, update base on users input which needs to be validated and then save back to the db. That sounds like I need another stack OptValidDb<A>(ReaderT<DbEnv, ValidationT<Error, OptionT<IO>>, A> RunOptValidDb) and the list goes on. I feel like for each usecase I need different stack and it is a lot of work to create one. If I would create those OptDb and OptValidDb I don't see how would those compose together so I would have to choose one "world" at the begining of the top level expression like listProducts and work in it.
I hope my confusion is visible from what I wrote. My question is simple. Am I right about the need for different stacks or is there a easier way?

[louthy]

You can leverage the fact that IO<A> supports the Fallible trait. So, if you make your Db also monad support Fallible then you can then add operators like | to Db<A> to start using @catch. That means you can inject Error values into the result and let them propagate if necessary, or catch them to handle them:

public abstract partial class Db : 
    Monad<Db>, 
    Readable<Db, DbEnv>,
    Fallible<Db>
{
    public static K<Db, A> Fail<A>(Error error) => 
        Lift(IO.fail<A>(error));

    public static K<Db, A> Catch<A>(K<Db, A> fa, Func<Error, bool> Predicate, Func<Error, K<Db, A>> Fail) =>
        Ask().Bind(env => fa.MapIO(io => io.Catch(Predicate, e => Fail(e).Run(env))));

    public static K<Db, B> MapIO<A, B>(K<Db, A> ma, Func<IO<A>, IO<B>> f) => 
        new Db<B>(new ReaderT<DbEnv, IO, B>(env => f(ma.Run(env))));

    public static K<Db, IO<A>> ToIO<A>(K<Db, A> ma) =>
        ma.MapIO(IO.pure);

So, you can see above I added Fallible<Db>. That asks me to implement Fail and Catch.

I also provided overrides for MonadIO.MapIO and MonadIO.ToIO. These two methods give you easy access to the underlying IO monad, that makes implementing Catch a little simpler. This isn't required, you could implement Catch more manually:

    new Db<A>(
        new ReaderT<DbEnv, IO, A>(
            env => fa.Run(env).Catch(Predicate, e => Fail(e).As().RunDb.Run(env))));

But the other benefit is that now Db<A> also supports Retry, RetryUntil, RetryWhile, etc. -- all of the functionality of the IO monad becomes available to Db<A>. Which includes forking, repeating, retrying, folding, zipping, etc.

Then add the operators to Db<A>:

    public static Db<A> operator |(Db<A> ma, Db<A> mb) =>
        ma.Catch(mb).As();

    public static Db<A> operator |(Db<A> ma, CatchM<Error, Db, A> mb) =>
        ma.Catch(mb).As();

    public static Db<A> operator |(Db<A> ma, Pure<A> mb) =>
        ma.Catch(mb).As();

    public static Db<A> operator |(Db<A> ma, Error mb) =>
        ma.Catch(mb).As();

These will allow you to write mx | my to coalesce failure to the rhs operator. @catch creates a CatchM type, Pure(123) creates a Pure<int>, and Error.New("my error") creates a new Error. These can all be used to handle failure.

So, failure now can be either exceptional (the underlying calls to EF throw exceptions), or manually raised using: Db.Fail(Error).

I hope that helps.

[louthy]

Really, it's just about formalising what happens with failure-values or alternative-values. There are a number of traits that help standardise the approach:

Fallible<E, F>

Provides the following methods:

• K<F, A> Fail<A>(E error)
• K<F, A> Catch<A>(K<F, A> fa, Func<E, bool> predicate, Func<E, K<F, A>> fail)

This allows a type to raise errors of type E and to Catch them, matching using the predicate and providing a new operation to run if true.

You can use the Catch extension:

operation.Catch(e => e.Is(Errors.SequenceEmpty), e => ...)

Or, if you have implemented operator | (F<A> lhs, CatchM<E, F, A> rhs):

operation 
    | @catch(Errors.SequenceEmpty, e => ...)
    | @catch(Errors.Cancelled, e => ...)
    | Pure(unit);

This makes error handling really easy. It makes the addition of error context as you go higher easier too.

You can see a sample in the EffectsExamples. The Eff<RT, A> type is Fallible<F>.

Fallible<F>

As above but supports the built-in Error type only.

SemigroupK<F>

This provides:

• K<M, A> Combine<A>(K<M, A> lhs, K<M, A> rhs)

The idea of Combine is to do structural composing. For example, the concatenation of lists, or something similar. This is not designed to be a choice, or an alternative.

The intended operator for Combine is operator +.

Choice<F>

This is both an Applicative<F> and a SemigroupK<F> and provides:

• K<F, A> Choose<A>(K<F, A> fa, K<F, A> fb)
• Also, a default implementation of Combine that calls Choose.

The intended operator for Combine is operator |. The expected behaviour is that (when calling lhs.Choose(rhs) or lhs | rhs) then the lhs operand is invoked first. If it succeeds, then the result of that operation is returned. Otherwise, the rhs operand is invoked and returned.

There are laws that the Choice-trait supporting type should enforce:

• Applicative laws
• Left-zero law: choose(empty, pure(x)) = pure(x)
• Right-zero law: choose(pure(x), empty) = pure(x)
• Left-catch law: choose(pure(x), pure(y)) = pure(x)

Any type that implements Choice can be tested with ChoiceLaw<F>.assert. You can see how the various Choice supporting types in LanguageExt.Core are tested.

MonoidK<F>

MonoidK<F> is just a SemigroupK<F> (from above) with an additional Empty() method that returns a K<F, A> in an 'empty' state. This is usually the natural unit/identity/empty value for the type.

Alternative<F>

Alternative<F> is just a Choice<F> (from above) with an additional Empty() method that returns a K<F, A> in an 'empty' state. This is usually the natural unit/identity/empty value for the type.

This has the same laws as Choice<F>:

• Applicative laws
• Left-zero law: choose(empty, pure(x)) = pure(x)
• Right-zero law: choose(pure(x), empty) = pure(x)
• Left-catch law: choose(pure(x), pure(y)) = pure(x)

And can be tested with AlternativeLaw<F>.assert. You can see how the various Alternative supporting types in LanguageExt.Core are tested.

Conclusion

So, there's Combine for smushing types together. Choice for picking alternatives values when failure happens. And Fallible for picking alternatives values when failure happens, but additionally, making the error-value available for interrogation.

Your type can implement, some, all, or none of these traits.

[wujido]

@louthy Thank you for your answers. I know that these traits exists but I never considered using them because I was not sure if I understand their purpose. This explanation helped a bit. However, I did some experiments primary with the Fallible trait from your original answer and I am not sure if I see how to use it to omit creation of OptDb<A>(ReaderT<DbEnv, OptionT<IO>, A> RunOptDb) and OptValidDb<A>(ReaderT<DbEnv, ValidationT<Error, OptionT<IO>>, A> RunOptValidDb).

I have implemented Fallible and | operators exactly as you showed. Then I tried to use it to fix Get from my question:

    public static Db<Product> Get(int id) =>
        from ctx in Db.Ctx<AppDbContext>()
        from p in ctx.Products.FindAsync(id).ToDb()
        from pr in p is null
                       ? Db.Fail<Product>(DbError.NotFound)
                       : Db.Pure(p)
        select pr;

I don't feel like this conversion of null to Error is the pretties think I saw but I don't find another way of doing it. Based on your answer I have assumed that your intention was something like from p in ctx.Products.FindAsync(id).ToDb() | DbError.NotFound but none of the | overloads do the null check so they are not usable in here. I can add this:

    public static Db<A> operator |(Db<A?> db, Error err) =>
        db.Bind(
            a => a is null
                     ? Db.Fail<A>(err)
                     : Db.Pure(a)
        ).As();

to make from p in ctx.Products.FindAsync(id).ToDb() | DbError.NotFound work but I am not sure if that's what you were aiming for.
Here is the error for context:

public static class DbError
{
    public enum Code
    {
        NotFound = 10000,
    }

    public static readonly Error NotFound =
        Error.New((int)Code.NotFound, "Not found");
}

Nomatter how the Get inject error to the Db the usage part confuses me too. I tried extend usage from my question with @catch but I don't find a good way of doing so:

var getProduct =
    from product in ProductRepository.Get(id) | @catch(DbError, e => Db.Lift(Printer.PrintProductNotFound(id)))
    from _ in Printer.PrintProduct(product)
    select _;

will obviously not work since @catch return Db<Unit> and product in the rest of the computation is Unit and not Product. Here is the Printer:

public static class Printer
{
    public static IO<Unit> PrintProduct(Product product) =>
        lift(() => {
                 Console.WriteLine(
                     $"""
                      Found product ({product.Id})
                          * Name: {product.Name}
                          * Price: {product.Price}
                      """
                 );
             });

    public static IO<Unit> PrintProductNotFound(int id) =>
        lift(() => {
                 Console.WriteLine($"Product with id {id} was not found");
             });
}

To make it work I need to catch the whole getProduct expression:

var getProduct =
    (from product in ProductRepository.Get(id)
     from _ in Printer.PrintProduct(product)
     select _) | @catch(DbError.NotFound, e => Db.Lift(Printer.PrintProductNotFound(id)));

Which is not the worst thing I have seen and I can maybe find some formatting I will be ok with.

Next operation was update where I introduced OptValidDb<A>. How would implementing of Faillible (or other traits) avoid doing so? I would like to have operations like this:

public record Product
{
    public int Id { get; init; }
    public string Name { get; init; } = string.Empty;
    public decimal Price { get; init; }

    public Validation<Error, Product> SetPrice(decimal price)
        => price > 10
               ? Pure(this with { Price = price })
               : Fail(Error.New("Price too low"));

    public Validation<Error, Product> SetName(string name)
        => name.Length > 6
               ? Pure(this with { Name = name })
               : Fail(Error.New("Name too short"));
}

But I don't know how to integrate it with my Db and how to make sure that those error would be accumulated. At the usage part I then somehow need to check if I got successful operation, not found or accumulation of validation errors, but I was not successful in implementation of this by utilizing the traits you explained.

I have one more maybe a bit unrelated question. I sometimes see mention of free monad (your articles, 1liveowl mentioned it, I think that the IO is implemented like that) but I don't know nothing about it. Do you know about any source where I could learn more about it and it wasn't Haskell or some deep mathematical theory?

[louthy]

The best approach is to implement the trait and then use the trait-implementations in your operators and the like. The traits have lots of supplementary functionality, so once implemented you gain a lot.

Here's a minimal implementation of Db<A>:

public record DbEnv;
public record Db<A>(ReaderT<DbEnv, IO, A> RunDb) : K<Db, A>
{
    public Db<B> Select<B>(Func<A, B> m) => this.Kind().Select(m).As();
    public Db<C> SelectMany<B, C>(Func<A, K<Db, B>> b, Func<A, B, C> p) => this.Kind().SelectMany(b, p).As();
    public Db<C> SelectMany<B, C>(Func<A, K<IO, B>> b, Func<A, B, C> p) => this.Kind().SelectMany(b, p).As();
}

public static class DbExtensions
{
    public static Db<A> As<A>(this K<Db, A> ma) =>
        (Db<A>)ma;
}
public class Db : Monad<Db>, Fallible<Db>, Readable<Db, DbEnv>
{
    public static K<Db, B> Bind<A, B>(K<Db, A> ma, Func<A, K<Db, B>> f) =>
        new Db<B>(ma.As().RunDb.Bind(x => f(x).As().RunDb));

    public static K<Db, B> Map<A, B>(Func<A, B> f, K<Db, A> ma) => 
        new Db<B>(ma.As().RunDb.Map(f));

    public static K<Db, A> Pure<A>(A value) => 
        new Db<A>(ReaderT.pure<DbEnv, IO, A>(value));

    public static K<Db, B> Apply<A, B>(K<Db, Func<A, B>> mf, K<Db, A> ma) => 
        new Db<B>(mf.As().RunDb.Apply(ma.As().RunDb));

    public static K<Db, A> Fail<A>(Error error) => 
        new Db<A>(ReaderT.liftIO<DbEnv, IO, A>(error));

    public static K<Db, A> Catch<A>(K<Db, A> fa, Func<Error, bool> Predicate, Func<Error, K<Db, A>> Fail) =>
        from env in Readable.ask<Db, DbEnv>()
        from res in fa.As()
                      .RunDb
                      .runReader(env)
                      .Catch(Predicate, x => Fail(x).As().RunDb.runReader(env)) 
        select res;

    public static K<Db, A> Asks<A>(Func<DbEnv, A> f) => 
        new Db<A>(ReaderT.asks<IO, A, DbEnv>(f));

    public static K<Db, A> Local<A>(Func<DbEnv, DbEnv> f, K<Db, A> ma) => 
        new Db<A>(ReaderT.local(f, ma.As().RunDb));

    public static K<Db, A> LiftIO<A>(IO<A> ma) => 
        new Db<A>(ReaderT.liftIO<DbEnv, IO, A>(ma));

    public static K<Db, B> MapIO<A, B>(K<Db, A> ma, Func<IO<A>, IO<B>> f) => 
        new Db<B>(ma.As().RunDb.MapIO(f).As());

    public static K<Db, IO<A>> ToIO<A>(K<Db, A> ma) =>
        ma.MapIO(IO.pure);
}

Notice how Catch simply defers the catching behaviour to the inner IO monad (which is Fallible). All of the other trait implementations are simply wrappers around the ReaderT<DbEnv, IO> monad.

If you don't have an inner-monad to defer to, then you need something like this (pseudo-code) :

F<A> Catch(F<A> fa, Func<Error, bool> Predicate, Func<Error, F<A>> Fail) =>
    new F<A>(() =>
    {
        try
        {
            return fa.Run();
        }
        catch(Exception e)
        {
           if(Predicate(e)) return Fail(e).Run();
           return F.Fail(e);
        }
    }

Anyway, because we have an inner IO monad, we can leverage its Catch implementation instead. Once you have implemented Catch you can add the operators that make composition really easy:

    public static Db<A> operator |(Db<A> lhs, Db<A> rhs) =>
        lhs.Catch(rhs).As();

    public static Db<A> operator |(Db<A> lhs, Pure<A> rhs) =>
        lhs.Catch(Db.pure(rhs.Value)).As();

    public static Db<A> operator |(Db<A> lhs, Fail<Error> rhs) =>
        lhs.Catch(rhs).As();

    public static Db<A> operator |(Db<A> lhs, Error rhs) =>
        lhs.Catch(rhs).As();

    public static Db<A> operator |(Db<A> lhs, CatchM<Error, Db, A> rhs) =>
        lhs.Catch(rhs).As();

You can also do BiMap, MapFail, Match, etc.

    public Db<A> MapFail(Func<Error, Error> f) => 
        this.Catch(f).As();

    public Db<B> BiMap<B>(Func<A, B> Succ, Func<Error, Error> Fail) =>
        Map(Succ).Catch(Fail).As();

    public Db<B> Match<B>(Func<A, B> Succ, Func<Error, B> Fail) =>
        Map(Succ).Catch(Fail).As();

If you also implement Final<Db> then you can do Bracket:

    public Db<C> Bracket<B, C>(Func<A, Db<C>> Use, Func<Error, Db<C>> Catch, Func<A, Db<B>> Fin) =>
        Bind(x => Use(x).Catch(Catch).Finally(Fin(x)));

etc.

So, yeah, try to stick to having the core functionality in the trait-implementation and then leveraging all of the overloads provided by lang-ext to build your Db<A> type. Fallible is loaded with additional functionality that you can leverage.

[wujido]

I can understand how to implement trait and use it to build my own type. That wasn't what I was asking about from the begining. The issue I have is that my Db is esentialy combination of ReaderT and IO. But during implementation of Get and Update operation in the CRUD api I need to work with optional values or validation. My initial way of thinking was to create separate types for each of those scenarios. You then had an idea to use Fallible to represent optional or validation states. However, I don't understand how to utilize Errors to distinguish between the case where the computation should fast forward because the optional part is none and the case where the validation should accumulate errors. Also I was a bit confused about the intended syntax of raising errors inside the computation (null from EF to Error that I can catch using | operator), but that is the less important part of my question. Could you please show how to use the Db which is only Monad<Db>, Fallible<Db>, Readable<Db, DbEnv> in the scenarios where I need optional values and validation (and those two together)?

[louthy]

It's not entirely clear what you're asking and unfortunately I'm going to be away for the next four days, so I can get too deep into a reply here.

But, you could take a look at Eff<RT, A>. It is a wrapper around ReaderT<RT, IO, A> just like your Db<A> type. It's a little quirky in that Eff<RT> is the trait implementaton. Hopefully, all of the implementation details you need are there. You could just copy its behaviours.

However, I don't understand how to utilize Errors to distinguish between the case where the computation should fast forward because the optional part is none and the case where the validation should accumulate errors.

This is a little unclear. None when using the inner IO monad to carry the alternative value is Errors.None, which is just an empty ManyErrors type (derived from Error). Behaviour-wise, there is no difference between a None and an Error, they both shortcut in the same way. If you use applicative behaviour to collect multiple errors, then Errors.None will still be 'zero error values'. So, multiple Errors.None will accumulate zero error values.

Errors.None + Errors.None = Errors.None
Error       + Errors.None = Error
Errors.None + Error       = Error
Error       + Error       = ManyErrors[Error, Error]

[aloslider]

I understand what louthy says like this: you don't need to use custom OptDb<A> or OptValidDb<A> types, but instead you can use IO's capabilities and existing traits for fail/alt values (in your case, Fallible is enough). So, instead of using Db<Option<Product>> when trying to query an item, you may return a specific error and catch it on the caller's side; and instead of using `Db<Validation<Error, Option>> when trying to update an item, you may return just specific Errors errors indicating what went wrong. And yes, you can not only "fast-worward" (I guess you mean "short-circuit") the computation, but also accumulate errors.
By the way, your thoughts on making custom subtypes of db operations look like a free monad approach, so it may be useful to search for this topic in other discussions.

Here's a working example of how it could be done (BEWARE that I'm learning this library and FP as well 😄, so something may be overdone or misused):

using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using LanguageExt;
using LanguageExt.Common;
using LanguageExt.Traits;
using Microsoft.EntityFrameworkCore;
using static LanguageExt.Prelude;

AppDbContext dbCtx = new();
dbCtx.AddFakeData();
DbEnv env = new(dbCtx);

// Test printing
var listProducts =
    from ps in ProductRepository.list()
    from _  in Printer.printProducts(ps)
    select unit;
await listProducts.Run(env).RunAsync();

// Test when not found
var getProduct =
   (from p in ProductRepository.get(999) // use non existing id so it fails
    from _ in Printer.printProduct(p)
    select unit)
  | @catch(DbError.NotFound, err => Db.LiftIO(Printer.error(err))) // catch specific errors if you need to handle them in some custom way
  | @catch(err => Db.LiftIO(Printer.error(err))); // or catch any errors
await getProduct.Run(env).RunAsync();

// Test adding with invalid properties
var addInvalidProduct =
   (from _0 in ProductRepository.add(new Product() { Id = -1, Name = null! })
    from _1 in Db.Save()
    select unit)
   .MapFail(DbError.AddFailed)
 | @catch(err => Db.LiftIO(Printer.error(err))); // catch any errors
await addInvalidProduct.Run(env).RunAsync();

// Test adding with valid properties
var addValidProduct =
   (from _0 in ProductRepository.add(new Product() { Id = 6, Name = "My product" })
    from _1 in Db.Save()
    from _2 in Printer.info("Added successfully")
    select unit)
 | @catch(err => Db.LiftIO(Printer.error(err))); // catch any errors
await addValidProduct.Run(env).RunAsync();

// Modules
static class ProductRepository
{
    public static K<Db, List<Product>> list() =>
        from ctx in Db.Ctx<AppDbContext>()
        from ps  in liftIO(async () => await ctx.Products.ToListAsync())
        select ps;

    public static K<Db, Product> get(int id) => // no need to use Db<Option<Product>> to short-circuit on error
        from ctx in Db.Ctx<AppDbContext>()
        from p   in Db.LiftIO(ctx.Products.FindAsync(id))
        from _   in guard(notnull(p), DbError.NotFound) // check if product is not null; otherwise, provide the error and stop the computation
        select p;

    public static K<Db, Unit> add(Product product) => // no need to use Db<Validation<Product>> to harvest the errors
        from p      in Db.Lift(ProductValidation.validate(product))
        from ctx    in Db.Ctx<AppDbContext>()
        from addRes in Db.LiftIO(ctx.AddAsync(p))
        select unit;
}

static class DbError
{
    public enum Code
    {
        NotFound = 1,
        AddFailed = 2
    }

    public static readonly Error NotFound =
        Error.New((int)Code.NotFound, "Not found");

    public static Error AddFailed(Error e) =>
        Error.New((int)Code.AddFailed, $"Failed to add: {e.Message}");
}

static class ProductValidation
{
    public static Validation<Error, Product> validate(Product p) =>
        fun<Product, Product, Product>((_, _) => p)
            .Map(validateId(p))
            .Apply(validateName(p))
            .As();

    public static Validation<Error, Product> validateId(Product p) =>
        p.Id > 0
      ? Pure(p)
      : Fail(ProductValidationError.InvalidId);

    public static Validation<Error, Product> validateName(Product p) =>
        !string.IsNullOrEmpty(p.Name)
      ? Pure(p)
      : Fail(ProductValidationError.InvalidName);
}

static class ProductValidationError
{
    public enum Code
    {
        InvalidId = 10,
        InvalidName = 20
    }

    public static readonly Error InvalidId =
        Error.New((int)Code.InvalidId, "Id should be >0");

    public static readonly Error InvalidName =
        Error.New((int)Code.InvalidName, "Name should not be null or empty");
}

static class Printer
{
    public static IO<Unit> info(string msg) =>
        liftIO(() =>
        {
            Console.WriteLine(msg);
            return Task.FromResult(unit);
        });

    public static IO<Unit> error(Error e) =>
        liftIO(() =>
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(e.Message);
            Console.ForegroundColor = ConsoleColor.Gray;
            return Task.FromResult(unit);
        });

    public static IO<Unit> printProduct(Product product) =>
        liftIO(() =>
        {
            Console.WriteLine($"{product.Id}: {product.Name}"); // using built-in Console directly as I'm busy
            return Task.FromResult(unit);
        });

    public static IO<Unit> printProducts(List<Product> products) =>
        products.AsIterable().Traverse(printProduct).IgnoreF().As();
}

// Data access
class Product
{
    [Key]
    [DatabaseGenerated(DatabaseGeneratedOption.None)]
    public int Id { get; set; }
    public string Name { get; set; }
};

class AppDbContext : DbContext
{
    public DbSet<Product> Products { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseInMemoryDatabase("test");
    }
}

static class AppDbContextExtensions
{
    public static void AddFakeData(this AppDbContext dbCtx)
    {
        dbCtx.AddRange(Enumerable.Range(0, 5).Select(id => new Product()
        {
            Id = id,
            Name = $"Product #{id}"
        }));
        dbCtx.SaveChanges();
    }
}

// Db monad related
record DbEnv(AppDbContext DbContext);

record Db<A>(ReaderT<DbEnv, IO, A> RunDb) : K<Db, A>
{
    public Db<B> Select<B>(Func<A, B> m) => this.Kind().Select(m).As();

    public Db<C> SelectMany<B, C>(Func<A, K<Db, B>> b, Func<A, B, C> p) => 
        this.Kind().SelectMany(b, p).As();

    public Db<C> SelectMany<B, C>(Func<A, K<IO, B>> b, Func<A, B, C> p) => 
        this.Kind().SelectMany(b, p).As();

    public static Db<A> operator |(Db<A> ma, Db<A> mb) =>
        ma.Catch(mb).As();

    public static Db<A> operator |(Db<A> ma, CatchM<Error, Db, A> mb) =>
        ma.Catch(mb).As();

    public static Db<A> operator |(Db<A> ma, Pure<A> mb) =>
        ma.Catch(mb).As();

    public static Db<A> operator |(Db<A> ma, Error mb) =>
        ma.Catch(mb).As();
}

static class DbExtensions
{
    public static Db<A> As<A>(this K<Db, A> kind) => 
        (Db<A>)kind;

    public static K<ReaderT<DbEnv, IO>, A> Run<A>(this K<Db, A> db) => 
        db.As().RunDb;

    public static IO<A> Run<A>(this K<Db, A> db, DbEnv env) => 
        db.Run().Run(env).As();

    public static Db<A> MapFail<A>(this K<Db, A> db, Func<Error, Error> f) =>
        db.Catch(f).As();
}

abstract partial class Db : Monad<Db>, Readable<Db, DbEnv>, Fallible<Db>
{
    public static K<Db, B> Map<A, B>(Func<A, B> mapFunc, K<Db, A> db) => 
        new Db<B>(db.As().RunDb.Map(mapFunc).As());

    public static K<Db, A> Pure<A>(A value) => 
        new Db<A>(ReaderT<DbEnv, IO, A>.Pure(value));

    public static K<Db, B> Apply<A, B>(K<Db, Func<A, B>> applyFunc, K<Db, A> db) => 
        new Db<B>(applyFunc.As().RunDb.Apply(db.As().RunDb));

    public static K<Db, B> Bind<A, B>(K<Db, A> db, Func<A, K<Db, B>> bindFunc) => 
        new Db<B>(db.Run().Bind(x => bindFunc(x).Run()).As());

    public static K<Db, A> Asks<A>(Func<DbEnv, A> f) => 
        new Db<A>(ReaderT.asks<IO, A, DbEnv>(f));

    public static K<Db, A> Local<A>(Func<DbEnv, DbEnv> f, K<Db, A> db) => 
        new Db<A>(ReaderT.local(f, db.Run().As()));

    public static K<Db, A> Fail<A>(Error error) =>
        new Db<A>(ReaderT.liftIO<DbEnv, IO, A>(error));

    public static K<Db, A> Catch<A>(K<Db, A> fa, Func<Error, bool> Predicate, Func<Error, K<Db, A>> Fail) =>
        from env in Readable.ask<Db, DbEnv>()
        from res in fa.As()
                      .RunDb
                      .runReader(env)
                      .Catch(Predicate, x => Fail(x).As().RunDb.runReader(env))
        select res;

    // WARNING: personally I'm very not sure about some of the ways of lifting below
    public static K<Db, A> Lift<A>(Validation<Error, A> ma) =>
        new Db<A>(
            ReaderT<DbEnv, IO, A>.Lift(
                ma.Match(
                    Succ: IO.pure,
                    Fail: IO.fail<A>)));

    public static K<Db, A> LiftIO<A>(ValueTask<A> f) =>
        new Db<A>(
            ReaderT.liftIO<DbEnv, IO, A>(
                IO.liftAsync(async envIO => await f.ConfigureAwait(false))));

    public static K<Db, A> LiftIO<A>(Task<A> f) =>
        new Db<A>(
            ReaderT.liftIO<DbEnv, IO, A>(
                IO.liftAsync(async envIO => await f.ConfigureAwait(false))));

    public static K<Db, A> LiftIO<A>(IO<A> ma) =>
        new Db<A>(
            ReaderT.liftIO<DbEnv, IO, A>(ma));

    public static K<Db, A> Lift<A>(Option<A> ma) =>
        new Db<A>(
            ReaderT.liftIO<DbEnv, IO, A>(IO.lift(ma.ToFin())));
}

abstract partial class Db
{
    public static Db<DbEnv> Ask() => 
        Readable.ask<Db, DbEnv>().As();

    public static Db<Context> Ctx<Context>() where Context : DbContext =>
        Ask().Select(env => (env.DbContext as Context)!);

    public static Db<Unit> Save() =>
        from env in Ask()
        from _     in liftIO(() => env.DbContext.SaveChangesAsync())
        select unit;
}

And the output:

0: Product #0
1: Product #1
2: Product #2
3: Product #3
4: Product #4
Not found
Failed to add: [Id should be >0, Name should not be null or empty]
Added successfully

[wujido]

Thanks a lot for this complete example. Now I have been able to finish my code in a way that is pure, I can understand and is not complete syntax hell!
The main part I did not realize is that I can work with Validation<Error, Product> without knowing anything about the Db and then just lift it to Db in a way that does exactly what I was aiming for. Regardles of your warning this is the crucial part:

    public static K<Db, A> Lift<A>(Validation<Error, A> ma) =>
        new Db<A>(
            ReaderT<DbEnv, IO, A>.Lift(
                ma.Match(
                    Succ: IO.pure,
                    Fail: IO.fail<A>)));

[louthy]

That's completely valid. In category-theory, which this is all derived from, that's known as a 'Natural Transformation'.

Working in a more limited type (Validation), when all you need are those capabilities, is to be encouraged. Your code is more declarative that way.

The only concern is the amount of boilerplate if you're switching contexts often. So, sometimes it's better to lift the simpler functions into the more complex space.

There's a trait called Natural, which you can use to formalise the conversion methods between higher-kinded types.