I would like to inquire about the proper usage of Disposable and DisposableAsync

[seungyongshim]

Excuse, me

I am currently studying version 5 and would like to utilize DisposableAsync correctly. However, I am uncertain about the appropriate method to do so. Could you please review the code below?

Thank you for your assistance.

Best regards,

Version

5.0.0-beta-18

Result

## 1. Expect
- DisposedAsync 1

## 2. use using IO
- Disposed 2

## 3. use using IO w/ EnvIO

## 4. use using Eff

## 5. use using Eff w/ Runtime

Code

using LanguageExt;
using LanguageExt.Sys.Live;
using static LanguageExt.Prelude;

Console.WriteLine("## 1. Expect");
await Expect();

Console.WriteLine("\n## 2. use using IO");
await Case2();

Console.WriteLine("\n## 3. use using IO w/ EnvIO");
await Case3();

Console.WriteLine("\n## 4. use using Eff");
await Case4();

Console.WriteLine("\n## 5. use using Eff w/ Runtime");
await Case5();


async Task Expect()
{
    try
    {
        await using var x = new DisposableClass("1");
        throw new Exception("crash");
    }
    catch { }

}

async Task Case2()
{
    var io =
        from _1 in use(() => new DisposableClass("2"))
        from __ in liftIO(() => throw new Exception("crash"))
        from _2 in release(_1)
        select unit;

    try
    {
        await io.RunAsync();
    }
    catch { }
}

async Task Case3()
{
    var io =
        from _1 in use(() => new DisposableClass("3"))
        from __ in liftIO(() => throw new Exception("crash"))
        from _2 in release(_1)
        select unit;

    try
    {
        await io.RunAsync(EnvIO.New());
    }
    catch { }
}

async Task Case4()
{
    Eff<Unit> effect =
        from _1 in use(() => new DisposableClass("4"))
        from __ in liftIO(() => throw new Exception("crash"))
        from _2 in release(_1)
        select unit;

    await effect.RunAsync();
}

async Task Case5()
{
    Eff<Runtime, Unit> effect =
        from _1 in use(() => new DisposableClass("5"))
        from __ in liftIO(() => throw new Exception("crash"))
        from _2 in release(_1)
        select unit;

    await effect.RunAsync(Runtime.New());
}

public class DisposableClass(string Id) : IDisposable, IAsyncDisposable
{
    public void Dispose()
    {
        Console.WriteLine($"- Disposed {Id}");
    }
    public ValueTask DisposeAsync()
    {
        Console.WriteLine($"- DisposedAsync {Id}");

        return ValueTask.CompletedTask;
    }
}

[louthy]

The only disposable 'thing' in the IO monad is the EnvIO. If you pass your own EnvIO to Run or RunAsync then you are expected to dispose it. If you don't pass an EnvIO to Run or RunAsync, then one will be generated for you and it will be disposed automatically.

For Eff, the same is true for the EnvIO. The RT runtime is entirely your responsibility, because you pass it to Run, it's up to you to dispose it.

So, for your functions:

• Case2() is correct and all resources will be cleaned-up automatically.
• Case3() is wrong, you need to clean-up the EnvIO that you pass to RunAsync
• Case4() is correct and all resources will be cleaned-up automatically.
• Case5() is only correct if your Runtime has nothing to clean-up, otherwise you should be disposing the Runtime; everything else is cleaned-up automatically.

It should also be noted that certain IO functions create local 'scopes' that do partial disposals.

For example, Fork, creates a local EnvIO that collects the acquired resources in its forked thread; and will automatically clean-up anything used in that thread when it's complete. The fork still has access to the parent IO thread's resources. They're left untouched when the forked IO finishes.

This also happens in Repeat, RepeatUntil, RepeatWhile. All resources acquired in the repeated IO section will be automatically freed at the end of the section.

Retry, RetryWhile, and RetryUntil do not have the same behaviour of Repeat*. Instead, it collects all of the resources in the usual way. I may change this, not sure yet.

@catch and Catch will also auto-dispose of any acquired resources if an error/exception is thrown in the IO expression being tried. This is so acquired resources in failed operations don't end up hanging around.

In terms of DisposeAsync. The EnvIO doesn't need it, so it's irrelevant there. Obviously if you need an asynchronous disposal for your Runtime then it's up to you to add it and dispose of it.

NOTE: The resource-management system has had minimal testing so far. If there's one area of v5 that I think is more likely to have bugs, it's that. So, if you spot any errors, please let me know.

NOTE 2.0: I saw an issue in one of the Eff.Run overloads that has now been fixed, so get v5.0.0-beta-19.

EDIT

I should really read questions properly before answering! ;-)

Anyway, all of the above is correct, but I realise you were specifically asking about support for IAsyncDisposable. There wasn't any specific support for IAsyncDisposable, but you (previously) could have done so by using the version of use that has a second release parameter:

public static IO<A> use<A>(Func<A> acquire, Func<A, IO<Unit>> release);

public static K<M, A> use<M, A>(K<M, A> acquire, Func<A, IO<Unit>> release);

This version of use allows you to have any disposal functionality you like. And because IO supports async, you can have an asynchronous disposal.

However, having explicit support for IAsyncDisposable is probably valuable. And so, I have added useAsync. Which expects the resource to derive from IAsyncDisposable.

I have also added implicit support for IAsyncDisposable where the resource is also IDisposable (as in your example). That means you can still use the use function that accepts IDisposable and if it's also an IAsyncDisposable, then DisposeAsync is invoked when the release behaviours are run.

I added your examples to my TestBed app (with the correct-usage changes I mentioned at the start of this response).

When I run it, I get:

## 1. Expect
- DisposedAsync 1

## 2. use using IO
- DisposedAsync 2

## 3. use using IO w/ EnvIO
- DisposedAsync 3

## 4. use using Eff
- DisposedAsync 4

## 5. use using Eff w/ Runtime
- DisposedAsync 5