public static TryAsync <Stck <B> > Traverse <A, B>(this Stck <TryAsync <A> > ma, Func <A, B> f)
{
return(ToTry(() => Go(ma, f)));
async Task <Result <Stck <B> > > Go(Stck <TryAsync <A> > ma, Func <A, B> f)
{
var rb = await Task.WhenAll(ma.Reverse().Map(a => a.Map(f).Try())).ConfigureAwait(false);
return(rb.Exists(d => d.IsFaulted)
? rb.Filter(b => b.IsFaulted).Map(b => new Result <Stck <B> >(b.Exception)).Head()
: new Result <Stck <B> >(new Stck <B>(rb.Map(d => d.Value))));
}
}
public static EitherAsync <L, Stck <B> > Traverse <L, A, B>(this Stck <EitherAsync <L, A> > ma, Func <A, B> f)
{
return(new EitherAsync <L, Stck <B> >(Go(ma, f)));
async Task <EitherData <L, Stck <B> > > Go(Stck <EitherAsync <L, A> > ma, Func <A, B> f)
{
var rb = await Task.WhenAll(ma.Reverse().Map(a => a.Map(f).Data)).ConfigureAwait(false);
return(rb.Exists(d => d.State == EitherStatus.IsLeft)
? rb.Filter(d => d.State == EitherStatus.IsLeft).Map(d => EitherData.Left <L, Stck <B> >(d.Left)).Head()
: EitherData.Right <L, Stck <B> >(new Stck <B>(rb.Map(d => d.Right))));
}
}
public static State <S, Stck <A> > Sequence <S, A>(this Stck <State <S, A> > ta) => SequenceFast(ta.Reverse()).Map(toStack);
public static State <S, Stck <B> > Traverse <S, A, B>(this Stck <State <S, A> > ma, Func <A, B> f) => TraverseFast(ma.Reverse(), f).Map(toStack);
public static Lst <Stck <B> > Traverse <A, B>(this Stck <Lst <A> > ma, Func <A, B> f) => CollT.AllCombinationsOf(ma.Reverse().Map(xs => xs.ToList()).ToArray(), f) .Map(toStack) .Freeze();
public static HashSet <Stck <B> > Traverse <A, B>(this Stck <HashSet <A> > ma, Func <A, B> f) =>
toHashSet(CollT.AllCombinationsOf(ma.Reverse().Map(xs => xs.ToList()).ToArray(), f)
.Map(toStack));
public static RWS <MonoidW, R, W, S, Stck <B> > Traverse <MonoidW, R, W, S, A, B>(this Stck <RWS <MonoidW, R, W, S, A> > ma, Func <A, B> f) where MonoidW : struct, Monoid <W> => TraverseFast(ma.Reverse(), f).Map(toStack);
public static RWS <MonoidW, R, W, S, Stck <A> > Sequence <MonoidW, R, W, S, A>(this Stck <RWS <MonoidW, R, W, S, A> > ma) where MonoidW : struct, Monoid <W> => SequenceFast(ma.Reverse()).Map(toStack);
/// <summary> /// Reverses the order of the items in the stack /// </summary> /// <returns></returns> public static Stck <T> rev <T>(Stck <T> stack) => stack.Reverse();
public static IEnumerable <Stck <B> > Traverse <A, B>(this Stck <IEnumerable <A> > ma, Func <A, B> f) => CollT.AllCombinationsOf(ma.Reverse().Map(xs => xs.ToList()).ToArray(), f) .Map(toStack);
public static Arr <Stck <B> > Traverse <A, B>(this Stck <Arr <A> > xxs, Func <A, B> f) => CollT.AllCombinationsOf(xxs.Reverse().Map(xs => xs.ToList()).ToArray(), f) .Map(toStack) .ToArr();
public static Reader <Env, Stck <B> > Traverse <Env, A, B>(this Stck <Reader <Env, A> > ma, Func <A, B> f) => TraverseFast(ma.Reverse(), f).Map(toStack);
public static Reader <Env, Stck <A> > Sequence <Env, A>(this Stck <Reader <Env, A> > ma) => SequenceFast(ma.Reverse()).Map(toStack);
public static async ValueTask <Stck <B> > Traverse <A, B>(this Stck <ValueTask <A> > ma, Func <A, B> f)
{
var rb = await Task.WhenAll(ma.Reverse().Map(async a => f(await a.ConfigureAwait(false)))).ConfigureAwait(false);
return(new Stck <B>(rb));
}
public static Writer <MonoidW, W, Stck <A> > Sequence <MonoidW, W, A>(this Stck <Writer <MonoidW, W, A> > ta) where MonoidW : struct, Monoid <W> => SequenceFast(ta.Reverse()).Map(toStack);
public static async Task <Stck <B> > Traverse <A, B>(this Stck <Task <A> > ma, Func <A, B> f)
{
var rb = await Task.WhenAll(ma.Reverse().Map(async a => f(await a)));
return(new Stck <B>(rb));
}
