public async Task RunSCLFromFile(string path) { var scl = await File.ReadAllTextAsync(path); TestOutputHelper.WriteLine(scl); var sfs = StepFactoryStore.Create(); var stepResult = SCLParsing.TryParseStep(scl) .Bind(x => x.TryFreeze(TypeReference.Any.Instance, sfs)); if (stepResult.IsFailure) { throw new XunitException( string.Join( ", ", stepResult.Error.GetAllErrors() .Select(x => x.Message + " " + x.Location.AsString()) ) ); } var monad = new StateMonad( TestOutputHelper.BuildLogger(), SCLSettings.EmptySettings, sfs, ExternalContext.Default, new Dictionary <string, object>() ); var r = await stepResult.Value.Run <Unit>(monad, CancellationToken.None); r.ShouldBeSuccessful(); }
private static StateMonad <TState, Tree <Tuple <TState, TContents> > > MakeMonad(Tree <TContents> t, Func <StateMonad <TState, TState> > updater) { if (t is Leaf <TContents> ) { var lf = (t as Leaf <TContents>); return(updater() .Bind(n => StateMonad <TState, Tree <Tuple <TState, TContents> > > .Return(new Leaf <Tuple <TState, TContents> >(Tuple.Create(n, lf.Contents))))); } if (t is Branch <TContents> ) { var br = (t as Branch <TContents>); var oldleft = br.Left; var oldright = br.Right; return(MakeMonad(oldleft, _leftUpdater) .Bind(newleft => MakeMonad(oldright, _rightUpdater) .Bind(newright => StateMonad <TState, Tree <Tuple <TState, TContents> > > .Return(new Branch <Tuple <TState, TContents> >(newleft, newright))))); } throw new Exception("MakeMonad/MLabel: impossible Tree subtype"); }
public virtual async Task <StateMonad> GetStateMonad( MockRepository mockRepository, ILogger logger) { var externalContext = ExternalContextSetupHelper.GetExternalContext(mockRepository); var tStepAssembly = Assembly.GetAssembly(typeof(TStep)) !; var sfs = StepFactoryStoreToUse.Unwrap( StepFactoryStore.Create(Settings, tStepAssembly) ); var stateMonad = new StateMonad( logger, Settings, sfs, externalContext, new Dictionary <string, object>() ); foreach (var action in InitialStateActions) { await action(stateMonad); } return(stateMonad); }
public static StateMonad <TState, IEnumerable <StateContentPair <TState, TContent> > > CreateStateMonadFunctionally <TState, TContent>(IEnumerable <TContent> list, StateMonad <TState, TState> updateMonad) { var monad = list .Aggregate(StateMonad.Return <TState, IEnumerable <StateContentPair <TState, TContent> > >(new List <StateContentPair <TState, TContent> >()), (current, s) => current .Bind(x1 => updateMonad .Bind(x => StateMonad.Return <TState, IEnumerable <StateContentPair <TState, TContent> > >(new[] { StateContentPair.Create(x, s) })) .Bind(x2 => StateMonad.Return <TState, IEnumerable <StateContentPair <TState, TContent> > >(x1.Concat(x2))))); return(monad); }
private static StateMonad <TState, IEnumerable <StateContentPair <TState, TContent> > > CreateStateMonadRecursively <TState, TContent>(IReadOnlyCollection <TContent> list, StateMonad <TState, TState> updateMonad, StateMonad <TState, IEnumerable <StateContentPair <TState, TContent> > > result) { if (!list.Any()) { return(result); } return(CreateStateMonadRecursively(list.Skip(1).ToList(), updateMonad, result .Bind(res => updateMonad .Bind(state => StateMonad.Return <TState, IEnumerable <StateContentPair <TState, TContent> > >(new[] { StateContentPair.Create(state, list.First()) })) .Bind(nextItem => StateMonad.Return <TState, IEnumerable <StateContentPair <TState, TContent> > >(res.Concat(nextItem)))))); }
/** * Simple example of running a string through a calculation involving * destructive update modelled by a state monad. * * @param initial the starting string. * @return the result of running the string through the computation. */ public static String ToUpperCase(String initial) { var m = new StateMonad(); // do a <- lookup // mutate(a.toUpperCase) // lookup Computation c = m.Bind(m.Lookup(), new C(m)); return((String)m.Run(c, initial).Value()); }
public static StateMonad CreateStateMonad(ILogger logger) { var repo = new MockRepository(MockBehavior.Strict); var stateMonad = new StateMonad( logger, SCLSettings.EmptySettings, StepFactoryStore.Create(), repo.OneOf <IExternalContext>(), new Dictionary <string, object>() ); return(stateMonad); }
/// <summary> /// Runs an SCL sequence without injecting any metadata /// </summary> public async Task <Result <Unit, IError> > RunSequence( string text, IReadOnlyDictionary <string, object> sequenceMetadata, CancellationToken cancellationToken) { var stepResult = SCLParsing.TryParseStep(text) .Bind(x => x.TryFreeze(TypeReference.Any.Instance, _stepFactoryStore)) .Map(ConvertToUnitStep); if (stepResult.IsFailure) { return(stepResult.ConvertFailure <Unit>()); } using var loggingScope = _logger.BeginScope(TopLevelLoggingScope); var stateMonad = new StateMonad( _logger, _settings, _stepFactoryStore, _externalContext, sequenceMetadata ); LogSituation.SequenceStarted.Log(stateMonad, null); var connectorSettings = _settings.Entity.TryGetValue(SCLSettings.ConnectorsKey); if (connectorSettings.HasValue) { LogSituation.ConnectorSettings.Log( stateMonad, null, connectorSettings.Value.Serialize() ); } var runResult = await stepResult.Value.Run(stateMonad, cancellationToken); await stateMonad.DisposeAsync(); _logger.LogSituation( LogSituation.SequenceCompleted, null, sequenceMetadata, Array.Empty <object?>() ); return(runResult); }
private static StateMonad <TState, Tree <StateContentPair <TState, T> > > CreateLabeledTree <TState, T>(Tree <T> tree, StateMonad <TState, TState> updateMonad) { if (tree is Leaf <T> ) { var leaf = (tree as Leaf <T>); return(updateMonad.Bind(n => StateMonad.Return <TState, Tree <StateContentPair <TState, T> > >(Leaf.Create(StateContentPair.Create(n, leaf.Content))))); } if (tree is Branch <T> ) { var branch = (tree as Branch <T>); // recursion return(CreateLabeledTree(branch.Left, updateMonad) .Bind(newleft => CreateLabeledTree(branch.Right, updateMonad) .Bind(newright => StateMonad.Return <TState, Tree <StateContentPair <TState, T> > >(Branch.Create(newleft, newright))))); } throw new Exception("MakeMonad/MLabel: impossible tree subtype"); }
public static IEnumerable <StateContentPair <TState, TContent> > Label <TState, TContent>(IEnumerable <TContent> list, StateMonad <TState, TState> updateMonad, TState initialState) { var monad = CreateStateMonadFunctionally(list, updateMonad); return(monad.ToStateContentPair(initialState).Content); }
private static StateMonad <TState, IEnumerable <StateContentPair <TState, TContent> > > CreateStateMonadRecursively <TState, TContent>(IEnumerable <TContent> list, StateMonad <TState, TState> updateMonad) { return(CreateStateMonadRecursively(list.ToList(), updateMonad, StateMonad.Return <TState, IEnumerable <StateContentPair <TState, TContent> > >(new List <StateContentPair <TState, TContent> >()))); }
public static Tree <StateContentPair <TState, T> > Label <TState, T>(Tree <T> tree, StateMonad <TState, TState> updateMonad, TState initialState) { var monad = CreateLabeledTree(tree, updateMonad); var stateContentPair = monad.ToStateContentPair(initialState); return(stateContentPair.Content); }
public C(StateMonad m) { this.m = m; }