/// <summary>
/// Executes the Effect using semantics from the provided effect handler.
/// </summary>
/// <param name="effectHandler">Effect handler to be used in execution.</param>
/// <returns>A task computing the result of the Effect.</returns>
public async Task <TResult> Run(IEffectHandler effectHandler)
{
var effectAwaiter = new EffectAwaiter <TResult>(this);
await effectHandler.Handle(effectAwaiter).ConfigureAwait(false);
return(effectAwaiter.GetResult());
}
public override ValueTask Handle <TResult>(EffectAwaiter <TResult> awaiter)
{
switch (awaiter)
{
case EffectAwaiter <Unit> {
Effect: PushEffectHandlerEffect info
} awtr:
{
_handlerStack.Push(info.Handler);
awtr.SetResult(Unit.Value);
}
break;
case EffectAwaiter <Unit> {
Effect: PopEffectHandlerEffect info
} awtr:
{
_ = _handlerStack.Pop();
awtr.SetResult(Unit.Value);
}
break;
default:
foreach (var handler in _handlerStack)
{
handler.Handle(awaiter);
if (awaiter.IsCompleted)
{
break;
}
}
break;
}
return(default);
public override async Task Handle <TResult>(EffectAwaiter <TResult> awaiter)
{
await base.Handle(awaiter);
var result = RecordedResult.FromAwaiter(awaiter);
_results.Add(result);
}
public override async Task Handle <TResult>(EffectAwaiter <TResult> effect)
{
await base.Handle(effect);
results.Add(new EffectResult {
Value = effect.Result, Type = typeof(TResult)
});
}
public override async ValueTask Handle <TResult>(EffectAwaiter <TResult> awaiter)
{
if (awaiter is EffectAwaiter <IEffectHandler> {
Effect : GetCurrentHandlerEffect _
} awtr)
{
awtr.SetResult(this);
}
public override async Task Handle <TResult>(EffectAwaiter <TResult> awaiter)
{
if (_pos == _replayResults.Length)
{
throw new InvalidOperationException("Reached end of replay log.");
}
_replayResults[_pos++].WriteToAwaiter(awaiter);
}
public override async Task Handle <TResult>(EffectAwaiter <TResult> effect)
{
var result =
_results.Single(it => it.FilePath == effect.CallerFilePath &&
it.MemberName == effect.CallerMemberName &&
it.LineNumber == effect.CallerLineNumber);
effect.SetResult((TResult)Convert.ChangeType(result.Value, result.Type));
}
public override ValueTask Handle <TResult>(EffectAwaiter <TResult> awaiter)
{
if (awaiter is EffectAwaiter <DateTime> {
Effect : DateTimeNowEffect info
} awtr)
{
awtr.SetResult(DateTime.Now);
}
return(default);
public override async Task Handle <TResult>(EffectAwaiter <TResult> awaiter)
{
switch (awaiter.Effect)
{
case DependencyEffect <TResult> _:
awaiter.SetResult(_container.Get <TResult>());
break;
}
;
}
ValueTask IEffectHandler.Handle <TResult>(EffectAwaiter <TResult> awaiter)
{
Debug.Assert(_suspendedAwaiter == null);
if (awaiter is EffectAwaiter {
Effect : SuspendEffect
} suspendedAwaiter)
{
_suspendedAwaiter = suspendedAwaiter;
}
return(default);
public override ValueTask Handle <TResult>(EffectAwaiter <TResult> awaiter)
{
switch (awaiter)
{
case EffectAwaiter <DateTime> {
Effect: DateTimeNowEffect _
} awtr:
awtr.SetResult(_now);
break;
case { Effect: FuncEffect <TResult> funcEffect } :
public override ValueTask Handle <TResult>(EffectAwaiter <TResult> effect)
{
if (_index == _results.Length)
{
throw new InvalidOperationException();
}
var result = _results[_index++];
result.ToAwaiter(effect);
return(default);
public async Task Handle <TValue>(EffectAwaiter <TValue> awaiter)
{
switch (awaiter.Effect)
{
case MaybeEffect <TValue> me:
if (me.Result.HasValue)
{
awaiter.SetResult(me.Result.Value);
await ContinueStateMachine();
}
break;
}
}
public async Task Handle <TValue>(EffectAwaiter <TValue> awaiter)
{
switch (awaiter.Effect)
{
case NonDetEffect <TValue> nde:
foreach (var result in nde.Choices)
{
awaiter.SetResult(result);
await ContinueStateMachine(clone : true);
}
break;
}
}
public override ValueTask Handle <TResult>(EffectAwaiter <TResult> awaiter)
{
switch (awaiter)
{
case EffectAwaiter <string> {
Effect: ConfigEffect eff
} awtr:
var value = ConfigurationManager.AppSettings[eff.Key];
awtr.SetResult(value);
break;
}
;
return(default);
public override Task Handle <TResult>(EffectAwaiter <TResult> awaiter)
{
switch (awaiter)
{
case EffectAwaiter <System.Threading.CancellationToken> {
Effect: CancellationTokenEffect _
} awter:
awter.SetResult(_token);
break;
}
;
return(Task.CompletedTask);
}
public async override Task Handle <TValue>(EffectAwaiter <TValue> awaiter)
{
switch (awaiter.Effect)
{
case MaybeEffect <TValue> me:
if (me.Result.HasValue)
{
awaiter.SetResult(me.Result.Value);
var next = _continuation.MoveNext();
Result = MaybeEffectHandler.Run(next);
}
break;
}
}
public override async ValueTask Handle <TResult>(EffectAwaiter <TResult> awaiter)
{
try
{
await base.Handle(awaiter);
}
catch (Exception e)
{
awaiter.SetException(e);
}
var persistedEffect = PersistedEffect.FromCompletedAwaiter(awaiter);
_results.Add(persistedEffect);
}
/// <summary>
/// Handles awaiters containing a <see cref="CancellationTokenEffect"/>.
/// </summary>
public override ValueTask Handle <TResult>(EffectAwaiter <TResult> awaiter)
{
CancellationToken.ThrowIfCancellationRequested();
switch (awaiter)
{
case EffectAwaiter <CancellationToken> {
Effect: CancellationTokenEffect _
} awter:
awter.SetResult(CancellationToken);
break;
}
;
return(default);
public override Task Handle <TResult>(EffectAwaiter <TResult> awaiter)
{
Token.ThrowIfCancellationRequested();
switch (awaiter)
{
case EffectAwaiter <CancellationToken> {
Effect: CancellationTokenEffect.Effect _
} awter:
awter.SetResult(Token);
break;
}
;
return(Task.CompletedTask);
}
public override Task Handle <TResult>(EffectAwaiter <TResult> awaiter)
{
switch (awaiter)
{
case EffectAwaiter <string> {
Effect: ConfigEffect {
Key : string key
}
} awtr :
var value = ConfigurationManager.AppSettings[key];
awtr.SetResult(value);
break;
}
;
return(Task.CompletedTask);
}
public override ValueTask Handle<TResult>(EffectAwaiter<TResult> awaiter)
{
switch (awaiter)
{
case EffectAwaiter { Effect: ConsolePrintEffect printEffect } awtr:
System.Console.Write(printEffect.Message);
awtr.SetResult();
break;
case EffectAwaiter<string?> { Effect: ConsoleReadEffect _ } awtr:
string? message = System.Console.ReadLine();
awtr.SetResult(message);
break;
default:
throw new NotSupportedException(awaiter.Effect.GetType().Name);
}
return default;
}
public override async Task Handle <TResult>(EffectAwaiter <TResult> awaiter)
{
switch (awaiter.Effect)
{
case DoEffect <TResult> doEffect:
awaiter.SetResult(doEffect.Func(_ctx));
break;
}
_results.Add(new Result
{
FilePath = awaiter.CallerFilePath,
MemberName = awaiter.CallerMemberName,
LineNumber = awaiter.CallerLineNumber,
Value = awaiter.Result,
Type = typeof(TResult),
});
}
public override async Task Handle <TResult>(EffectAwaiter <TResult> awaiter)
{
switch (awaiter.Effect)
{
case DependencyEffect <TResult> depEffect:
try
{
var result = await depEffect.Handle(Container).ConfigureAwait(false);
awaiter.SetResult(result);
}
catch (Exception e)
{
awaiter.SetException(e);
}
break;
}
}
public override ValueTask Handle <TResult>(EffectAwaiter <TResult> awaiter)
{
switch (awaiter)
{
case EffectAwaiter <string> {
Effect: ReadLineEffect info
} awtr:
{
var line = System.Console.ReadLine();
awtr.SetResult(line);
//awtr.SetResult($"#1: {line}");
//awtr.SetResult($"#2: {line}");
}
break;
case EffectAwaiter <Unit> {
Effect: WriteLineEffect info
} awtr:
{
System.Console.Write(_indent);
System.Console.WriteLine(info.Line);
awtr.SetResult(Unit.Value);
}
break;
case EffectAwaiter <Unit> {
Effect: IncrementIndentLineEffect info
} awtr:
{
var newLength = _indent.Length + info.Spaces;
if (newLength < 0)
{
throw new InvalidOperationException("Cannot decrement indentation below zero.");
}
_indent = new String(' ', newLength);
awtr.SetResult(Unit.Value);
}
break;
}
return(default);
public override Task Handle <TResult>(EffectAwaiter <TResult> awaiter)
{
switch (awaiter)
{
case EffectAwaiter <Unit> {
Effect: ConsolePrintEffect printEffect
} awtr:
System.Console.Write(printEffect.Message);
awtr.SetResult(Unit.Value);
break;
case EffectAwaiter <string> {
Effect: ConsoleReadEffect _
} awtr:
string message = System.Console.ReadLine();
awtr.SetResult(message);
break;
default:
throw new NotSupportedException(awaiter.Id);
}
return(Task.CompletedTask);
}
public override async Task Handle <TResult>(EffectAwaiter <TResult> effect)
{
}
public override Task Handle <TResult>(EffectAwaiter <TResult> awaiter)
{
awaiter.SetException(new TException());
return(Task.CompletedTask);
}
public override Task Handle <TResult>(EffectAwaiter <TResult> awaiter)
{
throw new TException();
}
public override Task Handle <TResult>(EffectAwaiter <TResult> awaiter) => Task.CompletedTask;
