How to handle IDisposable with Aff/Eff?

[kengreim]

Hi all,

I am starting to try to understand Aff/Eff but am struggling with how to deal with side-effects that return an IDisposable that I need to use in future functions, but also want to be sure to dispose in both success and failure cases. I am staying away from Runtimes for now until I at least get my head around some of the simpler concepts.

I started with something like this, based on some other code that I found here:

public static Aff<T> Get<T>(HttpClient client, string url, ILogger logger) =>
      from response in GetHttpResponse(client, url) | CatchAndLogError<HttpResponseMessage>(logger, url)
      from objectT in DeserializeFromJson<T>(response) | CatchAndLogError<T>(logger, url)
      from _ in Dispose(response)
      select objectT;
  
  private static Aff<T> DeserializeFromJson<T>(HttpResponseMessage response) =>
      AffMaybe(async () =>
          await response.Content.ReadFromJsonAsync<T>() switch
          {
              null => FinFail<T>(new JsonNullError("JSON deserialization returned null")),
              var obj => FinSucc(obj)
          }
      );

  private static Eff<Unit> Dispose(HttpResponseMessage response) =>
      Eff(() =>
      {
          response.Dispose();
          return unit;
      });

  private static Aff<HttpResponseMessage> GetHttpResponse(HttpClient client, string url) =>
      AffMaybe(async () =>
          await client.GetAsync(url) switch
          {
              { IsSuccessStatusCode: true } response => FinSucc(response),
              var response => FinFail<HttpResponseMessage>(new HttpError(response))
          }
      );

   private static AffCatch<T> CatchAndLogError<T>(ILogger logger, string url) =>
       @catch(error =>
       {
           error.Exception.Match(
               None: () => logger.LogInformation("Error with url {url}: {error}", url, error.Message),
               Some: exception => logger.LogWarning(exception, "Exception occured with url {url}", url)
           );
           return FailAff<T>(error);
       });

But then I realized that Dispose would only execute in the success path; any errors before then would cause the computation to stop and Dispose to not be called.

The simplest thing might be to wrap GetHttpResponse and DeserializeFromJson in a single Aff to make resource disposal easier, but I want to keep them separate if possible.

I found some other ideas like a "Use" function below, but in tracing the logs, the finally block isn't being executed in an error case. I assume that's because the Bind and return f(a).Run() isn't the correct concept, but I'm a little stuck. Any best practices on how to deal with something like this?

public static Aff<B> Use<A, B>(Aff<A> ma, Func<A, Aff<B>> f) where A : HttpResponseMessage =>
    ma.Bind(a =>
        AffMaybe(() =>
        {
            try
            {
                Log.Logger.Write(LogEventLevel.Information, "here");
                return f(a).Run();
            }
            finally
            {
                Log.Logger.Write(LogEventLevel.Information, "disposing");
                if (a is HttpResponseMessage)
                {
                    Log.Logger.Write(LogEventLevel.Information, "disposing for {url}", a.RequestMessage.RequestUri);
                }
                a?.Dispose();
            }
        }));

public static Aff<T> Get2<T>(HttpClient client, string url, ILogger logger) =>
    Use(from response in GetHttpResponse(client, url) | CatchAndLogError<HttpResponseMessage>(logger, url)
        select response,
        response =>
            from objectT in DeserializeFromJson<T>(response) | CatchAndLogError<T>(logger, url)
            select objectT);

[kengreim]

Doh...I should've realized that there is a use function for exactly this reason, and I don't need to write my own

public static Aff<T> Get<T>(HttpClient client, string url, ILogger logger) =>
    use(
        GetHttpResponse(client, url) | CatchAndLogError<HttpResponseMessage>(logger, url),
        response => 
            DeserializeFromJson<T>(response) | CatchAndLogError<T>(logger, url)
    );