How can I avoid mapping duplication

[illunix]

Problem

Currently, in the logic for retrieving or creating a ConversationThread, I call the mapper twice to map the entity to CreatedConversationThreadDto:

return FinSucc(mapper.MapConversationThreadToCreatedConversationThreadDto(q));
...
return FinSucc(mapper.MapConversationThreadToCreatedConversationThreadDto(q));

Can I somehow use some method and map it at the end? Any other suggestions to my code would be great because it's my first time using this lib

    public static Either<Error, ConversationThread> Create(
        Guid itemId,
        Guid sellerUserId,
        Guid buyerUserId
    )
    {
        if (sellerUserId == buyerUserId)
            return Left(Error.New("Cannot start conversation with self."));

        return Right(new ConversationThread
        {
            ItemId = itemId,
            SellerUserId = sellerUserId,
            BuyerUserId = buyerUserId
        });
    }

 return await Optional(await ctx.Threads
     .AsNoTracking()
     .FirstOrDefaultAsync(q =>
         q.ItemId == cmd.ConversationThread.ItemId &&
         q.BuyerUserId == cmd.ConversationThread.BuyerUserId,
         ct
     )
 )
 .MatchAsync(
     Some: q =>
     {
         logger.LogInformation(
             "Retrieving existing conversation thread with ID: {ThreadId}",
             q.Id
         );

         return FinSucc(mapper.MapConversationThreadToCreatedConversationThreadDto(q));
     },
     None: async () =>
     {
         logger.LogInformation(
             "Creating new conversation thread for item with ID: {ItemId} seller with ID: {SellerUserId} and buyer with ID: {BuyerUserId}",
             cmd.ConversationThread.ItemId,
             sellerUserId,
             cmd.ConversationThread.BuyerUserId
         );

         return await ConversationThread
             .Create(
                 cmd.ConversationThread.ItemId,
                 sellerUserId,
                 cmd.ConversationThread.BuyerUserId
             )
             .MatchAsync(
                 RightAsync: async q =>
                 {
                     ctx.Add(q);
                     await ctx.SaveChangesAsync(ct);
                     return FinSucc(mapper.MapConversationThreadToCreatedConversationThreadDto(q));
                 },
                 Left: err => FinFail<CreatedConversationThreadDto>(err)
             );
     }
 );

[aloslider]

I may be misunderstanding something, but you are not calling logging twice, but rather calling it once for each branch, as the message is different. So there's nothing bad in it. Could you elaborate more?
Also, there's a v5 version of the library (thought it's currently packaged as pre-release, its has already a stable api for almost all of its parts), so I'd suggest you to update it or at least check it out.

[aloslider]

But your code doesn't have it called twice

[illunix]

Yes I'm calling it in Some and None in FinSucc

[aloslider]

But its not technically twice, as only one branch gets executed at one time.

[illunix]

But is it possible to move this mapping after the match and just return from Some and None not mapped conversation thread

[harrhp]

Just remove call to mapper from Match? Something like this

return await Optional(await ctx.Threads
     .AsNoTracking()
     .FirstOrDefaultAsync(q =>
         q.ItemId == cmd.ConversationThread.ItemId &&
         q.BuyerUserId == cmd.ConversationThread.BuyerUserId,
         ct
     )
 )
 .MatchAsync(
     Some: q =>
     {
         logger.LogInformation(
             "Retrieving existing conversation thread with ID: {ThreadId}",
             q.Id
         );

         return FinSucc(q);
     },
     None: async () =>
     {
         logger.LogInformation(
             "Creating new conversation thread for item with ID: {ItemId} seller with ID: {SellerUserId} and buyer with ID: {BuyerUserId}",
             cmd.ConversationThread.ItemId,
             sellerUserId,
             cmd.ConversationThread.BuyerUserId
         );

         return await ConversationThread
             .Create(
                 cmd.ConversationThread.ItemId,
                 sellerUserId,
                 cmd.ConversationThread.BuyerUserId
             )
             .MatchAsync(
                 RightAsync: async q =>
                 {
                     ctx.Add(q);
                     await ctx.SaveChangesAsync(ct);
                     return FinSucc(q);
                 },
                 Left: err => FinFail<ConversationThread>(err)
             );
     }
 ).Map(q => mapper.MapConversationThreadToCreatedConversationThreadDto(q));

[aloslider]

I don't see any better solutions using the same code you've provided, it's already correct in terms of logic. I would rather change more than moving one mapping method outside of match branches.

Since you are using v4, it has some "limitations" in the context of using different monads in the same context. For example, your calling method is using Option, then matches it and returns a Fin, and it internally calls Create that returns another monad Either, and also some of its parts using async code.
So, if you really have to use them all at once, then you would need to do a "plumbing" (as louthy calls it) and write custom methods for these monad stacks (you can learn it more here). But I think all of it can be done with a one Eff/Aff monads, since it supports running side-effects and error handling:

static class Errors
{
    public enum Code
    {
        FailedToGetThreadError
    }

    public static readonly Error FailedToGetThreadError = Error.New((int)Code.FailedToGetThreadError, "FailedToGetThreadError");
}

class Repository(ILogger logger, DbCtx ctx, IMapper mapper)
{
    public Aff<CreatedConversationThreadDto> CreateConversationThread(Cmd cmd, Guid sellerUserId, CancellationToken ct) =>
       (from thread  in GetThread(cmd, sellerUserId, ct)
        from created in MapConversationThreadToCreatedConversationThreadDto(thread)
        from _ in Eff(() => 
        { 
            logger.LogInformation("Retrieving existing conversation thread with ID: {ThreadId}", thread.Id); 
            return unit; 
        })
        select default(CreatedConversationThreadDto))
      | @catch((int)Errors.Code.FailedToGetThreadError, _ => CreateNewThread(cmd, sellerUserId, ct));

    Aff<ConversationThread> GetThread(Cmd cmd, Guid sellerUserId, CancellationToken ct) =>
        OptionalAsync(
            ctx.Threads
                .AsNoTracking()
                .FirstOrDefaultAsync(q =>
                    q.ItemId == cmd.ConversationThread.ItemId &&
                    q.BuyerUserId == cmd.ConversationThread.BuyerUserId,
                    ct)).ToAff();

    Aff<CreatedConversationThreadDto> CreateNewThread(Cmd cmd, Guid sellerUserId, CancellationToken ct) =>
        from thread  in ConversationThread.Create(cmd.ConversationThread.ItemId, sellerUserId, cmd.ConversationThread.BuyerUserId)
        from created in MapConversationThreadToCreatedConversationThreadDto(thread)
        from _ in Eff(() =>
        {
            logger.LogInformation("Creating new conversation thread for item with ID: {ItemId} seller with ID: {SellerUserId} and buyer with ID: {BuyerUserId}",
                cmd.ConversationThread.ItemId,
                sellerUserId, 
                cmd.ConversationThread.BuyerUserId);
            return unit;
        })
        select default(CreatedConversationThreadDto);

    Eff<CreatedConversationThreadDto> MapConversationThreadToCreatedConversationThreadDto(ConversationThread thread) =>
        Eff(() => mapper.MapConversationThreadToCreatedConversationThreadDto(thread));
}

[illunix]

This piece of code is weird I will stick with that @harrhp wrote

[aloslider]

It's ok since you've said its your first time using this library. But I recommend to learn the wiki and discussions labeled as "example / documentation", because integrating this library only for simple structures like Either, Fin, Option e.t.c doesn't reach its full potential

[illunix]

I only want to use result and option monads in my code

[illunix]

After update to 5.0.0-beta-54 Option and Either does not have MatchAsync so how can I replace it? @aloslider

[aloslider]

Take a look at this and this

[louthy]

Also take a look at the FAQ

[illunix]

What do you guys think about this? Is there anything that I can improve? And Why liftAsync, pure and fail are written not in camel case? Also how the performance of something like this look comparsion to impterative code?

return await liftAsync(async () => await marketplaceApi.GetSellerUserIdAsync(
    cmd.ConversationThread.ItemId,
    ct
))
    .Bind(sellerUserId => liftAsync(async () => Optional(await ctx.Threads
        .AsNoTracking()
        .FirstOrDefaultAsync(q =>
            q.ItemId == cmd.ConversationThread.ItemId &&
            q.BuyerUserId == cmd.ConversationThread.BuyerUserId,
            ct
        )
    ))
    .Bind(q => q.Match(
        Some: thread =>
        {
            logger.LogInformation(
                "Retrieving existing conversation thread with ID: {ThreadId}",
                thread.Id
            );
            return pure(thread);
        },
        None: () =>
        {
            logger.LogInformation(
                "Creating new conversation thread for item with ID: {ItemId} seller with ID: {SellerUserId} and buyer with ID: {BuyerUserId}",
                cmd.ConversationThread.ItemId,
                sellerUserId,
                cmd.ConversationThread.BuyerUserId
            );
            return ConversationThread
                .Create(
                    cmd.ConversationThread.ItemId,
                    sellerUserId,
                    cmd.ConversationThread.BuyerUserId
                )
                .Match(
                    Succ: thread => liftAsync(async () =>
                    {
                        ctx.Add(thread);
                        await ctx.SaveChangesAsync(ct);
                        return thread;
                    }),
                    Fail: err =>
                    {
                        logger.LogWarning(
                            "Failed to create conversation thread: {Error}",
                            err.Message
                        );
                        return fail<ConversationThread>(err);
                    }
                );
        }
    )))
    .Map(mapper.MapConversationThreadToCreatedConversationThreadDto)
    .RunSafeAsync();

[illunix]

Okey so I benchmarked it without async and db, is it make sense to use it on prod because I like the way of writting with this lib?

| Method             | Mean      | Error     | StdDev    | Median    |
|------------------- |----------:|----------:|----------:|----------:|
| CreateObj          | 10.563 ns | 0.4665 ns | 1.3756 ns | 10.001 ns |
| CreateObjException |  9.480 ns | 0.2516 ns | 0.5362 ns |  9.183 ns |
| CreateFp           | 27.125 ns | 0.3830 ns | 0.3582 ns | 27.090 ns |
| CreateFpError      | 26.798 ns | 0.1727 ns | 0.1615 ns | 26.796 ns |

https://paste.mod.gg/arexawyrpziy/0

[louthy]

There are a billion nanoseconds in a second. So, sure, differences in performance will show up if you're doing 100s of millions of these operations per second. Well, it will show up on one core, if you have a multicore CPU then you're likely going to be able to do billions of these operations per second. Well, probably not, because your IO will end up be the limiting factor, not anything in this library.

This article is a bit old, but I wrote about FP performance here.

Much of the new v5 library changes is to try and remove async/await and Task from your life. You wrap up your Task in an IO<A> and then just work with the IO monad from that point on. The IO monad has a number of benefits:

• It's pure (Task isn't)
• It's a functor, so you can Map it easily
• It's a monad, so you can use it in LINQ (Bind)
• It's an applicative, which makes it super easy to do parallel and batch processing

What you shouldn't do is call Run* on it. Well, you should only call Run* at the 'edge' of your program. The 'edge' of all programs is Main: the entry point. The idea is that an IO<A> data-structure is pure up until the point you call Run*. At the location of the Run* is where all of the effectful side-effects are going to happen. So, to achieve the goal of Pure Functional Programming (the most robust form of FP) then we want to move the side-effects right out the very edge of our application (Main).

Take a look at the CardGame sample, notice how Run is only called in main.

Now, because this is C# and not everything in .NET land has been written to follow the pure-FP paradigm, we sometimes have to compromise. So, what we might do is call Run* in a request-handler in ASP.NET, or on a button-click in a Avalonia app. We make a pragmatic choice to do so, knowing that we are injecting potentially problematic side-effects at the location of the Run* method invocation.

But we want to keep the number of Run* invocations small, so it's cognitively easy for us to deal with.

In terms of making this 'better'. Yes, there's a lot of learning of FP technique in your future, but also about the some of the core elements of the library.

This is what your code will look like when we're done

IO<ConversationThread> getThreadOrCreateNew(Command cmd, Context ctx, IMarketPlaceAPI api) =>
    from user in getSellerUserId(cmd, api)
    from thrd in headUserThread(user, cmd, ctx)
                 | createNewThread(user, cmd, ctx)
    select thrd;

First, make small, static, pure, reusable functions

Pure reusable functions are lego construction kits for programming. Once you've made the bricks they all slot together and are endlessly stackable, because they're pure. This is fundamentally the superpower of pure-FP.

I have broken out each part of your expression into reusable functions:

public static class MarketPlaceAPI
{
    public static IO<UserId> getSellerUserId(Command cmd, IMarketPlaceAPI marketplaceApi) =>
        IO.liftAsync(async env => await marketplaceApi.GetSellerUserIdAsync(
            cmd.ConversationThread.ItemId,
            env.Token));

    public static IO<Seq<ConversationThread>> filterUserThreads(Func<ConversationThread, bool> f, Context ctx) =>
        IO.liftAsync(async env => await ctx.Threads.AsNoTracking().Where(f, env.Token))
          .Map(toSeq);
    
    public static IO<ConversationThread> headUserThread(UserId uid, Command cmd, Context ctx) =>
        filterUserThreads(q => q.ItemId == cmd.ConversationThread.ItemId &&
                               q.BuyerUserId == cmd.ConversationThread.BuyerUserId, ctx)
            .Map(ts => ts.Head.IfNone(() => throw AppErrors.NoThreads));

    public static IO<ConversationThread> createNewThread(UserId sellerUserId, Command cmd, Context ctx) =>
        ConversationThread
            .Create(cmd.ConversationThread.ItemId, sellerUserId, cmd.ConversationThread.BuyerUserId)
            .Match(
                Succ: thread => IO.liftAsync(async env =>
                {
                    ctx.Add(thread);
                    await ctx.SaveChangesAsync(env.Token);
                    return thread;
                }),
                Fail: err => IO.lift<ConversationThread>(err));
}

I also created an AppErrors for reusable Error instances:

public static class AppErrors
{
    public static readonly Error NoThreads = Error.New("no threads"); 
}

So what about the thread mapping?

Just stay in the IO monad (don't Run* it) and call:

getThreadOrCreateNew(cmd, ctx, marketplaceApi)
    .Map(mapper.MapConversationThreadToCreatedConversationThreadDto)

And then everything is done.

Can we do more?

Yes. The final method:

IO<ConversationThread> getThreadOrCreateNew(Command cmd, Context ctx, IMarketPlaceAPI api) =>
    from user in getSellerUserId(cmd, api)
    from thrd in headUserThread(user, cmd, ctx)
                 | createNewThread(user, cmd, ctx)
    select thrd;

Passes around contextual information (Context and IMarketPlaceAPI). By using the runtime-system of the Eff monad, you can get that passed around automatically. It would make the code look like this:

Eff<Runtime, ConversationThread> getThreadOrCreateNew(Command cmd) =>
    from user in getSellerUserId(cmd)
    from thrd in headUserThread(user, cmd)
                 | createNewThread(user, cmd)
    select thrd;

It's probably a step too far for you right now, but the EffectExample sample shows how the runtimes are used. And the CardGame and Newsletter samples show how this is done for bespoke monads and completely generalised monads.

Request for conciseness

I had to create a load of placeholder types to make this response (below). I have no idea what your code looks like and so this is just a guess by how the types line up, but it would be better in future if you boiled down any questions to more concise examples. I realise this was also a question of technique, so I do kinda understand, but in these cases it would be good if you can provide the shape of any methods or types. Ta.

public readonly record struct ItemId(string Value);
public readonly record struct UserId(string Value);

public record ConversationThread(ItemId ItemId, UserId BuyerUserId)
{
    public static Fin<ConversationThread> Create(ItemId id, UserId sellerUserId, UserId buyerUserId) =>
        throw new NotImplementedException();
}

public record Command(ConversationThread ConversationThread);

public record Context(ThreadsContext Threads)
{
    public Context Add(ConversationThread thrd) => throw new NotImplementedException();
    public Task<Context> SaveChangesAsync(CancellationToken token) =>  throw new NotImplementedException();
}
public record ThreadsContext
{
    public ThreadsContext AsNoTracking() => this;
    public Task<IQueryable<ConversationThread>> Where(Func<ConversationThread, bool> f, CancellationToken cancellationToken) => 
        throw new NotImplementedException();
    public Task<ConversationThread?> FirstOrDefaultAsync(Func<ConversationThread, bool> f, CancellationToken cancellationToken) => 
        throw new NotImplementedException();
}
public interface IMarketPlaceAPI
{
    public Task<UserId> GetSellerUserIdAsync(ItemId Id, CancellationToken cancellationToken);
}

[illunix]

So at this moment I have something like this based on this code that you've posted, I have a problem because I don't know how to access sellerUserId from Bind in my Match where Guid.Empty is, can you help me? @louthy

public sealed class CreateConversationThreadCommandHandler(
    IChatDbContext ctx,
    IMarketplaceModuleApi marketplaceApi,
    ConversationThreadMapper mapper,
    ILogger<CreateConversationThreadCommandHandler> logger
) : ICommandHandler<CreateConversationThreadCommand, Fin<CreatedConversationThreadDto>>
{
    public async ValueTask<Fin<CreatedConversationThreadDto>> Handle(
        CreateConversationThreadCommand cmd,
        CancellationToken ct
    )
        => await GetSellerUserId(cmd.ConversationThread.ItemId)
                .Bind(sellerUserId => GetConversationThread(
                    cmd.ConversationThread.ItemId,
                    cmd.ConversationThread.BuyerUserId
                ))
                .Run()
                .Match(
                    Some: thrd => pure(thrd),
                    None: () => CreateConversationThread(
                        Guid.Empty,
                        cmd.ConversationThread
                    )
                )
                .Map(mapper.MapConversationThreadToCreatedConversationThreadDto)
                .RunSafeAsync();

    private IO<Guid> GetSellerUserId(Guid itemId)
       => liftAsync(async env => await marketplaceApi.GetSellerUserIdAsync(
           itemId,
           env.Token
       ));

    private IO<Option<ConversationThread>> GetConversationThread(
        Guid itemId,
        Guid buyerUserId
    )
        => liftAsync(async env => Optional(await ctx.Threads
                .AsNoTracking()
                .FirstOrDefaultAsync(q =>
                    q.ItemId == itemId &&
                    q.BuyerUserId == buyerUserId,
                    env.Token
                )
        ));

    private IO<ConversationThread> CreateConversationThread(
        Guid sellerUserId,
        CreateConversationThreadDto conversationThread
    ) => ConversationThread
            .Create(
                conversationThread.ItemId,
                sellerUserId,
                conversationThread.BuyerUserId
            )
            .Match(
                Succ: thrd => liftAsync(async env =>
                {
                    ctx.Add(thrd);
                    await ctx.SaveChangesAsync(env.Token);
                    return thrd;
                }),
                Fail: err => {
                    logger.LogWarning(
                        "Failed to create conversation thread: {Error}",
                        err.Message
                    );
                    return fail<ConversationThread>(err);
                }
            );
}