From dc4ec153b87f864be16f3fec0b32a39dcf58ce97 Mon Sep 17 00:00:00 2001
From: bfren <bf@bfren.dev>
Date: Fri, 27 Feb 2026 12:04:48 +0000
Subject: [PATCH 1/4] Adding direct implementations instead of overloads - #63

---
 .../Enumerable/EnumerableExtensions.Bind.cs   | 52 +++++++++++---
 .../Enumerable/EnumerableExtensions.Filter.cs | 64 ++++++++++++++---
 .../EnumerableExtensions.FilterBind.cs        | 72 +++++++++++++++----
 .../EnumerableExtensions.FilterMap.cs         | 72 +++++++++++++++----
 .../EnumerableExtensions.Iterate.cs           | 48 ++++++++++---
 .../Enumerable/EnumerableExtensions.Map.cs    | 52 +++++++++++---
 6 files changed, 304 insertions(+), 56 deletions(-)

diff --git a/src/All/Extensions/Enumerable/EnumerableExtensions.Bind.cs b/src/All/Extensions/Enumerable/EnumerableExtensions.Bind.cs
index 7b867a2b..6fdafd69 100644
--- a/src/All/Extensions/Enumerable/EnumerableExtensions.Bind.cs
+++ b/src/All/Extensions/Enumerable/EnumerableExtensions.Bind.cs
@@ -28,12 +28,30 @@ public static IEnumerable<Maybe<TReturn>> Bind<T, TReturn>(this IEnumerable<Mayb
 	}
 
 	/// <inheritdoc cref="Bind{T, TReturn}(IEnumerable{Maybe{T}}, Func{T, Maybe{TReturn}})"/>
-	public static Task<List<Maybe<TReturn>>> BindAsync<T, TReturn>(this IEnumerable<Maybe<T>> @this, Func<T, Task<Maybe<TReturn>>> f) =>
-		BindAsync(Task.FromResult(@this), f);
+	public static async Task<List<Maybe<TReturn>>> BindAsync<T, TReturn>(this IEnumerable<Maybe<T>> @this, Func<T, Task<Maybe<TReturn>>> f)
+	{
+		var items = new List<Maybe<TReturn>>();
+
+		foreach (var item in @this.Filter())
+		{
+			items.Add(await item.BindAsync(f));
+		}
+
+		return items;
+	}
 
 	/// <inheritdoc cref="Bind{T, TReturn}(IEnumerable{Maybe{T}}, Func{T, Maybe{TReturn}})"/>
-	public static Task<List<Maybe<TReturn>>> BindAsync<T, TReturn>(this Task<IEnumerable<Maybe<T>>> @this, Func<T, Maybe<TReturn>> f) =>
-		BindAsync(@this, async x => f(x));
+	public static async Task<List<Maybe<TReturn>>> BindAsync<T, TReturn>(this Task<IEnumerable<Maybe<T>>> @this, Func<T, Maybe<TReturn>> f)
+	{
+		var items = new List<Maybe<TReturn>>();
+
+		foreach (var item in await @this.FilterAsync())
+		{
+			items.Add(item.Bind(f));
+		}
+
+		return items;
+	}
 
 	/// <inheritdoc cref="Bind{T, TReturn}(IEnumerable{Maybe{T}}, Func{T, Maybe{TReturn}})"/>
 	public static async Task<List<Maybe<TReturn>>> BindAsync<T, TReturn>(this Task<IEnumerable<Maybe<T>>> @this, Func<T, Task<Maybe<TReturn>>> f)
@@ -69,12 +87,30 @@ public static IEnumerable<Result<TReturn>> Bind<T, TReturn>(this IEnumerable<Res
 	}
 
 	/// <inheritdoc cref="Bind{T, TReturn}(IEnumerable{Result{T}}, Func{T, Result{TReturn}})"/>
-	public static Task<List<Result<TReturn>>> BindAsync<T, TReturn>(this IEnumerable<Result<T>> @this, Func<T, Task<Result<TReturn>>> f) =>
-		BindAsync(Task.FromResult(@this), f);
+	public static async Task<List<Result<TReturn>>> BindAsync<T, TReturn>(this IEnumerable<Result<T>> @this, Func<T, Task<Result<TReturn>>> f)
+	{
+		var items = new List<Result<TReturn>>();
+
+		foreach (var item in @this)
+		{
+			items.Add(await item.BindAsync(f));
+		}
+
+		return items;
+	}
 
 	/// <inheritdoc cref="Bind{T, TReturn}(IEnumerable{Result{T}}, Func{T, Result{TReturn}})"/>
-	public static Task<List<Result<TReturn>>> BindAsync<T, TReturn>(this Task<IEnumerable<Result<T>>> @this, Func<T, Result<TReturn>> f) =>
-		BindAsync(@this, async x => f(x));
+	public static async Task<List<Result<TReturn>>> BindAsync<T, TReturn>(this Task<IEnumerable<Result<T>>> @this, Func<T, Result<TReturn>> f)
+	{
+		var items = new List<Result<TReturn>>();
+
+		foreach (var item in await @this)
+		{
+			items.Add(item.Bind(f));
+		}
+
+		return items;
+	}
 
 	/// <inheritdoc cref="Bind{T, TReturn}(IEnumerable{Result{T}}, Func{T, Result{TReturn}})"/>
 	public static async Task<List<Result<TReturn>>> BindAsync<T, TReturn>(this Task<IEnumerable<Result<T>>> @this, Func<T, Task<Result<TReturn>>> f)
diff --git a/src/All/Extensions/Enumerable/EnumerableExtensions.Filter.cs b/src/All/Extensions/Enumerable/EnumerableExtensions.Filter.cs
index 79e4fc0c..0d260371 100644
--- a/src/All/Extensions/Enumerable/EnumerableExtensions.Filter.cs
+++ b/src/All/Extensions/Enumerable/EnumerableExtensions.Filter.cs
@@ -63,12 +63,36 @@ public static IEnumerable<Maybe<T>> Filter<T>(this IEnumerable<Maybe<T>> @this,
 	}
 
 	/// <inheritdoc cref="Filter{T}(IEnumerable{Maybe{T}}, Func{T, bool})"/>
-	public static Task<List<Maybe<T>>> FilterAsync<T>(this IEnumerable<Maybe<T>> @this, Func<T, Task<bool>> fTest) =>
-		FilterAsync(Task.FromResult(@this), fTest);
+	public static async Task<List<Maybe<T>>> FilterAsync<T>(this IEnumerable<Maybe<T>> @this, Func<T, Task<bool>> fTest)
+	{
+		var list = new List<Maybe<T>>();
+
+		foreach (var item in @this)
+		{
+			foreach (var value in await item.FilterAsync(fTest))
+			{
+				list.Add(value);
+			}
+		}
+
+		return list;
+	}
 
 	/// <inheritdoc cref="Filter{T}(IEnumerable{Maybe{T}}, Func{T, bool})"/>
-	public static Task<List<Maybe<T>>> FilterAsync<T>(this Task<IEnumerable<Maybe<T>>> @this, Func<T, bool> fTest) =>
-		FilterAsync(@this, async x => fTest(x));
+	public static async Task<List<Maybe<T>>> FilterAsync<T>(this Task<IEnumerable<Maybe<T>>> @this, Func<T, bool> fTest)
+	{
+		var list = new List<Maybe<T>>();
+
+		foreach (var item in await @this)
+		{
+			foreach (var value in item.Filter(fTest))
+			{
+				list.Add(value);
+			}
+		}
+
+		return list;
+	}
 
 	/// <inheritdoc cref="Filter{T}(IEnumerable{Maybe{T}}, Func{T, bool})"/>
 	public static async Task<List<Maybe<T>>> FilterAsync<T>(this Task<IEnumerable<Maybe<T>>> @this, Func<T, Task<bool>> fTest)
@@ -109,12 +133,36 @@ public static IEnumerable<Result<T>> Filter<T>(this IEnumerable<Result<T>> @this
 	}
 
 	/// <inheritdoc cref="Filter{T}(IEnumerable{Result{T}}, Func{T, bool})"/>
-	public static Task<List<Result<T>>> FilterAsync<T>(this IEnumerable<Result<T>> @this, Func<T, Task<bool>> fTest) =>
-		FilterAsync(Task.FromResult(@this), fTest);
+	public static async Task<List<Result<T>>> FilterAsync<T>(this IEnumerable<Result<T>> @this, Func<T, Task<bool>> fTest)
+	{
+		var list = new List<Result<T>>();
+
+		foreach (var item in @this)
+		{
+			foreach (var value in await item.FilterAsync(fTest).Unsafe())
+			{
+				list.Add(value);
+			}
+		}
+
+		return list;
+	}
 
 	/// <inheritdoc cref="Filter{T}(IEnumerable{Result{T}}, Func{T, bool})"/>
-	public static Task<List<Result<T>>> FilterAsync<T>(this Task<IEnumerable<Result<T>>> @this, Func<T, bool> fTest) =>
-		FilterAsync(@this, async x => fTest(x));
+	public static async Task<List<Result<T>>> FilterAsync<T>(this Task<IEnumerable<Result<T>>> @this, Func<T, bool> fTest)
+	{
+		var list = new List<Result<T>>();
+
+		foreach (var item in await @this)
+		{
+			foreach (var value in item.Filter(fTest).Unsafe())
+			{
+				list.Add(value);
+			}
+		}
+
+		return list;
+	}
 
 	/// <inheritdoc cref="Filter{T}(IEnumerable{Result{T}}, Func{T, bool})"/>
 	public static async Task<List<Result<T>>> FilterAsync<T>(this Task<IEnumerable<Result<T>>> @this, Func<T, Task<bool>> fTest)
diff --git a/src/All/Extensions/Enumerable/EnumerableExtensions.FilterBind.cs b/src/All/Extensions/Enumerable/EnumerableExtensions.FilterBind.cs
index 1119e7b2..47f40a50 100644
--- a/src/All/Extensions/Enumerable/EnumerableExtensions.FilterBind.cs
+++ b/src/All/Extensions/Enumerable/EnumerableExtensions.FilterBind.cs
@@ -35,18 +35,42 @@ Func<T, Maybe<TReturn>> f
 	}
 
 	/// <inheritdoc cref="FilterBind{T, TReturn}(IEnumerable{Maybe{T}}, Func{T, bool}, Func{T, Maybe{TReturn}})"/>
-	public static Task<List<Maybe<TReturn>>> FilterBindAsync<T, TReturn>(this IEnumerable<Maybe<T>> @this,
+	public static async Task<List<Maybe<TReturn>>> FilterBindAsync<T, TReturn>(this IEnumerable<Maybe<T>> @this,
 		Func<T, bool> fTest,
 		Func<T, Task<Maybe<TReturn>>> f
-	) =>
-		FilterBindAsync(Task.FromResult(@this), fTest, f);
+	)
+	{
+		var items = new List<Maybe<TReturn>>();
+
+		foreach (var item in @this)
+		{
+			foreach (var value in await item.BindIfAsync(fTest, f))
+			{
+				items.Add(value);
+			}
+		}
+
+		return items;
+	}
 
 	/// <inheritdoc cref="FilterBind{T, TReturn}(IEnumerable{Maybe{T}}, Func{T, bool}, Func{T, Maybe{TReturn}})"/>
-	public static Task<List<Maybe<TReturn>>> FilterBindAsync<T, TReturn>(this Task<IEnumerable<Maybe<T>>> @this,
+	public static async Task<List<Maybe<TReturn>>> FilterBindAsync<T, TReturn>(this Task<IEnumerable<Maybe<T>>> @this,
 		Func<T, bool> fTest,
 		Func<T, Maybe<TReturn>> f
-	) =>
-		FilterBindAsync(@this, fTest, async x => f(x));
+	)
+	{
+		var items = new List<Maybe<TReturn>>();
+
+		foreach (var item in await @this)
+		{
+			foreach (var value in item.BindIf(fTest, f))
+			{
+				items.Add(value);
+			}
+		}
+
+		return items;
+	}
 
 	/// <inheritdoc cref="FilterBind{T, TReturn}(IEnumerable{Maybe{T}}, Func{T, bool}, Func{T, Maybe{TReturn}})"/>
 	public static async Task<List<Maybe<TReturn>>> FilterBindAsync<T, TReturn>(this Task<IEnumerable<Maybe<T>>> @this,
@@ -95,18 +119,42 @@ Func<T, Result<TReturn>> f
 	}
 
 	/// <inheritdoc cref="FilterBind{T, TReturn}(IEnumerable{Result{T}}, Func{T, bool}, Func{T, Result{TReturn}})"/>
-	public static Task<List<Result<TReturn>>> FilterBindAsync<T, TReturn>(this IEnumerable<Result<T>> @this,
+	public static async Task<List<Result<TReturn>>> FilterBindAsync<T, TReturn>(this IEnumerable<Result<T>> @this,
 		Func<T, bool> fTest,
 		Func<T, Task<Result<TReturn>>> f
-	) =>
-		FilterBindAsync(Task.FromResult(@this), fTest, f);
+	)
+	{
+		var items = new List<Result<TReturn>>();
+
+		foreach (var item in @this)
+		{
+			foreach (var value in await item.BindIfAsync(fTest, f).Unsafe())
+			{
+				items.Add(value);
+			}
+		}
+
+		return items;
+	}
 
 	/// <inheritdoc cref="FilterBind{T, TReturn}(IEnumerable{Result{T}}, Func{T, bool}, Func{T, Result{TReturn}})"/>
-	public static Task<List<Result<TReturn>>> FilterBindAsync<T, TReturn>(this Task<IEnumerable<Result<T>>> @this,
+	public static async Task<List<Result<TReturn>>> FilterBindAsync<T, TReturn>(this Task<IEnumerable<Result<T>>> @this,
 		Func<T, bool> fTest,
 		Func<T, Result<TReturn>> f
-	) =>
-		FilterBindAsync(@this, fTest, async x => f(x));
+	)
+	{
+		var items = new List<Result<TReturn>>();
+
+		foreach (var item in await @this)
+		{
+			foreach (var value in item.BindIf(fTest, f).Unsafe())
+			{
+				items.Add(value);
+			}
+		}
+
+		return items;
+	}
 
 	/// <inheritdoc cref="FilterBind{T, TReturn}(IEnumerable{Result{T}}, Func{T, bool}, Func{T, Result{TReturn}})"/>
 	public static async Task<List<Result<TReturn>>> FilterBindAsync<T, TReturn>(this Task<IEnumerable<Result<T>>> @this,
diff --git a/src/All/Extensions/Enumerable/EnumerableExtensions.FilterMap.cs b/src/All/Extensions/Enumerable/EnumerableExtensions.FilterMap.cs
index 68249a56..3a7df4e5 100644
--- a/src/All/Extensions/Enumerable/EnumerableExtensions.FilterMap.cs
+++ b/src/All/Extensions/Enumerable/EnumerableExtensions.FilterMap.cs
@@ -35,18 +35,42 @@ Func<T, TReturn> f
 	}
 
 	/// <inheritdoc cref="FilterMap{T, TReturn}(IEnumerable{Maybe{T}}, Func{T, bool}, Func{T, TReturn})"/>
-	public static Task<List<Maybe<TReturn>>> FilterMapAsync<T, TReturn>(this IEnumerable<Maybe<T>> @this,
+	public static async Task<List<Maybe<TReturn>>> FilterMapAsync<T, TReturn>(this IEnumerable<Maybe<T>> @this,
 		Func<T, bool> fTest,
 		Func<T, Task<TReturn>> f
-	) =>
-		FilterMapAsync(Task.FromResult(@this), fTest, f);
+	)
+	{
+		var list = new List<Maybe<TReturn>>();
+
+		foreach (var item in @this)
+		{
+			foreach (var value in await item.MapIfAsync(fTest, f))
+			{
+				list.Add(value);
+			}
+		}
+
+		return list;
+	}
 
 	/// <inheritdoc cref="FilterMap{T, TReturn}(IEnumerable{Maybe{T}}, Func{T, bool}, Func{T, TReturn})"/>
-	public static Task<List<Maybe<TReturn>>> FilterMapAsync<T, TReturn>(this Task<IEnumerable<Maybe<T>>> @this,
+	public static async Task<List<Maybe<TReturn>>> FilterMapAsync<T, TReturn>(this Task<IEnumerable<Maybe<T>>> @this,
 		Func<T, bool> fTest,
 		Func<T, TReturn> f
-	) =>
-		FilterMapAsync(@this, fTest, async x => f(x));
+	)
+	{
+		var list = new List<Maybe<TReturn>>();
+
+		foreach (var item in await @this)
+		{
+			foreach (var value in item.MapIf(fTest, f))
+			{
+				list.Add(value);
+			}
+		}
+
+		return list;
+	}
 
 	/// <inheritdoc cref="FilterMap{T, TReturn}(IEnumerable{Maybe{T}}, Func{T, bool}, Func{T, TReturn})"/>
 	public static async Task<List<Maybe<TReturn>>> FilterMapAsync<T, TReturn>(this Task<IEnumerable<Maybe<T>>> @this,
@@ -95,18 +119,42 @@ Func<T, TReturn> f
 	}
 
 	/// <inheritdoc cref="FilterMap{T, TReturn}(IEnumerable{Result{T}}, Func{T, bool}, Func{T, TReturn})"/>
-	public static Task<List<Result<TReturn>>> FilterMapAsync<T, TReturn>(this IEnumerable<Result<T>> @this,
+	public static async Task<List<Result<TReturn>>> FilterMapAsync<T, TReturn>(this IEnumerable<Result<T>> @this,
 		Func<T, bool> fTest,
 		Func<T, Task<TReturn>> f
-	) =>
-		FilterMapAsync(Task.FromResult(@this), fTest, f);
+	)
+	{
+		var list = new List<Result<TReturn>>();
+
+		foreach (var item in @this)
+		{
+			foreach (var value in await item.MapIfAsync(fTest, f).Unsafe())
+			{
+				list.Add(value);
+			}
+		}
+
+		return list;
+	}
 
 	/// <inheritdoc cref="FilterMap{T, TReturn}(IEnumerable{Result{T}}, Func{T, bool}, Func{T, TReturn})"/>
-	public static Task<List<Result<TReturn>>> FilterMapAsync<T, TReturn>(this Task<IEnumerable<Result<T>>> @this,
+	public static async Task<List<Result<TReturn>>> FilterMapAsync<T, TReturn>(this Task<IEnumerable<Result<T>>> @this,
 		Func<T, bool> fTest,
 		Func<T, TReturn> f
-	) =>
-		FilterMapAsync(@this, fTest, async x => f(x));
+	)
+	{
+		var list = new List<Result<TReturn>>();
+
+		foreach (var item in await @this)
+		{
+			foreach (var value in item.MapIf(fTest, f).Unsafe())
+			{
+				list.Add(value);
+			}
+		}
+
+		return list;
+	}
 
 	/// <inheritdoc cref="FilterMap{T, TReturn}(IEnumerable{Result{T}}, Func{T, bool}, Func{T, TReturn})"/>
 	public static async Task<List<Result<TReturn>>> FilterMapAsync<T, TReturn>(this Task<IEnumerable<Result<T>>> @this,
diff --git a/src/All/Extensions/Enumerable/EnumerableExtensions.Iterate.cs b/src/All/Extensions/Enumerable/EnumerableExtensions.Iterate.cs
index 62f17ce0..d5384acc 100644
--- a/src/All/Extensions/Enumerable/EnumerableExtensions.Iterate.cs
+++ b/src/All/Extensions/Enumerable/EnumerableExtensions.Iterate.cs
@@ -30,12 +30,28 @@ public static void Iterate<T>(this IEnumerable<Maybe<T>> @this, Action<T> f)
 	}
 
 	/// <inheritdoc cref="Iterate{T}(IEnumerable{Maybe{T}}, Action{T})"/>
-	public static Task IterateAsync<T>(this IEnumerable<Maybe<T>> @this, Func<T, Task> f) =>
-		IterateAsync(Task.FromResult(@this), f);
+	public static async Task IterateAsync<T>(this IEnumerable<Maybe<T>> @this, Func<T, Task> f)
+	{
+		foreach (var item in @this)
+		{
+			foreach (var value in item)
+			{
+				await f(value);
+			}
+		}
+	}
 
 	/// <inheritdoc cref="Iterate{T}(IEnumerable{Maybe{T}}, Action{T})"/>
-	public static Task IterateAsync<T>(this Task<IEnumerable<Maybe<T>>> @this, Action<T> f) =>
-		IterateAsync(@this, async x => f(x));
+	public static async Task IterateAsync<T>(this Task<IEnumerable<Maybe<T>>> @this, Action<T> f)
+	{
+		foreach (var item in await @this)
+		{
+			foreach (var value in item)
+			{
+				f(value);
+			}
+		}
+	}
 
 	/// <inheritdoc cref="Iterate{T}(IEnumerable{Maybe{T}}, Action{T})"/>
 	public static async Task IterateAsync<T>(this Task<IEnumerable<Maybe<T>>> @this, Func<T, Task> f)
@@ -72,12 +88,28 @@ public static void Iterate<T>(this IEnumerable<Result<T>> @this, Action<T> f)
 	}
 
 	/// <inheritdoc cref="Iterate{T}(IEnumerable{Result{T}}, Action{T})"/>
-	public static Task IterateAsync<T>(this IEnumerable<Result<T>> @this, Func<T, Task> f) =>
-		IterateAsync(Task.FromResult(@this), f);
+	public static async Task IterateAsync<T>(this IEnumerable<Result<T>> @this, Func<T, Task> f)
+	{
+		foreach (var item in @this)
+		{
+			foreach (var value in item.Unsafe())
+			{
+				await f(value);
+			}
+		}
+	}
 
 	/// <inheritdoc cref="Iterate{T}(IEnumerable{Result{T}}, Action{T})"/>
-	public static Task IterateAsync<T>(this Task<IEnumerable<Result<T>>> @this, Action<T> f) =>
-		IterateAsync(@this, async x => f(x));
+	public static async Task IterateAsync<T>(this Task<IEnumerable<Result<T>>> @this, Action<T> f)
+	{
+		foreach (var item in await @this)
+		{
+			foreach (var value in item.Unsafe())
+			{
+				f(value);
+			}
+		}
+	}
 
 	/// <inheritdoc cref="Iterate{T}(IEnumerable{Result{T}}, Action{T})"/>
 	public static async Task IterateAsync<T>(this Task<IEnumerable<Result<T>>> @this, Func<T, Task> f)
diff --git a/src/All/Extensions/Enumerable/EnumerableExtensions.Map.cs b/src/All/Extensions/Enumerable/EnumerableExtensions.Map.cs
index 4bb8f97f..fc6bc1d9 100644
--- a/src/All/Extensions/Enumerable/EnumerableExtensions.Map.cs
+++ b/src/All/Extensions/Enumerable/EnumerableExtensions.Map.cs
@@ -28,12 +28,30 @@ public static IEnumerable<Maybe<TReturn>> Map<T, TReturn>(this IEnumerable<Maybe
 	}
 
 	/// <inheritdoc cref="Map{T, TReturn}(IEnumerable{Maybe{T}}, Func{T, TReturn})"/>
-	public static Task<List<Maybe<TReturn>>> MapAsync<T, TReturn>(this IEnumerable<Maybe<T>> @this, Func<T, Task<TReturn>> f) =>
-		MapAsync(Task.FromResult(@this), f);
+	public static async Task<List<Maybe<TReturn>>> MapAsync<T, TReturn>(this IEnumerable<Maybe<T>> @this, Func<T, Task<TReturn>> f)
+	{
+		var list = new List<Maybe<TReturn>>();
+
+		foreach (var item in @this)
+		{
+			list.Add(await item.MapAsync(f));
+		}
+
+		return list;
+	}
 
 	/// <inheritdoc cref="Map{T, TReturn}(IEnumerable{Maybe{T}}, Func{T, TReturn})"/>
-	public static Task<List<Maybe<TReturn>>> MapAsync<T, TReturn>(this Task<IEnumerable<Maybe<T>>> @this, Func<T, TReturn> f) =>
-		MapAsync(@this, async x => f(x));
+	public static async Task<List<Maybe<TReturn>>> MapAsync<T, TReturn>(this Task<IEnumerable<Maybe<T>>> @this, Func<T, TReturn> f)
+	{
+		var list = new List<Maybe<TReturn>>();
+
+		foreach (var item in await @this)
+		{
+			list.Add(item.Map(f));
+		}
+
+		return list;
+	}
 
 	/// <inheritdoc cref="Map{T, TReturn}(IEnumerable{Maybe{T}}, Func{T, TReturn})"/>
 	public static async Task<List<Maybe<TReturn>>> MapAsync<T, TReturn>(this Task<IEnumerable<Maybe<T>>> @this, Func<T, Task<TReturn>> f)
@@ -69,12 +87,30 @@ public static IEnumerable<Result<TReturn>> Map<T, TReturn>(this IEnumerable<Resu
 	}
 
 	/// <inheritdoc cref="Map{T, TReturn}(IEnumerable{Result{T}}, Func{T, TReturn})"/>
-	public static Task<List<Result<TReturn>>> MapAsync<T, TReturn>(this IEnumerable<Result<T>> @this, Func<T, Task<TReturn>> f) =>
-		MapAsync(Task.FromResult(@this), f);
+	public static async Task<List<Result<TReturn>>> MapAsync<T, TReturn>(this IEnumerable<Result<T>> @this, Func<T, Task<TReturn>> f)
+	{
+		var list = new List<Result<TReturn>>();
+
+		foreach (var item in @this)
+		{
+			list.Add(await item.MapAsync(f));
+		}
+
+		return list;
+	}
 
 	/// <inheritdoc cref="Map{T, TReturn}(IEnumerable{Result{T}}, Func{T, TReturn})"/>
-	public static Task<List<Result<TReturn>>> MapAsync<T, TReturn>(this Task<IEnumerable<Result<T>>> @this, Func<T, TReturn> f) =>
-		MapAsync(@this, async x => f(x));
+	public static async Task<List<Result<TReturn>>> MapAsync<T, TReturn>(this Task<IEnumerable<Result<T>>> @this, Func<T, TReturn> f)
+	{
+		var list = new List<Result<TReturn>>();
+
+		foreach (var item in await @this)
+		{
+			list.Add(item.Map(f));
+		}
+
+		return list;
+	}
 
 	/// <inheritdoc cref="Map{T, TReturn}(IEnumerable{Result{T}}, Func{T, TReturn})"/>
 	public static async Task<List<Result<TReturn>>> MapAsync<T, TReturn>(this Task<IEnumerable<Result<T>>> @this, Func<T, Task<TReturn>> f)

From 15e0bcb69235c21a89923a9c37395878ac667890 Mon Sep 17 00:00:00 2001
From: bfren <bf@bfren.dev>
Date: Fri, 27 Feb 2026 12:07:09 +0000
Subject: [PATCH 2/4] Write directly to Utf8JsonWriter - #63

---
 src/All/Json/MonadJsonConverter.cs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/All/Json/MonadJsonConverter.cs b/src/All/Json/MonadJsonConverter.cs
index cb4cf18f..60238e5b 100644
--- a/src/All/Json/MonadJsonConverter.cs
+++ b/src/All/Json/MonadJsonConverter.cs
@@ -60,7 +60,6 @@ public override void Write(Utf8JsonWriter writer, TMonad value, JsonSerializerOp
 			return;
 		}
 
-		var json = JsonSerializer.SerializeToUtf8Bytes(value.Value, options);
-		writer.WriteRawValue(json);
+		JsonSerializer.Serialize(writer, value.Value, options);
 	}
 }

From 3e2fc09dae7074a2761392cbc6fec97ab8825ade Mon Sep 17 00:00:00 2001
From: bfren <bf@bfren.dev>
Date: Fri, 27 Feb 2026 12:08:20 +0000
Subject: [PATCH 3/4] Adding GetOrCreate overload when no options - #63

---
 src/Caching/WrapCache.cs | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/src/Caching/WrapCache.cs b/src/Caching/WrapCache.cs
index 6148bc9e..99879a2b 100644
--- a/src/Caching/WrapCache.cs
+++ b/src/Caching/WrapCache.cs
@@ -108,7 +108,12 @@ public Maybe<TValue> GetOrCreate<TValue>(TKey key, Func<TValue> valueFactory, Me
 		GetOrCreate(key, () => M.Wrap(valueFactory()), opt);
 
 	/// <inheritdoc/>
-	public Maybe<TValue> GetOrCreate<TValue>(TKey key, Func<Maybe<TValue>> valueFactory)
+	public Maybe<TValue> GetOrCreate<TValue>(TKey key, Func<Maybe<TValue>> valueFactory) =>
+		GetOrCreate(key, valueFactory, new());
+
+
+	/// <inheritdoc/>
+	public Maybe<TValue> GetOrCreate<TValue>(TKey key, Func<Maybe<TValue>> valueFactory, MemoryCacheEntryOptions opt)
 	{
 		// Check whether or not the value already exists
 		var value = GetValue<TValue>(key);
@@ -133,7 +138,7 @@ public Maybe<TValue> GetOrCreate<TValue>(TKey key, Func<Maybe<TValue>> valueFact
 						.Ctx(nameof(WrapCache), nameof(GetOrCreate))
 				)
 				.Map(
-					x => Cache.GetOrCreate(key, e => { _ = e.SetValue(x!); return x; })!
+					x => Cache.GetOrCreate(key, e => { _ = e.SetOptions(opt).SetValue(x!); return x; })!
 				);
 		}
 		catch (Exception ex)
@@ -150,10 +155,6 @@ public Maybe<TValue> GetOrCreate<TValue>(TKey key, Func<Maybe<TValue>> valueFact
 		}
 	}
 
-	/// <inheritdoc/>
-	public Maybe<TValue> GetOrCreate<TValue>(TKey key, Func<Maybe<TValue>> valueFactory, MemoryCacheEntryOptions opt) =>
-		GetOrCreateAsync(key, async () => valueFactory(), opt).Result;
-
 	/// <inheritdoc/>
 	public Task<Maybe<TValue>> GetOrCreateAsync<TValue>(TKey key, Func<Task<TValue>> valueFactory) =>
 		GetOrCreateAsync(key, async () => M.Wrap(await valueFactory()), new());

From 70448569cc3785b3ba0d002cf412406116324c35 Mon Sep 17 00:00:00 2001
From: bfren <bf@bfren.dev>
Date: Fri, 27 Feb 2026 12:14:50 +0000
Subject: [PATCH 4/4] Cache GetProperty in F.Format - #63

---
 src/Common/Functions/F.Format.cs | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/src/Common/Functions/F.Format.cs b/src/Common/Functions/F.Format.cs
index 28c63eb0..f0cfb60d 100644
--- a/src/Common/Functions/F.Format.cs
+++ b/src/Common/Functions/F.Format.cs
@@ -2,6 +2,7 @@
 // Copyright (c) bfren - licensed under https://mit.bfren.dev/2019
 
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Reflection;
 using System.Text.RegularExpressions;
@@ -10,6 +11,9 @@ namespace Wrap;
 
 public static partial class F
 {
+	internal static ConcurrentDictionary<Type, Dictionary<string, PropertyInfo>> TypeInfoCache =
+		new();
+
 	/// <inheritdoc cref="Format{T}(string, T, string?)"/>
 	public static string Format<T>(string formatString, T source) =>
 		Format(formatString, source, null);
@@ -41,7 +45,6 @@ public static string Format<T>(string formatString, T source, string? replaceIfN
 		var values = new List<object>(regex.Count(formatString));
 		var replaceIndex = 0; // keeps track of replace loop so we can match named template values with an array source
 		var numberedTemplates = true;
-		var flags = BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance;
 		var rewrittenFormat = regex.Replace(formatString, (m) =>
 		{
 			// This is the value inside the braces, e.g. "0" in "{0}" or "A" in "{A}"
@@ -66,7 +69,7 @@ public static string Format<T>(string formatString, T source, string? replaceIfN
 					val,
 
 				// Source object - get matching property value for named template
-				{ } obj when !numberedTemplates && typeof(T).GetProperty(template, flags)?.GetValue(obj) is object val =>
+				{ } obj when !numberedTemplates && PropertyCache<T>.GetProperty(template)?.GetValue(obj) is object val =>
 					val,
 
 				// Nothing matches so put placeholder back
@@ -132,4 +135,13 @@ public static string Format<T>(string formatString, T source, string? replaceIfN
 	/// </summary>
 	[GeneratedRegex("(?<start>\\{)+(?<template>[\\w\\.\\[\\]@]+)(?<format>:[^}]+)?(?<end>\\})+", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)]
 	private static partial Regex TemplateMatcherRegex();
+
+	private static class PropertyCache<T>
+	{
+		private static readonly ConcurrentDictionary<string, PropertyInfo?> Cache = new();
+		private static readonly BindingFlags Flags = BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance;
+
+		internal static PropertyInfo? GetProperty(string name) =>
+			Cache.GetOrAdd(name, static n => typeof(T).GetProperty(n, Flags));
+	}
 }