Merge pull request #866 from polyadic/add-flatten

Add Flatten to monads

Author: csillikd-messerli

Funcky.Test/Extensions/EnumerableExtensions/Flatten.cs

@@ -0,0 +1,11 @@
+namespace Funcky.Test.Extensions.EnumerableExtensions;
+
+public sealed class Flatten
+{
+    [Fact]
+    public void FlattenFlatsIEnumerable()
+    {
+        var elements = new List<int> { 1, 2, 3 };
+        Assert.Equal(elements, new List<IEnumerable<int>> { elements }.Flatten());
+    }
+}

Funcky.Test/Monads/EitherTest.Flatten.cs

@@ -0,0 +1,22 @@
+namespace Funcky.Test.Monads;
+
+public sealed partial class EitherTest
+{
+    [Fact]
+    public void FlattenLeftIsLeft()
+    {
+        Assert.Equal("test", FunctionalAssert.Left(Either<string, Either<string, int>>.Left("test").Flatten()));
+    }
+
+    [Fact]
+    public void FlattenRightLeftIsLeft()
+    {
+        Assert.Equal("test", FunctionalAssert.Left(Either<string, Either<string, int>>.Right(Either<string, int>.Left("test")).Flatten()));
+    }
+
+    [Fact]
+    public void FlattenRightRightIsRight()
+    {
+        FunctionalAssert.Right(4711, Either<string, Either<string, int>>.Right(Either<string, int>.Right(4711)).Flatten());
+    }
+}

Funcky.Test/Monads/LazyTest.Flatten.cs

@@ -0,0 +1,12 @@
+using FsCheck;
+using Funcky.FsCheck;
+using Funcky.Test.TestUtils;
+
+namespace Funcky.Test.Monads;
+
+public sealed partial class LazyTest
+{
+    [FunckyProperty]
+    public Property FlattenLazyLazyIsLazy(Lazy<string> input)
+        => CheckAssert.Equal(Lazy.Return(input).Flatten(), input);
+}

Funcky.Test/Monads/OptionTest.Flatten.cs

@@ -0,0 +1,22 @@
+namespace Funcky.Test.Monads;
+
+public sealed partial class OptionTest
+{
+    [Fact]
+    public void FlattenNoneIsNone()
+    {
+        FunctionalAssert.None(Option<Option<int>>.None.Flatten());
+    }
+
+    [Fact]
+    public void FlattenSomeNoneIsNone()
+    {
+        FunctionalAssert.None(Option.Some(Option<int>.None).Flatten());
+    }
+
+    [Fact]
+    public void FlattenSomeSomeIsSome()
+    {
+        FunctionalAssert.Some(4711, Option.Some(Option.Some(4711)).Flatten());
+    }
+}

Funcky.Test/Monads/ReaderTest.Flatten.cs

@@ -0,0 +1,12 @@
+using FsCheck;
+using Funcky.FsCheck;
+using Funcky.Test.TestUtils;
+
+namespace Funcky.Test.Monads;
+
+public sealed partial class ReaderTest
+{
+    [FunckyProperty]
+    public Property FlattenReaderReaderIsReader(string environment, Reader<string, string> input)
+        => CheckAssert.Equal(input, Reader<string>.Return(input).Flatten(), environment);
+}

Funcky.Test/Monads/ResultTest.Flatten.cs

@@ -0,0 +1,22 @@
+namespace Funcky.Test.Monads;
+
+public sealed partial class ResultTest
+{
+    [Fact]
+    public void FlattenErrorIsError()
+    {
+        FunctionalAssert.Error(Result<Result<int>>.Error(new Exception()).Flatten());
+    }
+
+    [Fact]
+    public void FlattenOkErrorIsError()
+    {
+        FunctionalAssert.Error(Result.Ok(Result<int>.Error(new Exception())).Flatten());
+    }
+
+    [Fact]
+    public void FlattenOkOkIsOk()
+    {
+        FunctionalAssert.Ok(4711, Result.Ok(Result.Ok(4711)).Flatten());
+    }
+}

Funcky/Extensions/EnumerableExtensions/Flatten.cs

@@ -0,0 +1,7 @@
+namespace Funcky.Extensions;
+
+public static partial class EnumerableExtensions
+{
+    public static IEnumerable<T> Flatten<T>(this IEnumerable<IEnumerable<T>> enumerable)
+        => enumerable.SelectMany(Identity);
+}

Funcky/Monads/Either/EitherExtensions.cs

@@ -2,6 +2,11 @@ namespace Funcky.Monads;
 
 public static partial class EitherExtensions
 {
+    public static Either<TLeft, TRight> Flatten<TLeft, TRight>(this Either<TLeft, Either<TLeft, TRight>> either)
+        where TLeft : notnull
+        where TRight : notnull
+        => either.SelectMany(Identity);
+
     /// <summary>Returns the left value or <see cref="Option{TItem}.None()"/> if the <paramref name="either"/> is a right value.</summary>
     [Pure]
     public static Option<TLeft> LeftOrNone<TLeft, TRight>(this Either<TLeft, TRight> either)

Funcky/Monads/Lazy/LazyExtensions.cs

@@ -0,0 +1,10 @@
+using System.Diagnostics.CodeAnalysis;
+using static System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes;
+
+namespace Funcky.Monads;
+
+public static partial class LazyExtensions
+{
+    public static Lazy<T> Flatten<[DynamicallyAccessedMembers(PublicParameterlessConstructor)] T>(this Lazy<Lazy<T>> lazy)
+        => Lazy.FromFunc(() => lazy.Value.Value);
+}

Funcky/Monads/Option/OptionExtensions.cs

@@ -4,6 +4,10 @@ namespace Funcky.Monads;
 
 public static partial class OptionExtensions
 {
+    public static Option<T> Flatten<T>(this Option<Option<T>> option)
+        where T : notnull
+        => option.SelectMany(Identity);
+
     public static Either<TLeft, TRight> ToEither<TLeft, TRight>(this Option<TRight> option, TLeft left)
         where TLeft : notnull
         where TRight : notnull