public static EitherAsync <L, Aff <B> > Traverse <L, A, B>(this Aff <EitherAsync <L, A> > ma, Func <A, B> f)
{
return(new EitherAsync <L, Aff <B> >(Go(ma, f)));
async Task <EitherData <L, Aff <B> > > Go(Aff <EitherAsync <L, A> > ma, Func <A, B> f)
{
var result = await ma.Run().ConfigureAwait(false);
if (result.IsBottom)
{
return(EitherData <L, Aff <B> > .Bottom);
}
if (result.IsFail)
{
return(EitherData.Right <L, Aff <B> >(FailAff <B>(result.Error)));
}
var db = await result.Value.Data.ConfigureAwait(false);
if (db.State == EitherStatus.IsBottom)
{
return(EitherData <L, Aff <B> > .Bottom);
}
if (db.State == EitherStatus.IsLeft)
{
return(EitherData.Left <L, Aff <B> >(db.Left));
}
return(EitherData.Right <L, Aff <B> >(SuccessAff <B>(f(db.Right))));
}
}
public static TryOptionAsync <Aff <B> > Traverse <A, B>(this Aff <TryOptionAsync <A> > ma, Func <A, B> f)
{
return(ToTry(() => Go(ma, f)));
async Task <OptionalResult <Aff <B> > > Go(Aff <TryOptionAsync <A> > ma, Func <A, B> f)
{
var ra = await ma.Run().ConfigureAwait(false);
if (ra.IsFail)
{
return(new OptionalResult <Aff <B> >(FailAff <B>(ra.Error)));
}
var rb = await ra.Value.Try().ConfigureAwait(false);
if (rb.IsFaulted)
{
return(new OptionalResult <Aff <B> >(rb.Exception));
}
if (rb.IsNone)
{
return(OptionalResult <Aff <B> > .None);
}
return(new OptionalResult <Aff <B> >(SuccessAff <B>(f(rb.Value.Value))));
}
}
/// <summary>
/// Create a new cancellation context and run the provided Aff in that context
/// </summary>
/// <param name="ma">Operation to run in the next context</param>
/// <typeparam name="RT">Runtime environment</typeparam>
/// <typeparam name="A">Bound value type</typeparam>
/// <returns>An asynchronous effect that captures the operation running in context</returns>
public static Aff <RT, A> localCancel <RT, A>(Aff <RT, A> ma) where RT : struct, HasCancel <RT> =>
AffMaybe <RT, A>(async rt =>
{
var rt1 = rt.LocalCancel;
using (rt1.CancellationTokenSource)
{
return(await ma.ReRun(rt1).ConfigureAwait(false));
}
});
public static async ValueTask <Aff <B> > Traverse <A, B>(this Aff <ValueTask <A> > ma, Func <A, B> f)
{
var da = await ma.Run().ConfigureAwait(false);
if (da.IsBottom)
{
throw new BottomException();
}
if (da.IsFail)
{
return(FailAff <B>(da.Error));
}
var a = await da.Value.ConfigureAwait(false);
return(SuccessAff(f(a)));
}
/// <summary>
/// Safely use a disposable resource
/// </summary>
/// <param name="Acq">Acquire resource</param>
/// <param name="Use">Use resource</param>
public static Aff <R> use <H, R>(Aff <H> Acq, Func <H, Eff <R> > Use) where H : IDisposable =>
AffMaybe(async() =>
{
var h = await Acq.ReRun().ConfigureAwait(false);
if (h.IsFail)
{
return(h.Cast <R>());
}
try
{
return(Use(h.Value).Run());
}
finally
{
h.Value?.Dispose();
}
});
/// <summary>
/// Safely use a disposable resource
/// </summary>
/// <param name="Acq">Acquire resource</param>
/// <param name="Use">Use resource</param>
public static Aff <RT, R> use <RT, H, R>(Aff <H> Acq, Func <H, Eff <RT, R> > Use)
where RT : struct, HasCancel <RT>
where H : IDisposable =>
AffMaybe <RT, R>(async env =>
{
var h = await Acq.ReRun().ConfigureAwait(false);
if (h.IsFail)
{
return(h.Cast <R>());
}
try
{
return(Use(h.Value).Run(env));
}
finally
{
h.Value?.Dispose();
}
});
/// <summary> /// Catch an error if the error `Code` matches the `errorCode` argument provided /// </summary> public static AffCatch <RT, A> @catch <RT, A>(int errorCode, Aff <RT, A> Fail) where RT : struct, HasCancel <RT> => matchError(e => e.Code == errorCode, _ => Fail);
/// <summary> /// Catch an error if the error message matches the `errorText` argument provided /// </summary> public static AffCatch <RT, A> @catch <RT, A>(string errorText, Aff <RT, A> Fail) where RT : struct, HasCancel <RT> => matchError(e => e.Message == errorText, _ => Fail);
/// <summary> /// Catch an error if the error matches the argument provided /// </summary> public static AffCatch <RT, A> @catch <RT, A>(Error error, Aff <RT, A> Fail) where RT : struct, HasCancel <RT> => matchError(e => e == error, _ => Fail);
/// <summary> /// Catch an error if it's of a specific exception type /// </summary> public static AffCatch <RT, A> @catch <RT, A>(Func <Exception, bool> predicate, Aff <RT, A> Fail) where RT : struct, HasCancel <RT> => matchError(e => e.Exception.Map(predicate).IfNone(false), e => Fail);
/// <summary> /// Catch an error if the error `Code` matches the `errorCode` argument provided /// </summary> public static Aff <A> Catch <A>(this Aff <A> ma, int errorCode, Func <Error, Aff <A> > Fail) => ma | matchError(e => e.Code == errorCode, Fail);
/// <summary> /// Catch an error if the error matches the argument provided /// </summary> public static Aff <A> Catch <A>(this Aff <A> ma, Error error, Aff <A> Fail) => ma | matchError(e => e == error, _ => Fail);
/// <summary> /// Catch an error if the error matches the argument provided /// </summary> public static Aff <A> Catch <A>(this Aff <A> ma, Error error, Func <Error, Aff <A> > Fail) => ma | matchError(e => e.Is(error), Fail);
/// <summary> /// Catch an error if the error matches the argument provided /// </summary> public static Aff <RT, A> Catch <RT, A>(this Aff <RT, A> ma, Error error, Func <Error, Aff <A> > Fail) where RT : struct, HasCancel <RT> => ma | matchError(e => e.Is(error), Fail);
public static TryAsync <Aff <B> > Sequence <A, B>(this Aff <A> ta, Func <A, TryAsync <B> > f) => ta.Map(f).Traverse(Prelude.identity);
/// <summary> /// Catch all errors /// </summary> public static Aff <RT, A> Catch <RT, A>(this Aff <RT, A> ma, Aff <RT, A> Fail) where RT : struct, HasCancel <RT> => ma | matchError(static _ => true, e => Fail);
/// <summary> /// Catch an error if the error matches the argument provided /// </summary> public static Aff <RT, A> Catch <RT, A>(this Aff <RT, A> ma, Error error, Aff <A> Fail) where RT : struct, HasCancel <RT> => ma | matchError(e => e == error, _ => Fail);
public static Aff <OuterRT, A> localAff <OuterRT, InnerRT, A>(Func <OuterRT, InnerRT> f, Aff <InnerRT, A> ma)
where OuterRT : struct, HasCancel <OuterRT>
where InnerRT : struct, HasCancel <InnerRT> =>
/// <summary> /// Catch an error if the error `Code` matches the `errorCode` argument provided /// </summary> public static Aff <RT, A> Catch <RT, A>(this Aff <RT, A> ma, int errorCode, Func <Error, Aff <A> > Fail) where RT : struct, HasCancel <RT> => ma | matchError(e => e.Code == errorCode, Fail);
public static TryAsync <Aff <A> > Sequence <A>(this Aff <TryAsync <A> > ta) => ta.Traverse(identity);
/// <summary> /// Catch an error if it's of a specific exception type /// </summary> public static AffCatch <A> @catch <A>(Func <Exception, bool> predicate, Aff <A> Fail) => matchError(e => e.Exception.Map(predicate).IfNone(false), e => Fail);
public static EitherAsync <L, Aff <B> > Sequence <L, A, B>(this Aff <A> ta, Func <A, EitherAsync <L, B> > f) => ta.Map(f).Traverse(Prelude.identity);
/// <summary> /// Catch all errors /// </summary> public static AffCatch <RT, A> @catch <RT, A>(Aff <RT, A> Fail) where RT : struct, HasCancel <RT> => matchError(static _ => true, e => Fail);
/// <summary> /// Catch an error if the error message matches the `errorText` argument provided /// </summary> public static Aff <RT, A> Catch <RT, A>(this Aff <RT, A> ma, string errorText, Func <Error, Aff <A> > Fail) where RT : struct, HasCancel <RT> => ma | matchError(e => e.Message == errorText, Fail);
/// <summary> /// Catch an error if the error matches the argument provided /// </summary> public static AffCatch <A> @catch <A>(Error error, Aff <A> Fail) => matchError(e => e == error, _ => Fail);
/// <summary> /// Catch an error if the error message matches the `errorText` argument provided /// </summary> public static Aff <A> Catch <A>(this Aff <A> ma, string errorText, Func <Error, Aff <A> > Fail) => ma | matchError(e => e.Message == errorText, Fail);
/// <summary> /// Catch an error if the error message matches the `errorText` argument provided /// </summary> public static AffCatch <A> @catch <A>(string errorText, Aff <A> Fail) => matchError(e => e.Message == errorText, _ => Fail);
/// <summary> /// Catch an error if it's of a specific exception type /// </summary> public static Aff <A> Catch <A>(this Aff <A> ma, Func <Exception, bool> predicate, Func <Exception, Aff <A> > Fail) => ma | matchError(e => e.Exception.Map(predicate).IfNone(false), e => Fail(e));
/// <summary> /// Catch an error if the error `Code` matches the `errorCode` argument provided /// </summary> public static AffCatch <A> @catch <A>(int errorCode, Aff <A> Fail) => matchError(e => e.Code == errorCode, _ => Fail);
/// <summary> /// Catch an error if it's of a specific exception type /// </summary> public static Aff <RT, A> Catch <RT, A>(this Aff <A> ma, Func <Exception, bool> predicate, Func <Exception, Aff <RT, A> > Fail) where RT : struct, HasCancel <RT> => ma | matchError(e => e.Exception.Map(predicate).IfNone(false), e => Fail(e));
