How to use Fin with sync and async method calls

[dirkil]

Suppose I have two methods that I want to call one after the other. Both can fail and one of them is async. The second call should only be made, when the first cal succeeds.

Method 1: Fin<string> GetId()
Method 2: Task<Fin<string>> DeleteItem(string id)

Now I would like to have code such as:
var result = GetId().BindAsync(id => DeleteItem(id));

If the second call was synchronous the chaining with Bind() works well. But how can I do it with async calls?

Is there anything I could do to get this to work? Or is there an alternative to chaining the calls with Bind()?

[olegdunkan]

from id in EffMayby(GetId)
from result in AffMayby(async ValueTask<Fin<string>>()
{
   return await DeleteItem(id);//awkward 
})
select result;

If DeleteItem would return ValueTask<Fin> then no need for wrapper.

from id in EffMayby(GetId)
from result in AffMayby(() => DeleteItem(id))
select result;

[louthy]

There is no FinAsync<A> yet, so unlike the other monads there isn't an async pairing. However, as mentioned above you can use Aff<A>. Aff<A> is equivalent to Func<ValueTask<Fin<A>>>.

You can get a Fin<A> from an Aff<A> by calling:

    await aff.Run();

You can convert from a Fin<A> to a Aff<A> by calling:

   fin.ToAff();

Also, be aware that Fin<A> is not a lazy type and therefore can't catch exceptions. So anything you write that throws exceptions won't magically turn into a Fin<A> in a Fail state. Instead you may want to switch to using Eff (synchronous effects) and Aff (asynchronous effects). They are both lazy and can therefore catch exceptions.

[dirkil]

Very interesting! Thank you guys a lot.

I tried to put the ideas together but I don't know exactly how to run it. Maybe you can point me in the right direction. Here is a little contrived example and I would be very happy if you could fill in the code in Run() that should first call GetId() (synchronously) to get an id and then use that id in the asynchronous call to DeleteItem(id). The result of DeleteItem(id) should be the result of the Run() method.

public class AffDemo
{
    public Fin<string> Run()
    {
        // How can I chain the calls to GetId() and DeleteItem() and return the result?
    }
    
    public Fin<string> GetId()
    {
        return "5";
    }
            
    public Aff<string> DeleteItem(string itemId) =>
        Aff(async () => await Delete(itemId));

    private async Task<string> Delete(string id)
    {
        // Just for the sake of having an asynchronous method...
        throw new NotImplementedException();
    }
}

Thank you very much in advance.

[louthy]

It's important to understand that you can't mix and match monadic types (unless they have specific cross-monadic bindings defined - as in the case of Eff and Aff). So, Fin<A> isn't directly compatible with Aff<A>. You need to convert one into the other so they can be composed properly.

Because Aff<A> has more capability than Fin<A>, you should convert your Fin<A> values into Aff<A> to compose them:

public class AffDemo
{
    public async Task<Fin<string>> Main() =>
        await MainAff().Run();

    // NOTE: the result is `Aff`
    public Aff<string> MainAff() =>
        from id in GetId().ToAff()    // `Fin` is promoted to an `Aff`
        from rs in DeleteItem(id)
        select rs;

    public Fin<string> GetId() =>
        FinSucc("5");

    public Aff<string> DeleteItem(string itemId)
    {
        return Aff(async () => await Go(itemId));

        // It's useful to make the Task based function local 
        async Task<string> Go(string id)
        {
            // Just for the sake of having an asynchronous method...
            throw new NotImplementedException();
        }
    }
}

Here's the same example: but instead of using Fin for GetId I use Eff, which is designed to work side-by-side with Aff. That means there's no need for the call to ToAff:

public class AffDemo
{
    public async Task<Fin<string>> Main() =>
        await MainAff().Run();

    public Aff<string> MainAff() =>
        from id in GetId()
        from rs in DeleteItem(id)
        select rs;

    public Eff<string> GetId() =>
        SuccessEff("5");

    public Aff<string> DeleteItem(string itemId)
    {
        return Aff(async () => await Go(itemId));

        async Task<string> Go(string id)
        {
            // Just for the sake of having an asynchronous method...
            throw new NotImplementedException();
        }
    }
}

[dirkil]

That looks very promising and I must admit that I am getting excited about this Eff/Aff business! :)

In your last code example, where is the code that handles errors? After all Go() contains the main code that could fail. That's why I modelled DeleteItem() to return Fin<string> in the first place.

Suppose I want to implement Go() now with some real code then I would come to a point where — in case of an error — I would do return Error.New("some error message"). But this is now impossible since Go() returns Task<string>. Should I change the return type of Go() to Task<Fin<string>>? But how would that integrate with Aff?

By the way, why is it useful to make the tasked based function local?

[louthy]

It's worth reading the wiki on how to deal with side-effects and at the EffectsExamples sample application. They both mostly focus on using the runtime-supporting version of Aff and Eff, but most of the capabilities of the runtime versions is also available in the non-runtime versions of Aff and Eff.

Some interesting highlights in the EffectsExample code:

• Main is simply the running of an Aff monad. So the whole application lives inside an effect. It's useful to think this way, as each application is one big side-effect. It's also useful to think about web-requests or events in this way too.
• Menu is the launcher for the various examples
• There are examples that show error handling [1], [2], [3]
• The full set of examples are in the Examples folder

By the way, why is it useful to make the tasked based function local?

Encapsulation. It shows that the Task based function isn't meant to be consumed directly.

Should I change the return type of Go() to Task<Fin>? But how would that integrate with Aff?

Use AffMaybe to wrap a function that returns a Fin

    public Aff<string> DeleteItem(string itemId)
    {
        return AffMaybe(async () => await Go(itemId));

        async Task<Fin<string>> Go(string id)
        {
            // Just for the sake of having an asynchronous method...
            throw new NotImplementedException();
        }
    }

[dirkil]

This is exactly what I was looking for. Incredible stuff!

Thank you louthy for your dedication and your patience. I really appreciate it.