How do I avoid "Avoid using 'async' lambdas when delegate return type is void" when the success delegate is sync?

[MrYossu]

Suppose I have code like this...

await DoSomething()
  .Match(x => OnSuccess(x), async ex => OnFailure(ex));

...where DoSomething returns a TryAsync and OnSuccess is synchronous.

Resharper gives me the warning shown in the title on the async keyword in the failure lambda. As far as I know, that warning means that if anything throws an exception in the async OnFailure method, the exception won't be caught, as it will be in the returned Task that isn't handled, as the compiler is assuming the failure lambda is void.

My guess (and please correct me if I'm wrong) is that as DoSomething is a sync void method, the compiler uses the overload for Match that takes an Action for the success lambda, as opposed to the overload that takes a Func.

I know I could change the code to...

await DoSomething()
  .Match(x => Task.Run(OnSuccess(x)), async ex => OnFailure(ex));

...but this seems odd. It also gives a warning "Return value of pure method is not used" on the call to Match, but I guess I can live with that, as I know the return value isn't significant.

Anyone able to advise what is the best way to do this? Thanks.

[CK-LinoPro]

The most crucial information in your question is missing, what do OnSuccess and OnFailure return?
Both should have the same return type T or Task<T> or one should return T and one Task<T> for your code to work as expected.

For example:

Unit Foo() => unit;
Task<Unit> Bar() => unit.AsTask();

TryAsync(unit).Match(Succ: _ => Foo(), Fail: _ => Bar());

Also, avoid using async without await.

The second Warnings comes from the fact that non-Action overloads of Match are marked as Pure, so you should do something with its return value.
One thing you could do, if your return value is Unit and you're using your Match call for impure code, is to write _ = await /* ... */ to tell the analyzer explicitly that you don't care about the return value.

Another thing I like to do is defining an extension method Unit Ignore<T>(this T value) => unit that makes it a bit more explicit in my opinion.

[MrYossu]

@CK-LinoPro Thanks for the explanation. My problem was that OnSuccess was sync and OnFailure was async, so the compiler picked the overload for Match that takes sync lambdas, which is why R# gave me a warning. I realise now that in such a case I need to wrap the OnSuccess in Task.Run() to convince the compiler to call the overload I want. Adds a bit of noise to the code, but fixes the warning (and presumably the underlying issue that comes with it).

Thanks also for the explanation about the pure warning. Makes a lot of sense. I like the extension method, as you say, makes it clearer.

[StanJav]

Another thing I like to do is defining an extension method Unit Ignore<T>(this T value) => unit that makes it a bit more explicit in my opinion.

Just in case you haven't seen it, there is Unit ignore<A>(A anything) => unit; also in this library. It is not an extension method, but I personally use using static LanguageExt.Prelude; almost everywhere so it is always there for me.

[MrYossu]

@StanJav Ooh, I didn't realise it was part of the library (obvious really, it's too useful to have been missed!).

Thanks for pointing that out.

[MrYossu]

@StanJav Hmm, just tried it, and it can't resolve the symbol ignore even though I have using static LanguageExt.Prelude

I'm trying this on the end of a call to TryAsync.Match()

Any ideas?

[MrYossu]

Duh, silly me. I was looking for it as an extension method, not a standalone method (I know, I should read people's replies more carefully!).

Thanks again.

[MrYossu]

@CK-LinoPro and @StanJav I have come across a similar issue, which I explained in a new discussion (as it's not quite the same as this one).

Would you be able to take a look and see what I did wrong? Thanks again.