Merge pull request #6 from pfpack/dev

Dev
pfpack · Jun 4, 2022 · fc3b41f · fc3b41f
2 parents b798c1d + 2dfc066
commit fc3b41f
Show file tree

Hide file tree

Showing 65 changed files with 235 additions and 235 deletions.
diff --git a/src/core-asyncpipeline/AsyncPipeline/AsyncPipeline.Result/AsyncPipeline.Result.cs b/src/core-asyncpipeline/AsyncPipeline/AsyncPipeline.Result/AsyncPipeline.Result.cs
@@ -0,0 +1,11 @@
+namespace System;
+
+public readonly partial struct AsyncPipeline<TSuccess, TFailure> : IEquatable<AsyncPipeline<TSuccess, TFailure>>
+    where TFailure : struct
+{
+    private readonly AsyncPipeline<Result<TSuccess, TFailure>> pipeline;
+
+    internal AsyncPipeline(AsyncPipeline<Result<TSuccess, TFailure>> pipeline)
+        =>
+        this.pipeline = pipeline;
+}
diff --git a/...yncResultFlow/Equality/Equality.Common.cs → ...peline.Result/Equality/Equality.Common.cs b/...yncResultFlow/Equality/Equality.Common.cs → ...peline.Result/Equality/Equality.Common.cs
@@ -2,11 +2,11 @@
 
 namespace System;
 
-partial struct AsyncResultFlow<TSuccess, TFailure>
+partial struct AsyncPipeline<TSuccess, TFailure>
 {
     private static Type EqualityContract
         =>
-        typeof(AsyncResultFlow<TSuccess, TFailure>);
+        typeof(AsyncPipeline<TSuccess, TFailure>);
 
     private static EqualityComparer<Type> EqualityContractComparer
         =>

diff --git a/src/core-asyncpipeline/AsyncPipeline/AsyncPipeline.Result/Equality/Equality.Equals.Impl.cs b/src/core-asyncpipeline/AsyncPipeline/AsyncPipeline.Result/Equality/Equality.Equals.Impl.cs
@@ -0,0 +1,8 @@
+namespace System;
+
+partial struct AsyncPipeline<TSuccess, TFailure>
+{
+    public bool Equals(AsyncPipeline<TSuccess, TFailure> other)
+        =>
+        AsyncPipelineComparer.Equals(pipeline, other.pipeline);
+}
diff --git a/src/core-asyncpipeline/AsyncPipeline/AsyncPipeline.Result/Equality/Equality.Equals.Wrap.cs b/src/core-asyncpipeline/AsyncPipeline/AsyncPipeline.Result/Equality/Equality.Equals.Wrap.cs
@@ -0,0 +1,23 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace System;
+
+partial struct AsyncPipeline<TSuccess, TFailure>
+{
+    public static bool Equals(AsyncPipeline<TSuccess, TFailure> left, AsyncPipeline<TSuccess, TFailure> right)
+        =>
+        left.Equals(right);
+
+    public static bool operator ==(AsyncPipeline<TSuccess, TFailure> left, AsyncPipeline<TSuccess, TFailure> right)
+        =>
+        left.Equals(right);
+
+    public static bool operator !=(AsyncPipeline<TSuccess, TFailure> left, AsyncPipeline<TSuccess, TFailure> right)
+        =>
+        left.Equals(right) is false;
+
+    public override bool Equals([NotNullWhen(true)] object? obj)
+        =>
+        obj is AsyncPipeline<TSuccess, TFailure> other &&
+        Equals(other);
+}
diff --git a/...sultFlow/Equality/Equality.GetHashCode.cs → ...e.Result/Equality/Equality.GetHashCode.cs b/...sultFlow/Equality/Equality.GetHashCode.cs → ...e.Result/Equality/Equality.GetHashCode.cs
@@ -1,10 +1,10 @@
 namespace System;
 
-partial struct AsyncResultFlow<TSuccess, TFailure>
+partial struct AsyncPipeline<TSuccess, TFailure>
 {
     public override int GetHashCode()
         =>
         HashCode.Combine(
             EqualityContractComparer.GetHashCode(EqualityContract),
-            AsyncPipelineComparer.GetHashCode(asyncPipeline));
+            AsyncPipelineComparer.GetHashCode(pipeline));
 }
diff --git a/...ine/AsyncResultFlow/Filter/Filter.Task.cs → ...syncPipeline.Result/Filter/Filter.Task.cs b/...ine/AsyncResultFlow/Filter/Filter.Task.cs → ...syncPipeline.Result/Filter/Filter.Task.cs
@@ -3,25 +3,25 @@
 
 namespace System
 {
-    partial struct AsyncResultFlow<TSuccess, TFailure>
+    partial struct AsyncPipeline<TSuccess, TFailure>
     {
-        public AsyncResultFlow<TSuccess, TFailure> Filter(
+        public AsyncPipeline<TSuccess, TFailure> Filter(
             Func<TSuccess, CancellationToken, Task<bool>> predicateAsync,
             Func<TSuccess, TFailure> causeFactory)
             =>
             InnerFilter(
                 predicateAsync ?? throw new ArgumentNullException(nameof(predicateAsync)),
                 causeFactory ?? throw new ArgumentNullException(nameof(causeFactory)));
 
-        public AsyncResultFlow<TSuccess, TFailure> Filter(
+        public AsyncPipeline<TSuccess, TFailure> Filter(
             Func<TSuccess, CancellationToken, Task<bool>> predicateAsync,
             Func<TSuccess, CancellationToken, Task<TFailure>> causeFactoryAsync)
             =>
             InnerFilter(
                 predicateAsync ?? throw new ArgumentNullException(nameof(predicateAsync)),
                 causeFactoryAsync ?? throw new ArgumentNullException(nameof(causeFactoryAsync)));
 
-        private AsyncResultFlow<TSuccess, TFailure> InnerFilter(
+        private AsyncPipeline<TSuccess, TFailure> InnerFilter(
             Func<TSuccess, CancellationToken, Task<bool>> predicateAsync,
             Func<TSuccess, TFailure> causeFactory)
             =>
@@ -30,7 +30,7 @@ private AsyncResultFlow<TSuccess, TFailure> InnerFilter(
                     s => predicateAsync.Invoke(s, t),
                     f => f.InternalPipe(causeFactory).InternalPipe(Task.FromResult)));
 
-        private AsyncResultFlow<TSuccess, TFailure> InnerFilter(
+        private AsyncPipeline<TSuccess, TFailure> InnerFilter(
             Func<TSuccess, CancellationToken, Task<bool>> predicateAsync,
             Func<TSuccess, CancellationToken, Task<TFailure>> causeFactoryAsync)
             =>

diff --git a/...Pipeline/AsyncResultFlow/Filter/Filter.cs → ...ine/AsyncPipeline.Result/Filter/Filter.cs b/...Pipeline/AsyncResultFlow/Filter/Filter.cs → ...ine/AsyncPipeline.Result/Filter/Filter.cs
@@ -1,14 +1,14 @@
 namespace System
 {
-    partial struct AsyncResultFlow<TSuccess, TFailure>
+    partial struct AsyncPipeline<TSuccess, TFailure>
     {
-        public AsyncResultFlow<TSuccess, TFailure> Filter(Func<TSuccess, bool> predicate, Func<TSuccess, TFailure> causeFactory)
+        public AsyncPipeline<TSuccess, TFailure> Filter(Func<TSuccess, bool> predicate, Func<TSuccess, TFailure> causeFactory)
             =>
             InnerFilter(
                 predicate ?? throw new ArgumentNullException(nameof(predicate)),
                 causeFactory ?? throw new ArgumentNullException(nameof(causeFactory)));
 
-        private AsyncResultFlow<TSuccess, TFailure> InnerFilter(Func<TSuccess, bool> predicate, Func<TSuccess, TFailure> causeFactory)
+        private AsyncPipeline<TSuccess, TFailure> InnerFilter(Func<TSuccess, bool> predicate, Func<TSuccess, TFailure> causeFactory)
             =>
             InnerPipe(
                 r => r.Filter(predicate, causeFactory));

diff --git a/...ine/AsyncResultFlow/Filter/FilterValue.cs → ...syncPipeline.Result/Filter/FilterValue.cs b/...ine/AsyncResultFlow/Filter/FilterValue.cs → ...syncPipeline.Result/Filter/FilterValue.cs
@@ -3,25 +3,25 @@
 
 namespace System
 {
-    partial struct AsyncResultFlow<TSuccess, TFailure>
+    partial struct AsyncPipeline<TSuccess, TFailure>
     {
-        public AsyncResultFlow<TSuccess, TFailure> FilterValue(
+        public AsyncPipeline<TSuccess, TFailure> FilterValue(
             Func<TSuccess, CancellationToken, ValueTask<bool>> predicateAsync,
             Func<TSuccess, TFailure> causeFactory)
             =>
             InnerFilterValue(
                 predicateAsync ?? throw new ArgumentNullException(nameof(predicateAsync)),
                 causeFactory ?? throw new ArgumentNullException(nameof(causeFactory)));
 
-        public AsyncResultFlow<TSuccess, TFailure> FilterValue(
+        public AsyncPipeline<TSuccess, TFailure> FilterValue(
             Func<TSuccess, CancellationToken, ValueTask<bool>> predicateAsync,
             Func<TSuccess, CancellationToken, ValueTask<TFailure>> causeFactoryAsync)
             =>
             InnerFilterValue(
                 predicateAsync ?? throw new ArgumentNullException(nameof(predicateAsync)),
                 causeFactoryAsync ?? throw new ArgumentNullException(nameof(causeFactoryAsync)));
 
-        private AsyncResultFlow<TSuccess, TFailure> InnerFilterValue(
+        private AsyncPipeline<TSuccess, TFailure> InnerFilterValue(
             Func<TSuccess, CancellationToken, ValueTask<bool>> predicateAsync,
             Func<TSuccess, TFailure> causeFactory)
             =>
@@ -30,7 +30,7 @@ private AsyncResultFlow<TSuccess, TFailure> InnerFilterValue(
                     s => predicateAsync.Invoke(s, t),
                     f => f.InternalPipe(causeFactory).InternalPipe(ValueTask.FromResult)));
 
-        private AsyncResultFlow<TSuccess, TFailure> InnerFilterValue(
+        private AsyncPipeline<TSuccess, TFailure> InnerFilterValue(
             Func<TSuccess, CancellationToken, ValueTask<bool>> predicateAsync,
             Func<TSuccess, CancellationToken, ValueTask<TFailure>> causeFactoryAsync)
             =>

diff --git a/...ipeline/AsyncResultFlow/Fold/Fold.Task.cs → ...ne/AsyncPipeline.Result/Fold/Fold.Task.cs b/...ipeline/AsyncResultFlow/Fold/Fold.Task.cs → ...ne/AsyncPipeline.Result/Fold/Fold.Task.cs
@@ -3,7 +3,7 @@
 
 namespace System
 {
-    partial struct AsyncResultFlow<TSuccess, TFailure>
+    partial struct AsyncPipeline<TSuccess, TFailure>
     {
         public AsyncPipeline<TResult> Fold<TResult>(
             Func<TSuccess, CancellationToken, Task<TResult>> mapSuccessAsync,
@@ -17,7 +17,7 @@ private AsyncPipeline<TResult> InnerFilter<TResult>(
             Func<TSuccess, CancellationToken, Task<TResult>> mapSuccessAsync,
             Func<TFailure, CancellationToken, Task<TResult>> mapFailureAsync)
             =>
-            asyncPipeline.InternalPipe(
+            pipeline.InternalPipe(
                 (r, t) => r.FoldAsync(
                     s => mapSuccessAsync.Invoke(s, t),
                     f => mapFailureAsync.Invoke(f, t)));

diff --git a/...syncPipeline/AsyncResultFlow/Fold/Fold.cs → ...ipeline/AsyncPipeline.Result/Fold/Fold.cs b/...syncPipeline/AsyncResultFlow/Fold/Fold.cs → ...ipeline/AsyncPipeline.Result/Fold/Fold.cs
@@ -1,6 +1,6 @@
 namespace System
 {
-    partial struct AsyncResultFlow<TSuccess, TFailure>
+    partial struct AsyncPipeline<TSuccess, TFailure>
     {
         public AsyncPipeline<TResult> Fold<TResult>(Func<TSuccess, TResult> mapSuccess, Func<TFailure, TResult> mapFailure)
             =>
@@ -10,7 +10,7 @@ public AsyncPipeline<TResult> Fold<TResult>(Func<TSuccess, TResult> mapSuccess,
 
         private AsyncPipeline<TResult> InnerFold<TResult>(Func<TSuccess, TResult> mapSuccess, Func<TFailure, TResult> mapFailure)
             =>
-            asyncPipeline.InternalPipe(
+            pipeline.InternalPipe(
                 r => r.Fold(mapSuccess, mapFailure));
     }
 }
diff --git a/...ipeline/AsyncResultFlow/Fold/FoldValue.cs → ...ne/AsyncPipeline.Result/Fold/FoldValue.cs b/...ipeline/AsyncResultFlow/Fold/FoldValue.cs → ...ne/AsyncPipeline.Result/Fold/FoldValue.cs
@@ -3,7 +3,7 @@
 
 namespace System
 {
-    partial struct AsyncResultFlow<TSuccess, TFailure>
+    partial struct AsyncPipeline<TSuccess, TFailure>
     {
         public AsyncPipeline<TResult> FoldValue<TResult>(
             Func<TSuccess, CancellationToken, ValueTask<TResult>> mapSuccessAsync,
@@ -17,7 +17,7 @@ private AsyncPipeline<TResult> InnerFilterValue<TResult>(
             Func<TSuccess, CancellationToken, ValueTask<TResult>> mapSuccessAsync,
             Func<TFailure, CancellationToken, ValueTask<TResult>> mapFailureAsync)
             =>
-            asyncPipeline.InternalPipeValue(
+            pipeline.InternalPipeValue(
                 (r, t) => r.FoldValueAsync(
                     s => mapSuccessAsync.Invoke(s, t),
                     f => mapFailureAsync.Invoke(f, t)));

diff --git a/...e/AsyncResultFlow/Forward/Forward.Task.cs → ...ncPipeline.Result/Forward/Forward.Task.cs b/...e/AsyncResultFlow/Forward/Forward.Task.cs → ...ncPipeline.Result/Forward/Forward.Task.cs
@@ -3,9 +3,9 @@
 
 namespace System
 {
-    partial struct AsyncResultFlow<TSuccess, TFailure>
+    partial struct AsyncPipeline<TSuccess, TFailure>
     {
-        public AsyncResultFlow<TNextSuccess, TFailure> Forward<TNextSuccess, TNextFailure>(
+        public AsyncPipeline<TNextSuccess, TFailure> Forward<TNextSuccess, TNextFailure>(
             Func<TSuccess, CancellationToken, Task<Result<TNextSuccess, TNextFailure>>> nextAsync,
             Func<TNextFailure, TFailure> mapFailure)
             where TNextFailure : struct
@@ -14,7 +14,7 @@ public AsyncResultFlow<TNextSuccess, TFailure> Forward<TNextSuccess, TNextFailur
                 nextAsync ?? throw new ArgumentNullException(nameof(nextAsync)),
                 mapFailure ?? throw new ArgumentNullException(nameof(mapFailure)));
 
-        public AsyncResultFlow<TNextSuccess, TFailure> Forward<TNextSuccess, TNextFailure>(
+        public AsyncPipeline<TNextSuccess, TFailure> Forward<TNextSuccess, TNextFailure>(
             Func<TSuccess, CancellationToken, Task<Result<TNextSuccess, TNextFailure>>> nextAsync,
             Func<TNextFailure, CancellationToken, Task<TFailure>> mapFailureAsync)
             where TNextFailure : struct
@@ -23,7 +23,7 @@ public AsyncResultFlow<TNextSuccess, TFailure> Forward<TNextSuccess, TNextFailur
                 nextAsync ?? throw new ArgumentNullException(nameof(nextAsync)),
                 mapFailureAsync ?? throw new ArgumentNullException(nameof(mapFailureAsync)));
 
-        public AsyncResultFlow<TNextSuccess, TNextFailure> Forward<TNextSuccess, TNextFailure>(
+        public AsyncPipeline<TNextSuccess, TNextFailure> Forward<TNextSuccess, TNextFailure>(
             Func<TSuccess, CancellationToken, Task<Result<TNextSuccess, TNextFailure>>> nextAsync,
             Func<TFailure, TNextFailure> mapFailure)
             where TNextFailure : struct
@@ -32,7 +32,7 @@ public AsyncResultFlow<TNextSuccess, TNextFailure> Forward<TNextSuccess, TNextFa
                 nextAsync ?? throw new ArgumentNullException(nameof(nextAsync)),
                 mapFailure ?? throw new ArgumentNullException(nameof(mapFailure)));
 
-        public AsyncResultFlow<TNextSuccess, TNextFailure> Forward<TNextSuccess, TNextFailure>(
+        public AsyncPipeline<TNextSuccess, TNextFailure> Forward<TNextSuccess, TNextFailure>(
             Func<TSuccess, CancellationToken, Task<Result<TNextSuccess, TNextFailure>>> nextAsync,
             Func<TFailure, CancellationToken, Task<TNextFailure>> mapFailureAsync)
             where TNextFailure : struct
@@ -41,13 +41,13 @@ public AsyncResultFlow<TNextSuccess, TNextFailure> Forward<TNextSuccess, TNextFa
                 nextAsync ?? throw new ArgumentNullException(nameof(nextAsync)),
                 mapFailureAsync ?? throw new ArgumentNullException(nameof(mapFailureAsync)));
 
-        public AsyncResultFlow<TNextSuccess, TFailure> Forward<TNextSuccess>(
+        public AsyncPipeline<TNextSuccess, TFailure> Forward<TNextSuccess>(
             Func<TSuccess, CancellationToken, Task<Result<TNextSuccess, TFailure>>> nextAsync)
             =>
             InnerForward(
                 nextAsync ?? throw new ArgumentNullException(nameof(nextAsync)));
 
-        private AsyncResultFlow<TNextSuccess, TFailure> InnerForward<TNextSuccess, TNextFailure>(
+        private AsyncPipeline<TNextSuccess, TFailure> InnerForward<TNextSuccess, TNextFailure>(
             Func<TSuccess, CancellationToken, Task<Result<TNextSuccess, TNextFailure>>> nextAsync,
             Func<TNextFailure, TFailure> mapFailure)
             where TNextFailure : struct
@@ -60,7 +60,7 @@ private AsyncResultFlow<TNextSuccess, TFailure> InnerForward<TNextSuccess, TNext
                         return next.MapFailure(mapFailure);
                     }));
 
-        private AsyncResultFlow<TNextSuccess, TFailure> InnerForward<TNextSuccess, TNextFailure>(
+        private AsyncPipeline<TNextSuccess, TFailure> InnerForward<TNextSuccess, TNextFailure>(
             Func<TSuccess, CancellationToken, Task<Result<TNextSuccess, TNextFailure>>> nextAsync,
             Func<TNextFailure, CancellationToken, Task<TFailure>> mapFailureAsync)
             where TNextFailure : struct
@@ -73,7 +73,7 @@ private AsyncResultFlow<TNextSuccess, TFailure> InnerForward<TNextSuccess, TNext
                         return await next.MapFailureAsync(f => mapFailureAsync.Invoke(f, t)).ConfigureAwait(false);
                     }));
 
-        private AsyncResultFlow<TNextSuccess, TNextFailure> InnerForward<TNextSuccess, TNextFailure>(
+        private AsyncPipeline<TNextSuccess, TNextFailure> InnerForward<TNextSuccess, TNextFailure>(
             Func<TSuccess, CancellationToken, Task<Result<TNextSuccess, TNextFailure>>> nextAsync,
             Func<TFailure, TNextFailure> mapFailure)
             where TNextFailure : struct
@@ -83,7 +83,7 @@ private AsyncResultFlow<TNextSuccess, TNextFailure> InnerForward<TNextSuccess, T
                     s => nextAsync.Invoke(s, t),
                     f => f.InternalPipe(mapFailure).InternalPipe(Task.FromResult)));
 
-        private AsyncResultFlow<TNextSuccess, TNextFailure> InnerForward<TNextSuccess, TNextFailure>(
+        private AsyncPipeline<TNextSuccess, TNextFailure> InnerForward<TNextSuccess, TNextFailure>(
             Func<TSuccess, CancellationToken, Task<Result<TNextSuccess, TNextFailure>>> nextAsync,
             Func<TFailure, CancellationToken, Task<TNextFailure>> mapFailureAsync)
             where TNextFailure : struct
@@ -93,7 +93,7 @@ private AsyncResultFlow<TNextSuccess, TNextFailure> InnerForward<TNextSuccess, T
                     s => nextAsync.Invoke(s, t),
                     f => mapFailureAsync.Invoke(f, t)));
 
-        private AsyncResultFlow<TNextSuccess, TFailure> InnerForward<TNextSuccess>(
+        private AsyncPipeline<TNextSuccess, TFailure> InnerForward<TNextSuccess>(
             Func<TSuccess, CancellationToken, Task<Result<TNextSuccess, TFailure>>> nextAsync)
             =>
             InnerPipe(

diff --git a/...peline/AsyncResultFlow/Forward/Forward.cs → ...e/AsyncPipeline.Result/Forward/Forward.cs b/...peline/AsyncResultFlow/Forward/Forward.cs → ...e/AsyncPipeline.Result/Forward/Forward.cs
@@ -1,8 +1,8 @@
 namespace System
 {
-    partial struct AsyncResultFlow<TSuccess, TFailure>
+    partial struct AsyncPipeline<TSuccess, TFailure>
     {
-        public AsyncResultFlow<TNextSuccess, TFailure> Forward<TNextSuccess, TNextFailure>(
+        public AsyncPipeline<TNextSuccess, TFailure> Forward<TNextSuccess, TNextFailure>(
             Func<TSuccess, Result<TNextSuccess, TNextFailure>> next,
             Func<TNextFailure, TFailure> mapFailure)
             where TNextFailure : struct
@@ -11,7 +11,7 @@ public AsyncResultFlow<TNextSuccess, TFailure> Forward<TNextSuccess, TNextFailur
                 next ?? throw new ArgumentNullException(nameof(next)),
                 mapFailure ?? throw new ArgumentNullException(nameof(mapFailure)));
 
-        public AsyncResultFlow<TNextSuccess, TNextFailure> Forward<TNextSuccess, TNextFailure>(
+        public AsyncPipeline<TNextSuccess, TNextFailure> Forward<TNextSuccess, TNextFailure>(
             Func<TSuccess, Result<TNextSuccess, TNextFailure>> next,
             Func<TFailure, TNextFailure> mapFailure)
             where TNextFailure : struct
@@ -20,13 +20,13 @@ public AsyncResultFlow<TNextSuccess, TNextFailure> Forward<TNextSuccess, TNextFa
                 next ?? throw new ArgumentNullException(nameof(next)),
                 mapFailure ?? throw new ArgumentNullException(nameof(mapFailure)));
 
-        public AsyncResultFlow<TNextSuccess, TFailure> Forward<TNextSuccess>(
+        public AsyncPipeline<TNextSuccess, TFailure> Forward<TNextSuccess>(
             Func<TSuccess, Result<TNextSuccess, TFailure>> next)
             =>
             InnerForward(
                 next ?? throw new ArgumentNullException(nameof(next)));
 
-        private AsyncResultFlow<TNextSuccess, TFailure> InnerForward<TNextSuccess, TNextFailure>(
+        private AsyncPipeline<TNextSuccess, TFailure> InnerForward<TNextSuccess, TNextFailure>(
             Func<TSuccess, Result<TNextSuccess, TNextFailure>> next,
             Func<TNextFailure, TFailure> mapFailure)
             where TNextFailure : struct
@@ -35,15 +35,15 @@ private AsyncResultFlow<TNextSuccess, TFailure> InnerForward<TNextSuccess, TNext
                 r => r.Forward(
                     s => next.Invoke(s).MapFailure(mapFailure)));
 
-        private AsyncResultFlow<TNextSuccess, TNextFailure> InnerForward<TNextSuccess, TNextFailure>(
+        private AsyncPipeline<TNextSuccess, TNextFailure> InnerForward<TNextSuccess, TNextFailure>(
             Func<TSuccess, Result<TNextSuccess, TNextFailure>> next,
             Func<TFailure, TNextFailure> mapFailure)
             where TNextFailure : struct
             =>
             InnerPipe(
                 r => r.Forward(next, mapFailure));
 
-        private AsyncResultFlow<TNextSuccess, TFailure> InnerForward<TNextSuccess>(
+        private AsyncPipeline<TNextSuccess, TFailure> InnerForward<TNextSuccess>(
             Func<TSuccess, Result<TNextSuccess, TFailure>> next)
             =>
             InnerPipe(