out parameters with nullable reference types

Question

I have implemented an Option type for some project of mine like this:

public abstract Option<T> {}

public class None<T> : Option<T>

public class Some<T> : Option<T> 
{
    public T Value { get; }

    public Some(T value)
    {
        Value = value;
    }
}

For finding out if an Option contains a value I use this extension method which makes use of pattern matching:

public static bool TryGetValue<T>(this Option<T> option, out T value)
{
    if (option is Some<T> some)
    {
        value = some.Value;
        return true;
    }

    value = default;
    return false;
}

I now get the following warning for return default;

Cannot convert null literal to non nullable reference or unconstrained type parameter

It is impossible for me to restrict the generic parameter T to class or struct.

For example, if I restricted the generic parameter to class, I couldn't generate Option<int?> instances as the Nullable<int> type is a struct itself. Declaring the out parameter as nullable via postfixing ? is also not a solution as it seems.

To me the type system is somewhat broken or not thoroughly thought through at this stage. Either Nullable should have been a class or there needs to be a generic parameter restriction like:

public static bool TryGetValue<T>(this Option<T> option, out T value) 
    where T : nullable [...]

Is there another approach that might be suitable for this issue? What am I missing?

I think you should watch this youtube.com/watch?v=F9bznonKc64 Mark Seemann talk about monads. After this you stop trying to get value out of monad. :) — Michał K.
Regardless, I would like to know what the default value is for a non-nullable reference type — Jaybird
Well I copied your code and it does not prompt your warning. Sorry I can't help you. Do you use VS2019? — Michał K.
Why not add an abstract Value property on the abstract class, and in case of None<T> implement it by returning default, and on Some<T> by returning it's value? — EluciusFTW

Yair Halberstadt Yair Halberstadt · Accepted Answer · 2019-03-31T18:01:25

Use the MaybeNullWhenAttribute or the NotNullWhenAttribute. I recommend MaybeNullWhen since it works even on a type parameter not constrained to a struct or reference type.

public static bool TryGetValue<T>(this Option<T> option, [MaybeNullWhen(false)] out T value)
{
    if (option is Some<T> some)
    {
        value = some.Value;
        return true;
    }

    value = default;
    return false;
}

Usage:

if(option.TryGetValue(out var value))
{
    value.SomeMethod(); // no warning - value is known to be non-null here
}
value.SomeMethod(); // warning - value may be null here.

The attribute is not available pre .Net standard 2.1/.new core 3.0, but you can manually define it yourself if it's not available. Make sure it's internal, as otherwise if another library also defines it as public and someone inherits from both libraries it will cause conflicts:

namespace System.Diagnostics.CodeAnalysis
{
    /// <summary>Specifies that when a method returns <see cref="ReturnValue"/>, the parameter may be null even if the corresponding type disallows it.</summary>
    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
    internal sealed class MaybeNullWhenAttribute : Attribute
    {
        /// <summary>Initializes the attribute with the specified return value condition.</summary>
        /// <param name="returnValue">
        /// The return value condition. If the method returns this value, the associated parameter may be null.
        /// </param>
        public MaybeNullWhenAttribute(bool returnValue) => ReturnValue = returnValue;

        /// <summary>Gets the return value condition.</summary>
        public bool ReturnValue { get; }
    }

(taken from https://github.com/dotnet/runtime/blob/6077cf01f951a711a26a8d5970b211b6031b5158/src/libraries/System.Private.CoreLib/src/System/Diagnostics/CodeAnalysis/NullableAttributes.cs#L45-L60)

out parameters with nullable reference types

2 Answers