Fix for 'v5 - Use custom sub-type of Expected losses all custom prope…

…rties after RunAsync

#1340'

#1340

LanguageExt.Core/Common/Error.cs

@@ -390,7 +390,7 @@ public override string ToString() =>
     /// </summary>
     [Pure]
     public override ErrorException ToErrorException() => 
-        new ExpectedException(Message, Code, Inner.Map(static e => e.ToErrorException()));
+        new WrappedErrorExpectedException(this);
 
     /// <summary>
     /// Returns false because this type isn't exceptional
@@ -482,9 +482,9 @@ public override Exception ToException() =>
     /// </summary>
     /// <returns></returns>
     [Pure]
-    public override ErrorException ToErrorException() => 
+    public override ErrorException ToErrorException() =>
         Value == null
-            ? new ExceptionalException(Message, Code)
+            ? new WrappedErrorExceptionalException(this)
             : new ExceptionalException(Value);
 
     /// <summary>

LanguageExt.Core/Common/ErrorException.cs

@@ -177,7 +177,7 @@ public static ErrorException Many(Seq<ErrorException> errors) =>
 /// <summary>
 /// Represents expected errors
 /// </summary>
-public sealed class ExpectedException : ErrorException
+public class ExpectedException : ErrorException
 {
     public ExpectedException(string message, int code, Option<ErrorException> inner) : base(code) =>
         (Message, Code, Inner) = (message, code, inner);
@@ -232,6 +232,17 @@ error is ManyExceptions m
             : new ManyExceptions(Seq(this, error));
 }
 
+/// <summary>
+/// Wraps an `Error` maintaining its type for subsequent conversion back to an `Error` later
+/// </summary>
+/// <param name="Error"></param>
+public sealed class WrappedErrorExpectedException(Error Error) : 
+    ExpectedException(Error.Message, Error.Code, Error.Inner.Map(e => e.ToErrorException()))
+{
+    public override Error ToError() => 
+        Error;
+}
+
 /// <summary>
 /// Represents an exceptional (unexpected) error
 /// </summary>
@@ -306,6 +317,17 @@ error is ManyExceptions m
             : new ManyExceptions(Seq(this, error));
 }
 
+/// <summary>
+/// Wraps an `Error` maintaining its type for subsequent conversion back to an `Error` later
+/// </summary>
+/// <param name="Error"></param>
+public sealed class WrappedErrorExceptionalException(Error Error) : 
+    ExceptionalException(Error.Message, Error.Code)
+{
+    public override Error ToError() => 
+        Error;
+}
+
 /// <summary>
 /// Represents multiple errors
 /// </summary>

LanguageExt.Core/Monads/State and Environment Monads/Reader/ReaderT/ReaderT.Monad.cs

@@ -55,5 +55,4 @@ static K<ReaderT<Env, M>, B> Monad<ReaderT<Env, M>>.WithRunInIO<A, B>(
     static K<ReaderT<Env, M>, A> SemigroupK<ReaderT<Env, M>>.Combine<A>(
         K<ReaderT<Env, M>, A> ma, K<ReaderT<Env, M>, A> mb) =>
         new ReaderT<Env, M, A>(env => M.Combine(ma.As().runReader(env), mb.As().runReader(env)));
-
 }

LanguageExt.Tests/IssuesTests.cs

@@ -4,6 +4,8 @@
 using Newtonsoft.Json;
 using System.Threading.Tasks;
 using System.Runtime.Serialization;
+using LanguageExt.Common;
+using static LanguageExt.Prelude;
 
 namespace LanguageExt.Tests
 {
@@ -425,4 +427,33 @@ from r in ExecuteCommand(f, cmd)
                        .Traverse(x => x).As();
         }
     }
+
+
+    public class Issue1340
+    {
+        public sealed record CustomExpected(string Message, int Code, string Another) : Expected(Message, Code);
+
+        [Fact]
+        public void Test()
+        {
+            // Arrange
+            var      expected = new CustomExpected("Name", 100, "This is loss");
+            Eff<int> effect   = liftEff<int>(() => expected);
+
+            // Act
+            Fin<int> fin = effect.Run();
+
+            // Assert
+            fin.Match(_ => Assert.True(false),
+                      error =>
+                      {
+                          Assert.Equal(error.Code, expected.Code);
+                          Assert.Equal(error.Message, expected.Message);
+
+                          var fail = (CustomExpected)error;
+                          Assert.Equal(fail.Another, expected.Another);
+                      });
+
+        }
+    }
 }