Behavior with Nullable Interface while implicit maybe-generation

Currently if facing in an issue / behavior with the implicit Maybe-generation. As for an example:

    public interface ITest
    {
        
    }

        private Maybe<ITest> CallMethod()
        {
            ITest? test = null;
            return test;
        }

The return test resulted in an error cannot convert expression ITest? to return type Maybe<ITest>. Is there not an implicit conversion for nullable interfaces? The above described problem is an easy example. In my code i receive (from Quartz.net) e.g. a Task<ITrigger?> and, also for async operations, the implicit conversion does not work.

Regards Laszlo

[LaszloLueck]

Hi Vladimir, thanks for your response. I think you´re right. It is not the best idea to wrap an extension like maybe over a low level nullable handling like in c# 8.0 (which is exactly designed for). As i coded in Scala, there was the best practice to handle nulls as None<T> or not nulls as Some<T> to avoid nulls from your code.

I leave my function extensions to remove the nullables in my project. This is primarily syntactic sugar for me, to avoid the handling with ?? and ?.

Thanks for your patience,

Regards, Laszlo

[vkhorikov]

Sorry for late replies.

You can have it both ways:

Maybe<ITest> maybe = Maybe.From(test);

or

Maybe<ITest?> maybe = Maybe.From(test);

The compiler will agree with either option.

Your suggestion is to add extensions for T?, in addition to Maybe<T>? If so, I don’t think it’s a good idea, from the point of keeping the library focused on the one way of doing things. T? is an alternative to Maybe<T>. It makes sense to support the conversion from one to the other, but not re-implement the existing extension methods on top of both.