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 async Task Condition(Func <Task <bool> > waitCondition, Func <WaitBuilderAsync <bool>, WaitAsync <bool> > buildWaiter, string timeoutMessage) { var waiter = WaitAsync <bool> .CreateBuilder(waitCondition); waiter.SetTimeOutMessage(timeoutMessage); await buildWaiter(waiter) .For(x => x).OnFailureThrowException(); }
protected override async Task OnRun_Async() { //打开Login界面 await ViewManager.Instance.OpenAsync("KNFrame", View.State.Fixing); await WaitAsync.WaitForSeconds(1.0f); //隐藏进度条 GameLoading.Instance.Hide(); Debug.Log("GameStage -- Init data complete."); }
/// <summary> /// 开始异步执行GameStage /// </summary> public async Task Run_Async() { for (int i = 0; i < taskList.Count; i++) { taskList[i].Run_Async().WarpErrors(); } //等待这个索引的所有的Task执行完成后,才进入下一个索引 while (!CheckStageIsCompleted()) { await WaitAsync.WaitForEndOfFrame(); } this.isStageCompleted = true; }
/// <summary> /// 开始异步执行GameStage /// </summary> public async Task Run_Async() { for (int i = 0; i < taskList.Count; i++) { #pragma warning disable 4014 taskList[i].Run_Async(); #pragma warning restore 4014 } //等待这个索引的所有的Task执行完成后,才进入下一个索引 while (!CheckStageIsCompleted()) { await WaitAsync.WaitForEndOfFrame(); } this.isStageCompleted = true; }
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)); } });