From 3690776d846de5e1440a757faf1e2ee09516e73c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?D=C3=A1vid=20J=C3=A1nos=20Csillik?=
 <david.csillik@messerli.ch>
Date: Wed, 28 May 2025 23:06:53 +0200
Subject: [PATCH 1/5] Add Flatten to monads

---
 Funcky.Test/Monads/EitherTest.Flatten.cs      | 22 +++++++++++++++++++
 Funcky.Test/Monads/IEnumerableTest.Flatten.cs | 11 ++++++++++
 Funcky.Test/Monads/LazyTest.Flatten.cs        | 12 ++++++++++
 Funcky.Test/Monads/OptionTest.Flatten.cs      | 22 +++++++++++++++++++
 Funcky.Test/Monads/ReaderTest.Flatten.cs      | 12 ++++++++++
 Funcky.Test/Monads/ResultTest.Flatten.cs      | 22 +++++++++++++++++++
 Funcky/Monads/Either/EitherExtensions.cs      |  5 +++++
 .../IEnumerable/IEnumerableExtensions.cs      |  8 +++++++
 Funcky/Monads/Lazy/LazyExtensions.cs          | 10 +++++++++
 Funcky/Monads/Option/OptionExtensions.cs      |  4 ++++
 Funcky/Monads/Reader/ReaderExtensions.cs      |  9 ++++++++
 .../Result/ResultExtensions.Traversable.cs    |  2 +-
 Funcky/Monads/Result/ResultExtensions.cs      |  8 +++++++
 Funcky/PublicAPI.Shipped.txt                  |  7 ++++++
 14 files changed, 153 insertions(+), 1 deletion(-)
 create mode 100644 Funcky.Test/Monads/EitherTest.Flatten.cs
 create mode 100644 Funcky.Test/Monads/IEnumerableTest.Flatten.cs
 create mode 100644 Funcky.Test/Monads/LazyTest.Flatten.cs
 create mode 100644 Funcky.Test/Monads/OptionTest.Flatten.cs
 create mode 100644 Funcky.Test/Monads/ReaderTest.Flatten.cs
 create mode 100644 Funcky.Test/Monads/ResultTest.Flatten.cs
 create mode 100644 Funcky/Monads/IEnumerable/IEnumerableExtensions.cs
 create mode 100644 Funcky/Monads/Lazy/LazyExtensions.cs
 create mode 100644 Funcky/Monads/Reader/ReaderExtensions.cs
 create mode 100644 Funcky/Monads/Result/ResultExtensions.cs

diff --git a/Funcky.Test/Monads/EitherTest.Flatten.cs b/Funcky.Test/Monads/EitherTest.Flatten.cs
new file mode 100644
index 000000000..f3ac9e6e7
--- /dev/null
+++ b/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());
+    }
+}
diff --git a/Funcky.Test/Monads/IEnumerableTest.Flatten.cs b/Funcky.Test/Monads/IEnumerableTest.Flatten.cs
new file mode 100644
index 000000000..8f0586843
--- /dev/null
+++ b/Funcky.Test/Monads/IEnumerableTest.Flatten.cs
@@ -0,0 +1,11 @@
+namespace Funcky.Test.Monads;
+
+public sealed partial class IEnumerableTest
+{
+    [Fact]
+    public void FlattenFlatsIEnumerable()
+    {
+        var elements = new List<int> { 1, 2, 3 };
+        Assert.Equal(elements, new List<IEnumerable<int>> { elements }.Flatten());
+    }
+}
diff --git a/Funcky.Test/Monads/LazyTest.Flatten.cs b/Funcky.Test/Monads/LazyTest.Flatten.cs
new file mode 100644
index 000000000..4842c099b
--- /dev/null
+++ b/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);
+}
diff --git a/Funcky.Test/Monads/OptionTest.Flatten.cs b/Funcky.Test/Monads/OptionTest.Flatten.cs
new file mode 100644
index 000000000..d2d3a2be0
--- /dev/null
+++ b/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());
+    }
+}
diff --git a/Funcky.Test/Monads/ReaderTest.Flatten.cs b/Funcky.Test/Monads/ReaderTest.Flatten.cs
new file mode 100644
index 000000000..2f8f7fa1f
--- /dev/null
+++ b/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);
+}
diff --git a/Funcky.Test/Monads/ResultTest.Flatten.cs b/Funcky.Test/Monads/ResultTest.Flatten.cs
new file mode 100644
index 000000000..0946962e5
--- /dev/null
+++ b/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 FlattenSomeNoneIsNone()
+    {
+        FunctionalAssert.Error(Result.Ok(Result<int>.Error(new Exception())).Flatten());
+    }
+
+    [Fact]
+    public void FlattenSomeSomeIsSome()
+    {
+        FunctionalAssert.Ok(4711, Result.Ok(Result.Ok(4711)).Flatten());
+    }
+}
diff --git a/Funcky/Monads/Either/EitherExtensions.cs b/Funcky/Monads/Either/EitherExtensions.cs
index 126c2e119..55b13ad2f 100644
--- a/Funcky/Monads/Either/EitherExtensions.cs
+++ b/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)
diff --git a/Funcky/Monads/IEnumerable/IEnumerableExtensions.cs b/Funcky/Monads/IEnumerable/IEnumerableExtensions.cs
new file mode 100644
index 000000000..213e2f6b7
--- /dev/null
+++ b/Funcky/Monads/IEnumerable/IEnumerableExtensions.cs
@@ -0,0 +1,8 @@
+namespace Funcky.Monads;
+
+public static partial class IEnumerableExtensions
+{
+    public static IEnumerable<T> Flatten<T>(this IEnumerable<IEnumerable<T>> enumerable)
+        where T : notnull
+        => enumerable.SelectMany(Identity);
+}
diff --git a/Funcky/Monads/Lazy/LazyExtensions.cs b/Funcky/Monads/Lazy/LazyExtensions.cs
new file mode 100644
index 000000000..a30efe080
--- /dev/null
+++ b/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)
+        => new Lazy<T>(() => lazy.Value.Value);
+}
diff --git a/Funcky/Monads/Option/OptionExtensions.cs b/Funcky/Monads/Option/OptionExtensions.cs
index 0e516c645..d6f3bc91a 100644
--- a/Funcky/Monads/Option/OptionExtensions.cs
+++ b/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
diff --git a/Funcky/Monads/Reader/ReaderExtensions.cs b/Funcky/Monads/Reader/ReaderExtensions.cs
new file mode 100644
index 000000000..2b3685a08
--- /dev/null
+++ b/Funcky/Monads/Reader/ReaderExtensions.cs
@@ -0,0 +1,9 @@
+namespace Funcky.Monads;
+
+public static partial class ReaderExtensions
+{
+    public static Reader<TEnvironment, TItem> Flatten<TEnvironment, TItem>(this Reader<TEnvironment, Reader<TEnvironment, TItem>> reader)
+        where TEnvironment : notnull
+        where TItem : notnull
+        => reader.SelectMany(Identity);
+}
diff --git a/Funcky/Monads/Result/ResultExtensions.Traversable.cs b/Funcky/Monads/Result/ResultExtensions.Traversable.cs
index 8c21d6ff5..70eed4b4d 100644
--- a/Funcky/Monads/Result/ResultExtensions.Traversable.cs
+++ b/Funcky/Monads/Result/ResultExtensions.Traversable.cs
@@ -3,7 +3,7 @@
 
 namespace Funcky.Monads;
 
-public static class ResultExtensions
+public static partial class ResultExtensions
 {
     [Pure]
     public static Either<TLeft, Result<TRight>> Traverse<TValidResult, TLeft, TRight>(
diff --git a/Funcky/Monads/Result/ResultExtensions.cs b/Funcky/Monads/Result/ResultExtensions.cs
new file mode 100644
index 000000000..b929c30c5
--- /dev/null
+++ b/Funcky/Monads/Result/ResultExtensions.cs
@@ -0,0 +1,8 @@
+namespace Funcky.Monads;
+
+public static partial class ResultExtensions
+{
+    public static Result<T> Flatten<T>(this Result<Result<T>> result)
+        where T : notnull
+        => result.SelectMany(Identity);
+}
diff --git a/Funcky/PublicAPI.Shipped.txt b/Funcky/PublicAPI.Shipped.txt
index 2650399f2..46bd6f3ff 100644
--- a/Funcky/PublicAPI.Shipped.txt
+++ b/Funcky/PublicAPI.Shipped.txt
@@ -123,6 +123,7 @@ Funcky.Monads.OptionEqualityComparer<TItem>
 Funcky.Monads.OptionExtensions
 Funcky.Monads.OptionJsonConverter
 Funcky.Monads.OptionJsonConverter.OptionJsonConverter() -> void
+Funcky.Monads.IEnumerableExtensions
 Funcky.Monads.Reader<TEnvironment, TResult>
 Funcky.Monads.Reader<TEnvironment>
 Funcky.Monads.ReaderExtensions
@@ -758,11 +759,13 @@ static Funcky.Monads.EitherExtensions.Traverse<TLeft, TRight, T>(this Funcky.Mon
 static Funcky.Monads.EitherExtensions.Traverse<TLeft, TRight, TEnvironment, TResult>(this Funcky.Monads.Either<TLeft, TRight> either, System.Func<TRight, Funcky.Monads.Reader<TEnvironment, TResult>!>! selector) -> Funcky.Monads.Reader<TEnvironment, Funcky.Monads.Either<TLeft, TResult>>!
 static Funcky.Monads.EitherExtensions.Traverse<TLeft, TRight, TItem>(this Funcky.Monads.Either<TLeft, TRight> either, System.Func<TRight, Funcky.Monads.Option<TItem>>! selector) -> Funcky.Monads.Option<Funcky.Monads.Either<TLeft, TItem>>
 static Funcky.Monads.EitherExtensions.Traverse<TLeft, TRight, TValidResult>(this Funcky.Monads.Either<TLeft, TRight> either, System.Func<TRight, Funcky.Monads.Result<TValidResult>>! selector) -> Funcky.Monads.Result<Funcky.Monads.Either<TLeft, TValidResult>>
+static Funcky.Monads.EitherExtensions.Flatten<TLeft, TRight>(this Funcky.Monads.Either<TLeft, Funcky.Monads.Either<TLeft, TRight>> either) -> Funcky.Monads.Either<TLeft, TRight>
 static Funcky.Monads.Lazy.FromFunc<T>(System.Func<T>! valueFactory) -> System.Lazy<T>!
 static Funcky.Monads.Lazy.Return<T>(T value) -> System.Lazy<T>!
 static Funcky.Monads.LazyExtensions.Select<T, TResult>(this System.Lazy<T>! lazy, System.Func<T, TResult>! selector) -> System.Lazy<TResult>!
 static Funcky.Monads.LazyExtensions.SelectMany<T, TLazy, TResult>(this System.Lazy<T>! lazy, System.Func<T, System.Lazy<TLazy>!>! selector, System.Func<T, TLazy, TResult>! resultSelector) -> System.Lazy<TResult>!
 static Funcky.Monads.LazyExtensions.SelectMany<T, TResult>(this System.Lazy<T>! lazy, System.Func<T, System.Lazy<TResult>!>! selector) -> System.Lazy<TResult>!
+static Funcky.Monads.LazyExtensions.Flatten<T>(this System.Lazy<System.Lazy<T>!>! lazy) -> System.Lazy<T>!
 static Funcky.Monads.Option.FromBoolean(bool boolean) -> Funcky.Monads.Option<Funcky.Unit>
 static Funcky.Monads.Option.FromBoolean<TItem>(bool boolean, System.Func<TItem>! selector) -> Funcky.Monads.Option<TItem>
 static Funcky.Monads.Option.FromBoolean<TItem>(bool boolean, TItem item) -> Funcky.Monads.Option<TItem>
@@ -797,12 +800,15 @@ static Funcky.Monads.OptionExtensions.Traverse<TItem, T>(this Funcky.Monads.Opti
 static Funcky.Monads.OptionExtensions.Traverse<TItem, TEnvironment, TResult>(this Funcky.Monads.Option<TItem> option, System.Func<TItem, Funcky.Monads.Reader<TEnvironment, TResult>!>! selector) -> Funcky.Monads.Reader<TEnvironment, Funcky.Monads.Option<TResult>>!
 static Funcky.Monads.OptionExtensions.Traverse<TItem, TLeft, TRight>(this Funcky.Monads.Option<TItem> option, System.Func<TItem, Funcky.Monads.Either<TLeft, TRight>>! selector) -> Funcky.Monads.Either<TLeft, Funcky.Monads.Option<TRight>>
 static Funcky.Monads.OptionExtensions.Traverse<TItem, TValidResult>(this Funcky.Monads.Option<TItem> option, System.Func<TItem, Funcky.Monads.Result<TValidResult>>! selector) -> Funcky.Monads.Result<Funcky.Monads.Option<TValidResult>>
+static Funcky.Monads.OptionExtensions.Flatten<T>(this Funcky.Monads.Option<Funcky.Monads.Option<T>> option) -> Funcky.Monads.Option<T>
+static Funcky.Monads.IEnumerableExtensions.Flatten<T>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>!>! enumerable) -> System.Collections.Generic.IEnumerable<T>!
 static Funcky.Monads.Reader<TEnvironment>.FromAction(System.Action<TEnvironment>! action) -> Funcky.Monads.Reader<TEnvironment, Funcky.Unit>!
 static Funcky.Monads.Reader<TEnvironment>.FromFunc<TResult>(System.Func<TEnvironment, TResult>! function) -> Funcky.Monads.Reader<TEnvironment, TResult>!
 static Funcky.Monads.Reader<TEnvironment>.Return<TResult>(TResult value) -> Funcky.Monads.Reader<TEnvironment, TResult>!
 static Funcky.Monads.ReaderExtensions.Select<TEnvironment, TSource, TResult>(this Funcky.Monads.Reader<TEnvironment, TSource>! source, System.Func<TSource, TResult>! selector) -> Funcky.Monads.Reader<TEnvironment, TResult>!
 static Funcky.Monads.ReaderExtensions.SelectMany<TEnvironment, TSource, TReader, TResult>(this Funcky.Monads.Reader<TEnvironment, TSource>! source, System.Func<TSource, Funcky.Monads.Reader<TEnvironment, TReader>!>! selector, System.Func<TSource, TReader, TResult>! resultSelector) -> Funcky.Monads.Reader<TEnvironment, TResult>!
 static Funcky.Monads.ReaderExtensions.SelectMany<TEnvironment, TSource, TResult>(this Funcky.Monads.Reader<TEnvironment, TSource>! source, System.Func<TSource, Funcky.Monads.Reader<TEnvironment, TResult>!>! selector) -> Funcky.Monads.Reader<TEnvironment, TResult>!
+static Funcky.Monads.ReaderExtensions.Flatten<TEnvironment, TItem>(this Funcky.Monads.Reader<TEnvironment, Funcky.Monads.Reader<TEnvironment, TItem>!>! reader) -> Funcky.Monads.Reader<TEnvironment, TItem>!
 static Funcky.Monads.Result.Ok<TValidResult>(TValidResult result) -> Funcky.Monads.Result<TValidResult>
 static Funcky.Monads.Result.Return<TValidResult>(TValidResult result) -> Funcky.Monads.Result<TValidResult>
 static Funcky.Monads.Result<TValidResult>.Error(System.Exception! exception) -> Funcky.Monads.Result<TValidResult>
@@ -819,6 +825,7 @@ static Funcky.Monads.ResultExtensions.Traverse<TValidResult, T>(this Funcky.Mona
 static Funcky.Monads.ResultExtensions.Traverse<TValidResult, TEnvironment, TResult>(this Funcky.Monads.Result<TValidResult> result, System.Func<TValidResult, Funcky.Monads.Reader<TEnvironment, TResult>!>! selector) -> Funcky.Monads.Reader<TEnvironment, Funcky.Monads.Result<TResult>>!
 static Funcky.Monads.ResultExtensions.Traverse<TValidResult, TItem>(this Funcky.Monads.Result<TValidResult> result, System.Func<TValidResult, Funcky.Monads.Option<TItem>>! selector) -> Funcky.Monads.Option<Funcky.Monads.Result<TItem>>
 static Funcky.Monads.ResultExtensions.Traverse<TValidResult, TLeft, TRight>(this Funcky.Monads.Result<TValidResult> result, System.Func<TValidResult, Funcky.Monads.Either<TLeft, TRight>>! selector) -> Funcky.Monads.Either<TLeft, Funcky.Monads.Result<TRight>>
+static Funcky.Monads.ResultExtensions.Flatten<T>(this Funcky.Monads.Result<Funcky.Monads.Result<T>> result) -> Funcky.Monads.Result<T>
 static Funcky.Sequence.Concat<TSource>(params System.Collections.Generic.IEnumerable<TSource>![]! sources) -> System.Collections.Generic.IEnumerable<TSource>!
 static Funcky.Sequence.Concat<TSource>(System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<TSource>!>! sources) -> System.Collections.Generic.IEnumerable<TSource>!
 static Funcky.Sequence.Cycle<TResult>(TResult element) -> System.Collections.Generic.IEnumerable<TResult>!

From ca7c88a06c070230a4e9300b48fa04ff896ca0ea Mon Sep 17 00:00:00 2001
From: csillikd-messerli <68327616+csillikd-messerli@users.noreply.github.com>
Date: Wed, 4 Jun 2025 13:32:28 +0200
Subject: [PATCH 2/5] Update Funcky.Test/Monads/ResultTest.Flatten.cs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Tau Gärtli <git@tau.garden>
---
 Funcky.Test/Monads/ResultTest.Flatten.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Funcky.Test/Monads/ResultTest.Flatten.cs b/Funcky.Test/Monads/ResultTest.Flatten.cs
index 0946962e5..7e1a7f5c5 100644
--- a/Funcky.Test/Monads/ResultTest.Flatten.cs
+++ b/Funcky.Test/Monads/ResultTest.Flatten.cs
@@ -9,7 +9,7 @@ public void FlattenErrorIsError()
     }
 
     [Fact]
-    public void FlattenSomeNoneIsNone()
+    public void FlattenOkErrorIsError()
     {
         FunctionalAssert.Error(Result.Ok(Result<int>.Error(new Exception())).Flatten());
     }

From 29d2a6029b60eda2257202c50121de895de7453f Mon Sep 17 00:00:00 2001
From: csillikd-messerli <68327616+csillikd-messerli@users.noreply.github.com>
Date: Wed, 4 Jun 2025 13:32:34 +0200
Subject: [PATCH 3/5] Update Funcky.Test/Monads/ResultTest.Flatten.cs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Tau Gärtli <git@tau.garden>
---
 Funcky.Test/Monads/ResultTest.Flatten.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Funcky.Test/Monads/ResultTest.Flatten.cs b/Funcky.Test/Monads/ResultTest.Flatten.cs
index 7e1a7f5c5..aeb391b97 100644
--- a/Funcky.Test/Monads/ResultTest.Flatten.cs
+++ b/Funcky.Test/Monads/ResultTest.Flatten.cs
@@ -15,7 +15,7 @@ public void FlattenOkErrorIsError()
     }
 
     [Fact]
-    public void FlattenSomeSomeIsSome()
+    public void FlattenOkOkIsOk()
     {
         FunctionalAssert.Ok(4711, Result.Ok(Result.Ok(4711)).Flatten());
     }

From 9f13947fc0834d12a059dce3c48e6dd9e8d81e0e Mon Sep 17 00:00:00 2001
From: csillikd-messerli <68327616+csillikd-messerli@users.noreply.github.com>
Date: Wed, 4 Jun 2025 13:32:46 +0200
Subject: [PATCH 4/5] Update Funcky/Monads/Lazy/LazyExtensions.cs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Tau Gärtli <git@tau.garden>
---
 Funcky/Monads/Lazy/LazyExtensions.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Funcky/Monads/Lazy/LazyExtensions.cs b/Funcky/Monads/Lazy/LazyExtensions.cs
index a30efe080..ffdfa59dd 100644
--- a/Funcky/Monads/Lazy/LazyExtensions.cs
+++ b/Funcky/Monads/Lazy/LazyExtensions.cs
@@ -6,5 +6,5 @@ namespace Funcky.Monads;
 public static partial class LazyExtensions
 {
     public static Lazy<T> Flatten<[DynamicallyAccessedMembers(PublicParameterlessConstructor)] T>(this Lazy<Lazy<T>> lazy)
-        => new Lazy<T>(() => lazy.Value.Value);
+        => Lazy.FromFunc(() => lazy.Value.Value);
 }

From 1f19945f6d699ecc6479e4ef16c879bc682a41ce Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?D=C3=A1vid=20J=C3=A1nos=20Csillik?=
 <david.csillik@messerli.ch>
Date: Wed, 4 Jun 2025 13:41:34 +0200
Subject: [PATCH 5/5] Move IEnumerable.Flatten to the right place

---
 .../EnumerableExtensions/Flatten.cs}                         | 4 ++--
 .../EnumerableExtensions/Flatten.cs}                         | 5 ++---
 Funcky/PublicAPI.Shipped.txt                                 | 3 +--
 3 files changed, 5 insertions(+), 7 deletions(-)
 rename Funcky.Test/{Monads/IEnumerableTest.Flatten.cs => Extensions/EnumerableExtensions/Flatten.cs} (70%)
 rename Funcky/{Monads/IEnumerable/IEnumerableExtensions.cs => Extensions/EnumerableExtensions/Flatten.cs} (57%)

diff --git a/Funcky.Test/Monads/IEnumerableTest.Flatten.cs b/Funcky.Test/Extensions/EnumerableExtensions/Flatten.cs
similarity index 70%
rename from Funcky.Test/Monads/IEnumerableTest.Flatten.cs
rename to Funcky.Test/Extensions/EnumerableExtensions/Flatten.cs
index 8f0586843..11e902838 100644
--- a/Funcky.Test/Monads/IEnumerableTest.Flatten.cs
+++ b/Funcky.Test/Extensions/EnumerableExtensions/Flatten.cs
@@ -1,6 +1,6 @@
-namespace Funcky.Test.Monads;
+namespace Funcky.Test.Extensions.EnumerableExtensions;
 
-public sealed partial class IEnumerableTest
+public sealed class Flatten
 {
     [Fact]
     public void FlattenFlatsIEnumerable()
diff --git a/Funcky/Monads/IEnumerable/IEnumerableExtensions.cs b/Funcky/Extensions/EnumerableExtensions/Flatten.cs
similarity index 57%
rename from Funcky/Monads/IEnumerable/IEnumerableExtensions.cs
rename to Funcky/Extensions/EnumerableExtensions/Flatten.cs
index 213e2f6b7..c8b2b3463 100644
--- a/Funcky/Monads/IEnumerable/IEnumerableExtensions.cs
+++ b/Funcky/Extensions/EnumerableExtensions/Flatten.cs
@@ -1,8 +1,7 @@
-namespace Funcky.Monads;
+namespace Funcky.Extensions;
 
-public static partial class IEnumerableExtensions
+public static partial class EnumerableExtensions
 {
     public static IEnumerable<T> Flatten<T>(this IEnumerable<IEnumerable<T>> enumerable)
-        where T : notnull
         => enumerable.SelectMany(Identity);
 }
diff --git a/Funcky/PublicAPI.Shipped.txt b/Funcky/PublicAPI.Shipped.txt
index 46bd6f3ff..c7b1e8bc0 100644
--- a/Funcky/PublicAPI.Shipped.txt
+++ b/Funcky/PublicAPI.Shipped.txt
@@ -123,7 +123,6 @@ Funcky.Monads.OptionEqualityComparer<TItem>
 Funcky.Monads.OptionExtensions
 Funcky.Monads.OptionJsonConverter
 Funcky.Monads.OptionJsonConverter.OptionJsonConverter() -> void
-Funcky.Monads.IEnumerableExtensions
 Funcky.Monads.Reader<TEnvironment, TResult>
 Funcky.Monads.Reader<TEnvironment>
 Funcky.Monads.ReaderExtensions
@@ -263,6 +262,7 @@ static Funcky.Extensions.EnumerableExtensions.ElementAtOrNone<TSource>(this Syst
 static Funcky.Extensions.EnumerableExtensions.ExclusiveScan<TSource, TAccumulate>(this System.Collections.Generic.IEnumerable<TSource>! source, TAccumulate seed, System.Func<TAccumulate, TSource, TAccumulate>! accumulator) -> System.Collections.Generic.IEnumerable<TAccumulate>!
 static Funcky.Extensions.EnumerableExtensions.FirstOrNone<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> Funcky.Monads.Option<TSource>
 static Funcky.Extensions.EnumerableExtensions.FirstOrNone<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! predicate) -> Funcky.Monads.Option<TSource>
+static Funcky.Extensions.EnumerableExtensions.Flatten<T>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>!>! enumerable) -> System.Collections.Generic.IEnumerable<T>!
 static Funcky.Extensions.EnumerableExtensions.ForEach<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Action<TSource>! action) -> Funcky.Unit
 static Funcky.Extensions.EnumerableExtensions.ForEach<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, Funcky.Unit>! action) -> Funcky.Unit
 static Funcky.Extensions.EnumerableExtensions.GetNonEnumeratedCountOrNone<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> Funcky.Monads.Option<int>
@@ -801,7 +801,6 @@ static Funcky.Monads.OptionExtensions.Traverse<TItem, TEnvironment, TResult>(thi
 static Funcky.Monads.OptionExtensions.Traverse<TItem, TLeft, TRight>(this Funcky.Monads.Option<TItem> option, System.Func<TItem, Funcky.Monads.Either<TLeft, TRight>>! selector) -> Funcky.Monads.Either<TLeft, Funcky.Monads.Option<TRight>>
 static Funcky.Monads.OptionExtensions.Traverse<TItem, TValidResult>(this Funcky.Monads.Option<TItem> option, System.Func<TItem, Funcky.Monads.Result<TValidResult>>! selector) -> Funcky.Monads.Result<Funcky.Monads.Option<TValidResult>>
 static Funcky.Monads.OptionExtensions.Flatten<T>(this Funcky.Monads.Option<Funcky.Monads.Option<T>> option) -> Funcky.Monads.Option<T>
-static Funcky.Monads.IEnumerableExtensions.Flatten<T>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>!>! enumerable) -> System.Collections.Generic.IEnumerable<T>!
 static Funcky.Monads.Reader<TEnvironment>.FromAction(System.Action<TEnvironment>! action) -> Funcky.Monads.Reader<TEnvironment, Funcky.Unit>!
 static Funcky.Monads.Reader<TEnvironment>.FromFunc<TResult>(System.Func<TEnvironment, TResult>! function) -> Funcky.Monads.Reader<TEnvironment, TResult>!
 static Funcky.Monads.Reader<TEnvironment>.Return<TResult>(TResult value) -> Funcky.Monads.Reader<TEnvironment, TResult>!