How to traverse an array of IDisposable? Array as Traversable and IDisposable as Applicative bracket?

[ingun37]

Hello. In Haskell, I can traverse (or sequence) when a bracket and an array of its input is given. How can I do the same with IDisposable objects in language-ext?

[louthy]

For the exact example with the IO monad:

public static IO<C> bracket<A, B, C>(
    IO<A> acquire,
    Func<A, IO<B>> release,
    Func<A, IO<C>> action) =>
    IO.lift(env =>
    {
        var x = acquire.Run(env);
        try
        {
            return action(x).Run(env);
        }
        finally
        {
            release(x).Run(env);
        }
    });

If the acquired resource is IDisposable then you can write a bracket function that doesn't need a release lambda argument:

public static IO<B> bracket<A, B>(
    IO<A> acquire,
    Func<A, IO<B>> action)
    where A : IDisposable =>
    IO.lift(env =>
    {
        var x = acquire.Run(env);
        try
        {
            return action(x).Run(env);
        }
        finally
        {
            x.Dispose();
        }
    });

This is using the IO monad from v5 (which is in alpha right now). But, the same principle will work for any monad in v4 too.

Support for a bracket function is in my v5 TODO-list. v5 also has a ResourceT monad transformer that automates tracking and releasing of resources - you can see the functions it supports here. If you look at the implementation of Eff<RT, A> you'll see how its implemented as a monad-transformer stack: StateT<ResourceT<IO, A>> -- which means Eff does resource-tracking automatically.

NOTE: None of this is tested yet. And if there's one thing I expect to not be perfect in the alpha it's the resource-tracking, so be aware that it's likely to have some bugs.

In v4 the resource tracking was almost non-existent. Pipes did auto-resource tracking, but nothing else. All other monadic types (that were computational and not pure data) had their own use functions. Here's the Eff and Aff use functions -- you'll see they're implemented like the bracket function above.

Resource tracking is one of the 'big pushes' of the v5 release; now that we can do higher-kinds and monad-transformer stacking, we can put resource management in the hands of the dev building their stack, rather than it all being prescribed by the monad implementations in language-ext.

You didn't give a huge amount of context, but hopefully that answers the question!