Is there any way to fire and forget a IO?

[illunix]

Hey, I need to fire and forget this piece of code, also I want do nothing or maybe just log something on none so idk if its good to just return empty error?
GetItemTitle returns IO<string>
NotifyUserByEmail returns IO<Unit>

 await marketplaceApi
     .GetItemTitle(itemId)
     .Bind(option =>
         option.Match(
             Some: itemTitle => notificationsApi.NotifyUserByEmail(
                 recipientUserId,
                 $"You have a new message from {itemTitle} seller.",
                 msg.Content
             ),
             None: () => Error.Empty
         )
     )
     .RunAsync();

[aloslider]

I need to fire and forget this piece of code

Task.Run, unless you specify full context of this code

if its good to just return empty error

Depends on your needs, but if you fire and forget, then why do you need to fail on None?

GetItemTitle returns IO

No it doesn't, judging by the code it returns IO<Option<string>>

[illunix]

Yeah my bad it returns what you said, so how it would look like without None like you said?

[aloslider]

using LanguageExt;
using static LanguageExt.Prelude;

var marketplaceApi = new MarketPlaceApi();
var notificationsApi = new NotificationApi();

Task.Run(() =>
    marketplaceApi
        .GetItemTitle(1)
        .Bind(title =>
           notificationsApi.NotifyUserByEmail(
               new NotificationMessage(1, $"You have a new message from {title} seller.")))
        .runOption.As().RunAsync());

class MarketPlaceApi
{
    public OptionT<IO, string> GetItemTitle(int itemId) => 
        OptionT.lift<IO, string>(Pure(string.Empty));
}

class NotificationApi
{
    public IO<Unit> NotifyUserByEmail(NotificationMessage msg) =>
        unitIO;
}

record NotificationMessage(int RecipientUserId, string Message);

[louthy]

I need to fire and forget this piece of code

Just don't await the Task. You seem to be ignoring my advice over reducing the usage of Run*, which is fine, you do you. But, if you're going to work with the side-effecting Task<T> then your questions are not for this forum/repo. You need to learn how to use the .NET Task<T> type and how concurrency and parallelism works in .NET. I've always liked the style of Joe Albahari.

If you want to follow the advice (avoid calling Run* until the 'edge' of your application), then you can just call Fork() on your IO<A> type. Any transformer type that supports MonadIO and MonadUnliftIO and lifts the IO monad (like OptionT<IO, A>) can also call ForkIO().

Fork and ForkIO uses Task.Run internally, but also manages local cancellation-tokens, local resource-management, and other things that you normally need to do manually if you use something like Task.Run.

It also returns an IO<ForkIO<A>>. Which means when the IO operation is finally run, it will yield a ForkIO<A>. It's a simple structure that looks like this:

public readonly record struct ForkIO<A>(
    IO<Unit> Cancel, 
    IO<A> Await);

That means you can compute Cancel to cancel the forked-operation and automatically clean-up any tracked resources or, at a later time, or compute Await to wait for the forked operation to complete. This is significantly more flexible and powerful than just sticking your evaluated task in a Task.Run(...) operation.

I would really encourage you to think about what it means when a computation is represented as an IO<A>. It is declarative. It is declaring "This thing does IO, so beware it has side-effects"! It is a warning to you and any other person working on your project that the code is non-deterministic and relies on external state. When you call RunAsync or any of the other Run* variants, it kills that declaration. The warning disappears. And also, it injects the side-effects in the same way as with OO. We don't know where or when they happen.

Something like this:

 await marketplaceApi
     .GetItemTitle(itemId)
     .Bind(option =>
         option.Match(
             Some: itemTitle => notificationsApi.NotifyUserByEmail(
                 recipientUserId,
                 $"You have a new message from {itemTitle} seller.",
                 msg.Content
             ),
             None: () => Error.Empty
         )
     )
     .RunAsync();

Could be written as:

// This is a simple static class that represents the 'edge' of your application, the idea is that
// we package up calls to other static `IO` yielding types and run them to get the underlying
// task.
public static ServiceRequest
{
    public static ValueTask<A> Foo(ItemId itemId, MarketPlace API api) =>
        ServiceAPI.Foo(itemId, api).RunAsync();
}

// This is where you keep your pure application logic.  NEVER leave IO once you're in it, it makes 
// it much easier to leverage the underlying capabilities of the IO monad, but also each methoid
// should be pure.  Which means composition for free.
public static ServiceAPI
{
    public static IO<A> Foo(ItemId itemId, MarketPlace API api)
        api.GetItemTitle(itemId)
              .Bind(option =>
                 option.Match(
                     Some: itemTitle => notificationsApi.NotifyUserByEmail(
                         recipientUserId,
                         $"You have a new message from {itemTitle} seller.",
                         msg.Content),
                     None: () => Error.Empty));
}

The exact approach should be yours, of course, but writing your pure logic in one place and then only computing it at the edges will give you superpowers.

There are also various samples that demonstrate forking, so it's worth searching the repo for 'fork'.

[illunix]

Okey so from what I understand it should look like this?

 marketplaceApi
     .GetItemTitle(itemId)
     .Bind(itemTitle => notificationsApi.NotifyUserByEmail(
         recipientUserId,
         $"You have a new message from {itemTitle} seller.",
         msg.Content
     ))
     .runOption
     .As()
     .ForkIO()
     .Run();

And how can I use FirstOrDefaultAsync here?

    public OptionT<IO, string> GetItemTitle(Guid itemId)
      => OptionT.lift<IO, string>(ctx.Items
              .AsNoTracking()
              .Where(q => q.Id == itemId)
              .Select(q => q.Title)
              .FirstOrDefault()
      );

    public IO<Unit> NotifyUserByEmail(
        Guid userId,
        string subject,
        string body
    )
        => liftAsync(async () => await mailgun
            .SendMail(
                "[email protected]",
                subject,
                body
            )
            .ToUnit()
        );

[illunix]

Can you take a look at my code please? @louthy