Removed non-generic Result (use Result<Unit> instead)

stidsborg · stidsborg · commit 85a76e60e530 · 2025-01-31T11:15:18.000+01:00
diff --git a/Core/Cleipnir.ResilientFunctions.Tests/InMemoryTests/RFunctionTests/DisposeTests.cs b/Core/Cleipnir.ResilientFunctions.Tests/InMemoryTests/RFunctionTests/DisposeTests.cs
@@ -19,7 +19,7 @@ public void RegisteringFunctionOnDisposedRFunctionsThrowsException()
         Should.Throw<ObjectDisposedException>(() =>
             _ = rFunctions.RegisterFunc(
                 "id".ToFlowType(),
-                (string _) => Succeed.WithoutValue.ToTask()
+                (string _) => Succeed.WithUnit.ToTask()
             )
         );
     }
diff --git a/Core/Cleipnir.ResilientFunctions.Tests/InMemoryTests/RFunctionTests/DuplicateRegistrationTests.cs b/Core/Cleipnir.ResilientFunctions.Tests/InMemoryTests/RFunctionTests/DuplicateRegistrationTests.cs
@@ -49,12 +49,12 @@ public void ReRegistrationRActionSucceedsWhenArgumentsAreIdentical()
         using var rFunctions = new FunctionsRegistry(new InMemoryFunctionStore());
         _ = rFunctions.RegisterFunc(
             "SomeFunctionType",
-            Task<Result>(string _) => Succeed.WithoutValue.ToTask()
+            Task<Result<Unit>>(string _) => Succeed.WithUnit.ToTask()
         );
 
         _ = rFunctions.RegisterFunc(
             "SomeFunctionType",
-            Task<Result> (string _) => Succeed.WithoutValue.ToTask()
+            Task<Result<Unit>> (string _) => Succeed.WithUnit.ToTask()
         );
     }
 
@@ -64,13 +64,13 @@ public void ReRegistrationRActionWithIncompatibleTypeThrowsException()
         using var rFunctions = new FunctionsRegistry(new InMemoryFunctionStore());
         _ = rFunctions.RegisterFunc(
             "SomeFunctionType",
-            Task<Result>(string _) => Succeed.WithoutValue.ToTask()
+            Task<Result<Unit>>(string _) => Succeed.WithUnit.ToTask()
         );
 
         Should.Throw<InvalidCastException>(() =>
             _ = rFunctions.RegisterFunc(
                 "SomeFunctionType",
-                Task<Result>(int _) => Succeed.WithoutValue.ToTask()
+                Task<Result<Unit>>(int _) => Succeed.WithUnit.ToTask()
             )
         );
     }
@@ -81,13 +81,13 @@ public void ReRegistrationFromFuncToActionThrowsArgumentException()
         using var rFunctions = new FunctionsRegistry(new InMemoryFunctionStore());
         _ = rFunctions.RegisterFunc(
             "SomeFunctionType",
-            Task<Result>(string _) => Succeed.WithoutValue.ToTask()
+            Task<Result<Unit>>(string _) => Succeed.WithUnit.ToTask()
         );
 
         Should.Throw<InvalidCastException>(() =>
             _ = rFunctions.RegisterAction(
                 "SomeFunctionType",
-                Task (int _) => Succeed.WithoutValue.ToTask()
+                Task (int _) => Succeed.WithUnit.ToTask()
             )
         );
     }
diff --git a/Core/Cleipnir.ResilientFunctions.Tests/InMemoryTests/RFunctionTests/InMemorySunshineTests.cs b/Core/Cleipnir.ResilientFunctions.Tests/InMemoryTests/RFunctionTests/InMemorySunshineTests.cs
@@ -48,7 +48,7 @@ await ExecuteFunc((functionsRegistry, callback)
             => functionsRegistry.RegisterFunc(
                 flowType: "",
                 Task<Result<string>>(string param) 
-                    => Result.SucceedWithValue(callback(param).Result).ToTask()
+                    => Succeed.WithValue(callback(param).Result).ToTask()
                )
             );
     }    
@@ -61,7 +61,7 @@ await ExecuteFunc((rFunctions, callback)
             => rFunctions.RegisterFunc(
                 flowType: "",
                 Task<Result<string>> (string param, Workflow _)
-                    => Result.SucceedWithValue(callback(param).Result).ToTask()
+                    => Succeed.WithValue(callback(param).Result).ToTask()
             )
         );
     }    
@@ -150,7 +150,7 @@ public async Task AsyncActionWithResultSunshineTest()
         await ExecuteAction((rFunctions, callback)
             => rFunctions.RegisterAction(
                 flowType: "",
-                Task<Result> (string param) => { callback(param); return Task.FromResult(Result.Succeed); }
+                Task<Result<Unit>> (string param) => { callback(param); return Succeed.WithUnit.ToTask(); }
             )
         );
     }    
@@ -162,7 +162,7 @@ public async Task AsyncActionWithWorkflowAndResultSunshineTest()
         await ExecuteAction((rFunctions, callback)
             => rFunctions.RegisterAction(
                 flowType: "",
-                Task<Result> (string param, Workflow workflow) => { callback(param); return Task.FromResult(Result.Succeed); }
+                Task<Result<Unit>> (string param, Workflow workflow) => { callback(param); return Succeed.WithUnit.ToTask(); }
             )
         );
     }    
diff --git a/Core/Cleipnir.ResilientFunctions.Tests/InMemoryTests/RFunctionTests/RegisterWithExplicitReturnTests.cs b/Core/Cleipnir.ResilientFunctions.Tests/InMemoryTests/RFunctionTests/RegisterWithExplicitReturnTests.cs
@@ -61,7 +61,7 @@ public async Task ActionWithExplicitReturnIsInvokedSuccessfully()
                 {
                     await Task.CompletedTask;
                     syncedParam.Value = param;
-                    return Succeed.WithoutValue;
+                    return Succeed.WithUnit;
                 })
             .Invoke;
 
@@ -81,7 +81,7 @@ public async Task ActionWithStateAndExplicitReturnIsInvokedSuccessfully()
                 {
                     await Task.CompletedTask;
                     syncedParam.Value = param;
-                    return Succeed.WithoutValue;
+                    return Succeed.WithUnit;
                 })
             .Invoke;
 
diff --git a/Core/Cleipnir.ResilientFunctions.Tests/InMemoryTests/ShutdownCoordinationTests/RFunctionsShutdownTests.cs b/Core/Cleipnir.ResilientFunctions.Tests/InMemoryTests/ShutdownCoordinationTests/RFunctionsShutdownTests.cs
@@ -75,7 +75,7 @@ public async Task RFunctionsShutdownTaskThrowsExceptionWhenWaitThresholdIsExceed
              (string _) =>
             {
                 insideRFuncFlag.Raise();
-                return NeverCompletingTask.OfType<Result>();
+                return NeverCompletingTask.OfType<Result<Unit>>();
             }
         ).Invoke;
 
@@ -163,7 +163,7 @@ public async Task RFunctionsShutdownTaskOnlyCompletesAfterPostponedWatchDogsRFun
             {
                 insideRFuncFlag.Raise();
                 await completeRFuncFlag.WaitForRaised();
-                return Succeed.WithoutValue;
+                return Succeed.WithUnit;
             }
         );
         
@@ -216,10 +216,10 @@ public async Task RFunctionsShutdownTaskCompletesWhenInvokedRFuncIsPostponed()
 
         var registration = functionsRegistry.RegisterAction(
             flowType,
-            Task<Result> (string _) =>
+            Task<Result<Unit>> (string _) =>
             {
                 counter.Increment();
-                return Postpone.For(500).ToResult().ToTask();
+                return Postpone.For(500).ToUnitResult.ToTask();
             }
         );
         var rAction = registration.Invoke;
diff --git a/Core/Cleipnir.ResilientFunctions.Tests/TestTemplates/RFunctionTests/FailedTests.cs b/Core/Cleipnir.ResilientFunctions.Tests/TestTemplates/RFunctionTests/FailedTests.cs
@@ -288,7 +288,7 @@ private async Task ExceptionThrowingActionWithStateIsNotCompletedByWatchDog(
                 (string _) =>
                 {
                     flag.Raise();
-                    return Succeed.WithoutValue.ToTask();
+                    return Succeed.WithUnit.ToTask();
                 }
             );
                 
diff --git a/Core/Cleipnir.ResilientFunctions.Tests/TestTemplates/RFunctionTests/PostponedTests.cs b/Core/Cleipnir.ResilientFunctions.Tests/TestTemplates/RFunctionTests/PostponedTests.cs
@@ -164,8 +164,8 @@ protected async Task PostponedActionIsCompletedByWatchDog(Task<IFunctionStore> s
                 )
             );
             var rAction = functionsRegistry.RegisterAction(
-                flowType,
-                (string _) => Postpone.Until(DateTime.UtcNow.AddMilliseconds(1_000)).ToResult().ToTask()
+                flowType, 
+                Task<Result<Unit>> (string _) => Postpone.Until(DateTime.UtcNow.AddMilliseconds(1_000)).ToUnitResult.ToTask()
             ).Invoke;
 
             await Should.ThrowAsync<InvocationPostponedException>(() => rAction(flowInstance.Value, param));
@@ -211,7 +211,7 @@ protected async Task PostponedActionWithStateIsCompletedByWatchDog(Task<IFunctio
             );
             var rAction = functionsRegistry.RegisterAction(
                 flowType,
-                (string _, Workflow _) => Postpone.For(1_000).ToResult().ToTask()
+                Task<Result<Unit>> (string _, Workflow _) => Postpone.For(1_000).ToUnitResult.ToTask()
             ).Invoke;
 
             await Should.ThrowAsync<InvocationPostponedException>(() => 
@@ -270,7 +270,7 @@ protected async Task PostponedActionIsCompletedByWatchDogAfterCrash(Task<IFuncti
                 )
             );
             var rFunc = functionsRegistry
-                .RegisterAction(functionId.Type, (string _) => Postpone.For(1_000).ToResult().ToTask())
+                .RegisterAction(functionId.Type, Task<Result<Unit>> (string _) => Postpone.For(1_000).ToUnitResult.ToTask())
                 .Invoke;
 
             var instanceId = functionId.Instance.ToString();
diff --git a/Core/Cleipnir.ResilientFunctions.Tests/TestTemplates/RFunctionTests/ScheduledInvocationTests.cs b/Core/Cleipnir.ResilientFunctions.Tests/TestTemplates/RFunctionTests/ScheduledInvocationTests.cs
@@ -73,7 +73,7 @@ protected async Task ScheduledFunctionIsInvokedAfterActionWithStateHasBeenPersis
         using var functionsRegistry = new FunctionsRegistry(store, new Settings(unhandledExceptionCatcher.Catch));
         var reg = functionsRegistry.RegisterAction(
             flowType,
-            (string _) => NeverCompletingTask.OfType<Result>()
+            (string _) => NeverCompletingTask.OfType<Result<Unit>>()
         );
         var schedule = reg.Schedule;
 
@@ -99,7 +99,7 @@ protected async Task ScheduledFunctionIsInvokedAfterActionStateHasBeenPersisted(
         using var functionsRegistry = new FunctionsRegistry(store, new Settings(unhandledExceptionCatcher.Catch));
         var reg = functionsRegistry.RegisterFunc(
             flowType,
-            (string _) => NeverCompletingTask.OfType<Result>()
+            (string _) => NeverCompletingTask.OfType<Result<Unit>>()
         );
         var schedule = reg.Schedule;
 
diff --git a/Core/Cleipnir.ResilientFunctions.Tests/TestTemplates/RFunctionTests/SunshineTests.cs b/Core/Cleipnir.ResilientFunctions.Tests/TestTemplates/RFunctionTests/SunshineTests.cs
@@ -101,7 +101,7 @@ public async Task SunshineScenarioParamlessWithResultReturnType(Task<IFunctionSt
                 inner: () =>
                 {
                     flag.Raise();
-                    return Result.Succeed.ToTask();
+                    return Succeed.WithUnit.ToTask();
                 });
         var invoke = reg.Invoke;
 
@@ -357,11 +357,11 @@ protected async Task InstancesCanBeFetched(Task<IFunctionStore> storeTask)
         
             var registration = functionsRegistry.RegisterAction(
                 flowType,
-                inner: Task<Result> (bool postpone) => 
+                inner: Task<Result<Unit>> (bool postpone) => 
                     Task.FromResult(
                         postpone 
                         ? Postpone.For(TimeSpan.FromHours(1)) 
-                        : Succeed.WithoutValue
+                        : Succeed.WithUnit
                     )
             );
             
@@ -546,11 +546,11 @@ public async Task FlowIdCanBeExtractedFromAmbientStateAfterSuspension(Task<IFunc
                     if (!postponed)
                     {
                         postponed = true;
-                        return Postpone.For(100).ToResult().ToTask();
+                        return Postpone.For(100).ToUnitResult.ToTask();
                     }
                         
                     storedId = CurrentFlow.StoredId;
-                    return Result.Succeed.ToTask();
+                    return Succeed.WithUnit.ToTask();
                 }
             );
         await reg.Schedule(instance);
diff --git a/Core/Cleipnir.ResilientFunctions.Tests/TestTemplates/RFunctionTests/SuspensionTests.cs b/Core/Cleipnir.ResilientFunctions.Tests/TestTemplates/RFunctionTests/SuspensionTests.cs
@@ -33,7 +33,7 @@ protected async Task ActionCanBeSuspended(Task<IFunctionStore> storeTask)
 
         var rAction = functionsRegistry.RegisterAction(
             flowType,
-            Task<Result> (string _) => throw new SuspendInvocationException()
+            Task<Result<Unit>> (string _) => throw new SuspendInvocationException()
         );
 
         await Should.ThrowAsync<InvocationSuspendedException>(
@@ -112,7 +112,7 @@ protected async Task DetectionOfEligibleSuspendedFunctionSucceedsAfterEventAdded
                 }
 
                 invocations++;
-                return Result.SucceedWithValue("completed").ToTask();
+                return Succeed.WithValue("completed").ToTask();
             });
 
         await Should.ThrowAsync<InvocationSuspendedException>(
@@ -155,7 +155,7 @@ protected async Task PostponedFunctionIsResumedAfterEventIsAppendedToMessages(Ta
                 }
 
                 invocations++;
-                return Result.SucceedWithValue("completed").ToTask();
+                return Succeed.WithValue("completed").ToTask();
             });
 
         await Should.ThrowAsync<InvocationPostponedException>(
@@ -192,7 +192,7 @@ protected async Task EligibleSuspendedFunctionIsPickedUpByWatchdog(Task<IFunctio
             flowType,
             Task<Result<string>> (_) =>
             {
-                if (flag.IsRaised) return Result.SucceedWithValue("success").ToTask();
+                if (flag.IsRaised) return Succeed.WithValue("success").ToTask();
                 flag.Raise();
                 return Suspend.Invocation.ToResult<string>().ToTask();
             });
diff --git a/Core/Cleipnir.ResilientFunctions.Tests/TestTemplates/WatchDogsTests/WatchdogCompoundTests.cs b/Core/Cleipnir.ResilientFunctions.Tests/TestTemplates/WatchDogsTests/WatchdogCompoundTests.cs
@@ -319,7 +319,7 @@ public async Task ActionCompoundTest(Task<IFunctionStore> storeTask)
                     inner: (Param p) =>
                     {
                         Task.Run(() => paramTcs.TrySetResult(p));
-                        return Postpone.For(100).ToResult().ToTask();
+                        return Postpone.For(100).ToUnitResult.ToTask();
                     }
                 );
 
@@ -435,7 +435,7 @@ public async Task ActionWithStateCompoundTest(Task<IFunctionStore> storeTask)
             _ = functionsRegistry
                 .RegisterAction(
                     flowType,
-                    async Task<Result> (Param p, Workflow workflow) =>
+                    async Task<Result<Unit>> (Param p, Workflow workflow) =>
                     {
                         _ = Task.Run(() => paramTcs.TrySetResult(p));
                         var state = await workflow.States.CreateOrGet<ListState>("Scraps");
diff --git a/Core/Cleipnir.ResilientFunctions/Domain/Result.cs b/Core/Cleipnir.ResilientFunctions/Domain/Result.cs
@@ -1,60 +1,19 @@
 ﻿using System;
-using Cleipnir.ResilientFunctions.CoreRuntime;
-using Cleipnir.ResilientFunctions.Domain.Exceptions;
 using Cleipnir.ResilientFunctions.Domain.Exceptions.Commands;
 using Cleipnir.ResilientFunctions.Helpers;
 
 namespace Cleipnir.ResilientFunctions.Domain;
 
-public class Result
+public static class Result
 {
-    public Outcome Outcome { get; }
-    public Postpone? Postpone { get; }
-    public FatalWorkflowException? Fail { get; }
-    public Suspend? Suspend { get; }
-
-    public Result() : this(succeed: true, postpone: null, fail: null, suspend: null) {}
-    public Result(Postpone postpone) : this(succeed: false, postpone, fail: null, suspend: null) {}
-    public Result(FatalWorkflowException exception) : this(succeed: false, postpone: null, fail: exception, suspend: null) {}
-    public Result(Suspend suspend) : this(succeed: false, postpone: null, fail: null, suspend) {}
-
-    private Result(bool succeed, Postpone? postpone, FatalWorkflowException? fail, Suspend? suspend)
-    {
-        if (succeed)
-            Outcome = Outcome.Succeed;
-        else if (postpone != null)
-            Outcome = Outcome.Postpone;
-        else if (fail != null)
-            Outcome = Outcome.Fail;
-        else
-            Outcome = Outcome.Suspend;
-        
-        Postpone = postpone;
-        Fail = fail;
-        Postpone = postpone;
-        Suspend = suspend;
-    }
-
-    public static Result Succeed { get; } = new Result();
-    public static implicit operator Result(Fail fail) => new Result(fail.Exception);
-    public static implicit operator Result(Postpone postpone) => new Result(postpone);
-    public static implicit operator Result(Suspend suspend) => new Result(suspend);
     public static Result<T> SucceedWithValue<T>(T value) => new(value);
-
-    public Result<Unit> ToUnit() => Outcome switch
-    {
-        Outcome.Succeed => new Result<Unit>(Unit.Instance),
-        Outcome.Postpone => new Result<Unit>(Postpone!),
-        Outcome.Fail => new Result<Unit>(Fail!),
-        Outcome.Suspend => new Result<Unit>(Suspend!),
-        _ => throw new ArgumentOutOfRangeException()
-    };
+    public static Result<Unit> SucceedWithUnit { get; } = new Result<Unit>(Unit.Instance);
 }
 
 public static class Succeed
 {
-    public static Result WithoutValue { get; } = new Result();
     public static Result<T> WithValue<T>(T value) => new Result<T>(value);
+    public static Result<Unit> WithUnit { get; } = new Result<Unit>(Unit.Instance);
 }
 
 public class Fail
@@ -75,7 +34,6 @@ public Fail(Exception exception) =>
     public static Fail WithException(Exception exception) => new Fail(exception);
     public static Fail WithException(FatalWorkflowException exception, FlowId flowId) => new Fail(flowId, exception);
 
-    public Result ToResult() => new(Exception);
     public Result<T> ToResult<T>() => new(Exception);
 }
 
@@ -85,8 +43,8 @@ public class Postpone
 
     private Postpone(DateTime dateTime) => DateTime = dateTime;
 
-    public Result ToResult() => new(this);
     public Result<T> ToResult<T>() => new(this);
+    public Result<Unit> ToUnitResult => ToResult<Unit>();
     
     public static Postpone Until(DateTime dateTime) => new(dateTime.ToUniversalTime());
 
diff --git a/Core/Cleipnir.ResilientFunctions/FunctionsRegistry.cs b/Core/Cleipnir.ResilientFunctions/FunctionsRegistry.cs
diff --git a/Core/Cleipnir.ResilientFunctions/InnerAdapters/InnerToAsyncResultAdapters.cs b/Core/Cleipnir.ResilientFunctions/InnerAdapters/InnerToAsyncResultAdapters.cs
diff --git a/Samples/Sample.ConsoleApp/Subscription/SubscriptionSaga.cs b/Samples/Sample.ConsoleApp/Subscription/SubscriptionSaga.cs

Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ public void RegisteringFunctionOnDisposedRFunctionsThrowsException()`
`19`	`19`	`Should.Throw<ObjectDisposedException>(() =>`
`20`	`20`	`_ = rFunctions.RegisterFunc(`
`21`	`21`	`"id".ToFlowType(),`
`22`		`- (string _) => Succeed.WithoutValue.ToTask()`
	`22`	`+ (string _) => Succeed.WithUnit.ToTask()`
`23`	`23`	`)`
`24`	`24`	`);`
`25`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ await ExecuteFunc((functionsRegistry, callback)`
`48`	`48`	`=> functionsRegistry.RegisterFunc(`
`49`	`49`	`flowType: "",`
`50`	`50`	`Task<Result<string>>(string param)`
`51`		`- => Result.SucceedWithValue(callback(param).Result).ToTask()`
	`51`	`+ => Succeed.WithValue(callback(param).Result).ToTask()`
`52`	`52`	`)`
`53`	`53`	`);`
`54`	`54`	`}`
`@@ -61,7 +61,7 @@ await ExecuteFunc((rFunctions, callback)`
`61`	`61`	`=> rFunctions.RegisterFunc(`
`62`	`62`	`flowType: "",`
`63`	`63`	`Task<Result<string>> (string param, Workflow _)`
`64`		`- => Result.SucceedWithValue(callback(param).Result).ToTask()`
	`64`	`+ => Succeed.WithValue(callback(param).Result).ToTask()`
`65`	`65`	`)`
`66`	`66`	`);`
`67`	`67`	`}`
`@@ -150,7 +150,7 @@ public async Task AsyncActionWithResultSunshineTest()`
`150`	`150`	`await ExecuteAction((rFunctions, callback)`
`151`	`151`	`=> rFunctions.RegisterAction(`
`152`	`152`	`flowType: "",`
`153`		`- Task<Result> (string param) => { callback(param); return Task.FromResult(Result.Succeed); }`
	`153`	`+ Task<Result<Unit>> (string param) => { callback(param); return Succeed.WithUnit.ToTask(); }`
`154`	`154`	`)`
`155`	`155`	`);`
`156`	`156`	`}`
`@@ -162,7 +162,7 @@ public async Task AsyncActionWithWorkflowAndResultSunshineTest()`
`162`	`162`	`await ExecuteAction((rFunctions, callback)`
`163`	`163`	`=> rFunctions.RegisterAction(`
`164`	`164`	`flowType: "",`
`165`		`- Task<Result> (string param, Workflow workflow) => { callback(param); return Task.FromResult(Result.Succeed); }`
	`165`	`+ Task<Result<Unit>> (string param, Workflow workflow) => { callback(param); return Succeed.WithUnit.ToTask(); }`
`166`	`166`	`)`
`167`	`167`	`);`
`168`	`168`	`}`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ public async Task RFunctionsShutdownTaskThrowsExceptionWhenWaitThresholdIsExceed`
`75`	`75`	`(string _) =>`
`76`	`76`	`{`
`77`	`77`	`insideRFuncFlag.Raise();`
`78`		`- return NeverCompletingTask.OfType<Result>();`
	`78`	`+ return NeverCompletingTask.OfType<Result<Unit>>();`
`79`	`79`	`}`
`80`	`80`	`).Invoke;`
`81`	`81`
`@@ -163,7 +163,7 @@ public async Task RFunctionsShutdownTaskOnlyCompletesAfterPostponedWatchDogsRFun`
`163`	`163`	`{`
`164`	`164`	`insideRFuncFlag.Raise();`
`165`	`165`	`await completeRFuncFlag.WaitForRaised();`
`166`		`- return Succeed.WithoutValue;`
	`166`	`+ return Succeed.WithUnit;`
`167`	`167`	`}`
`168`	`168`	`);`
`169`	`169`
`@@ -216,10 +216,10 @@ public async Task RFunctionsShutdownTaskCompletesWhenInvokedRFuncIsPostponed()`
`216`	`216`
`217`	`217`	`var registration = functionsRegistry.RegisterAction(`
`218`	`218`	`flowType,`
`219`		`- Task<Result> (string _) =>`
	`219`	`+ Task<Result<Unit>> (string _) =>`
`220`	`220`	`{`
`221`	`221`	`counter.Increment();`
`222`		`- return Postpone.For(500).ToResult().ToTask();`
	`222`	`+ return Postpone.For(500).ToUnitResult.ToTask();`
`223`	`223`	`}`
`224`	`224`	`);`
`225`	`225`	`var rAction = registration.Invoke;`
Original file line number	Diff line number	Diff line change
`@@ -288,7 +288,7 @@ private async Task ExceptionThrowingActionWithStateIsNotCompletedByWatchDog(`
`288`	`288`	`(string _) =>`
`289`	`289`	`{`
`290`	`290`	`flag.Raise();`
`291`		`- return Succeed.WithoutValue.ToTask();`
	`291`	`+ return Succeed.WithUnit.ToTask();`
`292`	`292`	`}`
`293`	`293`	`);`
`294`	`294`
Original file line number	Diff line number	Diff line change
`@@ -319,7 +319,7 @@ public async Task ActionCompoundTest(Task<IFunctionStore> storeTask)`
`319`	`319`	`inner: (Param p) =>`
`320`	`320`	`{`
`321`	`321`	`Task.Run(() => paramTcs.TrySetResult(p));`
`322`		`- return Postpone.For(100).ToResult().ToTask();`
	`322`	`+ return Postpone.For(100).ToUnitResult.ToTask();`
`323`	`323`	`}`
`324`	`324`	`);`
`325`	`325`
`@@ -435,7 +435,7 @@ public async Task ActionWithStateCompoundTest(Task<IFunctionStore> storeTask)`
`435`	`435`	`_ = functionsRegistry`
`436`	`436`	`.RegisterAction(`
`437`	`437`	`flowType,`
`438`		`- async Task<Result> (Param p, Workflow workflow) =>`
	`438`	`+ async Task<Result<Unit>> (Param p, Workflow workflow) =>`
`439`	`439`	`{`
`440`	`440`	`_ = Task.Run(() => paramTcs.TrySetResult(p));`
`441`	`441`	`var state = await workflow.States.CreateOrGet<ListState>("Scraps");`