public static Aff <RT, Func <D, E> > Apply <RT, A, B, C, D, E>(this Func <A, B, C, D, E> f, Aff <RT, A> ma, Aff <RT, B> mb, Aff <RT, C> mc) where RT : struct, HasCancel <RT> =>
AffMaybe <RT, Func <D, E> >(async rt =>
{
var(a, b, c) = await WaitAsync.WaitAll(ma.Run(rt), mb.Run(rt), mc.Run(rt)).ConfigureAwait(false);
if (a.IsFail || b.IsFail || c.IsFail)
{
var errs = Errors.None;
if (a.IsFail)
{
errs += a.Error;
}
if (b.IsFail)
{
errs += b.Error;
}
if (c.IsFail)
{
errs += c.Error;
}
return(errs);
}
else
{
return(FinSucc((D d) => f(a.Value, b.Value, c.Value, d)));
}
});
public static Aff <D> Apply <A, B, C, D>(this Aff <Func <A, B, C, D> > mf, Aff <A> ma, Aff <B> mb, Aff <C> mc) =>
AffMaybe <D>(async() =>
{
var(f, a, b, c) = await WaitAsync.WaitAll(mf.Run(), ma.Run(), mb.Run(), mc.Run()).ConfigureAwait(false);
if (f.IsFail || a.IsFail || b.IsFail || c.IsFail)
{
var errs = Errors.None;
if (f.IsFail)
{
errs += f.Error;
}
if (a.IsFail)
{
errs += a.Error;
}
if (b.IsFail)
{
errs += b.Error;
}
if (c.IsFail)
{
errs += c.Error;
}
return(errs);
}
else
{
return(f.Value(a.Value, b.Value, c.Value));
}
});
public static Aff <RT, Func <C, D, E> > Apply <RT, A, B, C, D, E>(this Aff <RT, Func <A, B, C, D, E> > mf, Aff <RT, A> ma, Aff <RT, B> mb) where RT : struct, HasCancel <RT> =>
AffMaybe <RT, Func <C, D, E> >(async rt =>
{
var(f, a, b) = await WaitAsync.WaitAll(mf.Run(rt), ma.Run(rt), mb.Run(rt)).ConfigureAwait(false);
if (f.IsFail || a.IsFail || b.IsFail)
{
var errs = Errors.None;
if (f.IsFail)
{
errs += f.Error;
}
if (a.IsFail)
{
errs += a.Error;
}
if (b.IsFail)
{
errs += b.Error;
}
return(errs);
}
else
{
return(FinSucc((C c, D d) => f.Value(a.Value, b.Value, c, d)));
}
});
public static Aff <RT, E> Apply <RT, A, B, C, D, E>(this Aff <RT, Func <A, B, C, D, E> > mf, Aff <RT, A> ma, Aff <RT, B> mb, Aff <RT, C> mc, Aff <RT, D> md) where RT : struct, HasCancel <RT> =>
AffMaybe <RT, E>(async rt =>
{
var(f, a, b, c, d) = await WaitAsync.WaitAll(mf.Run(rt), ma.Run(rt), mb.Run(rt), mc.Run(rt), md.Run(rt)).ConfigureAwait(false);
if (f.IsFail || a.IsFail || b.IsFail || c.IsFail || d.IsFail)
{
var errs = Errors.None;
if (f.IsFail)
{
errs += f.Error;
}
if (a.IsFail)
{
errs += a.Error;
}
if (b.IsFail)
{
errs += b.Error;
}
if (c.IsFail)
{
errs += c.Error;
}
if (d.IsFail)
{
errs += d.Error;
}
return(errs);
}
else
{
return(f.Value(a.Value, b.Value, c.Value, d.Value));
}
});
public static Aff <Func <C, D, E> > Apply <A, B, C, D, E>(this Aff <Func <A, B, C, D, E> > mf, Aff <A> ma, Aff <B> mb) =>
AffMaybe(async() =>
{
var(f, a, b) = await WaitAsync.WaitAll(mf.Run(), ma.Run(), mb.Run()).ConfigureAwait(false);
if (f.IsFail || a.IsFail || b.IsFail)
{
var errs = Errors.None;
if (f.IsFail)
{
errs += f.Error;
}
if (a.IsFail)
{
errs += a.Error;
}
if (b.IsFail)
{
errs += b.Error;
}
return(errs);
}
else
{
return(FinSucc((C c, D d) => f.Value(a.Value, b.Value, c, d)));
}
});
public static Aff <RT, C> Apply <RT, A, B, C>(this Func <A, B, C> f, Aff <RT, A> ma, Aff <RT, B> mb) where RT : struct, HasCancel <RT> =>
AffMaybe <RT, C>(async rt =>
{
var(a, b) = await WaitAsync.WaitAll(ma.Run(rt), mb.Run(rt)).ConfigureAwait(false);
if (a.IsFail || b.IsFail)
{
var errs = Errors.None;
if (a.IsFail)
{
errs += a.Error;
}
if (b.IsFail)
{
errs += b.Error;
}
return(errs);
}
else
{
return(f(a.Value, b.Value));
}
});
// ------------ Aff<RT, A> -----------------------------------------------------------------------------------------
public static Aff <RT, B> Apply <RT, A, B>(this Aff <RT, Func <A, B> > mf, Aff <RT, A> ma) where RT : struct, HasCancel <RT> =>
AffMaybe <RT, B>(async rt =>
{
var(f, a) = await WaitAsync.WaitAll(mf.Run(rt), ma.Run(rt)).ConfigureAwait(false);
if (f.IsFail || a.IsFail)
{
var errs = Errors.None;
if (f.IsFail)
{
errs += f.Error;
}
if (a.IsFail)
{
errs += a.Error;
}
return(errs);
}
else
{
return(f.Value(a.Value));
}
});
public static Aff <Func <B, C, D> > Apply <A, B, C, D>(this Aff <Func <A, B, C, D> > mf, Aff <A> ma) =>
AffMaybe(async() =>
{
var(f, a) = await WaitAsync.WaitAll(mf.Run(), ma.Run()).ConfigureAwait(false);
if (f.IsFail || a.IsFail)
{
var errs = Seq <Error>();
if (f.IsFail)
{
errs = errs.Add(f.Error);
}
if (a.IsFail)
{
errs = errs.Add(a.Error);
}
return(Error.Many(errs));
}
else
{
return(FinSucc((B b, C c) => f.Value(a.Value, b, c)));
}
});
// ------------ Aff<A> ----------------------------------------------------------------------------------
public static Aff <B> Apply <A, B>(this Aff <Func <A, B> > mf, Aff <A> ma) =>
AffMaybe <B>(async() =>
{
var(f, a) = await WaitAsync.WaitAll(mf.Run(), ma.Run()).ConfigureAwait(false);
if (f.IsFail || a.IsFail)
{
var errs = Errors.None;
if (f.IsFail)
{
errs += f.Error;
}
if (a.IsFail)
{
errs += a.Error;
}
return(errs);
}
else
{
return(f.Value(a.Value));
}
});