Exceptions within TryAsync<T>.IfFail handler re-call the same handler

[geppettodivacin]

We've got several places where we would like to handle some errors, but if we can't handle the error, re-throw. This allows our the stock GRPC framework to catch that exception and send the client the correct error code, for example.

We'd like to use IfFail to do this processing, as shown below. However, whenever we rethrow, it gets handled twice. For example, the following code ends in two lines saying "We've never seen this error before!"

using static LanguageExt.Prelude;

const string unknownErrorMessage = "Catch me!";

var failure = TryAsyncFail<int>(new Exception(unknownErrorMessage));

var hopefullyNotFailure = await failure.IfFail(ex =>
    {
        if (ex.Message != unknownErrorMessage)
            return 42;

        Console.WriteLine("We've never seen this error before!");
        throw ex;
    }
);

Console.WriteLine(hopefullyNotFailure);

This is not the behavior that happens when we use Match:

var hopefullyNotFailure = await failure.Match(
    x => x,
    ex =>
    {
        if (ex.Message != unknownErrorMessage)
            return 42;

        Console.WriteLine("We've never seen this error before!");
        throw ex;
    }
);

We've resorted to using Match for the time being, but it would be more pleasant to be able to use IfFail for this, and it doesn't seem like intentional behavior. If the handler failed to handle the original error, how would we expect it to handle its own error?

[geppettodivacin]

Of course, the issue is that the Fail() call is within the try and in the catch. Do we want to handle the catch with the Fail() method? Or should that be exclusively for faulted tries?

language-ext/LanguageExt.Core/Monads/Alternative Value Monads/Try/TryAsync/TryAsync.Extensions.cs

Lines 293 to 305 in d5248b6

	try
	{
	var res = await self.Try().ConfigureAwait(false);
	if (res.IsFaulted)
	return Fail(res.Exception);
	else
	return res.Value;
	}
	catch (Exception e)
	{
	TryConfig.ErrorLogger(e);
	return Fail(e);
	}

[louthy]

I'm midway through a massive refactor at the moment, so I won't get to this any time soon. My suggestion would be that if you have a decent workaround, wrap it up in an extension method and use that; then it can all be changed later (as well as being a bit more convenient than writing out the same match expression many times).

[louthy]

By the way, if you want better error handling in general, check out Aff<A> it is a better TryAsync with many more options for error handling.

You don't need to use the runtime version (Aff<RT, A>) to get the benefits. There's a load of examples in the EffectsExamples sample project.