TryOptionAsync incorrect nullablity about language-ext HOT 4 CLOSED

Yep, that's a part of the library that's not been converted over to use nullable markup yet. I'll get to that eventually.

In the meantime there's also:

TryOptionAsync<A>(Option<A> v)
TryOptionAsync<A>(Task<Option<A>> v)

Which allows you to construct TryOptionAsync from Option, so convert your string? to an Option first using Prelude.Optional.

I'd also recommend, (depending on how deep your usage of the Try* monads are), to instead use Eff<A> and Aff<A> - they're much more featureful than Try* and are the primary focus of future development; the Try* types should be seen as legacy now (although I will keep supporting them, and will update them to nullable, they aren't going to be the future focus).

from language-ext.

Alright, thanks for the tip.

So I'd assume that (considering the nullability is fixed) I'd have to change

TryOptionAsync(SomethingReturningStringAsync())

To

Aff(async () => Prelude.Optional(await SomethingReturningStringAsync())

Or if desired

Aff<Option<string>>(async () => await SomethingReturningStringAsync())

from language-ext.

This:

TryOptionAsync(SomethingReturningStringAsync())

... is only the right way to go if you never need the execution of the SomethingReturningStringAsync wrapped inside the Try*. If you think about it the function SomethingReturningStringAsync could throw an exception and it not be caught, because you're only putting the result of SomethingReturningStringAsync() inside a Try* after it's run.

Which is why Try* uses delegates. This is the correct way to lift a function into a Try*:

// NOTE: no invocation of the function
var operation = TryOptionAsync(SomethingReturningStringAsync);  

The same goes for Aff (as it also catches exceptions). The equivalent lifting functions are Aff and AffMaybe. But in your case, because you want to get rid of the nullable-reference, you can add some additional conversion functions:

public static class YourPrelude
{
    public static Aff<A> OptionalAff<A>(this Func<Task<A?>> task) =>
        OptionalAff(task, Errors.None);
    
    public static Aff<A> OptionalAff<A>(this Func<Task<A?>> task, Error fail) =>
        AffMaybe(async () => 
            await task() switch
            {
                null => fail,
                var x => FinSucc(x)
            });
    
    public static Aff<A> OptionalAff<A>(this Func<ValueTask<A?>> task) =>
        OptionalAff(task, Errors.None);
    
    public static Aff<A> OptionalAff<A>(this Func<ValueTask<A?>> task, Error fail) =>
        AffMaybe(async () => 
            await task() switch
            {
                null => fail,
                var x => FinSucc(x)
            });
}

These make sure the Task is run inside of the Aff (so exceptions are caught properly), but also pattern-matches on null to turn it into the Error value provided.

You can then write:

    Aff<string> aff = OptionalAff(SomethingReturningStringAsync);

from language-ext.

Closing due to this: #1269

from language-ext.