// // Async types // public static TryOptionAsync <EitherAsync <L, B> > Traverse <L, A, B>(this EitherAsync <L, TryOptionAsync <A> > ma, Func <A, B> f) { return(ToTry(() => Go(ma, f))); async Task <OptionalResult <EitherAsync <L, B> > > Go(EitherAsync <L, TryOptionAsync <A> > ma, Func <A, B> f) { var da = await ma.Data; if (da.State == EitherStatus.IsBottom) { return(OptionalResult <EitherAsync <L, B> > .Bottom); } if (da.State == EitherStatus.IsLeft) { return(new OptionalResult <EitherAsync <L, B> >(EitherAsync <L, B> .Left(da.Left))); } var rb = await da.Right.Try(); if (rb.IsFaulted) { return(new OptionalResult <EitherAsync <L, B> >(rb.Exception)); } if (rb.IsNone) { return(OptionalResult <EitherAsync <L, B> > .None); } return(new OptionalResult <EitherAsync <L, B> >(EitherAsync <L, B> .Right(f(rb.Value.Value)))); } }
public EitherAsync <L, R> Plus(EitherAsync <L, R> ma, EitherAsync <L, R> mb) { async Task <EitherData <L, R> > Do(EitherAsync <L, R> mma, EitherAsync <L, R> mmb) { var resA = ma.ToEither(); var resB = mb.ToEither(); var tasks = Set <OrdTask <Either <L, R> >, Task <Either <L, R> > >(resA, resB); while (tasks.Count > 0) { // Return first one that completes var completed = await Task.WhenAny(tasks).ConfigureAwait(false); if (!completed.IsFaulted && !completed.Result.IsRight) { return(completed.Result.Head()); } tasks = tasks.Remove(completed); } if (resA.IsCompleted && !resA.IsFaulted && !resA.IsCanceled && resA.Result.IsRight) { return(resA.Result.Head()); } if (resB.IsCompleted && !resB.IsFaulted && !resB.IsCanceled && resB.Result.IsRight) { return(resB.Result.Head()); } return(EitherData <L, R> .Bottom); } return(new EitherAsync <L, R>(Do(ma, mb))); }
public EitherAsync <L, R> Apply(Func <R, R, R> f, EitherAsync <L, R> ma, EitherAsync <L, R> mb) { async Task <EitherData <L, R> > Do(Func <R, R, R> ff, EitherAsync <L, R> mma, EitherAsync <L, R> mmb) { var resA = ma.ToEither(); var resB = mb.ToEither(); await Task.WhenAll(resA, resB).ConfigureAwait(false); if (resA.IsCompleted && !resA.IsFaulted && !resA.IsCanceled && resA.Result.IsLeft) { return(resA.Result.Head()); } if (resB.IsCompleted && !resB.IsFaulted && !resB.IsCanceled && resB.Result.IsLeft) { return(resB.Result.Head()); } if (resA.Result.IsRight && resB.Result.IsRight) { return(new EitherData <L, R>(EitherStatus.IsRight, ff(resA.Result.RightValue, resB.Result.RightValue), default(L))); } return(EitherData <L, R> .Bottom); } return(new EitherAsync <L, R>(Do(f, ma, mb))); }
public Task <TokenDto> Handle(RegisterUserCommand request, CancellationToken cancellationToken) { return(_applicationUserDxo.Map(request) .MapAsync(async user => { var identityResult = await _userManager.CreateAsync(user, request.Password); return (user, identityResult); }) .Map(tuple => tuple.identityResult.Succeeded ? EitherAsync <IdentityResult, ApplicationUser> .Right(tuple.user) : EitherAsync <IdentityResult, ApplicationUser> .Left(tuple.identityResult)) .MapAsyncT(user => _jwtService.GenerateSecurityToken(user)) .MapT(s => _tokenDxo.Map(s)) .Match(async => async.Match( dto => { return dto.Match(tokenDto => tokenDto.AsTask(), exception => exception.AsFailedTask <TokenDto>()); }, result => { return new ArgumentException(string.Join(",", result.Errors.Select(error => error.Description))) .AsFailedTask <TokenDto>(); }), exception => exception.AsFailedTask <TokenDto>()) .Flatten()); }
// // Async types // public static TryAsync <EitherAsync <L, B> > Traverse <L, A, B>(this EitherAsync <L, TryAsync <A> > ma, Func <A, B> f) { return(ToTry(() => Go(ma, f))); async Task <Result <EitherAsync <L, B> > > Go(EitherAsync <L, TryAsync <A> > ma, Func <A, B> f) { var da = await ma.Data.ConfigureAwait(false); if (da.State == EitherStatus.IsBottom) { return(Result <EitherAsync <L, B> > .Bottom); } if (da.State == EitherStatus.IsLeft) { return(new Result <EitherAsync <L, B> >(da.Left)); } var rb = await da.Right.Try().ConfigureAwait(false); if (rb.IsFaulted) { return(new Result <EitherAsync <L, B> >(rb.Exception)); } return(new Result <EitherAsync <L, B> >(EitherAsync <L, B> .Right(f(rb.Value)))); } }
private void MockGetUser(EitherAsync <Error, User> result) { _getHandler.Handle(Arg.Any <GetUser.Request>()) .Returns(result); OverrideHandlerMetadata <GetUser.Request>( new HandlerInfo("IdentityAndAccess", "GetUser")); }
public static EitherAsync <L, EitherAsync <L, B> > Traverse <L, A, B>(this EitherAsync <L, EitherAsync <L, A> > ma, Func <A, B> f) { return(new EitherAsync <L, EitherAsync <L, B> >(Go(ma, f))); async Task <EitherData <L, EitherAsync <L, B> > > Go(EitherAsync <L, EitherAsync <L, A> > ma, Func <A, B> f) { var da = await ma.Data.ConfigureAwait(false); if (da.State == EitherStatus.IsBottom) { return(EitherData <L, EitherAsync <L, B> > .Bottom); } if (da.State == EitherStatus.IsLeft) { return(EitherData.Right <L, EitherAsync <L, B> >(EitherAsync <L, B> .Left(da.Left))); } var db = await da.Right.Data.ConfigureAwait(false); if (db.State == EitherStatus.IsBottom) { return(EitherData <L, EitherAsync <L, B> > .Bottom); } if (db.State == EitherStatus.IsLeft) { return(EitherData.Left <L, EitherAsync <L, B> >(db.Left)); } return(EitherData.Right <L, EitherAsync <L, B> >(EitherAsync <L, B> .Right(f(db.Right)))); } }
public static Task <IActionResult> ToActionResult <T>(this EitherAsync <RfcErrorInfo, T> result) { return(result.Match( r => (IActionResult) new ObjectResult(r), l => new ObjectResult(l.Message) { StatusCode = (int)HttpStatusCode.InternalServerError })); }
public MB BindAsync <MONADB, MB, B>(EitherAsync <L, R> ma, Func <R, Task <MB> > f) where MONADB : struct, MonadAsync <Unit, Unit, MB, B> { Task <MB> Do(Unit _) => ma.MatchAsync( Left: l => default(MONADB).Fail(l), RightAsync: async r => await f(r).ConfigureAwait(false), Bottom: () => default(MONADB).Fail(BottomException.Default)); return(default(MONADB).RunAsync(Do)); }
public static EitherAsync <TLeft, TRight> LogWarningLeft <TLeft, TRight>(this EitherAsync <TLeft, TRight> @this, ILogger logger, Func <TLeft, string> messageFunc) { @this.Match( _ => unit, leftCase => { logger.LogWarning(messageFunc(leftCase)); return(unit); }); return(@this); }
// // Async types // public static Aff <EitherAsync <L, B> > Traverse <L, A, B>(this EitherAsync <L, Aff <A> > ma, Func <A, B> f) { return(AffMaybe <EitherAsync <L, B> >(() => Go(ma, f))); async ValueTask <Fin <EitherAsync <L, B> > > Go(EitherAsync <L, Aff <A> > ma, Func <A, B> f) { var da = await ma.Data.ConfigureAwait(false); if (da.State == EitherStatus.IsBottom) { return(default);
public static Aff <RT, EitherAsync <L, B> > Traverse <RT, L, A, B>(this EitherAsync <L, Aff <RT, A> > ma, Func <A, B> f) where RT : struct, HasCancel <RT> { return(AffMaybe <RT, EitherAsync <L, B> >(env => Go(env, ma, f))); async ValueTask <Fin <EitherAsync <L, B> > > Go(RT env, EitherAsync <L, Aff <RT, A> > ma, Func <A, B> f) { var da = await ma.Data.ConfigureAwait(false); if (da.State == EitherStatus.IsBottom) { return(default);
public Task <EitherAsync <Error, Unit> > Handle(SaveXmlCommand request, CancellationToken cancellationToken) { return(_xmlTransactionService.GetXmlTransactionModel(request) .Bind(xmlTransactionModel => _xmlTransactionDxo.MapTransaction(xmlTransactionModel)) .Bind(transactions => _transactionRepository.CreateAsync(transactions)) .Bind(transactions => _transactionRepository.SaveAsync()) .Match(EitherAsync <Error, Unit> .Right, error => { _mediator.Publish(SaveXmlFailedEvent.CreateInstance(error.Message), cancellationToken).ToUnit(); return EitherAsync <Error, Unit> .Left(error); })); }
public static async ValueTask <EitherAsync <L, B> > Traverse <L, A, B>(this EitherAsync <L, ValueTask <A> > ma, Func <A, B> f) { var da = await ma.Data.ConfigureAwait(false); if (da.State == EitherStatus.IsBottom) { throw new BottomException(); } if (da.State == EitherStatus.IsLeft) { return(EitherAsync <L, B> .Left(da.Left)); } var a = await da.Right.ConfigureAwait(false); return(EitherAsync <L, B> .Right(f(a))); }
public EitherAsync <Error, Player> Get(TenantId tenant, PlayerId id) { return(PerformStorageOperation(_options.PlayersTable, tableRef => { var getOperation = TableOperation.Retrieve <PlayerEntity>(tenant.ToString(), id.ToString()); EitherAsync <Error, TableResult> getResult = tableRef.ExecuteAsync(getOperation); return getResult.Match <Either <Error, Player> >( tableResult => tableResult.Result switch { PlayerEntity playerEntity => _playerFactory.Create( _mapper.Map <PlayerEntity, PlayerFactoryDto>(playerEntity)), _ => Error.NotFound() },
public EitherAsync <Error, User> Add(User user) { return(PerformStorageOperation(_options.UsersTable, tableRef => { var userEntity = new UserEntity(user); var createOperation = TableOperation.Insert(userEntity); EitherAsync <Error, TableResult> createResult = tableRef.ExecuteAsync(createOperation); return createResult.Match( tableResult => tableResult.Result switch { UserEntity created => (Either <Error, User>)_userFactory.CreateUser( _mapper.Map <UserEntity, UserFactoryDto>(created)), _ => Error.InternalError( $"Azure Storage: Failed to create user with {tableResult.HttpStatusCode} error.") },
// // Async types // public static async Task <EitherAsync <L, B> > Traverse <L, A, B>(this EitherAsync <L, Task <A> > ma, Func <A, B> f) { var da = await ma.Data; if (da.State == EitherStatus.IsBottom) { throw new BottomException(); } if (da.State == EitherStatus.IsLeft) { return(EitherAsync <L, B> .Left(da.Left)); } var a = await da.Right; if (da.Right.IsFaulted) { ExceptionDispatchInfo.Capture(da.Right.Exception.InnerException).Throw(); } return(EitherAsync <L, B> .Right(f(a))); }
public Task <TokenDto> Handle(SignInCommand request, CancellationToken cancellationToken) { return(TryAsync(async() => { var user = await _userManager.FindByEmailAsync(request.Email); var identityResult = await _userManager.CheckPasswordAsync(user, request.Password); return (user, identityResult); }).Map(tuple => tuple.identityResult ? EitherAsync <bool, ApplicationUser> .Right(tuple.user) : EitherAsync <bool, ApplicationUser> .Left(tuple.identityResult)) .MapAsyncT(user => _jwtService.GenerateSecurityToken(user)) .MapT(s => _tokenDxo.Map(s)) .Match(async => async.Match( dto => { return dto.Match(tokenDto => tokenDto.AsTask(), exception => exception.AsFailedTask <TokenDto>()); }, result => new ArgumentException("Bad password") .AsFailedTask <TokenDto>()), exception => exception.AsFailedTask <TokenDto>()) .Flatten()); }
public EitherAsync <L, A> PureAsync(Task <A> x) => EitherAsync <L, A> .RightAsync(x);
public EitherAsync <L, B> MapAsync(EitherAsync <L, A> ma, Func <A, Task <B> > f) => ma.MapAsync(f);
public EitherAsync <L, B> Map(EitherAsync <L, A> ma, Func <A, B> f) => ma.Map(f);
public EitherAsync <L, B> BiMapAsync(EitherAsync <L, A> ma, Func <L, Task <B> > fa, Func <A, Task <B> > fb) => default(FEitherAsync <L, A, B>).BiMapAsync(ma, fa, fb);
public EitherAsync <L, B> Apply(EitherAsync <L, Func <A, B> > fab, EitherAsync <L, A> fa) => from f in fab from a in fa select f(a);
public EitherAsync <L, B> Action(EitherAsync <L, A> fa, EitherAsync <L, B> fb) => from a in fa from b in fb select b;
public static EitherAsync <L, EitherAsync <L, B> > Sequence <L, A, B>(this EitherAsync <L, A> ta, Func <A, EitherAsync <L, B> > f) => ta.Map(f).Sequence();
public EitherAsync <Exception, Option <Tea> > FetchById(string id) => EitherAsync <Exception, Option <Tea> > .Right( new Option <Tea>(Some(_teas.Single())));
public EitherAsync <Exception, Option <IList <Tea> > > FetchAll() => EitherAsync <Exception, Option <IList <Tea> > > .Right( new Option <IList <Tea> >(Some(_teas)) );
public static TryAsync <EitherAsync <L, A> > Sequence <L, A>(this EitherAsync <L, TryAsync <A> > ta) => ta.Traverse(identity);
public static OptionAsync <EitherAsync <L, B> > Sequence <L, A, B>(this EitherAsync <L, A> ta, Func <A, OptionAsync <B> > f) => ta.Map(f).Sequence();
public static async Task ShouldBeRight <TLeft, TRight>(this EitherAsync <TLeft, TRight> @this, Action <TRight> rightValidation) => await @this.Match(rightValidation, Common.ThrowIfLeft);