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;
}
