From d0e1802eb141100faadd5521c8bb62b2e0d0aab5 Mon Sep 17 00:00:00 2001
From: Thomas Bruderer <apophis@apophis.ch>
Date: Wed, 29 May 2024 16:32:47 +0200
Subject: [PATCH] Support Downcast on the Monadic Types (Option, Either,
 Result) * with tests

---
 Funcky.Test/DownCastTest.cs    | 78 ++++++++++++++++++++++++++++++++++
 Funcky/DownCast.cs             | 35 +++++++++++++++
 Funcky/PublicAPI.Unshipped.txt |  5 ++-
 3 files changed, 117 insertions(+), 1 deletion(-)
 create mode 100644 Funcky.Test/DownCastTest.cs
 create mode 100644 Funcky/DownCast.cs

diff --git a/Funcky.Test/DownCastTest.cs b/Funcky.Test/DownCastTest.cs
new file mode 100644
index 00000000..3dbbfbd5
--- /dev/null
+++ b/Funcky.Test/DownCastTest.cs
@@ -0,0 +1,78 @@
+namespace Funcky.Test;
+
+public sealed class DownCastTest
+{
+    [Fact]
+    public void DownCastToObjectOfRuntimeTypeReturnsSomeOfTheRequestedType()
+    {
+        var option = Option.Some<object>("Hello world!");
+
+        FunctionalAssert.Some("Hello world!", DownCast<string>.From(option));
+    }
+
+    [Fact]
+    public void DownCastToWrongObjectOfRuntimeTypeReturnsNone()
+    {
+        var option = Option.Some(new object());
+
+        FunctionalAssert.None(DownCast<string>.From(option));
+    }
+
+    [Fact]
+    public void DownCastFromANoneAlwaysGivesNone()
+    {
+        var option = Option<object>.None;
+
+        FunctionalAssert.None(DownCast<string>.From(option));
+    }
+
+    [Fact]
+    public void DownCastToObjectOfRuntimeTypeReturnsRightOfTheRequestedType()
+    {
+        var either = Either<string, object>.Right("Hello world!");
+
+        FunctionalAssert.Right("Hello world!", DownCast<string>.From(either, () => "failed cast!"));
+    }
+
+    [Fact]
+    public void DownCastToWrongObjectOfRuntimeTypeReturnsLeft()
+    {
+        var either = Either<string, object>.Right(new object());
+
+        FunctionalAssert.Left("failed cast!", DownCast<string>.From(either, () => "failed cast!"));
+    }
+
+    [Fact]
+    public void DownCastFromALeftAlwaysGivesTheOldLeft()
+    {
+        var either = Either<string, object>.Left("initial left state!");
+
+        FunctionalAssert.Left("initial left state!", DownCast<string>.From(either, () => "failed cast!"));
+    }
+
+    [Fact]
+    public void DownCastToObjectOfRuntimeTypeReturnsOkOfTheRequestedType()
+    {
+        var result = Result.Ok<object>("Hello world!");
+
+        FunctionalAssert.Ok("Hello world!", DownCast<string>.From(result));
+    }
+
+    [Fact]
+    public void DownCastToWrongObjectOfRuntimeTypeReturnsError()
+    {
+        var result = Result.Ok(new object());
+
+        var exception = FunctionalAssert.Error(DownCast<string>.From(result));
+        Assert.IsType<InvalidCastException>(exception);
+    }
+
+    [Fact]
+    public void DownCastFromAnErrorAlwaysGivesTheOldError()
+    {
+        var result = Result<object>.Error(new FileNotFoundException());
+
+        var exception = FunctionalAssert.Error(DownCast<string>.From(result));
+        Assert.IsType<FileNotFoundException>(exception);
+    }
+}
diff --git a/Funcky/DownCast.cs b/Funcky/DownCast.cs
new file mode 100644
index 00000000..c4c77696
--- /dev/null
+++ b/Funcky/DownCast.cs
@@ -0,0 +1,35 @@
+namespace Funcky;
+
+public static class DownCast<TResult>
+    where TResult : class
+{
+    public static Option<TResult> From<TItem>(Option<TItem> option)
+        where TItem : class
+        => option.SelectMany(OptionDownCast);
+
+    public static Result<TResult> From<TItem>(Result<TItem> result)
+        where TItem : class
+        => result.SelectMany(ResultDownCast);
+
+    public static Either<TLeft, TResult> From<TLeft, TRight>(Either<TLeft, TRight> either, Func<TLeft> failedCast)
+        where TRight : class
+        where TLeft : notnull
+        => either.SelectMany(right => EitherDownCast(failedCast, right));
+
+    private static Option<TResult> OptionDownCast<TItem>(TItem item)
+        where TItem : class
+        => Option.FromNullable(item as TResult);
+
+    private static Result<TResult> ResultDownCast<TValidResult>(TValidResult result)
+        where TValidResult : class
+        => result as TResult is { } validResult
+            ? Result.Ok(validResult)
+            : Result<TResult>.Error(new InvalidCastException());
+
+    private static Either<TLeft, TResult> EitherDownCast<TLeft, TRight>(Func<TLeft> failedCast, TRight right)
+        where TRight : class
+        where TLeft : notnull
+        => right as TResult is { } result
+            ? Either<TLeft, TResult>.Right(result)
+            : Either<TLeft, TResult>.Left(failedCast());
+}
diff --git a/Funcky/PublicAPI.Unshipped.txt b/Funcky/PublicAPI.Unshipped.txt
index 074c6ad1..ad71e021 100644
--- a/Funcky/PublicAPI.Unshipped.txt
+++ b/Funcky/PublicAPI.Unshipped.txt
@@ -1,2 +1,5 @@
 #nullable enable
-
+Funcky.DownCast<TResult>
+static Funcky.DownCast<TResult>.From<TItem>(Funcky.Monads.Option<TItem!> option) -> Funcky.Monads.Option<TResult!>
+static Funcky.DownCast<TResult>.From<TItem>(Funcky.Monads.Result<TItem!> result) -> Funcky.Monads.Result<TResult!>
+static Funcky.DownCast<TResult>.From<TLeft, TRight>(Funcky.Monads.Either<TLeft, TRight!> either, System.Func<TLeft>! failedCast) -> Funcky.Monads.Either<TLeft, TResult!>