/// <seealso cref="Gather{TSource, TResult}" />
public static MonadZero <TResult> Apply <TSource, TResult>(
this MonadZero <Func <TSource, TResult> > @this,
MonadZero <TSource> value)
{
Require.NotNull(value, nameof(value));
return(value.Gather(@this));
}
public static MonadZero <TSource> PassBy <TSource, TOther>(
this MonadZero <TSource> @this,
MonadZero <TOther> other)
{
Require.NotNull(@this, nameof(@this));
return(@this.ZipWith(other, (arg, _) => arg));
}
public static MonadZero <TResult> ContinueWith <TSource, TResult>(
this MonadZero <TSource> @this,
MonadZero <TResult> other)
{
Require.NotNull(@this, nameof(@this));
return(@this.Bind(_ => other));
}
public static MonadZero <TResult> ReplaceBy <TSource, TResult>(
this MonadZero <TSource> @this,
TResult value)
{
Require.NotNull(@this, nameof(@this));
return(@this.Select(_ => value));
}
/// <seealso cref="MonadZero.Lift{T1, T2, T3, T4, T5, TResult}"/>
public static MonadZero <TResult> ZipWith <T1, T2, T3, T4, T5, TResult>(
this MonadZero <T1> @this,
MonadZero <T2> second,
MonadZero <T3> third,
MonadZero <T4> fourth,
MonadZero <T5> fifth,
Func <T1, T2, T3, T4, T5, TResult> zipper)
{
Require.NotNull(@this, nameof(@this));
Require.NotNull(second, nameof(second));
Require.NotNull(third, nameof(third));
Require.NotNull(fourth, nameof(fourth));
Require.NotNull(fifth, nameof(fifth));
Require.NotNull(zipper, nameof(zipper));
// > return @this.Bind(
// > arg1 => second.Bind(
// > arg2 => third.Bind(
// > arg3 => fourth.Bind(
// > arg4 => fifth.Select(
// > arg5 => zipper(arg1, arg2, arg3, arg4, arg5))))));
return(@this.Bind(
arg1 => second.ZipWith(
third,
fourth,
fifth,
(arg2, arg3, arg4, arg5) => zipper(arg1, arg2, arg3, arg4, arg5))));
}
public static MonadZero <TSource> Where <TSource>(
this MonadZero <TSource> @this,
Func <TSource, bool> predicate)
{
Require.NotNull(@this, nameof(@this));
Require.NotNull(predicate, nameof(predicate));
return(@this.Bind(val => predicate(val) ? MonadZero <TSource> .η(val) : MonadZero <TSource> .Zero));
}
public static MonadZero <TResult> Select <TSource, TResult>(
this MonadZero <TSource> @this,
Func <TSource, TResult> selector)
{
Require.NotNull(@this, nameof(@this));
Require.NotNull(selector, nameof(selector));
return(@this.Bind(val => MonadZero <TResult> .η(selector(val))));
}
/// <seealso cref="Apply{TSource, TResult}(MonadZero{Func{TSource, TResult}}, MonadZero{TSource})" />
public static MonadZero <TResult> Gather <TSource, TResult>(
this MonadZero <TSource> @this,
MonadZero <Func <TSource, TResult> > applicative)
{
Require.NotNull(@this, nameof(@this));
Require.NotNull(applicative, nameof(applicative));
return(applicative.Bind(func => @this.Select(func)));
}
// Select() with automatic resource management.
public static MonadZero <TResult> Using <TSource, TResult>(
this MonadZero <TSource> @this,
Func <TSource, TResult> selector)
where TSource : IDisposable
{
Require.NotNull(@this, nameof(@this));
Require.NotNull(selector, nameof(selector));
return(@this.Select(val => { using (val) { return selector(val); } }));
}
// Bind() with automatic resource management.
public static MonadZero <TResult> Using <TSource, TResult>(
this MonadZero <TSource> @this,
Func <TSource, MonadZero <TResult> > binder)
where TSource : IDisposable
{
Require.NotNull(@this, nameof(@this));
Require.NotNull(binder, nameof(binder));
return(@this.Bind(val => { using (val) { return binder(val); } }));
}
public static MonadZero <TResult> Join <TSource, TInner, TKey, TResult>(
this MonadZero <TSource> @this,
MonadZero <TInner> inner,
Func <TSource, TKey> outerKeySelector,
Func <TInner, TKey> innerKeySelector,
Func <TSource, TInner, TResult> resultSelector)
=> @this.Join(
inner,
outerKeySelector,
innerKeySelector,
resultSelector,
null);
private static Func <TKey, MonadZero <TInner> > GetKeyLookup <TInner, TKey>(
MonadZero <TInner> inner,
Func <TInner, TKey> innerKeySelector,
IEqualityComparer <TKey> comparer)
{
Debug.Assert(inner != null);
Debug.Assert(innerKeySelector != null);
return(outerKey =>
inner.Select(innerKeySelector)
.Where(innerKey => (comparer ?? EqualityComparer <TKey> .Default).Equals(innerKey, outerKey))
.ContinueWith(inner));
}
/// <seealso cref="MonadZero.Lift{T1, T2, TResult}"/>
public static MonadZero <TResult> ZipWith <T1, T2, TResult>(
this MonadZero <T1> @this,
MonadZero <T2> second,
Func <T1, T2, TResult> zipper)
{
Require.NotNull(@this, nameof(@this));
Require.NotNull(second, nameof(second));
Require.NotNull(zipper, nameof(zipper));
return(@this.Bind(
arg1 => second.Select(
arg2 => zipper(arg1, arg2))));
}
// Generalizes both Bind() and ZipWith<T1, T2, TResult>().
public static MonadZero <TResult> SelectMany <TSource, TMiddle, TResult>(
this MonadZero <TSource> @this,
Func <TSource, MonadZero <TMiddle> > selector,
Func <TSource, TMiddle, TResult> resultSelector)
{
Require.NotNull(@this, nameof(@this));
Require.NotNull(selector, nameof(selector));
Require.NotNull(resultSelector, nameof(resultSelector));
return(@this.Bind(
val => selector(val).Select(
middle => resultSelector(val, middle))));
}
public static MonadZero <TResult> Join <TSource, TInner, TKey, TResult>(
this MonadZero <TSource> @this,
MonadZero <TInner> inner,
Func <TSource, TKey> outerKeySelector,
Func <TInner, TKey> innerKeySelector,
Func <TSource, TInner, TResult> resultSelector,
IEqualityComparer <TKey> comparer)
{
Require.NotNull(@this, nameof(@this));
Require.NotNull(inner, nameof(inner));
Require.NotNull(resultSelector, nameof(resultSelector));
Require.NotNull(outerKeySelector, nameof(outerKeySelector));
Require.NotNull(innerKeySelector, nameof(innerKeySelector));
var lookup = GetKeyLookup(inner, innerKeySelector, comparer);
Func <TSource, MonadZero <TInner> > valueSelector = outer => lookup(outerKeySelector(outer));
return(@this.SelectMany(valueSelector, resultSelector));
}
/// <seealso cref="MonadZero.Lift{T1, T2, T3, TResult}"/>
public static MonadZero <TResult> ZipWith <T1, T2, T3, TResult>(
this MonadZero <T1> @this,
MonadZero <T2> second,
MonadZero <T3> third,
Func <T1, T2, T3, TResult> zipper)
{
Require.NotNull(@this, nameof(@this));
Require.NotNull(second, nameof(second));
Require.NotNull(third, nameof(third));
Require.NotNull(zipper, nameof(zipper));
// This is the same as:
// > return @this.Bind(
// > arg1 => second.Bind(
// > arg2 => third.Select(
// > arg3 => zipper(arg1, arg2, arg3))));
// but faster if ZipWith is locally shadowed.
return(@this.Bind(
arg1 => second.ZipWith(
third, (arg2, arg3) => zipper(arg1, arg2, arg3))));
}
public static MonadZero <unit> Skip <TSource>(this MonadZero <TSource> @this)
{
Require.NotNull(@this, nameof(@this));
return(@this.ContinueWith(MonadZero.Unit));
}
internal static MonadZero <T> μ(MonadZero <MonadZero <T> > square) => square.Bind(Stubs <MonadZero <T> > .Ident);
/// <summary> /// Removes one level of structure, projecting its bound value into the outer level. /// </summary> public static MonadZero <T> Flatten <T>(this MonadZero <MonadZero <T> > @this) => MonadZero <T> .μ(@this);