Implict Operators, Generics, and Nullable

[TonyValenti]

I have this code:

    public record struct Optional<T> {
        
        public bool IsPresent { get; init; }

        public T? Value { get; init; }

        public static implicit operator Optional<T>(T? Value) {
            // ...
        }
}

Which I can use like this:

 public class ActivityData {
        public Optional<long> Calendar_Entry_Id { get; set; } = new();
   }

//...

var C = new ActivityData(){ Calendar_Entry_Id = 23 };

I would like to be able to run a different code if a null/nullable value is used. For example:

var C = new ActivityData(){ Calendar_Entry_Id = default(long?) };

Specifically, in that situation, I want to create an Optional with IsPresent = false instead of an Optional<long?>.

What is the right way to do this?

[CyrusNajmabadi]

can't you just check if the value is null here:

        public static implicit operator Optional<T>(T? Value) {
            return value is null ? default : new { Value = value, IsPresent = true };
        }

?

[TonyValenti]

@CyrusNajmabadi I cant because the Optional<long?> operator is called instead of the Optional<long> operator.

[CyrusNajmabadi]

Oh . I see what you're trying to do. Yes, i don't think this would be possible here (without contraining T which i don't think is your desired intent).

[jnm2]

The way I do this is Optional.FromNullable(expr) which can have separate where T : class and where T : struct overloads.

public static class Optional
{
    public static Optional<T> FromNullable<T>(T? nullableValue) where T : struct
    {
        return nullableValue is { } value ? Optional.Some(value) : Optional.None<T>();
    }

    public static Optional<T> FromNullable<T>(T? nullableValue) where T : class
    {
        return nullableValue is { } value ? Optional.Some(value) : Optional.None<T>();
    }
    
    // Some<T>(T value) and None<T>() are also defined here 
}

[jnm2]

I don't like implicit operators because then Optional<object> can accidentally get boxed and become the object inside another Optional<object>. I like to see Optional.Some(...) around a thing if it's gaining a 'some' semantic.