public static CanCauseError <T, TError> NoError(T result) { var results = new CanCauseError <T, TError> { result = result, error = false }; return(results); }
public static CanCauseError <TValue> TryGetValue <TKey, TValue>(this IDictionary <TKey, TValue> dict, TKey key) { TValue value; return(dict.TryGetValue(key, out value) ? value : CanCauseError <TValue> .Error("No value with key {0} found.", key)); }
public static CanCauseError <T, TError> Error(TError error) { var result = new CanCauseError <T, TError> { error = true, errorState = error }; return(result); }
public static CanCauseError <TOut> ConvertError <TIn, TOut>(this CanCauseError <TIn> error) { if (error.CausedError) { return(error.ConvertError <TOut>()); } else { throw new InvalidCastException(); } }
public static CanCauseError <T> Where <T>(this CanCauseError <T> error, Func <T, bool> predicate) { if (error.CausedError || predicate(error.Result)) { return(error); } else { return(CanCauseError <T> .Error("Value failed predicate")); } }
public static CanCauseError ExceptionToError(this Action f) { try { f(); return(CanCauseError.NoError); } catch (Exception e) { return(CanCauseError.Error(e.Message)); } }
public static CanCauseError <T> ExceptionToError <T>(this Func <T> f) { try { var result = f(); return(CanCauseError <T> .NoError(result)); } catch (Exception e) { return(CanCauseError <T> .Error(e.Message)); } }
public static CanCauseError Bind(this IEnumerable <Func <CanCauseError> > functions) { CanCauseError result = null; foreach (var func in functions) { result = func(); if (result.CausedError) { break; } } return(result); }
public static CanCauseError <C, Error> SelectMany <A, B, C, Error>( this CanCauseError <A, Error> a, Func <A, CanCauseError <B, Error> > func, Func <A, B, C> select) { if (a.CausedError) { return(CanCauseError <C, Error> .Error(a.ErrorState)); } else { var b = func(a.Result); return(b.CausedError ? CanCauseError <C, Error> .Error(b.ErrorState) : select(a.Result, b.Result)); } }
public static CanCauseError <T> Bind <T>(this IEnumerable <Func <T, CanCauseError <T> > > functions, T start) { CanCauseError <T> result = CanCauseError <T> .NoError(start); foreach (var func in functions) { result = func(result.Result); if (result.CausedError) { break; } } return(result); }
public static CanCauseError <C> SelectMany <A, B, C>( this CanCauseError <A> a, Func <A, CanCauseError <B> > func, Func <A, B, C> select) { if (a.CausedError) { return(a.ConvertError <C>()); } else { var b = func(a.Result); return(b.CausedError ? b.ConvertError <C>() : select(a.Result, b.Result)); } }
public static CanCauseError <TOut> Map <TIn1, TIn2, TOut>( this Func <TIn1, TIn2, TOut> f, CanCauseError <TIn1> x, CanCauseError <TIn2> y) { if (x.CausedError) { return(x.ConvertError <TOut>()); } else if (y.CausedError) { return(y.ConvertError <TOut>()); } else { return(f(x.Result, y.Result)); } }
public CanCauseError HandleArgs(IEnumerable <string> args) { int parameterNumber = 0; foreach (var arg in args) { if (arg[0] == '-') { var split = arg.Split(new[] { ':' }, 2); var flagName = split[0].TrimStart('-'); var param = split.Length == 2 ? split[1] : null; Action <string> flagAction; if (flags.TryGetValue(flagName, out flagAction)) { flagAction(param); } else { return(CanCauseError.Error("No flag named {0} exists.", flagName)); } } else { if (parameterNumber < parameters.Length) { parameters[parameterNumber](arg); } else { return(CanCauseError.Error("Too many parameters.")); } } } return(CanCauseError.NoError); }
public static T ValueOrDefault <T>(this CanCauseError <T> error, T defaultValue = default(T)) { return(error.CausedError ? defaultValue : error.Result); }
public static CanCauseError <TOut> Select <TIn, TOut>( this CanCauseError <TIn> x, Func <TIn, TOut> f) { return(f.Map(x)); }
public static CanCauseError <TOut> Map <TIn, TOut>( this Func <TIn, TOut> f, CanCauseError <TIn> x) { return(x.CausedError ? x.ConvertError <TOut>() : f(x.Result)); }
public static T ValueOrDefault <T>(this CanCauseError <T> error, Func <T> defaultValue) { return(error.CausedError ? defaultValue() : error.Result); }
public static CanCauseError Bind(this Func <CanCauseError> first, Func <CanCauseError> second) { CanCauseError firstResult = first(); return(firstResult.CausedError ? firstResult : second()); }
public static CanCauseError <T> Bind <T>(this Func <CanCauseError <T> > first, Func <T, CanCauseError <T> > second) { CanCauseError <T> firstResult = first(); return(firstResult.CausedError ? firstResult : second(firstResult.Result)); }