public static Aff <RT, Stck <B> > TraverseParallel <RT, A, B>(this Stck <Aff <RT, A> > ma, Func <A, B> f)
where RT : struct, HasCancel <RT> =>
TraverseParallel <RT, A, B>(ma, f, SysInfo.DefaultAsyncSequenceParallelism);
public static Stck <T> distinct <T, K>(Stck <T> stack, Func <T, K> keySelector, Option <Func <K, K, bool> > compare = default(Option <Func <K, K, bool> >)) => toStackRev(List.distinct(stack, keySelector, compare));
public static Stck <T> takeWhile <T>(Stck <T> stack, Func <T, int, bool> pred) => toStackRev(List.takeWhile(stack, pred));
public static T peek <T>(Stck <T> stack) => stack.Peek();
public static Stck <T> distinct <T>(Stck <T> stack) => toStackRev(List.distinct(stack));
public static Option <T> find <T>(Stck <T> stack, Func <T, bool> pred) => List.find(stack, pred);
public static int length <T>(Stck <T> stack) => List.length(stack);
public static Stck <U> choose <T, U>(Stck <T> stack, Func <int, T, Option <U> > selector) => toStackRev(List.choose(stack, selector));
public static Stck <T> rev <T>(Stck <T> stack) => stack.Reverse();
public static Stck <R> map <T, R>(Stck <T> stack, Func <int, T, R> map) => toStackRev(List.map(stack, map));
public static Stck <T> filter <T>(Stck <T> stack, Func <T, bool> predicate) => toStackRev(List.filter(stack, predicate));
public static Stck <T> push <T>(Stck <T> stack, T value) => stack.Push(value);
public static R pop <T, R>(Stck <T> stack, Func <Stck <T>, T, R> Some, Func <R> None) => stack.Pop(Some, None);
public static Stck <T> pop <T>(Stck <T> stack, Action <T> Some, Action None) => stack.Pop(Some, None);
public static T reduceBack <T>(Stck <T> stack, Func <T, T, T> reducer) => List.reduceBack(stack, reducer);
public static Stck <R> collect <T, R>(Stck <T> stack, Func <T, IEnumerable <R> > map) => toStackRev(List.collect(stack, map));
public static Stck <S> scanBack <S, T>(Stck <T> stack, S state, Func <S, T, S> folder) => toStackRev(List.scanBack(stack, state, folder));
public static Stck <T> append <T>(Stck <T> lhs, IEnumerable <T> rhs) => toStackRev(List.append(lhs, rhs));
public static Stck <V> zip <T, U, V>(Stck <T> stack, IEnumerable <U> other, Func <T, U, V> zipper) => toStackRev(List.zip(stack, other, zipper));
public static S foldBack <S, T>(Stck <T> stack, S state, Func <S, T, S> folder) => List.foldBack(stack, state, folder);
/// <summary> /// Invokes an action for each item in the stack in order and supplies /// a running index value. /// </summary> /// <typeparam name="T">Stack item type</typeparam> /// <param name="stack">Stack to iterate</param> /// <param name="action">Action to invoke with each item</param> /// <returns>Unit</returns> public static Unit iter <T>(Stck <T> stack, Action <int, T> action) => List.iter(stack, action);
public static bool isEmpty <T>(Stck <T> stack) => stack.IsEmpty;
public static bool forall <T>(Stck <T> stack, Func <T, bool> pred) => List.forall(stack, pred);
public static S foldWhile <S, T>(Stck <T> stack, S state, Func <S, T, S> folder, Func <T, bool> preditem) => List.foldWhile(stack, state, folder, preditem: preditem);
public static Stck <T> distinct <EQ, T>(Stck <T> stack) where EQ : struct, Eq <T> => toStackRev(List.distinct <EQ, T>(stack));
public static S foldBackWhile <S, T>(Stck <T> stack, S state, Func <S, T, S> folder, Func <S, bool> predstate) => List.foldBackWhile(stack, state, folder, predstate: predstate);
public static Stck <T> take <T>(Stck <T> stack, int count) => toStackRev(List.take(stack, count));
public static Stck <T> clear <T>(Stck <T> stack) => stack.Clear();
public static bool exists <T>(Stck <T> stack, Func <T, bool> pred) => List.exists(stack, pred);
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));
}
