Questions: bracketIO + lifting ValueTask

[aloslider]

Hello, I'm currently exploring the v5 and decided to check the ways to work with unmanaged resources. I've tried to look for any examples of using new bracketIO function but found nothing :(
I was expecting the bracketIO to work same as comp2 with manually using use and release functions, but got different output.

Code:

using LanguageExt;
using static LanguageExt.Prelude;

var comp1 = bracketIO(
    Acq: IO.pure(new MyResource()),
    Use: res => 
        from _0 in liftIO(async () =>
        {
            await res.PrintAsync();
        })
        select "Finished1",
    Fin: res => release(res)); // I'm not sure what should be here instead of "release(...)"
await comp1.RunAsync();
Console.WriteLine("Finished comp1");
Console.WriteLine();

var comp2 =
    from res in use(() => new MyResource())
    from __0 in liftIO(async () =>
    {
        await res.PrintAsync();
    })
    from __1 in release(res)
    select "Finished2";
await comp2.RunAsync();
Console.WriteLine("Finished comp2");

class MyResource() : IDisposable
{
    public ValueTask PrintAsync()
    {
        Console.WriteLine("MyResource");
        return ValueTask.CompletedTask;
    }

    public void Dispose()
    {
        Console.WriteLine("Disposed");
    }
}

Output:

MyResource
Finished comp1

MyResource
Disposed
Finished comp2

1. How bracketIO is supposed to work? My assumption was that it would call Dispose on executing the bracketIO, but there's no "Disposed" message in the console.
2. Currently, liftIO only supports Tasks to be the return type. Will there be a support for a ValueTask as well?

[louthy]

bracketIO with the Acq, Use, and Fin is a more explicit approach to managing resources. It doesn't use the built-in resource-management, so release won't do anything because Acq didn't put the resource into its tracking-map.

So, if you want to use that approach, the Fin part should be: IO.lift(() => res.Dispose()).

This is what it looks like internally:

new IOAsync<C>(async env =>
    {
        var x = await RunAsync(env);
        try
        {
            return IOResponse.Complete(await Use(x).RunAsync(env));
        }
        catch (Exception e)
        {
            return IOResponse.Complete(await Catch(e).RunAsync(env));
        }
        finally
        {
            (await Finally(x).RunAsync(env))?.Ignore();
        }
    });

If you want something to guarantee that all resources within a particular scope are cleaned-up properly, use bracketIO(K<M, A>).

i.e:

var comp = bracketIO(
    from res in use(() => new MyResource())
    from _   in liftIO(async () => await res.PrintAsync())
    select "Finished2");

What that version of bracketIO does is create a local resource-tracking scope, so that when the inner computation has completed, it can clean everything up automatically.

This is what it looks like internally:

new IOAsync<A>(async env =>
    {
        using var lenv = env.LocalResources;
        return IOResponse.Complete(await RunAsync(lenv));
    });

The Dispose on the local resource (called by the using) cleans up the local context.

Hope that helps.

[aloslider]

Thanks a lot, I think I've got it!
What about ValueTask though?

[louthy]

You need to await it and it'll work. I did originally have a liftVIO, but it seemed overkill as it just called liftIO by awaiting.