Nullable reference types and "[CS8603] Possible null reference return."

Question

I have almost successfully updated an library of mine to be "nullable aware". However the following code gives me trouble.

public static Result<string, TValid> ResultMustBe<TValid>
(
    this TValid self,
    params Func<TValid, Result<string, TValid>>[] validators
)
{
    var caller = new StackFrame(1)?.GetMethod()?.DeclaringType?.FullName ?? "?";

    if (!validators.Any())
    {
        throw new ArgumentException($"No validators provided for EitherMustBe in {caller}");
    }

    Result<string, TValid>? result = null;

    foreach (var validator in validators)
    {
        try
        {
            result = validator(self);

            if (result is Result<string, TValid>.Invalid left)
            {
                return Result<string, TValid>.MakeInvalid(left.Error.Replace("<<caller>>", caller));
            }
        }
        catch (Exception ex)
        {
            throw new ValidationException($"Uncaught exception occured while validating {caller}", ex);
        }
    }
    // Warning produced here
    return result! as Result<string, TValid>.Valid;
}

public abstract class Result<TInvalid, TValid>
{
    public static Valid MakeValid(TValid data)
    {
        return new Valid(data);
    }

    public static Invalid MakeInvalid(TInvalid error)
    {
        return new Invalid(error);
    }

    public abstract bool IsValid { get; }

    public class Invalid : Result<TInvalid, TValid>
    {
        public TInvalid Error { get; }
        public override bool IsValid => false;

        public Invalid(TInvalid error)
        {
            Error = error;
        }
    }

    public class Valid : Result<TInvalid, TValid>
    {
        public TValid Data { get; }
        public override bool IsValid => true;

        public Valid(TValid data)
        {
            Data = data;
        }
    }
}

The compiler gives me a warning for the return with [CS8603] Possible null reference return which I sort of can understand, seeing as I initialize result with null. However the method can never actually return null, result will always be the latest returned value from validator.

Is a pragma warning diable my only option here, or am I missing something? I should add that I don't want to change the return type of my method Either (as again, it should be null-safe).

Edit: Renamed the class Either to Result (return type) as it distracted away from the question. Also included the code for the class. As asked in the comments the type was indeed inspired by FP, from Kotlin Arrow to be precise, but it was never intended to behave exactly like it.

Answer 1

// Warning produced here
return result! as Result<string, TValid>.Valid;

You are using the as operator, which can possibly return null, so the resulting type will be nullable. Use as when you think the type might not match and you want it to evaluate to null in cases that it doesn't. If you believe that it should always match, then use a regular cast.

return (Result<string, TValid>.Valid)result!;

This will throw if your assumption that result must be of type Valid is wrong, which is what you want. You might also want to add a null check to make sure you aren't somehow returning null (like if the last validator returned null.) (It's legal to cast a null value, so the cast will not catch it.)

Answer 2

The question is unclear even for functional programmers, because it contains no info on the Either type. Is it a custom class, does it come from a specific library? What is it's API?

C# doesn't have an Either type and F#, which does have discriminated unions and a Result Type uses different syntax and in fact, only people that know a bit about Haskell may know that the left type is supposed to be the "error" value.

In any case, the functional way of chaining Results is for each function to receive the previous one's input and if it's an Error, return it immediately. If not, apply the function. This is often called Railway oriented programming.

If you have a list/enumerable/array of functions (in this case validators), you can use fold in F# or LINQ's Aggregate in C# to call each validator and pass the previous result to it. Without knowing what Either looks like, or you can construct values for it, I can only propose a pseudocode example :

Either<string,TValue> ValidateEitherMustBe<TValid>
    (
        this TValid self,
        params Func<TValid, Either<string, TValid>>[] validators
    )
{
    var seed=Either<string, TValid>.MakeValid(self);
    var result=validators.Aggregate((previous,validator) => 
                       previous switch { Either<string, TValid>.Invalid _   => previous,
                                         Either<string, TValid>.Valid value => valid(value),
    });    
    return result;
}