private async Task <IResult <TOther> > FunctionCombinerAsync <TOther>([NotNull] Func <LazyEvaluatorAsync <T>, IResult <T>, Task <IResult <TOther> > > nextFunction, Func <IResult <TOther>, Task <IResult <TOther> > > onErrorFunc)
        {
            _lazyResultInternal = await EvaluateResultAsync();

            if (_lazyResultInternal.OnError)
            {
                return(ResultFactory.FailLazyEvaluatedFunction <TOther>(ProgrId, _identifier, _lazyResultInternal.Error));
            }

            if (_raisedExit)
            {
                return(LazyResult <TOther> .Parse <TOther, T>(_lazyResultInternal));
            }


            var c = await nextFunction.Invoke(this, _lazyResultInternal);

            if (_raisedExit || _lazyResultInternal.RaisedExit)
            {
                return(LazyResult <TOther> .Parse <TOther, T>(_lazyResultInternal));
            }

            if (!c.OnError || null == onErrorFunc)
            {
                return(c);
            }

            return(await onErrorFunc.Invoke(c));
        }
        public async Task <IResult <T> > RaiseExitAsync()
        {
            if (!_evaluated)
            {
                _lazyResultInternal = await EvaluateResultAsync();
            }

            _raisedExit = true;

            return(_lazyResultInternal.RaiseExit(ProgrId));
        }
 public static LazyResult <TEnd> Parse <TEnd, TSource>([NotNull] LazyResult <TSource> resultExited)
 {
     return(new LazyResult <TEnd>(resultExited.Identifier, resultExited.ProgrId));
 }