Migrating some extension methods upstream

[yringler]

I recently started using this library, and wrote some extension methods.
In particular, I found myself making Maybe<Result> and Maybe<Result>, so made some extension methods to make those easier to work with.

Do you think any of the ideas here would be useful in this library?

When you start with a field which might be null (eg user input), and then call .Map to try to parse it - you end up with a Maybe of Result.
But that's a pain to work with, because you have to dig into it to get any validation errors.
So I made an .Optional() extension method, which converts it to a Result of Maybe
and a .Required() extension, because the existing ToResult() would leave you with a Result of Result.

Optional

	/// <summary>
	/// Mark the possibly null value as optional. Null is not an error, it's just null. The inverse of CSharpFunctionalExtensions.MaybeExtensions.ToResult
	/// </summary>
	public static Result<Maybe<T>, TError> Optional<T, TError>(this Maybe<Result<T, TError>> maybe)
	{
		if (maybe.HasNoValue)
		{
			return Result.Success<Maybe<T>, TError>(Maybe<T>.None);
		}

		if (maybe.Value.IsFailure)
		{
			return Result.Failure<Maybe<T>, TError>(maybe.Value.Error);
		}

		return Result.Success<Maybe<T>, TError>(Maybe.From(maybe.Value.Value));
	}

Required is quite a bit simpler. I found creation was best left returning optional, and then if we want it to be required, that can be declared after words. So Required ends up working with a Result of Maybe, allowing us to do a simple bind.

public static Result<T, TError> Required<T, TError>(this Result<Maybe<T>, DetailedError> result, TError error) =>
		result.Bind(value => value.ToResult(error));

I also added a special case for Map. to map an optional value (Maybe) to an optional result (Result of Maybe).

	public static Result<Maybe<TOut>, TError> Map<TIn, TOut, TError>(this Maybe<TIn> maybe, Func<TIn, Result<TOut, TError>> map)
	{
		if (maybe.HasNoValue)
		{
			return Result.Success<Maybe<TOut>, TError>(Maybe<TOut>.None);
		}
		
		return map(maybe.Value).Map(Maybe.From);
	}

I think EnsureNot is also useful, and a BindOptional to make it easier to map Result of Maybe of T - it allows you to write a mapping function which transforms T, and not have to worry about the other wrappers.

	/// <summary>
	/// Change from one result type to another, while staying optional (the return type still contains <see cref="Maybe"/>)
	/// Even though it's a Result&lt;Maybe&gt;, the mapping function only has to
	/// operate on the innermost value, and is only called if it's present.
	/// </summary>
	public static Result<Maybe<TOut>, TError> BindOptional<TIn, TOut, TError>(
		this Result<Maybe<TIn>, TError> result,
		Func<TIn, Result<TOut, TError>> bind)
	{
		return result.Bind(value => value.Map(bind));
	}
	
	/// <inheritdoc cref="BindOptional{TIn,TOut,TError}"/>
	public static Result<Maybe<TOut>, TError> BindOptional<TIn, TOut, TError>(
		this Maybe<TIn> maybe,
		Func<TIn, Result<TOut, TError>> bind)
	{
		return maybe.Bind(v => Maybe.From(bind(v))).Optional();
	}

[vkhorikov]

Looks useful to me. Feel free to submit a PR.