Examples of State monad usage?

[rhemsuda]

I have the following code:

public class DocumentRegistryService
{
    ...
    private readonly DocumentRegistry _documentRegistry;

    public DocumentRegistryService(IServiceProvider serviceProvider)
    {
        _documentRepository = new DocumentRepository();
        _documentLocatorRepository = new DocumentLocatorRepository();
        _dbContext = new Lazy<DocumentDbContext>(
            () => serviceProvider.CreateScope().ServiceProvider.GetRequiredService<DocumentDbContext>()
        );

        var documentLocators = _documentLocatorRepository.GetAllDocumentLocatorsAsync(_dbContext.Value).Run().Match(
            Succ: locators => locators,
            Fail: ex => throw new Exception("Failed to retrieve document locators", ex)
        );

        var currentDocuments = _documentRepository.GetAllDocumentsAsync(_dbContext.Value).Run().Match(
            Succ: documents => documents,
            Fail: ex => throw new Exception("Failed to retrieve documents", ex)
        );

        _documentRegistry = DocumentRegistry.Create(documentLocators, 
            currentDocuments.Fold(Map<DateOnly, Seq<Document>>(), 
                (map, document) => map.AddOrUpdate(
                    document.FileDetails.CreatedAt, 
                    map.Find(document.FileDetails.CreatedAt).Match(
                        seq => seq.Add(document),
                        () => Seq(document)
                    )
                )    
            )
        ).Match(
            Right: documentRegistry => documentRegistry,
            Left: err => throw new Exception("Failed to create document registry", err)
        );
    }
    ...

and I want to be able to update the registry any time a new registry is created by registering a new document.

 public Either<Error, Unit> HandleIncomingFileRequest(byte[] fileData, FileDetails fileDetails) => 
        _documentRegistry.RegisterDocument(fileData, fileDetails)            
            .Match(
                Left: Left<Error, Unit>,
                Right: res =>
                    _documentRepository.AddDocumentAsync(_dbContext.Value, res.Item1) 
                    .Run().Match(
                        Fail: err => Left<Error, Unit>(err),
                        Succ: _ => StoreFileDataInBlobStorage(res.Item1)
                    )
            );

Right now, I am just returning a Unit from this function and the actual _documentRegistry is not being updated.

I want to do somehting like this:

public Either<Error, Unit> HandleIncomingFileRequest(byte[] fileData, FileDetails fileDetails) => 
        _documentRegistry = _documentRegistry.RegisterDocument(fileData, fileDetails)         
...

I feel that I am doing something incorrectly when it comes to managing the state in my application. At some point we need to hold onto some state, and particularly in the service layer of my asp.net application is where I need to actually start loading information from the database and dealing with incoming requests.

Until this point it has made sense to use FP, but I'm finding myself being forced more and more into using imperative design in order to hold onto state and manage state changes, and so I think I am doing something wrong.

I'm wondering if I need to be using State and Func monads more effectively? For some reason in C# this just isn't clicking. Maybe because in Haskell all libraries are made to work like this and so I realistically haven't put too much thought into this stuff..

Do you have any suggestions or examples of how I should go about this? I'm at the application layer of my system now and that is when it all falls apart. The libraries are pure and functional, but I can't seem to figure this part out. in terms of integrating with the service layer of ASP.Net. I am using Dependency Injection to create this service and so I need to hold onto some State of the application at this layer, but I'm struggling figuring out how the State monad is initialized and updated, and GPT just keeps hallucinating 🫠

Appreciate any help you or the community can provide.

Thanks,
Kyle

[louthy]

You don't seem to be following much of the advice I've given so far? The previous response about packaging up the subsystems with bespoke monadic types is really the way to go. It looks like you're mixing:

• Either - which is a very low feature monad, it has only an alternative value
• IO (I think) - it looks like you're calling Run inline, which is definitely not a good idea if you want pure code. It injects all of the side-effects at the point of invocation.
• Using stateful (non-static) classes which you're reading from in an impure way.
• Dependency Injection frameworks. Which are pure evil.

This approach is not gaining you anything. The code is neither declarative nor is it easy to write. I may well have misunderstood your code, which if that's the case, I apologise, that's just my inference from what I see above.

I haven't use ASP.NET Core in anger yet, so maybe I'm missing something here. But anything that involves magic-DI is bad IMHO. Try to separate your FP code from anything to do with ASP.NET, simply package up the data needed into state that can be passed to the pure functions.

The Game monad in the CardGame sample uses a StateT > OptionT > IO transformer-stack, so that could be useful as a guide. The module shows the basic interactions with the underlying state (GameState). And the main game logic shows how elegant C# can look, if you just put a bit of effort into the domain monads.

Really, you should take the exact same approach as you would in Haskell:

• Create a set of monadic types for the sub-domains in your application.
• Use static functions everywhere
• No instance classes for anything other than data

Taking the approach of mixing and matching is going to create the Match and Run hell you appear to be in.

In terms of dependency-injection. There are a number of approaches, but the most purely-functional would be using the Reader monad or the ReaderT monad-transformer. It takes an environment value and threads it through your code. That environment can contain pure data or it could contain injected interfaces and Func values that give you access to injected functionality.

If you need DI and state, then you could use the RWST monad-transformer (same as Haskell).

If we first create some data-types to hold the environment and state:

public record AppEnv;
public record AppState(DocumentState Document);
public record DocumentState(Option<DocumentDbContext> Context);

And then create an App monad that lifts RWST, EitherT, and M (it's a transformer):

public record App<M, A>(RWST<AppEnv, Unit, AppState, EitherT<Error, M>, A> runApp) : K<App<M>, A>
    where M : Monad<M>
{
    // Methods below copied from previous response and their type names changed...
    
    public static App<M, A> Pure(A value) => App<M>.Pure(value).As();
    public static App<M, A> Fail(Error value) => App.lift<M, A>(Left(value)).As();
    public static App<M, A> LiftIO(IO<A> ma) => App.liftIO<M, A>(ma).As();
        
    public App<M, B> Map<B>(Func<A, B> f) => this.Kind().Map(f).As();
    public App<M, B> Select<B>(Func<A, B> f) => this.Kind().Map(f).As();
    public App<M, A> MapFail(Func<Error, Error> f) => this.Kind().Catch(f).As();
    public App<M, B> Bind<B>(Func<A, K<App<M>, B>> f) => this.Kind().Bind(f).As();
    public App<M, B> Bind<B>(Func<A, K<IO, B>> f) => this.Kind().Bind(f).As();
    public App<M, C> SelectMany<B, C>(Func<A, K<App<M>, B>> b, Func<A, B, C> p) => this.Kind().SelectMany(b, p).As();
    public App<M, C> SelectMany<B, C>(Func<A, K<IO, B>> b, Func<A, B, C> p) => this.Kind().SelectMany(b, p).As();

    public static implicit operator App<M, A>(Pure<A> pure) => Pure(pure.Value);
    public static implicit operator App<M, A>(Error fail) => Fail(fail);
    public static implicit operator App<M, A>(Fail<Error> fail) => Fail(fail.Value);
    public static App<M, A> operator |(App<M, A> ma, K<App<M>, A> mb) => ma.Choose(mb).As();
    public static App<M, A> operator |(App<M, A> ma, Error mb) => ma.Choose(Fail(mb)).As();
    public static App<M, A> operator |(App<M, A> ma, CatchM<Error, App<M>, A> mb) => ma.Catch(mb).As();
    public static App<M, A> operator >> (App<M, A> ma, K<App<M>, A> mb) => ma.Bind(_ => mb);
    public static App<M, A> operator >> (App<M, A> ma, K<IO, A> mb) => ma.Bind(_ => mb);
    public static App<M, Unit> operator >> (App<M, A> ma, K<App<M>, Unit> mb) => ma.Bind(_ => mb);
    public static App<M, Unit> operator >> (App<M, A> ma, K<IO, Unit> mb) => ma.Bind(_ => mb);
}

And then implement its traits:

public class App<M> : 
    MonadT<App<M>, M>,          // Monad transformer 
    Choice<App<M>>,             // Allows for failure coalescing
    Fallible<App<M>>,           // Allows for failure catching and mapping
    Readable<App<M>, AppEnv>,   // Enables access to the DI environment
    Stateful<App<M>, AppState>  // Enables a stateful value to be put and set 
    where M : Monad<M>          // M allows us to lift any monad into the `App` transformer
{
    public static K<App<M>, B> Bind<A, B>(K<App<M>, A> ma, Func<A, K<App<M>, B>> f) =>
        new App<M, B>(ma.As().runApp.Bind(x => f(x).As().runApp));

    public static K<App<M>, B> Map<A, B>(Func<A, B> f, K<App<M>, A> ma) => 
        new App<M, B>(ma.As().runApp.Map(f));

    public static K<App<M>, A> Pure<A>(A value) =>
        new App<M, A>(RWST<AppEnv, Unit, AppState, EitherT<Error, M>, A>.Pure(value));

    public static K<App<M>, B> Apply<A, B>(K<App<M>, Func<A, B>> mf, K<App<M>, A> ma) =>
        new App<M, B>(mf.As().runApp.Apply(ma.As().runApp));

    public static K<App<M>, A> Lift<A>(K<M, A> ma) =>
        new App<M, A>(RWST<AppEnv, Unit, AppState, EitherT<Error, M>, A>.Lift(EitherT<Error, M, A>.Lift(ma)));

    public static K<App<M>, Unit> Put(AppState value) =>
        new App<M, Unit>(RWST<AppEnv, Unit, AppState, EitherT<Error, M>, Unit>.Put(value));

    public static K<App<M>, Unit> Modify(Func<AppState, AppState> modify) => 
        new App<M, Unit>(RWST<AppEnv, Unit, AppState, EitherT<Error, M>, Unit>.Modify(modify));

    public static K<App<M>, A> Gets<A>(Func<AppState, A> f) => 
        new App<M, A>(RWST<AppEnv, Unit, AppState, EitherT<Error, M>, A>.Gets(f));

    public static K<App<M>, A> Asks<A>(Func<AppEnv, A> f) => 
        new App<M, A>(RWST<AppEnv, Unit, AppState, EitherT<Error, M>, A>.Asks(f));

    public static K<App<M>, A> Local<A>(Func<AppEnv, AppEnv> f, K<App<M>, A> ma) => 
        new App<M, A>(ma.As().runApp.Local(f));

    public static K<App<M>, A> LiftIO<A>(K<IO, A> ma) => 
        new App<M, A>(RWST<AppEnv, Unit, AppState, EitherT<Error, M>, A>.LiftIO(ma));

    public static K<App<M>, A> Fail<A>(Error error) => 
        new App<M, A>(RWST<AppEnv, Unit, AppState, EitherT<Error, M>, A>.Lift(EitherT<Error, M, A>.Lift(error)));

    public static K<App<M>, A> Catch<A>(K<App<M>, A> fa, Func<Error, bool> Predicate, Func<Error, K<App<M>, A>> Fail) =>
        new App<M, A>(
            new RWST<AppEnv, Unit, AppState, EitherT<Error, M>, A>(
                inp =>
                    fa.As()
                      .runApp
                      .Run(inp.Env, inp.Output, inp.State)
                      .Catch(Predicate, e => Fail(e).As().runApp.Run(inp.Env, inp.Output, inp.State))));

    public static K<App<M>, A> Choose<A>(K<App<M>, A> fa, K<App<M>, A> fb) =>
        fa.Catch(fb);
}

And create some static functions for interacting:

public static class App
{
    public static App<M, A> As<M, A>(this K<App<M>, A> ma) 
        where M : Monad<M> =>
        (App<M, A>)ma;

    public static App<M, A> lift<M, A>(K<M, A> ma)
        where M : Monad<M> =>
        new (RWST<AppEnv, Unit, AppState, EitherT<Error, M>, A>.Lift(EitherT<Error, M, A>.Lift(ma)));        

    public static App<M, A> lift<M, A>(EitherT<Error, M, A> ma)
        where M : Monad<M> =>
        new (RWST<AppEnv, Unit, AppState, EitherT<Error, M>, A>.Lift(ma));

    public static App<M, A> lift<M, A>(Either<Error, A> ma)
        where M : Monad<M> =>
        lift(EitherT<Error, M, A>.Lift(ma));

    public static App<M, A> liftIO<M, A>(IO<A> ma)
        where M : Monad<M> =>
        new (RWST<AppEnv, Unit, AppState, EitherT<Error, M>, A>.LiftIO(ma));
    
    public static App<M, AppEnv> getEnv<M>()
        where M : Monad<M> =>
        Readable.ask<App<M>, AppEnv>().As();
    
    public static App<M, AppState> getState<M>()
        where M : Monad<M> =>
        Stateful.get<App<M>, AppState>().As();
    
    public static App<M, Unit> putDocumentState<M>(DocumentState state)
        where M : Monad<M> =>
        Stateful.modify<App<M>, AppState>(app => app with { Document = state }).As();
    
    public static App<M, Unit> modifyDocumentState<M>(Func<DocumentState, DocumentState> f)
        where M : Monad<M> =>
        Stateful.modify<App<M>, AppState>(app => app with { Document = f(app.Document) }).As();

    public static App<M, DocumentState> getDocumentState<M>()
        where M : Monad<M> =>
        Stateful.gets<App<M>, AppState, DocumentState>(app => app.Document).As();

    public static App<M, DocumentDbContext> documentDbContext<M>()
        where M : Monad<M> =>
        getDocumentState<M>()
           .Bind(d => lift<M, DocumentDbContext>(d.Context.ToEither(Error.New("DbContext not set")))).As();

    public static App<M, Unit> putDbContext<M>(DocumentDbContext ctx)
        where M : Monad<M> =>
        modifyDocumentState<M>(s => s with { Context = ctx });

    public static App<M, Unit> clearDbContext<M>()
        where M : Monad<M> =>
        modifyDocumentState<M>(s => s with { Context = None });

    public static App<M, A> withDbContext<M, A>(DocumentDbContext ctx, App<M, A> ma)
        where M : Monad<M> =>
        from _ in putDbContext<M>(ctx)
        from r in ma
        from x in clearDbContext<M>()
        select r;
}

Then I'm able to make your HandleIncomingFileRequest look like this:

public static App<IO, Unit> HandleIncomingFileRequest(byte[] fileData, FileDetails fileDetails) =>
    from res in DocumentRegistry.RegisterDocument(fileData, fileDetails)
    from ctx in App.documentDbContext<IO>()
    from _1  in DocumentRepository.AddDocumentAsync(ctx, res)
    from _2  in StoreFileDataInBlobStorage(res)
    select unit;

You can see I've lifted the IO monad into the App transformer (App<IO, A>). If you want to use it without a lifted effect, you can use App<Identity, A>

If you're a masochist you can avoid the above approach and use the wrapped type directly:

RWST<AppEnv, Unit, AppState, EitherT<Error, M>, A>

But it's a a lot of typing for every function that uses it and doesn't play well with refactoring!

If you have a single App monad, you can embed any DI into the AppEnv type; if you need state then you can have optional values that are turned on and off. You can also map your App monad to sub-systems; so if you want to go from App to Database, or App to Blob, then you need to write a natural-transformation that maps the two. You want your App monad to have more capability than the sub-systems, otherwise you can't map it without cheating.

Embedding AppEnv and AppState into a new monad like this isn't the only way of achieving this. You could take two additional parameters to every method and return a tuple (AppState, A) as the result. But, that's effort and the reason why the bespoke monads are better, even if it's some upfront typing.

[rhemsuda]

I do appreciate the constructive criticism here. And I do understand that the code I’ve written is far less than functional. I believe it’s because I’ve been trying to work it into the C# code that I’ve written before and the lines haven’t been clearly drawn for me. It looks like I may need to rewrite a lot of the code that I have as well as take a different approach with the ASP.Net and EF code.

I may have just misunderstood your previous messages and I do apologize for making you repeat yourself. I’ll take a step back and rewrite a lot of this code given your suggestions.

Thank you

[rhemsuda]

As for your previous response I just hadn't gotten around to implemneting those changes yet and now I'm seeing how related everything is. Thanks for the help you've given me so far. A rewrite is in order. I'll take a look at some of your samples to base my codebase off of as now I have a bit more experience with this library

[rhemsuda]

@louthy I've implemented a Database monad and added a generic context to it for the DbContext because I intend on having multiple contexts in various projects and was hoping to be able to define the monad once and mostly leverage type inferencing for the specific DbContext of the application I'm writing, but it seems that I've done this for little reason as the inference engine on C# makes this rather cumbersome. I'm wondering if you have any suggestions, whether I should just say screw it to this layer of abstraction or if there is something I'm missing that I can leverage to make this less "explicitly-typed".

For example I have the monad:

public record Database<A, CTX>(ReaderT<DbEnv<CTX>, IO, A> runDb) : K<Database<CTX>, A> where CTX : DbContext
{
    public static Database<A, CTX> Pure(A value) => new (ReaderT<DbEnv<CTX>, IO, A>.Pure(value));
    public static Database<A, CTX> Fail(Error value) => new (ReaderT<DbEnv<CTX>, IO, A>.LiftIO(IO.fail<A>(value)));
    public static Database<A, CTX> LiftIO(Func<A> f) => new (ReaderT<DbEnv<CTX>, IO, A>.LiftIO(IO.lift(f)));
    public static Database<A, CTX> LiftIO(Func<Task<A>> f) => new (ReaderT<DbEnv<CTX>, IO, A>.LiftIO(IO.liftAsync(f)));

    public Database<B, CTX> Map<B>(Func<A, B> f) => this.Kind().Map(f).As();
    public Database<B, CTX> Select<B>(Func<A, B> f) => this.Kind().Map(f).As();
    public Database<A, CTX> MapFail(Func<Error, Error> f) => this.Kind().Catch(f).As();
    public Database<B, CTX> Bind<B>(Func<A, K<Database<CTX>, B>> f) => this.Kind().Bind(f).As();
    public Database<B, CTX> Bind<B>(Func<A, K<IO, B>> f) => this.Kind().Bind(f).As();
    public Database<C, CTX> SelectMany<B, C>(Func<A, K<Database<CTX>, B>> b, Func<A, B, C> p) => this.Kind().SelectMany(b, p).As();
    public Database<C, CTX> SelectMany<B, C>(Func<A, K<IO, B>> b, Func<A, B, C> p) => this.Kind().SelectMany(b, p).As();
    public Database<C, CTX> SelectMany<C>(Func<A, Guard<Error, Unit>> b, Func<A, Unit, C> p) => SelectMany(a => Database.lift<CTX>(b(a)), p);

    public static implicit operator Database<A, CTX>(Pure<A> pure) => Pure(pure.Value);
    public static implicit operator Database<A, CTX>(Error fail) => Fail(fail);
    public static implicit operator Database<A, CTX>(Fail<Error> fail) => Fail(fail.Value);
    public static Database<A, CTX> operator |(Database<A, CTX> ma, K<Database<CTX>, A> mb) => ma.Choose(mb).As();
    public static Database<A, CTX> operator |(Database<A, CTX> ma, Error mb) => ma.Choose(Fail(mb)).As();
    public static Database<A, CTX> operator |(Database<A, CTX> ma, CatchM<Error, Database<CTX>, A> mb) => ma.Catch(mb).As();
    public static Database<A, CTX> operator >> (Database<A, CTX> ma, K<Database<CTX>, A> mb) => ma.Bind(_ => mb);
    public static Database<A, CTX> operator >> (Database<A, CTX> ma, K<IO, A> mb) => ma.Bind(_ => mb);
    public static Database<Unit, CTX> operator >> (Database<A, CTX> ma, K<Database<CTX>, Unit> mb) => ma.Bind(_ => mb);
    public static Database<Unit, CTX> operator >> (Database<A, CTX> ma, K<IO, Unit> mb) => ma.Bind(_ => mb);
}

Where I then explicitly implement CTX in the App monad:

public static App<M, A> lift<M, A>(Database<A, DocumentDbContext> db)
        where M : Monad<M>, MonadIO<M> =>
        from env in getEnv<M>()
        from result in lift(
            EitherT<Error, M, A>.LiftIO(db.Run(env.DbEnv))
        )
        select result;

But then I get into issues like this in my DocumentRepository, where I have to explicitly type everything:

public static class DocumentRepository
{
    public static Database<List<Document>, DocumentDbContext> GetAllDocuments() =>
        from env in Database.env<DocumentDbContext>()
        from documents in Database.liftIO<List<Document>, DocumentDbContext>(() =>
            env.Context.Documents
                .Map(e => e.ToDomain())
                .ToList())
        select documents;    
}

particularly in the usage of liftIO. I've tried creating a type alias for Document<A, DocumentDbContext> but no such feature seems to exist in CSharp, which has be in this explicitly-typed version of hell that I'm in at the moment.

Do you have any suggestions for me? Am I a lunatic for trying to make the implementation of Database more generic than it needs to be? Should I just have a Database monad in each of my projects and use good-old copy-paste? Or am I missing some key feature of C# that will make this possible?

[kirill-gerasimenko-da]

Have you considered the option where you don't have to specify DB context specific type? You could be just using base DbContext and use .Set<Model>() method on it when you need to get down to the db set. Of course it's dynamic vs static, but might be less typing of explicit db context declaration.

[louthy]

A couple of thoughts. First (if you decide to keep the exposed context), it's idiomatic to switch your type-parameters from Database<A, CTX> to Database<CTX, A>. The general guidance is: the type that represents the value that changes the least comes first, the type that represents the value that changes the most comes last. It really threw me off when I read your code. Obviously, it doesn't really matter, but it's consistent with the other types in this library at least.

Secondly, my advice is to hide the context-type anyway. The Database monad will be responsible for everything database related. It is not itself a public-state-management-monad. The state or config value(s) it carries should all be database related. So, a really good way to do this is to create a discriminated-union of possible states it can be in. Then you can do pattern-matching within the Database module functions and never need to expose the state.

This also has benefits for future refactoring. Any manual state-type management will get carried through the code-base. This then becomes a headache if you decide to change it. Whereas encapsulation of the state will be trivial to refactor.

public abstract record DbContext
{
    public sealed record Disconnected(DbConfig Config) : DbContext;
    public sealed record Connected(DbConfig Config, DbConnection Connection) : DbContext;
   // etc...
}

This approach makes it much easier to hide the messy implementation details and create a knowable internal state-machine. You can validate that you are connected before doing any DB action, you could carry security credentials and do forced pre-authentication, and lots of other lovely things if you know what the state is.

[aloslider]

Some strange code I see for a "haskeller": everything is mostly imperative instead of computations 😄
Just in case: are you aware of monadic binding using LINQ (as Haskell's "do notation")? Because I've looked at all your previous discussions and suprisingly haven't find any code using it. For example, you could've write your function like this:

public Either<Error, Unit> HandleIncomingFileRequest(byte[] fileData, FileDetails fileDetails) => 
       from res1 in _documentRegistry.RegisterDocument(fileData, fileDetails)
       from res2 in _documentRepository.AddDocumentAsync(_dbContext.Value, res1.Item1) // I know it probably returns something like `IO<Unit>`, but I'll pretend it returns `Either<Error, Unit>` for simplicity
       from _2 in  StoreFileDataInBlobStorage(res2.Item1)
       select unit;

[rhemsuda]

I do have code that is using the LINQ from..in syntax yeah, admittedly I’ve just gotten lazy and for some reason it’s making sense in Haskell but not in C#.. idk why my brain just isn’t comprehending it and I sometimes can get things to compile better by just explicitly binding things together. My plan was to clean up the code afterwards, but now I've gotten into an explicitly typed version of hell. Admittedly I’m still quite new to Haskell as well. Really only been doing it for a year, so it's really testing my knowledge of how Haskell ACTUALLY works. I didn’t mean to give the impression that I was
professional with this sort of thing. Apologies if I did 😅

[aloslider]

Oh, I thought you are experienced with FP in Haskell but just struggling with C# specifically :)

I don't know whether you checked other discussions, but in many of them (especially labeled as "example/documentation") Paul offers a lot of examples with detailed commentaries and thoughts on hows and whys (this one for example). I also suggest you to read language-ext wiki pages if you haven't done it yet: even though they were written for v4, the concepts are the same and still relevant for v5.

[rhemsuda]

I would say I’m mediocre at Haskell 😅 I understand a lot of this but I’ve never written my own monads or really worked with a lot of the primitive types in Haskell, mostly been inside the box of Reflex-FRP and Obelisk framework and used a lot of these concepts but never had to really understand them fully. Working with LanguageExt has been a really great experience at challenging my understanding of FP in general, as it’s forcing me to understand these concepts. Continue to roast the hell out of me cuz it’s just making me a better functional programmer 🤘🏼

I appreciate those links I’ll dive into them tonight.

Cheers,
Kyle