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));
}
