With (Combine) (#1)

Fist stage

Author: SuperJMN

CSharpFunctionalExtensions/CSharpFunctionalExtensions.csproj

@@ -36,6 +36,10 @@
   <ItemGroup Condition="'$(TargetFramework)'=='net40'">
     <PackageReference Include="Microsoft.Bcl.Async" Version="1.0.168" />
   </ItemGroup>
+	
+  <ItemGroup Condition="$(TargetFramework.StartsWith('net4')) OR $(TargetFramework)=='netstandard2.0'">
+    <PackageReference Include="System.ValueTuple" Version="4.*" />
+  </ItemGroup>
 
   <ItemGroup>
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0">

CSharpFunctionalExtensions/Result/Extensions/BindError.cs

@@ -0,0 +1,29 @@
+using System;
+
+namespace CSharpFunctionalExtensions
+{
+    public partial class ResultExtensions
+    {
+        public static Result<T, E2> BindError<T, E, E2>(this Result<T, E> self,
+            Func<E, Result<T, E2>> func)
+        {
+            if (self.IsSuccess)
+            {
+                return Result.Success<T, E2>(self.Value);
+            }
+
+            return func(self.Error);
+        }
+
+        public static Result<T> BindError<T>(this Result<T> self,
+            Func<string, Result<T>> func)
+        {
+            if (self.IsSuccess)
+            {
+                return Result.Success(self.Value);
+            }
+
+            return func(self.Error);
+        }
+    }
+}

CSharpFunctionalExtensions/Result/Extensions/With/AsyncResultOfT.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions
+{
+    public static partial class ResultExtensions
+    {
+        public static Task<Result<TResult>> WithMap<T1, T2, TResult>(this Result<T1> a,
+            Result<T2> b,
+            Func<T1, T2, Task<TResult>> func)
+        {
+            var mapSuccess =
+                a.BindError(e1 => b
+                        .MapError(e2 => Errors.Join(e1, e2))
+                        .Bind(_ => Result.Failure<T1>(e1)))
+                    .Bind(x => b
+                        .Map(y => func(x, y))
+                        .MapError(el => el));
+
+            return mapSuccess;
+        }
+
+        public static Task<Result<TResult>> WithBind<T1, T2, TResult>(this Result<T1> a,
+            Result<T2> b,
+            Func<T1, T2, Task<Result<TResult>>> func)
+        {
+            var mapSuccess =
+                a.BindError(e1 => b
+                        .MapError(e2 => Errors.Join(e1, e2))
+                        .Bind(_ => Result.Failure<T1>(e1)))
+                    .Bind(x => b
+                        .Bind(y => func(x, y))
+                        .MapError(el => el));
+
+            return mapSuccess;
+        }
+    }
+}

CSharpFunctionalExtensions/Result/Extensions/With/AsyncResultOfTE.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Threading.Tasks;
+
+namespace CSharpFunctionalExtensions
+{
+    public static partial class ResultExtensions
+    {
+        public static Task<Result<TResult, E>> WithBind<T1, T2, E, TResult>(this Result<T1, E> a,
+            Result<T2, E> b,
+            Func<T1, T2, Task<Result<TResult, E>>> map, Func<E, E, E> combineError)
+        {
+            var mapSuccess =
+                a.BindError(e1 => b
+                        .MapError(e2 => combineError(e1, e2))
+                        .Bind(_ => Result.Failure<T1, E>(e1)))
+                    .Bind(x => b
+                        .Bind(y => map(x, y))
+                        .MapError(el => el));
+
+            return mapSuccess;
+        }
+
+        public static Task<Result<TResult, E>> WithMap<T1, T2, E, TResult>(this Result<T1, E> a,
+            Result<T2, E> b,
+            Func<T1, T2, Task<TResult>> map, Func<E, E, E> combineError)
+        {
+            var mapSuccess =
+                a.BindError(e1 => b
+                        .MapError(e2 => combineError(e1, e2))
+                        .Bind(_ => Result.Failure<T1, E>(e1)))
+                    .Bind(x => b
+                        .Map(y => map(x, y))
+                        .MapError(el => el));
+
+            return mapSuccess;
+        }
+    }
+}

CSharpFunctionalExtensions/Result/Extensions/With/Errors.cs

@@ -0,0 +1,10 @@
+namespace CSharpFunctionalExtensions
+{
+    public static class Errors
+    {
+        public static string Join(string e1, string e2)
+        {
+            return string.Join(Result.ErrorMessagesSeparator, e1, e2);
+        }
+    }
+}

CSharpFunctionalExtensions/Result/Extensions/With/ResultOfT.cs

@@ -0,0 +1,40 @@
+using System;
+
+namespace CSharpFunctionalExtensions
+{
+    public static partial class ResultExtensions
+    {
+        public static Result<(T1, T2)> With<T1, T2>(Result<T1> a, Result<T2> b)
+        {
+            return a.WithMap(b, (x, y) => (x, y));
+        }
+
+        public static Result<TResult> WithMap<T, K, TResult>(
+            this Result<T> a,
+            Result<K> b,
+            Func<T, K, TResult> func)
+        {
+            return a
+                .BindError(e1 => b
+                    .MapError(e2 => Errors.Join(e1, e2))
+                    .Bind(_ => Result.Failure<T>(e1))
+                ).Bind(x => b
+                    .Map(y => func(x, y))
+                    .MapError(e => e));
+        }
+
+        public static Result<TResult> WithBind<T, K, TResult>(
+            this Result<T> a,
+            Result<K> b,
+            Func<T, K, Result<TResult>> func)
+        {
+            return a
+                .BindError(e1 => b
+                    .MapError(e2 => Errors.Join(e1, e2))
+                    .Bind(_ => Result.Failure<T>(e1))
+                ).Bind(x => b
+                    .Bind(y => func(x, y))
+                    .MapError(e => e));
+        }
+    }
+}

CSharpFunctionalExtensions/Result/Extensions/With/ResultOfTE.cs

@@ -0,0 +1,52 @@
+using System;
+
+namespace CSharpFunctionalExtensions
+{
+    public static partial class ResultExtensions
+    {
+        public static Result<T, E> WithBind<T, E>(
+            this Result<T, E> a,
+            Result<T, E> b,
+            Func<T, T, Result<T, E>> func, Func<E, E, E> combineError)
+        {
+            return a
+                .BindError(e1 => b
+                    .MapError(e2 => combineError(e1, e2))
+                    .Bind(_ => Result.Failure<T, E>(e1)))
+                .Bind(x => b
+                    .Bind(y => func(x, y))
+                    .MapError(el => el));
+        }
+
+
+        public static Result<R, E> WithMap<T1, T2, E, R>(this Result<T1, E> a,
+            Result<T2, E> b,
+            Func<T1, T2, R> func, Func<E, E, E> combineError)
+        {
+            var mapSuccess =
+                a.BindError(e1 => b
+                        .MapError(e2 => combineError(e1, e2))
+                        .Bind(_ => Result.Failure<T1, E>(e1)))
+                    .Bind(x => b
+                        .Map(y => func(x, y))
+                        .MapError(el => el));
+
+            return mapSuccess;
+        }
+
+        public static Result<R, E> WithBind<T1, T2, E, R>(this Result<T1, E> a,
+            Result<T2, E> b,
+            Func<T1, T2, Result<R, E>> func, Func<E, E, E> combineError)
+        {
+            var mapSuccess =
+                a.BindError(e1 => b
+                        .MapError(e2 => combineError(e1, e2))
+                        .Bind(_ => Result.Failure<T1, E>(e1)))
+                    .Bind(x => b
+                        .Bind(y => func(x, y))
+                        .MapError(el => el));
+
+            return mapSuccess;
+        }
+    }
+}