/// <inheritdoc /> protected override async Task <Result <Unit, IError> > Run( IStateMonad stateMonad, CancellationToken cancellationToken) { return(await Value.Run(stateMonad, cancellationToken) .Bind(x => stateMonad.SetVariableAsync(Variable, x, true, this))); }
/// <inheritdoc /> protected override async Task <Result <Unit, IError> > Run( IStateMonad stateMonad, CancellationToken cancellationToken) { var variable = stateMonad.GetVariable <int>(Variable).MapError(x => x.WithLocation(this)); if (variable.IsFailure) { return(variable.ConvertFailure <Unit>()); } var amount = await Amount.Run(stateMonad, cancellationToken); if (amount.IsFailure) { return(amount.ConvertFailure <Unit>()); } var r = await stateMonad.SetVariableAsync( Variable, variable.Value + amount.Value, false, this ); return(r); }
/// <inheritdoc /> protected override async Task <Result <Unit, IError> > Run( IStateMonad stateMonad, CancellationToken cancellationToken) { var str = await String.Run(stateMonad, cancellationToken) .Map(x => x.GetStringAsync()); if (str.IsFailure) { return(str.ConvertFailure <Unit>()); } var currentValue = stateMonad.GetVariable <StringStream>(Variable) .MapError(x => x.WithLocation(this)); if (currentValue.IsFailure) { return(currentValue.ConvertFailure <Unit>()); } var newValue = await currentValue.Value.GetStringAsync() + str.Value; var r = await stateMonad.SetVariableAsync( Variable, new StringStream(newValue), false, this ); if (r.IsFailure) { return(r.ConvertFailure <Unit>()); } return(Unit.Default); }
/// <inheritdoc /> protected override async Task <Result <Unit, IError> > Run( IStateMonad stateMonad, CancellationToken cancellationToken) { var variableName = VariableName.Index; var from = await From.Run(stateMonad, cancellationToken); if (from.IsFailure) { return(from.ConvertFailure <Unit>()); } var to = await To.Run(stateMonad, cancellationToken); if (to.IsFailure) { return(to.ConvertFailure <Unit>()); } var increment = await Increment.Run(stateMonad, cancellationToken); if (increment.IsFailure) { return(increment.ConvertFailure <Unit>()); } var currentValue = from.Value; var setResult = await stateMonad.SetVariableAsync(variableName, currentValue, false, this); if (setResult.IsFailure) { return(setResult.ConvertFailure <Unit>()); } if (increment.Value == 0) { return(new SingleError(new ErrorLocation(this), ErrorCode.DivideByZero)); } while (increment.Value > 0 ? currentValue <= to.Value : currentValue >= to.Value) { var r = await Action.Run(stateMonad, cancellationToken); if (r.IsFailure) { return(r); } var currentValueResult = stateMonad.GetVariable <int>(variableName) .MapError(e => e.WithLocation(this)); if (currentValueResult.IsFailure) { return(currentValueResult.ConvertFailure <Unit>()); } currentValue = currentValueResult.Value; currentValue += increment.Value; var setResult2 = await stateMonad.SetVariableAsync( variableName, currentValue, false, this ); if (setResult2.IsFailure) { return(setResult.ConvertFailure <Unit>()); } } await stateMonad.RemoveVariableAsync(VariableName.Index, false, this); return(Unit.Default); }
/// <inheritdoc /> protected override async Task <Result <Unit, IError> > Run( IStateMonad stateMonad, CancellationToken cancellationToken) { var sclResult = await SCL.Run(stateMonad, cancellationToken).Map(x => x.GetStringAsync()); if (sclResult.IsFailure) { return(sclResult.ConvertFailure <Unit>()); } List <VariableName> variablesToExport; if (Export is null) { variablesToExport = new List <VariableName>(); } else { var exportResult = await Export.Run(stateMonad, cancellationToken) .Bind(x => x.GetElementsAsync(cancellationToken)); if (exportResult.IsFailure) { return(exportResult.ConvertFailure <Unit>()); } variablesToExport = exportResult.Value.Select(x => x.GetString()) .Select(x => new VariableName(x)) .ToList(); } var stepResult = SCLParsing.TryParseStep(sclResult.Value) .Bind(x => x.TryFreeze(TypeReference.Unit.Instance, stateMonad.StepFactoryStore)); if (stepResult.IsFailure) { return(stepResult.ConvertFailure <Unit>()); } await using var monad2 = new ScopedStateMonad( stateMonad, ImmutableDictionary <VariableName, object> .Empty ); await stepResult.Value.Run <Unit>(monad2, cancellationToken); foreach (var variable in variablesToExport) { var value = monad2.GetVariable <object>(variable); var valueV = value.IsSuccess ? value.Value : null; await monad2.RemoveVariableAsync( variable, false, this ); //Remove the variable to prevent it being disposed await stateMonad.SetVariableAsync(variable, valueV, true, this); } return(Unit.Default); }