Is there a need for some syntactic suger? Or am i too blind to find it?

Hi, thank you for this nice extensions. Currently i using a similar extension, because of inactivity i assume to change to this one. I used your Maybe<T> functionality extensively to keep the nullables away from me. I came from the scala-world, so in this project am missing some syntactic sugar around the Maybe<T>. In scala it is a little part of pattern matching: e.g.

public static TOut ResolveOr<TIn, TOut>(this Maybe<TIn> source, Func<TIn, TOut> resolver,
            Func<TOut> alternative) => !source.HasValue ? alternative.Invoke() : resolver.Invoke(source.Value);

to realize something like this (resolve the Maybe<T> to a TOut):

Maybe<T> value = 
IEnumerable
.Select(some things)
.Where(some filter)
.TryFirst();

And then:

var result = value.ResolveOr(
resolver => {do a lot of stuff with resolver and give back a value},
() => {when TryFirst will give back nothing, here you can go an alternative way and give back a value}
)

result is then of the result-type of your resolver/alternative method.

Is there a need to put this generic sugar to your extension or exists those things in your extension but i´m too blind to find it (missing reference or else)?

[vkhorikov]

Is there a Wrapper for nullable (or the counterpart of unwrap)?

There’s an implicit conversion that does that. You can just do this and it will automatically wrap the null into a Maybe:

Maybe<string> MyMethod()
{
    return null;
}

OK, for the Values method there is a Choose method in your project. That seems nearly that what i was looking for. But its usage is a little bit more trickier as i need only a filter for the none-types withoud a Func<T,U>.

We can add an overload for this method that would omit the selector.

[LaszloLueck]

OK, for the Values method there is a Choose method in your project. That seems nearly that what i was looking for. But its usage is a little bit more trickier as i need only a filter for the none-types withoud a Func<T,U>.

As an example:

var l = new List<Maybe<int>>() {Maybe<int>.None, Maybe<int>.From(2), Maybe<int>.None, Maybe<int>.From(4)};

Your method needs a Func<T, U> selector as parameter. If you only need the filter you must write too much.

var result1 = l.Choose(k => k);

My signature filters only the None-Values and return the rest, so it´s easier to read IMHO.

var result2 = l.Values();

Regards, Laszlo