/// <summary> /// Allows values from multiple maybe instances to be combined in the select portion of a LINQ query. /// </summary> /// <typeparam name="T">The type of the first maybe instance.</typeparam> /// <typeparam name="TOther">The type of the second maybe instance.</typeparam> /// <typeparam name="TResult">The type of the result of combining the two types.</typeparam> /// <param name="maybe">A maybe instance to combine.</param> /// <param name="converter">A function that takes the value of <paramref name="maybe"/> (when non-empty) and returns a Maybe{TOther} result.</param> /// <param name="combiner">Function that combines values of T and TOther to return a TResult.</param> /// <returns>A Maybe{TResult} containing the result of the <paramref name="combiner"/> function. Will be Mabye{T}.Not</returns> /// <exception cref="System.ArgumentNullException">Thrown if <paramref name="converter"/> or <paramref name="combiner"/> is null.</exception> public static Maybe <TResult> SelectMany <T, TOther, TResult>(this Maybe <T> maybe, Func <T, Maybe <TOther> > converter, Func <T, TOther, TResult> combiner) { if (converter == null) { throw new ArgumentNullException(nameof(converter)); } if (combiner == null) { throw new ArgumentNullException(nameof(combiner)); } return(maybe.Bind <TResult> ( (a) => converter(a).Bind <TResult> ( (b) => (Maybe <TResult>)combiner(a, b) ) )); }
internal static Maybe <TAccumulate> FoldImpl <TSource, TAccumulate>( this IEnumerable <TSource> source, TAccumulate seed, Func <TAccumulate, TSource, Maybe <TAccumulate> > accumulator) { Debug.Assert(source != null); Debug.Assert(accumulator != null); Maybe <TAccumulate> retval = Maybe <TAccumulate> .η(seed); using (var iter = source.GetEnumerator()) { while (iter.MoveNext()) { retval = retval.Bind(val => accumulator(val, iter.Current)); } } return(retval); }
// Safe Version public static Maybe <List <IpsDataSet> > MGetEachDataSetWith(this Maybe <string> ipspath, Maybe <string> klapath) { var klaDataDict = klapath .Bind(x => Just(GetDirectoryName(x))) .Bind(x => Just(GetFiles(x))) .Match( () => null, x => GetKlaData(x)); var toAllPathList = ToAllPathListWith.Apply(klaDataDict); return(ipspath .Lift(GetDirectoryName) .Bind(MGetAllDirs) .Bind(MGetAllFileNames) .Bind(MGetIpsDataSetPaths) //[ SCalss , ResPath , RfltPath ] .Bind(x => x.Select(toAllPathList)) .Lift(ToIpsDataSet) .ToList()); }
internal static Maybe <TSource> ReduceImpl <TSource>( this IEnumerable <TSource> source, Func <TSource, TSource, Maybe <TSource> > accumulator) { Debug.Assert(source != null); Debug.Assert(accumulator != null); using (var iter = source.GetEnumerator()) { if (!iter.MoveNext()) { throw new InvalidOperationException("Source sequence was empty."); } Maybe <TSource> retval = Maybe <TSource> .η(iter.Current); while (iter.MoveNext()) { retval = retval.Bind(val => accumulator(val, iter.Current)); } return(retval); } }
public static Maybe <T> Join <T>(this Maybe <Maybe <T> > maybe) { return(maybe.Bind(a => a)); }
public static Maybe <TC> SelectMany <TA, TB, TC>(this Maybe <TA> ma, Func <TA, Maybe <TB> > f, Func <TA, TB, TC> select) => ma.Bind(a => f(a).Map(b => select(a, b)));
public static Maybe <TResult> SelectMany <TSource, TResult>(this Maybe <TSource> m, Func <TSource, TResult> f) { return(m.Bind(x => f(x).ToMaybe())); }
void RightIdentityHolds(Maybe <object> m) => Assert.Equal( m, m.Bind(Just));
public static Maybe <B> Select <A, B>(this Maybe <A> a, Func <A, Maybe <B> > func) { return(a.Bind(func)); }
private static string GetStringStacked(Maybe <string> input) { var stackedString = input.Bind(StringTransformers.StackString); return(GetStringIfDefined(stackedString)); }
public void TwoClauseLINQExpr(Maybe <string> maybeA, Maybe <string> maybeB) => Assert.Equal( from a in maybeA from b in maybeB select a + b, maybeA.Bind(a => maybeB.Map(b => a + b)));
public static Func <Maybe <TU>, Maybe <TResult> > Bind <TU, TIntermediate, TResult>([NotNull] Func <TU, Maybe <TIntermediate> > f, [NotNull] Func <Maybe <TIntermediate>, Maybe <TResult> > g) { return(Combine(Maybe <TU> .Bind(f), g)); }
public static Maybe <R> ApplyInTermsOfBind <T, R>(this Maybe <Func <T, R> > func, Maybe <T> arg) => arg.Bind(t => func.Bind <Func <T, R>, R>(f => f(t)));
public static Maybe <TResult> SelectMany <TSource, TMaybe, TResult>(this Maybe <TSource> m, Func <TSource, Maybe <TMaybe> > f, Func <TSource, TMaybe, TResult> g) { return(m.Bind(x => f(x).Bind(y => g(x, y).ToMaybe()))); }
public static Maybe <B> Bind <A, B>(Maybe <A> ma, Func <A, Maybe <B> > amb) { return(ma.Bind(amb)); }
public static Maybe <C> SelectMany <A, B, C>(this Maybe <A> a, Func <A, Maybe <B> > func, Func <A, B, C> select) { return(a.Bind(aval => func(aval).Bind(bval => select(aval, bval).ToMaybe()))); }
public static Maybe <B> SelectMany <A, B>(this Maybe <A> maybe, Func <A, Maybe <B> > selectManyFunc) { return(maybe.Bind(selectManyFunc)); }
public static Maybe <B> Ap <A, B>(this Maybe <Func <A, B> > f, Maybe <A> arg) { return(f.Bind(f0 => arg.Map(f0))); }
public static Maybe <C> SelectMany <A, B, C>(this Maybe <A> maybe, Func <A, Maybe <B> > selectManyFunc, Func <A, B, C> combineFunc) { return(maybe.Bind(a => selectManyFunc(a).Bind(b => Maybe.Just(combineFunc(a, b))))); }
void AssociativityHolds(Maybe <string> m) => Assert.Equal( m.Bind(Double.Parse).Bind(safeSqrt), m.Bind(x => Double.Parse(x).Bind(safeSqrt)));
public static Maybe <TValue> TryGetValue <TKey, TValue>(this Maybe <IDictionary <TKey, TValue> > dictionary, Maybe <TKey> key) { return(dictionary.Bind(x => key.Bind(x.TryGetValue))); }