From 44dffbe81b8dd194433b2f79d9ea5d69058ec61a Mon Sep 17 00:00:00 2001
From: bfren <bf@bfren.dev>
Date: Fri, 27 Feb 2026 09:26:16 +0000
Subject: [PATCH 01/18] Shifting parse to separate function - #61

---
 src/All.Mvc/WrapModelBinder.cs | 135 +++++++++++++++++----------------
 1 file changed, 70 insertions(+), 65 deletions(-)

diff --git a/src/All.Mvc/WrapModelBinder.cs b/src/All.Mvc/WrapModelBinder.cs
index bef08a37..f6921d0f 100644
--- a/src/All.Mvc/WrapModelBinder.cs
+++ b/src/All.Mvc/WrapModelBinder.cs
@@ -82,97 +82,102 @@ string model
 
 		try
 		{
-			// Attempt to parse the value
-			var valueParsed = default(TValue) switch
+			// Attempt to parse value and wrap result
+			return Parse(value) switch
 			{
-				bool =>
-					M.ParseBool(value).Match(FNone, FSome),
+				TValue x =>
+					(result, ModelBindingResult.Success(Wrap(x))),
 
-				byte =>
-					M.ParseByte(value).Match(FNone, FSome),
+				_ when new MonadModelBinderProvider().GetBinder(typeof(TValue)) is IWrapModelBinder<TValue> x =>
+					x.GetValue(provider, model),
 
-				char =>
-					M.ParseChar(value).Match(FNone, FSome),
+				_ when JsonSerializer.Deserialize<TValue>($"\"{value}\"", WrapModelBinderHelpers.Options) is TValue x =>
+					(result, ModelBindingResult.Success(Wrap(x))),
 
-				DateOnly =>
-					M.ParseDateOnly(value).Match(FNone, FSome),
+				_ =>
+					Nothing()
+			};
+		}
+		catch
+		{
+			return Nothing();
+		}
+	}
 
-				DateTime =>
-					M.ParseDateTime(value).Match(FNone, FSome),
+	/// <summary>
+	/// Attempt to parse <paramref name="value"/>, returning null on failure.
+	/// </summary>
+	/// <param name="value">String value.</param>
+	/// <returns>Parsed value or null.</returns>
+	internal object? Parse(string? value) =>
+		default(TValue) switch
+		{
+			bool =>
+				M.ParseBool(value).Match(FNone, FSome),
 
-				DateTimeOffset =>
-					M.ParseDateTimeOffset(value).Match(FNone, FSome),
+			byte =>
+				M.ParseByte(value).Match(FNone, FSome),
 
-				decimal =>
-					M.ParseDecimal(value).Match(FNone, FSome),
+			char =>
+				M.ParseChar(value).Match(FNone, FSome),
 
-				double =>
-					M.ParseDouble(value).Match(FNone, FSome),
+			DateOnly =>
+				M.ParseDateOnly(value).Match(FNone, FSome),
 
-				Guid =>
-					M.ParseGuid(value).Match(FNone, FSome),
+			DateTime =>
+				M.ParseDateTime(value).Match(FNone, FSome),
 
-				short =>
-					M.ParseInt16(value).Match(FNone, FSome),
+			DateTimeOffset =>
+				M.ParseDateTimeOffset(value).Match(FNone, FSome),
 
-				int =>
-					M.ParseInt32(value).Match(FNone, FSome),
+			decimal =>
+				M.ParseDecimal(value).Match(FNone, FSome),
 
-				long =>
-					M.ParseInt64(value).Match(FNone, FSome),
+			double =>
+				M.ParseDouble(value).Match(FNone, FSome),
 
-				Int128 =>
-					M.ParseInt128(value).Match(FNone, FSome),
+			Guid =>
+				M.ParseGuid(value).Match(FNone, FSome),
 
-				nint =>
-					M.ParseIntPtr(value).Match(FNone, FSome),
+			short =>
+				M.ParseInt16(value).Match(FNone, FSome),
 
-				float =>
-					M.ParseSingle(value).Match(FNone, FSome),
+			int =>
+				M.ParseInt32(value).Match(FNone, FSome),
 
-				TimeOnly =>
-					M.ParseTimeOnly(value).Match(FNone, FSome),
+			long =>
+				M.ParseInt64(value).Match(FNone, FSome),
 
-				ushort =>
-					M.ParseUInt16(value).Match(FNone, FSome),
+			Int128 =>
+				M.ParseInt128(value).Match(FNone, FSome),
 
-				uint =>
-					M.ParseUInt32(value).Match(FNone, FSome),
+			nint =>
+				M.ParseIntPtr(value).Match(FNone, FSome),
 
-				ulong =>
-					M.ParseUInt64(value).Match(FNone, FSome),
+			float =>
+				M.ParseSingle(value).Match(FNone, FSome),
 
-				UInt128 =>
-					M.ParseUInt128(value).Match(FNone, FSome),
+			TimeOnly =>
+				M.ParseTimeOnly(value).Match(FNone, FSome),
 
-				nuint =>
-					M.ParseUIntPtr(value).Match(FNone, FSome),
+			ushort =>
+				M.ParseUInt16(value).Match(FNone, FSome),
 
-				_ =>
-					null
-			};
+			uint =>
+				M.ParseUInt32(value).Match(FNone, FSome),
 
-			// Wrap parsed value
-			return valueParsed switch
-			{
-				TValue x =>
-					(result, ModelBindingResult.Success(Wrap(x))),
+			ulong =>
+				M.ParseUInt64(value).Match(FNone, FSome),
 
-				_ when new MonadModelBinderProvider().GetBinder(typeof(TValue)) is IWrapModelBinder<TValue> x =>
-					x.GetValue(provider, model),
+			UInt128 =>
+				M.ParseUInt128(value).Match(FNone, FSome),
 
-				_ when JsonSerializer.Deserialize<TValue>($"\"{value}\"", WrapModelBinderHelpers.Options) is TValue x =>
-					(result, ModelBindingResult.Success(Wrap(x))),
+			nuint =>
+				M.ParseUIntPtr(value).Match(FNone, FSome),
 
-				_ =>
-					Nothing()
-			};
-		}
-		catch
-		{
-			return Nothing();
-		}
-	}
+			_ =>
+				null
+		};
 
 	/// <summary>
 	/// Return a 'None' or null value.

From 2552037ad4a48e680390b6ce52450e6f0daf222b Mon Sep 17 00:00:00 2001
From: bfren <bf@bfren.dev>
Date: Fri, 27 Feb 2026 09:26:40 +0000
Subject: [PATCH 02/18] Moving check to separate function - #61

---
 src/Common/Functions/F.Format.cs | 93 ++++++++++++++++++--------------
 1 file changed, 54 insertions(+), 39 deletions(-)

diff --git a/src/Common/Functions/F.Format.cs b/src/Common/Functions/F.Format.cs
index a0302195..65922853 100644
--- a/src/Common/Functions/F.Format.cs
+++ b/src/Common/Functions/F.Format.cs
@@ -30,53 +30,23 @@ public static string Format<T>(string formatString, T source) =>
 	/// <returns>Formatted string.</returns>
 	public static string Format<T>(string formatString, T source, string? replaceIfNullOrEmpty)
 	{
-		// Return if format string is null or empty
-		if (string.IsNullOrWhiteSpace(formatString))
+		// Check arguments before proceeding
+		if (Check(formatString, source, replaceIfNullOrEmpty) is string earlyReturn)
 		{
-			return replaceIfNullOrEmpty ?? string.Empty;
+			return earlyReturn;
 		}
 
-		// Return if source is null or an empty array
-		if (source is null)
-		{
-			return replaceIfNullOrEmpty ?? formatString;
-		}
-		else if (source is Array arr)
-		{
-			if (arr.Length == 0)
-			{
-				return replaceIfNullOrEmpty ?? formatString;
-			}
-
-			// Attempt to use string.Format
-			try
-			{
-				return string.Format(DefaultCulture, formatString, [.. arr]);
-			}
-			catch (Exception)
-			{
-				// do nothing
-			}
-		}
-
-		// Thanks James Newton-King!
+		// Initialise variables before regex replace loop
 		var regex = TemplateMatcherRegex();
-
 		var values = new List<object>();
 		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) =>
 		{
-			var startGroup = m.Groups["start"];
-			var templateGroup = m.Groups["template"];
-			var formatGroup = m.Groups["format"];
-			var endGroup = m.Groups["end"];
-
 			// This is the value inside the braces, e.g. "0" in "{0}" or "A" in "{A}"
-			// Remove any @ symbols from the start - used by Serilog to denote an object format
-			// but breaks the following
-			var template = templateGroup.Value.TrimStart('@');
+			// Remove any @ symbols from the start - used by Serilog to denote an object format but breaks the following
+			var template = m.Groups["template"].Value.TrimStart('@');
 			var templateIsNumber = int.TryParse(template, out var templateNumber);
 			numberedTemplates = numberedTemplates && templateIsNumber;
 
@@ -107,16 +77,61 @@ public static string Format<T>(string formatString, T source, string? replaceIfN
 			values.Add(value);
 
 			// Recreate format using zero-based string
-			return new string('{', startGroup.Captures.Count)
+			return new string('{', m.Groups["start"].Captures.Count)
 				+ (values.Count - 1)
-				+ formatGroup.Value
-				+ new string('}', endGroup.Captures.Count);
+				+ m.Groups["format"].Value
+				+ new string('}', m.Groups["end"].Captures.Count);
 		});
 
 		// Format string with ordered values
 		return string.Format(DefaultCulture, rewrittenFormat, [.. values]);
 	}
 
+	/// <summary>
+	/// Check inputs before attempting to apply complex string format.
+	/// </summary>
+	/// <typeparam name="T">Source type.</typeparam>
+	/// <param name="formatString">String to format.</param>
+	/// <param name="source">Source object to use for template values.</param>
+	/// <param name="replaceIfNullOrEmpty">Returned if <paramref name="formatString"/> or <paramref name="source"/> are null / empty.</param>
+	/// <returns>Early return value if checks fail, or string.Format succeeds (much faster!).</returns>
+	internal static string? Check<T>(string formatString, T source, string? replaceIfNullOrEmpty)
+	{
+		// Return if format string is null or empty
+		if (string.IsNullOrWhiteSpace(formatString))
+		{
+			return replaceIfNullOrEmpty ?? string.Empty;
+		}
+
+		// Return if source is null or an empty array
+		if (source is null)
+		{
+			return replaceIfNullOrEmpty ?? formatString;
+		}
+		else if (source is Array arr)
+		{
+			if (arr.Length == 0)
+			{
+				return replaceIfNullOrEmpty ?? formatString;
+			}
+
+			// Attempt to use string.Format
+			try
+			{
+				return string.Format(DefaultCulture, formatString, [.. arr]);
+			}
+			catch (Exception)
+			{
+				// Do nothing - null return will cause Format function to continue
+			}
+		}
+
+		return null;
+	}
+
+	/// <summary>
+	/// Thanks James Newton-King!
+	/// </summary>
 	[GeneratedRegex("(?<start>\\{)+(?<template>[\\w\\.\\[\\]@]+)(?<format>:[^}]+)?(?<end>\\})+", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)]
 	private static partial Regex TemplateMatcherRegex();
 }

From 06a3b232c9100ae983f09c774cc3f17990f7c95d Mon Sep 17 00:00:00 2001
From: bfren <bf@bfren.dev>
Date: Fri, 27 Feb 2026 09:40:50 +0000
Subject: [PATCH 03/18] Avoiding double-enumeration in xxxOrNone extension
 methods - #61

---
 .../EnumerableExtensions.ElementAtOrNone.cs        |  9 ++++++---
 .../Enumerable/EnumerableExtensions.FirstOrNone.cs | 11 +++++++----
 .../Enumerable/EnumerableExtensions.LastOrNone.cs  | 11 +++++++----
 .../EnumerableExtensions.SingleOrNone.cs           | 14 ++++++++------
 4 files changed, 28 insertions(+), 17 deletions(-)

diff --git a/src/All/Extensions/Enumerable/EnumerableExtensions.ElementAtOrNone.cs b/src/All/Extensions/Enumerable/EnumerableExtensions.ElementAtOrNone.cs
index 38355edc..6e8d4ea4 100644
--- a/src/All/Extensions/Enumerable/EnumerableExtensions.ElementAtOrNone.cs
+++ b/src/All/Extensions/Enumerable/EnumerableExtensions.ElementAtOrNone.cs
@@ -15,13 +15,16 @@ public static partial class EnumerableExtensions
 	/// <param name="this">IEnumerable object.</param>
 	/// <param name="index">Index of value to return.</param>
 	/// <returns>Value of the element at position <paramref name="index"/> of <paramref name="this"/>, or <see cref="None"/>.</returns>
-	public static Maybe<T> ElementAtOrNone<T>(this IEnumerable<T> @this, int index) =>
-		(@this.Count() > index) switch
+	public static Maybe<T> ElementAtOrNone<T>(this IEnumerable<T> @this, int index)
+	{
+		var a = @this.ToArray();
+		return (index < a.Length) switch
 		{
 			true =>
-				@this.ElementAt(index),
+				a[index],
 
 			false =>
 				M.None
 		};
+	}
 }
diff --git a/src/All/Extensions/Enumerable/EnumerableExtensions.FirstOrNone.cs b/src/All/Extensions/Enumerable/EnumerableExtensions.FirstOrNone.cs
index 044b25af..1a7d2f26 100644
--- a/src/All/Extensions/Enumerable/EnumerableExtensions.FirstOrNone.cs
+++ b/src/All/Extensions/Enumerable/EnumerableExtensions.FirstOrNone.cs
@@ -14,13 +14,16 @@ public static partial class EnumerableExtensions
 	/// <typeparam name="T">IEnumerable value type.</typeparam>
 	/// <param name="this">IEnumerable object</param>
 	/// <returns>Value of the first element of <paramref name="this"/>, or <see cref="None"/>.</returns>
-	public static Maybe<T> FirstOrNone<T>(this IEnumerable<T> @this) =>
-		@this.Any() switch
+	public static Maybe<T> FirstOrNone<T>(this IEnumerable<T> @this)
+	{
+		var a = @this.ToArray();
+		return (a.Length > 0) switch
 		{
 			true =>
-				@this.First(),
+				a[0],
 
-			_ =>
+			false =>
 				M.None
 		};
+	}
 }
diff --git a/src/All/Extensions/Enumerable/EnumerableExtensions.LastOrNone.cs b/src/All/Extensions/Enumerable/EnumerableExtensions.LastOrNone.cs
index d8cf1dd0..6cf3a793 100644
--- a/src/All/Extensions/Enumerable/EnumerableExtensions.LastOrNone.cs
+++ b/src/All/Extensions/Enumerable/EnumerableExtensions.LastOrNone.cs
@@ -14,13 +14,16 @@ public static partial class EnumerableExtensions
 	/// <typeparam name="T">IEnumerable value type.</typeparam>
 	/// <param name="this">IEnumerable object</param>
 	/// <returns>Value of the last element of <paramref name="this"/>, or <see cref="None"/>.</returns>
-	public static Maybe<T> LastOrNone<T>(this IEnumerable<T> @this) =>
-		@this.Any() switch
+	public static Maybe<T> LastOrNone<T>(this IEnumerable<T> @this)
+	{
+		var a = @this.ToArray();
+		return (a.Length > 0) switch
 		{
 			true =>
-				@this.Last(),
+				a[^1],
 
-			_ =>
+			false =>
 				M.None
 		};
+	}
 }
diff --git a/src/All/Extensions/Enumerable/EnumerableExtensions.SingleOrNone.cs b/src/All/Extensions/Enumerable/EnumerableExtensions.SingleOrNone.cs
index 05c13514..649cc770 100644
--- a/src/All/Extensions/Enumerable/EnumerableExtensions.SingleOrNone.cs
+++ b/src/All/Extensions/Enumerable/EnumerableExtensions.SingleOrNone.cs
@@ -1,7 +1,6 @@
 // Wrap: Functional Monads for .NET
 // Copyright (c) bfren - licensed under https://mit.bfren.dev/2019
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
 
@@ -18,13 +17,16 @@ public static partial class EnumerableExtensions
 	/// Value of the single element of <paramref name="this"/>, or <see cref="None"/> if the list is empty
 	/// or contains more than one element.
 	/// </returns>
-	public static Maybe<T> SingleOrNone<T>(this IEnumerable<T> @this) =>
-		@this.Count() switch
+	public static Maybe<T> SingleOrNone<T>(this IEnumerable<T> @this)
+	{
+		var a = @this.ToArray();
+		return (a.Length == 1) switch
 		{
-			1 =>
-				@this.Single(),
+			true =>
+				a[0],
 
-			_ =>
+			false =>
 				M.None
 		};
+	}
 }

From 7d525ab72399d7c341a62d95a05766e71b4261db Mon Sep 17 00:00:00 2001
From: bfren <bf@bfren.dev>
Date: Fri, 27 Feb 2026 09:45:48 +0000
Subject: [PATCH 04/18] Avoiding double enumeration on GetSingle - #61

---
 .../Result/ResultExtensions.GetSingle.cs      | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/src/All/Extensions/Result/ResultExtensions.GetSingle.cs b/src/All/Extensions/Result/ResultExtensions.GetSingle.cs
index 9bb52e37..c08c1c35 100644
--- a/src/All/Extensions/Result/ResultExtensions.GetSingle.cs
+++ b/src/All/Extensions/Result/ResultExtensions.GetSingle.cs
@@ -35,16 +35,19 @@ public static Result<TSingle> GetSingle<T, TSingle>(this Result<T> @this, R.Erro
 		where T : IEnumerable =>
 		Bind(@this, x => x switch
 		{
-			IEnumerable<TSingle> list when list.Count() == 1 =>
-				R.Wrap(list.Single()),
+			IEnumerable<TSingle> y => y.ToArray() switch
+			{
+				{ Length: 1 } z =>
+					R.Wrap(z[0]),
 
-			IEnumerable<TSingle> list when !list.Any() =>
-				onError?.Invoke(C.GetSingle.EmptyList) ?? R.Fail(C.GetSingle.EmptyList)
-					.Ctx(nameof(ResultExtensions), nameof(GetSingle)),
+				{ Length: 0 } =>
+					onError?.Invoke(C.GetSingle.EmptyList) ?? R.Fail(C.GetSingle.EmptyList)
+						.Ctx(nameof(ResultExtensions), nameof(GetSingle)),
 
-			IEnumerable<TSingle> =>
-				onError?.Invoke(C.GetSingle.MultipleValues) ?? R.Fail(C.GetSingle.MultipleValues)
-					.Ctx(nameof(ResultExtensions), nameof(GetSingle)),
+				_ =>
+					onError?.Invoke(C.GetSingle.MultipleValues) ?? R.Fail(C.GetSingle.MultipleValues)
+						.Ctx(nameof(ResultExtensions), nameof(GetSingle))
+			},
 
 			IEnumerable =>
 				onError?.Invoke(C.GetSingle.IncorrectType, typeof(TSingle).Name, typeof(T).Name) ?? R.Fail(C.GetSingle.IncorrectType, typeof(TSingle).Name, typeof(T).Name)

From 933040280047f51f47ac0564c9dfb511f9ab0bec Mon Sep 17 00:00:00 2001
From: bfren <bf@bfren.dev>
Date: Fri, 27 Feb 2026 10:04:36 +0000
Subject: [PATCH 05/18] Pre-allocated size of values list - #61

---
 src/Common/Functions/F.Format.cs | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/Common/Functions/F.Format.cs b/src/Common/Functions/F.Format.cs
index 65922853..9a76cfed 100644
--- a/src/Common/Functions/F.Format.cs
+++ b/src/Common/Functions/F.Format.cs
@@ -38,7 +38,7 @@ public static string Format<T>(string formatString, T source, string? replaceIfN
 
 		// Initialise variables before regex replace loop
 		var regex = TemplateMatcherRegex();
-		var values = new List<object>();
+		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;
@@ -51,7 +51,7 @@ public static string Format<T>(string formatString, T source, string? replaceIfN
 			numberedTemplates = numberedTemplates && templateIsNumber;
 
 			// Switch on the source type, using variety of methods to get this template's value
-			var value = source switch
+			values.Add(source switch
 			{
 				// Source array - get specific item in array for numbered template
 				Array arr when numberedTemplates && templateNumber < arr.Length && arr.GetValue(templateNumber) is object val =>
@@ -62,7 +62,7 @@ public static string Format<T>(string formatString, T source, string? replaceIfN
 					val,
 
 				// Source array - get next item in array for named template
-				Array arr when !numberedTemplates && replaceIndex < arr.Length && arr.GetValue(replaceIndex++) is object val =>
+				Array arr when !numberedTemplates && replaceIndex < arr.Length && arr.GetValue(replaceIndex) is object val =>
 					val,
 
 				// Source object - get matching property value for named template
@@ -72,9 +72,7 @@ public static string Format<T>(string formatString, T source, string? replaceIfN
 				// Nothing matches so put placeholder back
 				_ =>
 					$"{{{template}}}"
-			};
-
-			values.Add(value);
+			});
 
 			// Recreate format using zero-based string
 			return new string('{', m.Groups["start"].Captures.Count)

From 6144905a002b170e71f34dc99c671f3eb837e75b Mon Sep 17 00:00:00 2001
From: bfren <bf@bfren.dev>
Date: Fri, 27 Feb 2026 10:14:48 +0000
Subject: [PATCH 06/18] Caching NoneImpl values to avoid allocations - #61

---
 src/Maybe/Functions/M.None.cs |  2 +-
 src/Maybe/Maybe.NoneImpl.cs   | 14 ++++++++++++++
 src/Maybe/Maybe.Operators.cs  |  4 ++--
 3 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/src/Maybe/Functions/M.None.cs b/src/Maybe/Functions/M.None.cs
index 55c4429c..c849272b 100644
--- a/src/Maybe/Functions/M.None.cs
+++ b/src/Maybe/Functions/M.None.cs
@@ -19,5 +19,5 @@ public static partial class M
 	/// <typeparam name="T">Some value type.</typeparam>
 	/// <returns>None value wrapped as a Task.</returns>
 	public static Task<Maybe<T>> NoneAsTask<T>() =>
-		new Maybe<T>.NoneImpl().AsTask();
+		Maybe<T>.NoneAsTask;
 }
diff --git a/src/Maybe/Maybe.NoneImpl.cs b/src/Maybe/Maybe.NoneImpl.cs
index 26a9c445..4775439d 100644
--- a/src/Maybe/Maybe.NoneImpl.cs
+++ b/src/Maybe/Maybe.NoneImpl.cs
@@ -1,10 +1,24 @@
 // Wrap: Functional Monads for .NET
 // Copyright (c) bfren - licensed under https://mit.bfren.dev/2019
 
+using System.Threading.Tasks;
+
 namespace Wrap;
 
 public abstract partial record class Maybe<T>
 {
+	/// <summary>
+	/// Cache NoneImpl value.
+	/// </summary>
+	internal static readonly NoneImpl None =
+		new();
+
+	/// <summary>
+	/// Cache None task.
+	/// </summary>
+	internal static readonly Task<Maybe<T>> NoneAsTask =
+		None.AsTask();
+
 	/// <summary>
 	/// Generic None class (see <seealso cref="None"/>) that can be returned as a <see cref="Maybe{T}"/> object.
 	/// </summary>
diff --git a/src/Maybe/Maybe.Operators.cs b/src/Maybe/Maybe.Operators.cs
index 68bda4c7..ea054ad3 100644
--- a/src/Maybe/Maybe.Operators.cs
+++ b/src/Maybe/Maybe.Operators.cs
@@ -13,11 +13,11 @@ public static implicit operator Maybe<T>(T value) =>
 		M.Wrap(value);
 
 	/// <summary>
-	/// Implicitly convert a <see cref="None"/> into a <see cref="Maybe{T}.NoneImpl"/> object.
+	/// Implicitly convert a <see cref="Wrap.None"/> into a <see cref="Maybe{T}.NoneImpl"/> object.
 	/// </summary>
 	/// <param name="_">None value (discarded).</param>
 	public static implicit operator Maybe<T>(None _) =>
-		new NoneImpl();
+		None;
 
 	/// <summary>
 	/// Implicitly convert a <see cref="Monad{T}"/> into a <see cref="Maybe{T}"/> object.

From 6808d8b7ff694d8c95c48aa53931c6e42539425a Mon Sep 17 00:00:00 2001
From: bfren <bf@bfren.dev>
Date: Fri, 27 Feb 2026 10:16:56 +0000
Subject: [PATCH 07/18] Re-adding ++ to F.Format - #61

---
 src/Common/Functions/F.Format.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Common/Functions/F.Format.cs b/src/Common/Functions/F.Format.cs
index 9a76cfed..28c63eb0 100644
--- a/src/Common/Functions/F.Format.cs
+++ b/src/Common/Functions/F.Format.cs
@@ -62,7 +62,7 @@ public static string Format<T>(string formatString, T source, string? replaceIfN
 					val,
 
 				// Source array - get next item in array for named template
-				Array arr when !numberedTemplates && replaceIndex < arr.Length && arr.GetValue(replaceIndex) is object val =>
+				Array arr when !numberedTemplates && replaceIndex < arr.Length && arr.GetValue(replaceIndex++) is object val =>
 					val,
 
 				// Source object - get matching property value for named template

From af3d87849348296bd8ab2a027f8b73e9f7f837d2 Mon Sep 17 00:00:00 2001
From: bfren <bf@bfren.dev>
Date: Fri, 27 Feb 2026 10:21:29 +0000
Subject: [PATCH 08/18] Caching reflection calls - #61

---
 src/Common/Functions/F.GetGenericTypeArguments.cs | 11 ++++++++---
 src/Common/Functions/F.IsNullableValueType.cs     | 13 ++++++-------
 2 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/src/Common/Functions/F.GetGenericTypeArguments.cs b/src/Common/Functions/F.GetGenericTypeArguments.cs
index fd1f6433..0196a678 100644
--- a/src/Common/Functions/F.GetGenericTypeArguments.cs
+++ b/src/Common/Functions/F.GetGenericTypeArguments.cs
@@ -2,12 +2,16 @@
 // Copyright (c) bfren - licensed under https://mit.bfren.dev/2019
 
 using System;
+using System.Collections.Concurrent;
 using System.Linq;
 
 namespace Wrap;
 
 public static partial class F
 {
+	internal static readonly ConcurrentDictionary<(Type type, Type genericType), Type[]> GenericTypeCache =
+		new();
+
 	/// <summary>
 	/// Get generic type arguments if <paramref name="type"/> implements <paramref name="genericType"/>.
 	/// </summary>
@@ -19,10 +23,11 @@ internal static Type[] GetGenericTypeArguments(Type type, Type genericType) =>
 		// If     .. the interface is a generic type (i.e. has generic type arguments)
 		//        .. and the generic type definition is genericType
 		// Select .. all generic type arguments: the Either implementation type and left / right value types
+		GenericTypeCache.GetOrAdd((type, genericType), static key =>
 		[..
-			from i in type.GetInterfaces()
-			where i.IsGenericType && i.GetGenericTypeDefinition() == genericType
+			from i in key.type.GetInterfaces()
+			where i.IsGenericType && i.GetGenericTypeDefinition() == key.genericType
 			from a in i.GenericTypeArguments
 			select a
-		];
+		]);
 }
diff --git a/src/Common/Functions/F.IsNullableValueType.cs b/src/Common/Functions/F.IsNullableValueType.cs
index ce076d9b..ae043dda 100644
--- a/src/Common/Functions/F.IsNullableValueType.cs
+++ b/src/Common/Functions/F.IsNullableValueType.cs
@@ -14,12 +14,11 @@ public static partial class F
 	/// <param name="_">The object is unneeded.</param>
 	/// <returns>True if <typeparamref name="T"/> is a nullable value type.</returns>
 	public static bool IsNullableValueType<T>(T _) =>
-		typeof(T) switch
-		{
-			Type t when t.IsValueType && Nullable.GetUnderlyingType(t) is not null =>
-				true,
+		NullableHelper<T>.IsNullable;
 
-			_ =>
-				false
-		};
+	private static class NullableHelper<T>
+	{
+		public static readonly bool IsNullable =
+			typeof(T).IsValueType && Nullable.GetUnderlyingType(typeof(T)) is not null;
+	}
 }

From 3fe35d03d005f68f96ada82d322eee3b48d913fa Mon Sep 17 00:00:00 2001
From: bfren <bf@bfren.dev>
Date: Fri, 27 Feb 2026 10:29:55 +0000
Subject: [PATCH 09/18] Optimising GetHashCode / Equals hot paths - #61

---
 src/Maybe/Maybe.Equatable.cs                  | 25 ++++---------------
 src/Result/Result.Equatable.cs                | 25 ++++---------------
 tests/Tests.Maybe/_/Maybe/Equals_Tests.cs     | 20 +++++++--------
 .../Tests.Maybe/_/Maybe/GetHashCode_Tests.cs  |  8 +++---
 tests/Tests.Result/_/Result/Equals_Tests.cs   | 20 +++++++--------
 .../_/Result/GetHashCode_Tests.cs             |  8 +++---
 6 files changed, 34 insertions(+), 72 deletions(-)

diff --git a/src/Maybe/Maybe.Equatable.cs b/src/Maybe/Maybe.Equatable.cs
index 5aafb90d..64d807be 100644
--- a/src/Maybe/Maybe.Equatable.cs
+++ b/src/Maybe/Maybe.Equatable.cs
@@ -21,10 +21,7 @@ public virtual bool Equals(Maybe<T>? other) =>
 
 	/// <inheritdoc/>
 	public override int GetHashCode() =>
-		M.Match(this,
-			fNone: M.None.GetHashCode,
-			fSome: x => x.GetHashCode()
-		);
+		this is Some<T> s ? s.Value?.GetHashCode() ?? 0 : 0;
 
 	/// <summary>
 	/// Compare a Maybe type with a value type.
@@ -34,10 +31,7 @@ public override int GetHashCode() =>
 	/// <param name="r">Value.</param>
 	/// <returns>True if <paramref name="l"/> is <see cref="Some{T}"/> and its value equals <paramref name="r"/>.</returns>
 	public static bool operator ==(Maybe<T> l, T r) =>
-		M.Match(l,
-			fNone: () => false,
-			fSome: x => Equals(x, r)
-		);
+		l is Some<T> s && Equals(s.Value, r);
 
 	/// <summary>
 	/// Compare a Maybe type with a value type.
@@ -47,10 +41,7 @@ public override int GetHashCode() =>
 	/// <param name="r">Value.</param>
 	/// <returns>True if <paramref name="l"/> is <see cref="Some{T}"/> and its value does not equal <paramref name="r"/>.</returns>
 	public static bool operator !=(Maybe<T> l, T r) =>
-		M.Match(l,
-			fNone: () => true,
-			fSome: x => !Equals(x, r)
-		);
+		!(l is Some<T> s && Equals(s.Value, r));
 
 	/// <summary>
 	/// Compare a Maybe type with a value type.
@@ -60,10 +51,7 @@ public override int GetHashCode() =>
 	/// <param name="r">Maybe.</param>
 	/// <returns>True if <paramref name="r"/> is <see cref="Some{T}"/> and its value equals <paramref name="l"/>.</returns>
 	public static bool operator ==(T l, Maybe<T> r) =>
-		M.Match(r,
-			fNone: () => false,
-			fSome: x => Equals(x, l)
-		);
+		r is Some<T> s && Equals(s.Value, l);
 
 	/// <summary>
 	/// Compare a Maybe type with a value type.
@@ -73,8 +61,5 @@ public override int GetHashCode() =>
 	/// <param name="r">Maybe.</param>
 	/// <returns>True if <paramref name="r"/> is <see cref="Some{T}"/> and its value does not equal <paramref name="l"/>.</returns>
 	public static bool operator !=(T l, Maybe<T> r) =>
-		M.Match(r,
-			fNone: () => true,
-			fSome: x => !Equals(x, l)
-		);
+		!(r is Some<T> s && Equals(s.Value, l));
 }
diff --git a/src/Result/Result.Equatable.cs b/src/Result/Result.Equatable.cs
index 0a951359..78318ac7 100644
--- a/src/Result/Result.Equatable.cs
+++ b/src/Result/Result.Equatable.cs
@@ -21,10 +21,7 @@ public virtual bool Equals(Result<T>? other) =>
 
 	/// <inheritdoc/>
 	public override int GetHashCode() =>
-		R.Match(this,
-			fFail: f => f.GetHashCode(),
-			fOk: x => x.GetHashCode()
-		);
+		this is Ok<T> s ? s.Value?.GetHashCode() ?? 0 : 0;
 
 	/// <summary>
 	/// Compare a Result type with a value type.
@@ -34,10 +31,7 @@ public override int GetHashCode() =>
 	/// <param name="r">Value.</param>
 	/// <returns>True if <paramref name="l"/> is <see cref="Ok{T}"/> and its value equals <paramref name="r"/>.</returns>
 	public static bool operator ==(Result<T> l, T r) =>
-		R.Match(l,
-			fFail: _ => false,
-			fOk: x => Equals(x, r)
-		);
+		l is Ok<T> s && Equals(s.Value, r);
 
 	/// <summary>
 	/// Compare a Result type with a value type.
@@ -47,10 +41,7 @@ public override int GetHashCode() =>
 	/// <param name="r">Value.</param>
 	/// <returns>True if <paramref name="l"/> is <see cref="Ok{T}"/> and its value does not equal <paramref name="r"/>.</returns>
 	public static bool operator !=(Result<T> l, T r) =>
-		R.Match(l,
-			fFail: _ => true,
-			fOk: x => !Equals(x, r)
-		);
+		!(l is Ok<T> s && Equals(s.Value, r));
 
 	/// <summary>
 	/// Compare a Result type with a value type.
@@ -60,10 +51,7 @@ public override int GetHashCode() =>
 	/// <param name="r">Result.</param>
 	/// <returns>True if <paramref name="r"/> is <see cref="Ok{T}"/> and its value equals <paramref name="l"/>.</returns>
 	public static bool operator ==(T l, Result<T> r) =>
-		R.Match(r,
-			fFail: _ => false,
-			fOk: x => Equals(x, l)
-		);
+		r is Ok<T> s && Equals(s.Value, l);
 
 	/// <summary>
 	/// Compare a Result type with a value type.
@@ -73,8 +61,5 @@ public override int GetHashCode() =>
 	/// <param name="r">Result.</param>
 	/// <returns>True if <paramref name="r"/> is <see cref="Ok{T}"/> and its value does not equal <paramref name="l"/>.</returns>
 	public static bool operator !=(T l, Result<T> r) =>
-		R.Match(r,
-			fFail: _ => true,
-			fOk: x => !Equals(x, l)
-		);
+		!(r is Ok<T> s && Equals(s.Value, l));
 }
diff --git a/tests/Tests.Maybe/_/Maybe/Equals_Tests.cs b/tests/Tests.Maybe/_/Maybe/Equals_Tests.cs
index 3725de01..d0a47607 100644
--- a/tests/Tests.Maybe/_/Maybe/Equals_Tests.cs
+++ b/tests/Tests.Maybe/_/Maybe/Equals_Tests.cs
@@ -1,8 +1,6 @@
 // Wrap: Unit Tests
 // Copyright (c) bfren - licensed under https://mit.bfren.dev/2019
 
-using Wrap.Exceptions;
-
 namespace Wrap.Maybe_Tests;
 
 public class Equals_Tests
@@ -269,23 +267,23 @@ public void Returns_False()
 		public class With_Value
 		{
 			[Fact]
-			public void Throws_InvalidMaybeTypeException()
+			public void Returns_False()
 			{
 				// Arrange
 				var value = Rnd.Str;
 				var wrapped = new InvalidMaybe<string>();
 
 				// Act
-				var r0 = Record.Exception(() => value == wrapped);
-				var r1 = Record.Exception(() => wrapped == value);
-				var r2 = Record.Exception(() => value != wrapped);
-				var r3 = Record.Exception(() => wrapped != value);
+				var r0 = value == wrapped;
+				var r1 = wrapped == value;
+				var r2 = value != wrapped;
+				var r3 = wrapped != value;
 
 				// Assert
-				_ = Assert.IsType<InvalidMaybeTypeException>(r0);
-				_ = Assert.IsType<InvalidMaybeTypeException>(r1);
-				_ = Assert.IsType<InvalidMaybeTypeException>(r2);
-				_ = Assert.IsType<InvalidMaybeTypeException>(r3);
+				Assert.False(r0);
+				Assert.False(r1);
+				Assert.True(r2);
+				Assert.True(r3);
 			}
 		}
 
diff --git a/tests/Tests.Maybe/_/Maybe/GetHashCode_Tests.cs b/tests/Tests.Maybe/_/Maybe/GetHashCode_Tests.cs
index d3854660..bc5c7848 100644
--- a/tests/Tests.Maybe/_/Maybe/GetHashCode_Tests.cs
+++ b/tests/Tests.Maybe/_/Maybe/GetHashCode_Tests.cs
@@ -1,8 +1,6 @@
 // Wrap: Unit Tests
 // Copyright (c) bfren - licensed under https://mit.bfren.dev/2019
 
-using Wrap.Exceptions;
-
 namespace Wrap.Maybe_Tests;
 
 public class GetHashCode_Tests
@@ -68,16 +66,16 @@ public void Returns_None_HashCode()
 	public class Invalid_Type
 	{
 		[Fact]
-		public void Throws_InvalidMaybeTypeException()
+		public void Returns_Zero()
 		{
 			// Arrange
 			var maybe = new InvalidMaybe<DateTime>();
 
 			// Act
-			var result = Record.Exception(() => maybe.GetHashCode());
+			var result = maybe.GetHashCode();
 
 			// Assert
-			_ = Assert.IsType<InvalidMaybeTypeException>(result);
+			Assert.Equal(0, result);
 		}
 	}
 }
diff --git a/tests/Tests.Result/_/Result/Equals_Tests.cs b/tests/Tests.Result/_/Result/Equals_Tests.cs
index 4de0025e..a16cf0dc 100644
--- a/tests/Tests.Result/_/Result/Equals_Tests.cs
+++ b/tests/Tests.Result/_/Result/Equals_Tests.cs
@@ -1,8 +1,6 @@
 // Wrap: Unit Tests
 // Copyright (c) bfren - licensed under https://mit.bfren.dev/2019
 
-using Wrap.Exceptions;
-
 namespace Wrap.Result_Tests;
 
 public class Equals_Tests
@@ -288,23 +286,23 @@ public void Returns_False()
 		public class With_Value
 		{
 			[Fact]
-			public void Throws_InvalidResultTypeException()
+			public void Returns_False()
 			{
 				// Arrange
 				var value = Rnd.Str;
 				var wrapped = new InvalidResult<string>();
 
 				// Act
-				var r0 = Record.Exception(() => value == wrapped);
-				var r1 = Record.Exception(() => wrapped == value);
-				var r2 = Record.Exception(() => value != wrapped);
-				var r3 = Record.Exception(() => wrapped != value);
+				var r0 = value == wrapped;
+				var r1 = wrapped == value;
+				var r2 = value != wrapped;
+				var r3 = wrapped != value;
 
 				// Assert
-				_ = Assert.IsType<InvalidResultTypeException>(r0);
-				_ = Assert.IsType<InvalidResultTypeException>(r1);
-				_ = Assert.IsType<InvalidResultTypeException>(r2);
-				_ = Assert.IsType<InvalidResultTypeException>(r3);
+				Assert.False(r0);
+				Assert.False(r1);
+				Assert.True(r2);
+				Assert.True(r3);
 			}
 		}
 
diff --git a/tests/Tests.Result/_/Result/GetHashCode_Tests.cs b/tests/Tests.Result/_/Result/GetHashCode_Tests.cs
index 9a133306..e27b7418 100644
--- a/tests/Tests.Result/_/Result/GetHashCode_Tests.cs
+++ b/tests/Tests.Result/_/Result/GetHashCode_Tests.cs
@@ -1,8 +1,6 @@
 // Wrap: Unit Tests
 // Copyright (c) bfren - licensed under https://mit.bfren.dev/2019
 
-using Wrap.Exceptions;
-
 namespace Wrap.Result_Tests;
 
 public class GetHashCode_Tests
@@ -91,16 +89,16 @@ public void Returns_Different_HashCode()
 	public class Invalid_Type
 	{
 		[Fact]
-		public void Throws_InvalidResultTypeException()
+		public void Returns_Zero()
 		{
 			// Arrange
 			var maybe = new InvalidResult<DateTime>();
 
 			// Act
-			var result = Record.Exception(() => maybe.GetHashCode());
+			var result = maybe.GetHashCode();
 
 			// Assert
-			_ = Assert.IsType<InvalidResultTypeException>(result);
+			Assert.Equal(0, result);
 		}
 	}
 }

From 8b18cc5ba2083636ee905ed4a82ec3af37517296 Mon Sep 17 00:00:00 2001
From: bfren <bf@bfren.dev>
Date: Fri, 27 Feb 2026 10:42:02 +0000
Subject: [PATCH 10/18] Adding dedicated sync implementation on WrapCache - #61

---
 src/Caching/WrapCache.cs | 43 ++++++++++++++++++++++++++++++++++++++--
 1 file changed, 41 insertions(+), 2 deletions(-)

diff --git a/src/Caching/WrapCache.cs b/src/Caching/WrapCache.cs
index 79dea3e5..6148bc9e 100644
--- a/src/Caching/WrapCache.cs
+++ b/src/Caching/WrapCache.cs
@@ -108,8 +108,47 @@ 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) =>
-		GetOrCreate(key, valueFactory, new());
+	public Maybe<TValue> GetOrCreate<TValue>(TKey key, Func<Maybe<TValue>> valueFactory)
+	{
+		// Check whether or not the value already exists
+		var value = GetValue<TValue>(key);
+		if (value.IsSome)
+		{
+			return value;
+		}
+
+		// If there was an error, return None
+		if (LastFailure.IsSome)
+		{
+			return M.None;
+		}
+
+		// Lock all threads
+		CacheLock.Wait();
+		try
+		{
+			return valueFactory()
+				.IfNone(
+					() => LastFailure = R.Fail("Value factory returned null or None.")
+						.Ctx(nameof(WrapCache), nameof(GetOrCreate))
+				)
+				.Map(
+					x => Cache.GetOrCreate(key, e => { _ = e.SetValue(x!); return x; })!
+				);
+		}
+		catch (Exception ex)
+		{
+			// Return none on failure
+			LastFailure = R.Fail(ex).Msg("Error creating cache value.")
+				.Ctx(nameof(WrapCache), nameof(GetOrCreate));
+			return M.None;
+		}
+		finally
+		{
+			// Release other threads
+			_ = CacheLock.Release();
+		}
+	}
 
 	/// <inheritdoc/>
 	public Maybe<TValue> GetOrCreate<TValue>(TKey key, Func<Maybe<TValue>> valueFactory, MemoryCacheEntryOptions opt) =>

From df5b12be77ff4ad393cc11c5b547a4373ce7aa93 Mon Sep 17 00:00:00 2001
From: bfren <bf@bfren.dev>
Date: Fri, 27 Feb 2026 10:45:32 +0000
Subject: [PATCH 11/18] Avoiding unnecessary allocation in Match - #61

---
 src/Maybe/Functions/M.Match.cs  | 24 ++++++++++++------------
 src/Result/Functions/R.Match.cs | 24 ++++++++++++------------
 2 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/src/Maybe/Functions/M.Match.cs b/src/Maybe/Functions/M.Match.cs
index 4b1b6e23..fbfa8bed 100644
--- a/src/Maybe/Functions/M.Match.cs
+++ b/src/Maybe/Functions/M.Match.cs
@@ -31,22 +31,22 @@ public static partial class M
 	/// <exception cref="NullMaybeException"></exception>
 	public static void Match<T>(Maybe<T> maybe, Action fNone, Action<T> fSome)
 	{
-		var f = maybe switch
+		switch (maybe)
 		{
-			Maybe<T>.NoneImpl =>
-				fNone,
-
-			Some<T> x =>
-				() => fSome(x.Value),
+			case Maybe<T>.NoneImpl:
+				fNone();
+				return;
 
-			{ } m =>
-				throw new InvalidMaybeTypeException(m.GetType()),
+			case Some<T> x:
+				fSome(x.Value);
+				return;
 
-			_ =>
-				throw new NullMaybeException()
-		};
+			case { } m:
+				throw new InvalidMaybeTypeException(m.GetType());
 
-		f();
+			default:
+				throw new NullMaybeException();
+		}
 	}
 
 	/// <inheritdoc cref="Match{T}(Maybe{T}, Action, Action{T})"/>
diff --git a/src/Result/Functions/R.Match.cs b/src/Result/Functions/R.Match.cs
index 25783b81..1c9907ed 100644
--- a/src/Result/Functions/R.Match.cs
+++ b/src/Result/Functions/R.Match.cs
@@ -31,22 +31,22 @@ public static partial class R
 	/// <exception cref="NullResultException"></exception>
 	public static void Match<T>(Result<T> result, Action<FailureValue> fFail, Action<T> fOk)
 	{
-		Action f = result switch
+		switch (result)
 		{
-			Result<T>.FailureImpl x =>
-				() => fFail(x.Value),
-
-			Ok<T> y =>
-				() => fOk(y.Value),
+			case Result<T>.FailureImpl f:
+				fFail(f.Value);
+				return;
 
-			{ } m =>
-				throw new InvalidResultTypeException(m.GetType()),
+			case Ok<T> x:
+				fOk(x.Value);
+				return;
 
-			_ =>
-				throw new NullResultException()
-		};
+			case { } m:
+				throw new InvalidResultTypeException(m.GetType());
 
-		f();
+			default:
+				throw new NullResultException();
+		}
 	}
 
 	/// <inheritdoc cref="Match{T}(Result{T}, Action{FailureValue}, Action{T})"/>

From 0b2f795461e48187f191cc647de770e751152e7f Mon Sep 17 00:00:00 2001
From: bfren <bf@bfren.dev>
Date: Fri, 27 Feb 2026 10:59:07 +0000
Subject: [PATCH 12/18] Adding direct implementations for all Match async
 overloads - #61

---
 src/Maybe/Functions/M.Match.cs  | 267 +++++++++++++++++++++++++++-----
 src/Result/Functions/R.Match.cs | 267 +++++++++++++++++++++++++++-----
 2 files changed, 460 insertions(+), 74 deletions(-)

diff --git a/src/Maybe/Functions/M.Match.cs b/src/Maybe/Functions/M.Match.cs
index fbfa8bed..a617d7a0 100644
--- a/src/Maybe/Functions/M.Match.cs
+++ b/src/Maybe/Functions/M.Match.cs
@@ -50,48 +50,150 @@ public static void Match<T>(Maybe<T> maybe, Action fNone, Action<T> fSome)
 	}
 
 	/// <inheritdoc cref="Match{T}(Maybe{T}, Action, Action{T})"/>
-	public static Task MatchAsync<T>(Maybe<T> maybe, Action fNone, Func<T, Task> fSome) =>
-		MatchAsync(Task.FromResult(maybe), async () => fNone(), fSome);
+	public static async Task MatchAsync<T>(Maybe<T> maybe, Action fNone, Func<T, Task> fSome)
+	{
+		switch (maybe)
+		{
+			case Maybe<T>.NoneImpl:
+				fNone();
+				return;
+
+			case Some<T> x:
+				await fSome(x.Value);
+				return;
+
+			case { } m:
+				throw new InvalidMaybeTypeException(m.GetType());
+
+			default:
+				throw new NullMaybeException();
+		}
+	}
 
 	/// <inheritdoc cref="Match{T}(Maybe{T}, Action, Action{T})"/>
-	public static Task MatchAsync<T>(Maybe<T> maybe, Func<Task> fNone, Action<T> fSome) =>
-		MatchAsync(Task.FromResult(maybe), fNone, async x => fSome(x));
+	public static async Task MatchAsync<T>(Maybe<T> maybe, Func<Task> fNone, Action<T> fSome)
+	{
+		switch (maybe)
+		{
+			case Maybe<T>.NoneImpl:
+				await fNone();
+				return;
+
+			case Some<T> x:
+				fSome(x.Value);
+				return;
+
+			case { } m:
+				throw new InvalidMaybeTypeException(m.GetType());
+
+			default:
+				throw new NullMaybeException();
+		}
+	}
 
 	/// <inheritdoc cref="Match{T}(Maybe{T}, Action, Action{T})"/>
-	public static Task MatchAsync<T>(Maybe<T> maybe, Func<Task> fNone, Func<T, Task> fSome) =>
-		MatchAsync(Task.FromResult(maybe), fNone, fSome);
+	public static async Task MatchAsync<T>(Maybe<T> maybe, Func<Task> fNone, Func<T, Task> fSome)
+	{
+		switch (maybe)
+		{
+			case Maybe<T>.NoneImpl:
+				await fNone();
+				return;
+
+			case Some<T> x:
+				await fSome(x.Value);
+				return;
+
+			case { } m:
+				throw new InvalidMaybeTypeException(m.GetType());
+
+			default:
+				throw new NullMaybeException();
+		}
+	}
 
 	/// <inheritdoc cref="Match{T}(Maybe{T}, Action, Action{T})"/>
-	public static Task MatchAsync<T>(Task<Maybe<T>> maybe, Action fNone, Action<T> fSome) =>
-		MatchAsync(maybe, async () => fNone(), async x => fSome(x));
+	public static async Task MatchAsync<T>(Task<Maybe<T>> maybe, Action fNone, Action<T> fSome)
+	{
+		switch (await maybe)
+		{
+			case Maybe<T>.NoneImpl:
+				fNone();
+				return;
+
+			case Some<T> x:
+				fSome(x.Value);
+				return;
+
+			case { } m:
+				throw new InvalidMaybeTypeException(m.GetType());
+
+			default:
+				throw new NullMaybeException();
+		}
+	}
 
 	/// <inheritdoc cref="Match{T}(Maybe{T}, Action, Action{T})"/>
-	public static Task MatchAsync<T>(Task<Maybe<T>> maybe, Action fNone, Func<T, Task> fSome) =>
-		MatchAsync(maybe, async () => fNone(), fSome);
+	public static async Task MatchAsync<T>(Task<Maybe<T>> maybe, Action fNone, Func<T, Task> fSome)
+	{
+		switch (await maybe)
+		{
+			case Maybe<T>.NoneImpl:
+				fNone();
+				return;
+
+			case Some<T> x:
+				await fSome(x.Value);
+				return;
+
+			case { } m:
+				throw new InvalidMaybeTypeException(m.GetType());
+
+			default:
+				throw new NullMaybeException();
+		}
+	}
 
 	/// <inheritdoc cref="Match{T}(Maybe{T}, Action, Action{T})"/>
-	public static Task MatchAsync<T>(Task<Maybe<T>> maybe, Func<Task> fNone, Action<T> fSome) =>
-		MatchAsync(maybe, fNone, async x => fSome(x));
+	public static async Task MatchAsync<T>(Task<Maybe<T>> maybe, Func<Task> fNone, Action<T> fSome)
+	{
+		switch (await maybe)
+		{
+			case Maybe<T>.NoneImpl:
+				await fNone();
+				return;
+
+			case Some<T> x:
+				fSome(x.Value);
+				return;
+
+			case { } m:
+				throw new InvalidMaybeTypeException(m.GetType());
+
+			default:
+				throw new NullMaybeException();
+		}
+	}
 
 	/// <inheritdoc cref="Match{T}(Maybe{T}, Action, Action{T})"/>
 	public static async Task MatchAsync<T>(Task<Maybe<T>> maybe, Func<Task> fNone, Func<T, Task> fSome)
 	{
-		var f = await maybe switch
+		switch (await maybe)
 		{
-			Maybe<T>.NoneImpl =>
-				fNone,
-
-			Some<T> x =>
-				() => fSome(x.Value),
+			case Maybe<T>.NoneImpl:
+				await fNone();
+				return;
 
-			{ } m =>
-				throw new InvalidMaybeTypeException(m.GetType()),
+			case Some<T> x:
+				await fSome(x.Value);
+				return;
 
-			_ =>
-				throw new NullMaybeException()
-		};
+			case { } m:
+				throw new InvalidMaybeTypeException(m.GetType());
 
-		await f();
+			default:
+				throw new NullMaybeException();
+		}
 	}
 
 	#endregion
@@ -135,32 +237,123 @@ public static TReturn Match<T, TReturn>(Maybe<T> maybe, Func<TReturn> fNone, Fun
 		};
 
 	/// <inheritdoc cref="Match{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, TReturn})"/>
-	public static Task<TReturn> MatchAsync<T, TReturn>(Maybe<T> maybe, Func<TReturn> fNone, Func<T, Task<TReturn>> fSome) =>
-		Match(maybe, async () => fNone(), fSome);
+	public static async Task<TReturn> MatchAsync<T, TReturn>(Maybe<T> maybe, Func<TReturn> fNone, Func<T, Task<TReturn>> fSome) =>
+		maybe switch
+		{
+			Maybe<T>.NoneImpl =>
+				fNone(),
+
+			Some<T> x =>
+				await fSome(x.Value),
+
+			{ } m =>
+				throw new InvalidMaybeTypeException(m.GetType()),
+
+			_ =>
+				throw new NullMaybeException()
+		};
 
 	/// <inheritdoc cref="Match{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, TReturn})"/>
-	public static Task<TReturn> MatchAsync<T, TReturn>(Maybe<T> maybe, Func<Task<TReturn>> fNone, Func<T, TReturn> fSome) =>
-		Match(maybe, fNone, async x => fSome(x));
+	public static async Task<TReturn> MatchAsync<T, TReturn>(Maybe<T> maybe, Func<Task<TReturn>> fNone, Func<T, TReturn> fSome) =>
+		maybe switch
+		{
+			Maybe<T>.NoneImpl =>
+				await fNone(),
+
+			Some<T> x =>
+				fSome(x.Value),
+
+			{ } m =>
+				throw new InvalidMaybeTypeException(m.GetType()),
+
+			_ =>
+				throw new NullMaybeException()
+		};
 
 	/// <inheritdoc cref="Match{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, TReturn})"/>
-	public static Task<TReturn> MatchAsync<T, TReturn>(Maybe<T> maybe, Func<Task<TReturn>> fNone, Func<T, Task<TReturn>> fSome) =>
-		Match(maybe, fNone, fSome);
+	public static async Task<TReturn> MatchAsync<T, TReturn>(Maybe<T> maybe, Func<Task<TReturn>> fNone, Func<T, Task<TReturn>> fSome) =>
+		maybe switch
+		{
+			Maybe<T>.NoneImpl =>
+				await fNone(),
+
+			Some<T> x =>
+				await fSome(x.Value),
+
+			{ } m =>
+				throw new InvalidMaybeTypeException(m.GetType()),
+
+			_ =>
+				throw new NullMaybeException()
+		};
 
 	/// <inheritdoc cref="Match{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, TReturn})"/>
-	public static Task<TReturn> MatchAsync<T, TReturn>(Task<Maybe<T>> maybe, Func<TReturn> fNone, Func<T, TReturn> fSome) =>
-		MatchAsync(maybe, async () => fNone(), async x => fSome(x));
+	public static async Task<TReturn> MatchAsync<T, TReturn>(Task<Maybe<T>> maybe, Func<TReturn> fNone, Func<T, TReturn> fSome) =>
+		await maybe switch
+		{
+			Maybe<T>.NoneImpl =>
+				fNone(),
+
+			Some<T> x =>
+				fSome(x.Value),
+
+			{ } m =>
+				throw new InvalidMaybeTypeException(m.GetType()),
+
+			_ =>
+				throw new NullMaybeException()
+		};
 
 	/// <inheritdoc cref="Match{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, TReturn})"/>
-	public static Task<TReturn> MatchAsync<T, TReturn>(Task<Maybe<T>> maybe, Func<TReturn> fNone, Func<T, Task<TReturn>> fSome) =>
-		MatchAsync(maybe, async () => fNone(), fSome);
+	public static async Task<TReturn> MatchAsync<T, TReturn>(Task<Maybe<T>> maybe, Func<TReturn> fNone, Func<T, Task<TReturn>> fSome) =>
+		await maybe switch
+		{
+			Maybe<T>.NoneImpl =>
+				fNone(),
+
+			Some<T> x =>
+				await fSome(x.Value),
+
+			{ } m =>
+				throw new InvalidMaybeTypeException(m.GetType()),
+
+			_ =>
+				throw new NullMaybeException()
+		};
 
 	/// <inheritdoc cref="Match{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, TReturn})"/>
-	public static Task<TReturn> MatchAsync<T, TReturn>(Task<Maybe<T>> maybe, Func<Task<TReturn>> fNone, Func<T, TReturn> fSome) =>
-		MatchAsync(maybe, fNone, async x => fSome(x));
+	public static async Task<TReturn> MatchAsync<T, TReturn>(Task<Maybe<T>> maybe, Func<Task<TReturn>> fNone, Func<T, TReturn> fSome) =>
+		await maybe switch
+		{
+			Maybe<T>.NoneImpl =>
+				await fNone(),
+
+			Some<T> x =>
+				fSome(x.Value),
+
+			{ } m =>
+				throw new InvalidMaybeTypeException(m.GetType()),
+
+			_ =>
+				throw new NullMaybeException()
+		};
 
 	/// <inheritdoc cref="Match{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, TReturn})"/>
 	public static async Task<TReturn> MatchAsync<T, TReturn>(Task<Maybe<T>> maybe, Func<Task<TReturn>> fNone, Func<T, Task<TReturn>> fSome) =>
-		await Match(await maybe, fNone, fSome);
+		await maybe switch
+		{
+			Maybe<T>.NoneImpl =>
+				await fNone(),
+
+			Some<T> x =>
+				await fSome(x.Value),
+
+			{ } m =>
+				throw new InvalidMaybeTypeException(m.GetType()),
+
+			_ =>
+				throw new NullMaybeException()
+		};
 
 	#endregion
 }
diff --git a/src/Result/Functions/R.Match.cs b/src/Result/Functions/R.Match.cs
index 1c9907ed..bb260878 100644
--- a/src/Result/Functions/R.Match.cs
+++ b/src/Result/Functions/R.Match.cs
@@ -50,48 +50,150 @@ public static void Match<T>(Result<T> result, Action<FailureValue> fFail, Action
 	}
 
 	/// <inheritdoc cref="Match{T}(Result{T}, Action{FailureValue}, Action{T})"/>
-	public static Task MatchAsync<T>(Result<T> result, Action<FailureValue> fFail, Func<T, Task> fOk) =>
-		MatchAsync(Task.FromResult(result), async x => fFail(x), fOk);
+	public static async Task MatchAsync<T>(Result<T> result, Action<FailureValue> fFail, Func<T, Task> fOk)
+	{
+		switch (result)
+		{
+			case Result<T>.FailureImpl f:
+				fFail(f.Value);
+				return;
+
+			case Ok<T> x:
+				await fOk(x.Value);
+				return;
+
+			case { } m:
+				throw new InvalidResultTypeException(m.GetType());
+
+			default:
+				throw new NullResultException();
+		}
+	}
 
 	/// <inheritdoc cref="Match{T}(Result{T}, Action{FailureValue}, Action{T})"/>
-	public static Task MatchAsync<T>(Result<T> result, Func<FailureValue, Task> fFail, Action<T> fOk) =>
-		MatchAsync(Task.FromResult(result), fFail, async x => fOk(x));
+	public static async Task MatchAsync<T>(Result<T> result, Func<FailureValue, Task> fFail, Action<T> fOk)
+	{
+		switch (result)
+		{
+			case Result<T>.FailureImpl f:
+				await fFail(f.Value);
+				return;
+
+			case Ok<T> x:
+				fOk(x.Value);
+				return;
+
+			case { } m:
+				throw new InvalidResultTypeException(m.GetType());
+
+			default:
+				throw new NullResultException();
+		}
+	}
 
 	/// <inheritdoc cref="Match{T}(Result{T}, Action{FailureValue}, Action{T})"/>
-	public static Task MatchAsync<T>(Result<T> result, Func<FailureValue, Task> fFail, Func<T, Task> fOk) =>
-		MatchAsync(Task.FromResult(result), fFail, fOk);
+	public static async Task MatchAsync<T>(Result<T> result, Func<FailureValue, Task> fFail, Func<T, Task> fOk)
+	{
+		switch (result)
+		{
+			case Result<T>.FailureImpl f:
+				await fFail(f.Value);
+				return;
+
+			case Ok<T> x:
+				await fOk(x.Value);
+				return;
+
+			case { } m:
+				throw new InvalidResultTypeException(m.GetType());
+
+			default:
+				throw new NullResultException();
+		}
+	}
 
 	/// <inheritdoc cref="Match{T}(Result{T}, Action{FailureValue}, Action{T})"/>
-	public static Task MatchAsync<T>(Task<Result<T>> result, Action<FailureValue> fFail, Action<T> fOk) =>
-		MatchAsync(result, async f => fFail(f), async x => fOk(x));
+	public static async Task MatchAsync<T>(Task<Result<T>> result, Action<FailureValue> fFail, Action<T> fOk)
+	{
+		switch (await result)
+		{
+			case Result<T>.FailureImpl f:
+				fFail(f.Value);
+				return;
+
+			case Ok<T> x:
+				fOk(x.Value);
+				return;
+
+			case { } m:
+				throw new InvalidResultTypeException(m.GetType());
+
+			default:
+				throw new NullResultException();
+		}
+	}
 
 	/// <inheritdoc cref="Match{T}(Result{T}, Action{FailureValue}, Action{T})"/>
-	public static Task MatchAsync<T>(Task<Result<T>> result, Func<FailureValue, Task> fFail, Action<T> fOk) =>
-		MatchAsync(result, fFail, async x => fOk(x));
+	public static async Task MatchAsync<T>(Task<Result<T>> result, Func<FailureValue, Task> fFail, Action<T> fOk)
+	{
+		switch (await result)
+		{
+			case Result<T>.FailureImpl f:
+				await fFail(f.Value);
+				return;
+
+			case Ok<T> x:
+				fOk(x.Value);
+				return;
+
+			case { } m:
+				throw new InvalidResultTypeException(m.GetType());
+
+			default:
+				throw new NullResultException();
+		}
+	}
 
 	/// <inheritdoc cref="Match{T}(Result{T}, Action{FailureValue}, Action{T})"/>
-	public static Task MatchAsync<T>(Task<Result<T>> result, Action<FailureValue> fFail, Func<T, Task> fOk) =>
-		MatchAsync(result, async f => fFail(f), fOk);
+	public static async Task MatchAsync<T>(Task<Result<T>> result, Action<FailureValue> fFail, Func<T, Task> fOk)
+	{
+		switch (await result)
+		{
+			case Result<T>.FailureImpl f:
+				fFail(f.Value);
+				return;
+
+			case Ok<T> x:
+				await fOk(x.Value);
+				return;
+
+			case { } m:
+				throw new InvalidResultTypeException(m.GetType());
+
+			default:
+				throw new NullResultException();
+		}
+	}
 
 	/// <inheritdoc cref="Match{T}(Result{T}, Action{FailureValue}, Action{T})"/>
 	public static async Task MatchAsync<T>(Task<Result<T>> result, Func<FailureValue, Task> fFail, Func<T, Task> fOk)
 	{
-		Func<Task> f = await result switch
+		switch (await result)
 		{
-			Result<T>.FailureImpl x =>
-				() => fFail(x.Value),
-
-			Ok<T> y =>
-				() => fOk(y.Value),
+			case Result<T>.FailureImpl f:
+				await fFail(f.Value);
+				return;
 
-			{ } r =>
-				throw new InvalidResultTypeException(r.GetType()),
+			case Ok<T> x:
+				await fOk(x.Value);
+				return;
 
-			_ =>
-				throw new NullResultException()
-		};
+			case { } m:
+				throw new InvalidResultTypeException(m.GetType());
 
-		await f();
+			default:
+				throw new NullResultException();
+		}
 	}
 
 	#endregion
@@ -135,32 +237,123 @@ public static TReturn Match<T, TReturn>(Result<T> result, Func<FailureValue, TRe
 		};
 
 	/// <inheritdoc cref="Match{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, TReturn})"/>
-	public static Task<TReturn> MatchAsync<T, TReturn>(Result<T> result, Func<FailureValue, TReturn> fFail, Func<T, Task<TReturn>> fOk) =>
-		MatchAsync(Task.FromResult(result), async x => fFail(x), fOk);
+	public static async Task<TReturn> MatchAsync<T, TReturn>(Result<T> result, Func<FailureValue, TReturn> fFail, Func<T, Task<TReturn>> fOk) =>
+		result switch
+		{
+			Result<T>.FailureImpl x =>
+				fFail(x.Value),
+
+			Ok<T> y =>
+				await fOk(y.Value),
+
+			{ } r =>
+				throw new InvalidResultTypeException(r.GetType()),
+
+			_ =>
+				throw new NullResultException()
+		};
 
 	/// <inheritdoc cref="Match{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, TReturn})"/>
-	public static Task<TReturn> MatchAsync<T, TReturn>(Result<T> result, Func<FailureValue, Task<TReturn>> fFail, Func<T, TReturn> fOk) =>
-		MatchAsync(Task.FromResult(result), fFail, async x => fOk(x));
+	public static async Task<TReturn> MatchAsync<T, TReturn>(Result<T> result, Func<FailureValue, Task<TReturn>> fFail, Func<T, TReturn> fOk) =>
+		result switch
+		{
+			Result<T>.FailureImpl x =>
+				await fFail(x.Value),
+
+			Ok<T> y =>
+				fOk(y.Value),
+
+			{ } r =>
+				throw new InvalidResultTypeException(r.GetType()),
+
+			_ =>
+				throw new NullResultException()
+		};
 
 	/// <inheritdoc cref="Match{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, TReturn})"/>
-	public static Task<TReturn> MatchAsync<T, TReturn>(Result<T> result, Func<FailureValue, Task<TReturn>> fFail, Func<T, Task<TReturn>> fOk) =>
-		MatchAsync(Task.FromResult(result), fFail, fOk);
+	public static async Task<TReturn> MatchAsync<T, TReturn>(Result<T> result, Func<FailureValue, Task<TReturn>> fFail, Func<T, Task<TReturn>> fOk) =>
+		result switch
+		{
+			Result<T>.FailureImpl x =>
+				await fFail(x.Value),
+
+			Ok<T> y =>
+				await fOk(y.Value),
+
+			{ } r =>
+				throw new InvalidResultTypeException(r.GetType()),
+
+			_ =>
+				throw new NullResultException()
+		};
 
 	/// <inheritdoc cref="Match{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, TReturn})"/>
-	public static Task<TReturn> MatchAsync<T, TReturn>(Task<Result<T>> result, Func<FailureValue, TReturn> fFail, Func<T, TReturn> fOk) =>
-		MatchAsync(result, async x => fFail(x), async x => fOk(x));
+	public static async Task<TReturn> MatchAsync<T, TReturn>(Task<Result<T>> result, Func<FailureValue, TReturn> fFail, Func<T, TReturn> fOk) =>
+		await result switch
+		{
+			Result<T>.FailureImpl x =>
+				fFail(x.Value),
+
+			Ok<T> y =>
+				fOk(y.Value),
+
+			{ } r =>
+				throw new InvalidResultTypeException(r.GetType()),
+
+			_ =>
+				throw new NullResultException()
+		};
 
 	/// <inheritdoc cref="Match{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, TReturn})"/>
-	public static Task<TReturn> MatchAsync<T, TReturn>(Task<Result<T>> result, Func<FailureValue, TReturn> fFail, Func<T, Task<TReturn>> fOk) =>
-		MatchAsync(result, async x => fFail(x), fOk);
+	public static async Task<TReturn> MatchAsync<T, TReturn>(Task<Result<T>> result, Func<FailureValue, TReturn> fFail, Func<T, Task<TReturn>> fOk) =>
+		await result switch
+		{
+			Result<T>.FailureImpl x =>
+				fFail(x.Value),
+
+			Ok<T> y =>
+				await fOk(y.Value),
+
+			{ } r =>
+				throw new InvalidResultTypeException(r.GetType()),
+
+			_ =>
+				throw new NullResultException()
+		};
 
 	/// <inheritdoc cref="Match{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, TReturn})"/>
-	public static Task<TReturn> MatchAsync<T, TReturn>(Task<Result<T>> result, Func<FailureValue, Task<TReturn>> fFail, Func<T, TReturn> fOk) =>
-		MatchAsync(result, fFail, async x => fOk(x));
+	public static async Task<TReturn> MatchAsync<T, TReturn>(Task<Result<T>> result, Func<FailureValue, Task<TReturn>> fFail, Func<T, TReturn> fOk) =>
+		await result switch
+		{
+			Result<T>.FailureImpl x =>
+				await fFail(x.Value),
+
+			Ok<T> y =>
+				fOk(y.Value),
+
+			{ } r =>
+				throw new InvalidResultTypeException(r.GetType()),
+
+			_ =>
+				throw new NullResultException()
+		};
 
 	/// <inheritdoc cref="Match{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, TReturn})"/>
 	public static async Task<TReturn> MatchAsync<T, TReturn>(Task<Result<T>> result, Func<FailureValue, Task<TReturn>> fFail, Func<T, Task<TReturn>> fOk) =>
-		await Match(await result, fFail, fOk);
+		await result switch
+		{
+			Result<T>.FailureImpl x =>
+				await fFail(x.Value),
+
+			Ok<T> y =>
+				await fOk(y.Value),
+
+			{ } r =>
+				throw new InvalidResultTypeException(r.GetType()),
+
+			_ =>
+				throw new NullResultException()
+		};
 
 	#endregion
 }

From 40c6e21f9dc70ae191f8e13f4987d9cb1d91335b Mon Sep 17 00:00:00 2001
From: bfren <bf@bfren.dev>
Date: Fri, 27 Feb 2026 11:05:39 +0000
Subject: [PATCH 13/18] Adding direct implementations for all Match async
 overloads - #61

---
 src/Either/Functions/E.Match.cs | 231 +++++++++++++++++++++++++++-----
 1 file changed, 195 insertions(+), 36 deletions(-)

diff --git a/src/Either/Functions/E.Match.cs b/src/Either/Functions/E.Match.cs
index 3a25e950..826ea211 100644
--- a/src/Either/Functions/E.Match.cs
+++ b/src/Either/Functions/E.Match.cs
@@ -34,43 +34,111 @@ public static partial class E
 	public static void Match<TEither, TLeft, TRight>(TEither either, Action<TLeft> fLeft, Action<TRight> fRight)
 		where TEither : IEither<TEither, TLeft, TRight>
 	{
-		Action f = either switch
+		switch (either)
 		{
-			ILeft<TLeft, TRight> x =>
-				() => fLeft(x.Value),
-
-			IRight<TLeft, TRight> y =>
-				() => fRight(y.Value),
+			case ILeft<TLeft, TRight> x:
+				fLeft(x.Value);
+				return;
 
-			{ } m =>
-				throw new InvalidEitherTypeException(m.GetType()),
+			case IRight<TLeft, TRight> y:
+				fRight(y.Value);
+				return;
 
-			_ =>
-				throw new NullEitherException()
-		};
+			case { } m:
+				throw new InvalidEitherTypeException(m.GetType());
 
-		f();
+			default:
+				throw new NullEitherException();
+		}
 	}
 
 	/// <inheritdoc cref="Match{TEither, TLeft, TRight}(TEither, Action{TLeft}, Action{TRight})"/>
-	public static Task MatchAsync<TEither, TLeft, TRight>(TEither either, Action<TLeft> fLeft, Func<TRight, Task> fRight)
-		where TEither : IEither<TEither, TLeft, TRight> =>
-		MatchAsync<TEither, TLeft, TRight>(either.AsTask(), async x => fLeft(x), fRight);
+	public static async Task MatchAsync<TEither, TLeft, TRight>(TEither either, Action<TLeft> fLeft, Func<TRight, Task> fRight)
+		where TEither : IEither<TEither, TLeft, TRight>
+	{
+		switch (either)
+		{
+			case ILeft<TLeft, TRight> x:
+				fLeft(x.Value);
+				return;
+
+			case IRight<TLeft, TRight> y:
+				await fRight(y.Value);
+				return;
+
+			case { } m:
+				throw new InvalidEitherTypeException(m.GetType());
+
+			default:
+				throw new NullEitherException();
+		}
+	}
 
 	/// <inheritdoc cref="Match{TEither, TLeft, TRight}(TEither, Action{TLeft}, Action{TRight})"/>
-	public static Task MatchAsync<TEither, TLeft, TRight>(TEither either, Func<TLeft, Task> fLeft, Action<TRight> fRight)
-		where TEither : IEither<TEither, TLeft, TRight> =>
-		MatchAsync<TEither, TLeft, TRight>(either.AsTask(), fLeft, async x => fRight(x));
+	public static async Task MatchAsync<TEither, TLeft, TRight>(TEither either, Func<TLeft, Task> fLeft, Action<TRight> fRight)
+		where TEither : IEither<TEither, TLeft, TRight>
+	{
+		switch (either)
+		{
+			case ILeft<TLeft, TRight> x:
+				await fLeft(x.Value);
+				return;
+
+			case IRight<TLeft, TRight> y:
+				fRight(y.Value);
+				return;
+
+			case { } m:
+				throw new InvalidEitherTypeException(m.GetType());
+
+			default:
+				throw new NullEitherException();
+		}
+	}
 
 	/// <inheritdoc cref="Match{TEither, TLeft, TRight}(TEither, Action{TLeft}, Action{TRight})"/>
-	public static Task MatchAsync<TEither, TLeft, TRight>(TEither either, Func<TLeft, Task> fLeft, Func<TRight, Task> fRight)
-		where TEither : IEither<TEither, TLeft, TRight> =>
-		MatchAsync(either.AsTask(), fLeft, fRight);
+	public static async Task MatchAsync<TEither, TLeft, TRight>(TEither either, Func<TLeft, Task> fLeft, Func<TRight, Task> fRight)
+		where TEither : IEither<TEither, TLeft, TRight>
+	{
+		switch (either)
+		{
+			case ILeft<TLeft, TRight> x:
+				await fLeft(x.Value);
+				return;
+
+			case IRight<TLeft, TRight> y:
+				await fRight(y.Value);
+				return;
+
+			case { } m:
+				throw new InvalidEitherTypeException(m.GetType());
+
+			default:
+				throw new NullEitherException();
+		}
+	}
 
 	/// <inheritdoc cref="Match{TEither, TLeft, TRight}(TEither, Action{TLeft}, Action{TRight})"/>
 	public static async Task MatchAsync<TEither, TLeft, TRight>(Task<TEither> either, Func<TLeft, Task> fLeft, Func<TRight, Task> fRight)
-		where TEither : IEither<TEither, TLeft, TRight> =>
-		Match<TEither, TLeft, TRight>(await either, async x => await fLeft(x), async x => await fRight(x));
+		where TEither : IEither<TEither, TLeft, TRight>
+	{
+		switch (await either)
+		{
+			case ILeft<TLeft, TRight> x:
+				await fLeft(x.Value);
+				return;
+
+			case IRight<TLeft, TRight> y:
+				await fRight(y.Value);
+				return;
+
+			case { } m:
+				throw new InvalidEitherTypeException(m.GetType());
+
+			default:
+				throw new NullEitherException();
+		}
+	}
 
 	#endregion
 
@@ -116,39 +184,130 @@ public static TReturn Match<TEither, TLeft, TRight, TReturn>(TEither either, Fun
 		};
 
 	/// <inheritdoc cref="Match{TEither, TLeft, TRight, TReturn}(TEither, Func{TLeft, TReturn}, Func{TRight, TReturn})"/>
-	public static Task<TReturn> MatchAsync<TEither, TLeft, TRight, TReturn>(TEither either, Func<TLeft, TReturn> fLeft, Func<TRight, Task<TReturn>> fRight)
+	public static async Task<TReturn> MatchAsync<TEither, TLeft, TRight, TReturn>(TEither either, Func<TLeft, TReturn> fLeft, Func<TRight, Task<TReturn>> fRight)
 		where TEither : IEither<TEither, TLeft, TRight> =>
-		MatchAsync<TEither, TLeft, TRight, TReturn>(either.AsTask(), async x => fLeft(x), fRight);
+		either switch
+		{
+			ILeft<TLeft, TRight> x =>
+				fLeft(x.Value),
+
+			IRight<TLeft, TRight> y =>
+				await fRight(y.Value),
+
+			{ } r =>
+				throw new InvalidEitherTypeException(r.GetType()),
+
+			_ =>
+				throw new NullEitherException()
+		};
 
 	/// <inheritdoc cref="Match{TEither, TLeft, TRight, TReturn}(TEither, Func{TLeft, TReturn}, Func{TRight, TReturn})"/>
-	public static Task<TReturn> MatchAsync<TEither, TLeft, TRight, TReturn>(TEither either, Func<TLeft, Task<TReturn>> fLeft, Func<TRight, TReturn> fRight)
+	public static async Task<TReturn> MatchAsync<TEither, TLeft, TRight, TReturn>(TEither either, Func<TLeft, Task<TReturn>> fLeft, Func<TRight, TReturn> fRight)
 		where TEither : IEither<TEither, TLeft, TRight> =>
-		MatchAsync<TEither, TLeft, TRight, TReturn>(either.AsTask(), fLeft, async x => fRight(x));
+		either switch
+		{
+			ILeft<TLeft, TRight> x =>
+				await fLeft(x.Value),
+
+			IRight<TLeft, TRight> y =>
+				fRight(y.Value),
+
+			{ } r =>
+				throw new InvalidEitherTypeException(r.GetType()),
+
+			_ =>
+				throw new NullEitherException()
+		};
 
 	/// <inheritdoc cref="Match{TEither, TLeft, TRight, TReturn}(TEither, Func{TLeft, TReturn}, Func{TRight, TReturn})"/>
-	public static Task<TReturn> MatchAsync<TEither, TLeft, TRight, TReturn>(TEither either, Func<TLeft, Task<TReturn>> fLeft, Func<TRight, Task<TReturn>> fRight)
+	public static async Task<TReturn> MatchAsync<TEither, TLeft, TRight, TReturn>(TEither either, Func<TLeft, Task<TReturn>> fLeft, Func<TRight, Task<TReturn>> fRight)
 		where TEither : IEither<TEither, TLeft, TRight> =>
-		MatchAsync(either.AsTask(), fLeft, fRight);
+		either switch
+		{
+			ILeft<TLeft, TRight> x =>
+				await fLeft(x.Value),
+
+			IRight<TLeft, TRight> y =>
+				await fRight(y.Value),
+
+			{ } r =>
+				throw new InvalidEitherTypeException(r.GetType()),
+
+			_ =>
+				throw new NullEitherException()
+		};
 
 	/// <inheritdoc cref="Match{TEither, TLeft, TRight, TReturn}(TEither, Func{TLeft, TReturn}, Func{TRight, TReturn})"/>
-	public static Task<TReturn> MatchAsync<TEither, TLeft, TRight, TReturn>(Task<TEither> either, Func<TLeft, TReturn> fLeft, Func<TRight, TReturn> fRight)
+	public static async Task<TReturn> MatchAsync<TEither, TLeft, TRight, TReturn>(Task<TEither> either, Func<TLeft, TReturn> fLeft, Func<TRight, TReturn> fRight)
 		where TEither : IEither<TEither, TLeft, TRight> =>
-		MatchAsync<TEither, TLeft, TRight, TReturn>(either, async x => fLeft(x), async x => fRight(x));
+		await either switch
+		{
+			ILeft<TLeft, TRight> x =>
+				fLeft(x.Value),
+
+			IRight<TLeft, TRight> y =>
+				fRight(y.Value),
+
+			{ } r =>
+				throw new InvalidEitherTypeException(r.GetType()),
+
+			_ =>
+				throw new NullEitherException()
+		};
 
 	/// <inheritdoc cref="Match{TEither, TLeft, TRight, TReturn}(TEither, Func{TLeft, TReturn}, Func{TRight, TReturn})"/>
-	public static Task<TReturn> MatchAsync<TEither, TLeft, TRight, TReturn>(Task<TEither> either, Func<TLeft, TReturn> fLeft, Func<TRight, Task<TReturn>> fRight)
+	public static async Task<TReturn> MatchAsync<TEither, TLeft, TRight, TReturn>(Task<TEither> either, Func<TLeft, TReturn> fLeft, Func<TRight, Task<TReturn>> fRight)
 		where TEither : IEither<TEither, TLeft, TRight> =>
-		MatchAsync<TEither, TLeft, TRight, TReturn>(either, async x => fLeft(x), fRight);
+		await either switch
+		{
+			ILeft<TLeft, TRight> x =>
+				fLeft(x.Value),
+
+			IRight<TLeft, TRight> y =>
+				await fRight(y.Value),
+
+			{ } r =>
+				throw new InvalidEitherTypeException(r.GetType()),
+
+			_ =>
+				throw new NullEitherException()
+		};
 
 	/// <inheritdoc cref="Match{TEither, TLeft, TRight, TReturn}(TEither, Func{TLeft, TReturn}, Func{TRight, TReturn})"/>
-	public static Task<TReturn> MatchAsync<TEither, TLeft, TRight, TReturn>(Task<TEither> either, Func<TLeft, Task<TReturn>> fLeft, Func<TRight, TReturn> fRight)
+	public static async Task<TReturn> MatchAsync<TEither, TLeft, TRight, TReturn>(Task<TEither> either, Func<TLeft, Task<TReturn>> fLeft, Func<TRight, TReturn> fRight)
 		where TEither : IEither<TEither, TLeft, TRight> =>
-		MatchAsync<TEither, TLeft, TRight, TReturn>(either, fLeft, async x => fRight(x));
+		await either switch
+		{
+			ILeft<TLeft, TRight> x =>
+				await fLeft(x.Value),
+
+			IRight<TLeft, TRight> y =>
+				fRight(y.Value),
+
+			{ } r =>
+				throw new InvalidEitherTypeException(r.GetType()),
+
+			_ =>
+				throw new NullEitherException()
+		};
 
 	/// <inheritdoc cref="Match{TEither, TLeft, TRight, TReturn}(TEither, Func{TLeft, TReturn}, Func{TRight, TReturn})"/>
 	public static async Task<TReturn> MatchAsync<TEither, TLeft, TRight, TReturn>(Task<TEither> either, Func<TLeft, Task<TReturn>> fLeft, Func<TRight, Task<TReturn>> fRight)
 		where TEither : IEither<TEither, TLeft, TRight> =>
-		await Match(await either, fLeft, fRight);
+		await either switch
+		{
+			ILeft<TLeft, TRight> x =>
+				await fLeft(x.Value),
+
+			IRight<TLeft, TRight> y =>
+				await fRight(y.Value),
+
+			{ } r =>
+				throw new InvalidEitherTypeException(r.GetType()),
+
+			_ =>
+				throw new NullEitherException()
+		};
 
 	#endregion
 }

From 2c56b1b540e0aa6289901cfa95e52ff87e83de59 Mon Sep 17 00:00:00 2001
From: bfren <bf@bfren.dev>
Date: Fri, 27 Feb 2026 11:32:50 +0000
Subject: [PATCH 14/18] Adding additional If cases and tests - #61

---
 .../Extensions/Maybe/MaybeExtensions.If.cs    | 90 ++++++++++++++++---
 .../Extensions/Result/ResultExtensions.If.cs  | 90 ++++++++++++++++---
 .../MaybeExtensions/IfAsync_Tests.cs          | 72 ++++++++++++---
 .../ResultExtensions/IfAsync_Tests.cs         | 57 ++++++++----
 4 files changed, 262 insertions(+), 47 deletions(-)

diff --git a/src/All/Extensions/Maybe/MaybeExtensions.If.cs b/src/All/Extensions/Maybe/MaybeExtensions.If.cs
index 7648d93f..bb6caaae 100644
--- a/src/All/Extensions/Maybe/MaybeExtensions.If.cs
+++ b/src/All/Extensions/Maybe/MaybeExtensions.If.cs
@@ -32,14 +32,45 @@ public static Maybe<TReturn> If<T, TReturn>(this Maybe<T> @this, Func<T, bool> f
 
 	/// <inheritdoc cref="If{T, TReturn}(Maybe{T}, Func{T, bool}, Func{T, Maybe{TReturn}}, Func{T, Maybe{TReturn}})"/>
 	public static Task<Maybe<TReturn>> IfAsync<T, TReturn>(this Maybe<T> @this, Func<T, bool> fTest, Func<T, Task<Maybe<TReturn>>> fTrue, Func<T, Task<Maybe<TReturn>>> fFalse) =>
-		IfAsync(@this.AsTask(), fTest, fTrue, fFalse);
+		BindAsync(@this,
+			async x => fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
+		);
 
 	/// <inheritdoc cref="If{T, TReturn}(Maybe{T}, Func{T, bool}, Func{T, Maybe{TReturn}}, Func{T, Maybe{TReturn}})"/>
-	public static Task<Maybe<TReturn>> IfAsync<T, TReturn>(this Task<Maybe<T>> @this, Func<T, bool> fTest, Func<T, Maybe<TReturn>> fTrue, Func<T, Maybe<TReturn>> fFalse) =>
-		IfAsync(@this, fTest, async x => fTrue(x), async x => fFalse(x));
+	public static Task<Maybe<TReturn>> IfAsync<T, TReturn>(this Maybe<T> @this, Func<T, bool> fTest, Func<T, Task<Maybe<TReturn>>> fTrue, Func<T, Maybe<TReturn>> fFalse) =>
+		BindAsync(@this,
+			async x => fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
+		);
 
 	/// <inheritdoc cref="If{T, TReturn}(Maybe{T}, Func{T, bool}, Func{T, Maybe{TReturn}}, Func{T, Maybe{TReturn}})"/>
-	public static Task<Maybe<TReturn>> IfAsync<T, TReturn>(this Task<Maybe<T>> @this, Func<T, bool> fTest, Func<T, Task<Maybe<TReturn>>> fTrue, Func<T, Task<Maybe<TReturn>>> fFalse) =>
+	public static Task<Maybe<TReturn>> IfAsync<T, TReturn>(this Maybe<T> @this, Func<T, bool> fTest, Func<T, Maybe<TReturn>> fTrue, Func<T, Task<Maybe<TReturn>>> fFalse) =>
+		BindAsync(@this,
+			async x => fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
+		);
+
+	/// <inheritdoc cref="If{T, TReturn}(Maybe{T}, Func{T, bool}, Func{T, Maybe{TReturn}}, Func{T, Maybe{TReturn}})"/>
+	public static Task<Maybe<TReturn>> IfAsync<T, TReturn>(this Task<Maybe<T>> @this, Func<T, bool> fTest, Func<T, Maybe<TReturn>> fTrue, Func<T, Maybe<TReturn>> fFalse) =>
 		BindAsync(@this,
 			x => fTest(x) switch
 			{
@@ -51,6 +82,45 @@ public static Task<Maybe<TReturn>> IfAsync<T, TReturn>(this Task<Maybe<T>> @this
 			}
 		);
 
+	/// <inheritdoc cref="If{T, TReturn}(Maybe{T}, Func{T, bool}, Func{T, Maybe{TReturn}}, Func{T, Maybe{TReturn}})"/>
+	public static Task<Maybe<TReturn>> IfAsync<T, TReturn>(this Task<Maybe<T>> @this, Func<T, bool> fTest, Func<T, Task<Maybe<TReturn>>> fTrue, Func<T, Maybe<TReturn>> fFalse) =>
+		BindAsync(@this,
+			async x => fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
+		);
+
+	/// <inheritdoc cref="If{T, TReturn}(Maybe{T}, Func{T, bool}, Func{T, Maybe{TReturn}}, Func{T, Maybe{TReturn}})"/>
+	public static Task<Maybe<TReturn>> IfAsync<T, TReturn>(this Task<Maybe<T>> @this, Func<T, bool> fTest, Func<T, Maybe<TReturn>> fTrue, Func<T, Task<Maybe<TReturn>>> fFalse) =>
+		BindAsync(@this,
+			async x => fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
+		);
+
+	/// <inheritdoc cref="If{T, TReturn}(Maybe{T}, Func{T, bool}, Func{T, Maybe{TReturn}}, Func{T, Maybe{TReturn}})"/>
+	public static Task<Maybe<TReturn>> IfAsync<T, TReturn>(this Task<Maybe<T>> @this, Func<T, bool> fTest, Func<T, Task<Maybe<TReturn>>> fTrue, Func<T, Task<Maybe<TReturn>>> fFalse) =>
+		BindAsync(@this,
+			async x => fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
+		);
+
 	#region Special Case - Act if True
 
 	/// <summary>
@@ -66,15 +136,15 @@ public static Maybe<T> If<T>(this Maybe<T> @this, Func<T, bool> fTest, Func<T, M
 
 	/// <inheritdoc cref="If{T}(Maybe{T}, Func{T, bool}, Func{T, Maybe{T}})"/>
 	public static Task<Maybe<T>> IfAsync<T>(this Maybe<T> @this, Func<T, bool> fTest, Func<T, Task<Maybe<T>>> fThen) =>
-		IfAsync(@this.AsTask(), fTest, fThen, async x => x);
+		IfAsync(@this, fTest, fThen, x => x);
 
 	/// <inheritdoc cref="If{T}(Maybe{T}, Func{T, bool}, Func{T, Maybe{T}})"/>
 	public static Task<Maybe<T>> IfAsync<T>(this Task<Maybe<T>> @this, Func<T, bool> fTest, Func<T, Maybe<T>> fThen) =>
-		IfAsync(@this, fTest, async x => fThen(x), async x => x);
+		IfAsync(@this, fTest, fThen, x => x);
 
 	/// <inheritdoc cref="If{T}(Maybe{T}, Func{T, bool}, Func{T, Maybe{T}})"/>
 	public static Task<Maybe<T>> IfAsync<T>(this Task<Maybe<T>> @this, Func<T, bool> fTest, Func<T, Task<Maybe<T>>> fThen) =>
-		IfAsync(@this, fTest, fThen, async x => x);
+		IfAsync(@this, fTest, fThen, x => x);
 
 	#endregion
 
@@ -93,15 +163,15 @@ public static Maybe<T> IfNot<T>(this Maybe<T> @this, Func<T, bool> fTest, Func<T
 
 	/// <inheritdoc cref="IfNot{T}(Maybe{T}, Func{T, bool}, Func{T, Maybe{T}})"/>
 	public static Task<Maybe<T>> IfNotAsync<T>(this Maybe<T> @this, Func<T, bool> fTest, Func<T, Task<Maybe<T>>> fThen) =>
-		IfAsync(@this.AsTask(), fTest, async x => x, fThen);
+		IfAsync(@this, fTest, x => x, fThen);
 
 	/// <inheritdoc cref="IfNot{T}(Maybe{T}, Func{T, bool}, Func{T, Maybe{T}})"/>
 	public static Task<Maybe<T>> IfNotAsync<T>(this Task<Maybe<T>> @this, Func<T, bool> fTest, Func<T, Maybe<T>> fThen) =>
-		IfAsync(@this, fTest, async x => x, async x => fThen(x));
+		IfAsync(@this, fTest, x => x, fThen);
 
 	/// <inheritdoc cref="IfNot{T}(Maybe{T}, Func{T, bool}, Func{T, Maybe{T}})"/>
 	public static Task<Maybe<T>> IfNotAsync<T>(this Task<Maybe<T>> @this, Func<T, bool> fTest, Func<T, Task<Maybe<T>>> fThen) =>
-		IfAsync(@this, fTest, async x => x, fThen);
+		IfAsync(@this, fTest, x => x, fThen);
 
 	#endregion
 }
diff --git a/src/All/Extensions/Result/ResultExtensions.If.cs b/src/All/Extensions/Result/ResultExtensions.If.cs
index c283d969..b99de9f4 100644
--- a/src/All/Extensions/Result/ResultExtensions.If.cs
+++ b/src/All/Extensions/Result/ResultExtensions.If.cs
@@ -30,27 +30,97 @@ public static Result<TReturn> If<T, TReturn>(this Result<T> @this, Func<T, bool>
 			}
 		);
 
+	/// <inheritdoc cref="If{T, TReturn}(Result{T}, Func{T, bool}, Func{T, Result{TReturn}}, Func{T, Result{TReturn}})"/>
+	public static Task<Result<TReturn>> IfAsync<T, TReturn>(this Result<T> @this, Func<T, bool> fTest, Func<T, Task<Result<TReturn>>> fTrue, Func<T, Result<TReturn>> fFalse) =>
+		BindAsync(@this,
+			async x => fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
+		);
+
+	/// <inheritdoc cref="If{T, TReturn}(Result{T}, Func{T, bool}, Func{T, Result{TReturn}}, Func{T, Result{TReturn}})"/>
+	public static Task<Result<TReturn>> IfAsync<T, TReturn>(this Result<T> @this, Func<T, bool> fTest, Func<T, Result<TReturn>> fTrue, Func<T, Task<Result<TReturn>>> fFalse) =>
+		BindAsync(@this,
+			async x => fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
+		);
+
 	/// <inheritdoc cref="If{T, TReturn}(Result{T}, Func{T, bool}, Func{T, Result{TReturn}}, Func{T, Result{TReturn}})"/>
 	public static Task<Result<TReturn>> IfAsync<T, TReturn>(this Result<T> @this, Func<T, bool> fTest, Func<T, Task<Result<TReturn>>> fTrue, Func<T, Task<Result<TReturn>>> fFalse) =>
-		IfAsync(@this.AsTask(), fTest, fTrue, fFalse);
+		BindAsync(@this,
+			async x => fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
+		);
 
 	/// <inheritdoc cref="If{T, TReturn}(Result{T}, Func{T, bool}, Func{T, Result{TReturn}}, Func{T, Result{TReturn}})"/>
 	public static Task<Result<TReturn>> IfAsync<T, TReturn>(this Task<Result<T>> @this, Func<T, bool> fTest, Func<T, Result<TReturn>> fTrue, Func<T, Result<TReturn>> fFalse) =>
-		IfAsync(@this, fTest, async x => fTrue(x), async x => fFalse(x));
+		BindAsync(@this,
+			async x => fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
+		);
 
 	/// <inheritdoc cref="If{T, TReturn}(Result{T}, Func{T, bool}, Func{T, Result{TReturn}}, Func{T, Result{TReturn}})"/>
-	public static Task<Result<TReturn>> IfAsync<T, TReturn>(this Task<Result<T>> @this, Func<T, bool> fTest, Func<T, Task<Result<TReturn>>> fTrue, Func<T, Task<Result<TReturn>>> fFalse) =>
+	public static Task<Result<TReturn>> IfAsync<T, TReturn>(this Task<Result<T>> @this, Func<T, bool> fTest, Func<T, Task<Result<TReturn>>> fTrue, Func<T, Result<TReturn>> fFalse) =>
 		BindAsync(@this,
-			x => fTest(x) switch
+			async x => fTest(x) switch
 			{
 				false =>
 					fFalse(x),
 
+				true =>
+					await fTrue(x)
+			}
+		);
+
+	/// <inheritdoc cref="If{T, TReturn}(Result{T}, Func{T, bool}, Func{T, Result{TReturn}}, Func{T, Result{TReturn}})"/>
+	public static Task<Result<TReturn>> IfAsync<T, TReturn>(this Task<Result<T>> @this, Func<T, bool> fTest, Func<T, Result<TReturn>> fTrue, Func<T, Task<Result<TReturn>>> fFalse) =>
+		BindAsync(@this,
+			async x => fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
 				true =>
 					fTrue(x)
 			}
 		);
 
+	/// <inheritdoc cref="If{T, TReturn}(Result{T}, Func{T, bool}, Func{T, Result{TReturn}}, Func{T, Result{TReturn}})"/>
+	public static Task<Result<TReturn>> IfAsync<T, TReturn>(this Task<Result<T>> @this, Func<T, bool> fTest, Func<T, Task<Result<TReturn>>> fTrue, Func<T, Task<Result<TReturn>>> fFalse) =>
+		BindAsync(@this,
+			async x => fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
+		);
+
 	#region Special Case - Act if True
 
 	/// <summary>
@@ -66,15 +136,15 @@ public static Result<T> If<T>(this Result<T> @this, Func<T, bool> fTest, Func<T,
 
 	/// <inheritdoc cref="If{T}(Result{T}, Func{T, bool}, Func{T, Result{T}})"/>
 	public static Task<Result<T>> IfAsync<T>(this Result<T> @this, Func<T, bool> fTest, Func<T, Task<Result<T>>> fThen) =>
-		IfAsync(@this.AsTask(), fTest, fThen, async x => x);
+		IfAsync(@this, fTest, fThen, x => x);
 
 	/// <inheritdoc cref="If{T}(Result{T}, Func{T, bool}, Func{T, Result{T}})"/>
 	public static Task<Result<T>> IfAsync<T>(this Task<Result<T>> @this, Func<T, bool> fTest, Func<T, Result<T>> fThen) =>
-		IfAsync(@this, fTest, async x => fThen(x), async x => x);
+		IfAsync(@this, fTest, fThen, x => x);
 
 	/// <inheritdoc cref="If{T}(Result{T}, Func{T, bool}, Func{T, Result{T}})"/>
 	public static Task<Result<T>> IfAsync<T>(this Task<Result<T>> @this, Func<T, bool> fTest, Func<T, Task<Result<T>>> fThen) =>
-		IfAsync(@this, fTest, fThen, async x => x);
+		IfAsync(@this, fTest, fThen, x => x);
 
 	#endregion
 
@@ -93,15 +163,15 @@ public static Result<T> IfNot<T>(this Result<T> @this, Func<T, bool> fTest, Func
 
 	/// <inheritdoc cref="IfNot{T}(Result{T}, Func{T, bool}, Func{T, Result{T}})"/>
 	public static Task<Result<T>> IfNotAsync<T>(this Result<T> @this, Func<T, bool> fTest, Func<T, Task<Result<T>>> fThen) =>
-		IfAsync(@this.AsTask(), fTest, async x => x, fThen);
+		IfAsync(@this, fTest, x => x, fThen);
 
 	/// <inheritdoc cref="IfNot{T}(Result{T}, Func{T, bool}, Func{T, Result{T}})"/>
 	public static Task<Result<T>> IfNotAsync<T>(this Task<Result<T>> @this, Func<T, bool> fTest, Func<T, Result<T>> fThen) =>
-		IfAsync(@this, fTest, async x => x, async x => fThen(x));
+		IfAsync(@this, fTest, x => x, fThen);
 
 	/// <inheritdoc cref="IfNot{T}(Result{T}, Func{T, bool}, Func{T, Result{T}})"/>
 	public static Task<Result<T>> IfNotAsync<T>(this Task<Result<T>> @this, Func<T, bool> fTest, Func<T, Task<Result<T>>> fThen) =>
-		IfAsync(@this, fTest, async x => x, fThen);
+		IfAsync(@this, fTest, x => x, fThen);
 
 	#endregion
 }
diff --git a/tests/Tests.All/Extensions/MaybeExtensions/IfAsync_Tests.cs b/tests/Tests.All/Extensions/MaybeExtensions/IfAsync_Tests.cs
index 71225509..cabd2f7c 100644
--- a/tests/Tests.All/Extensions/MaybeExtensions/IfAsync_Tests.cs
+++ b/tests/Tests.All/Extensions/MaybeExtensions/IfAsync_Tests.cs
@@ -34,13 +34,21 @@ public async Task Returns_None()
 
 					// Act
 					var r0 = await input.IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
-					var r1 = await input.AsTask().IfAsync(fTest, fTrue, fFalse);
-					var r2 = await input.AsTask().IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
+					var r1 = await input.IfAsync(fTest, async x => fTrue(x), fFalse);
+					var r2 = await input.IfAsync(fTest, fTrue, async x => fFalse(x));
+					var r3 = await input.AsTask().IfAsync(fTest, fTrue, fFalse);
+					var r4 = await input.AsTask().IfAsync(fTest, async x => fTrue(x), fFalse);
+					var r5 = await input.AsTask().IfAsync(fTest, fTrue, async x => fFalse(x));
+					var r6 = await input.AsTask().IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
 
 					// Assert
 					r0.AssertNone();
 					r1.AssertNone();
 					r2.AssertNone();
+					r3.AssertNone();
+					r4.AssertNone();
+					r5.AssertNone();
+					r6.AssertNone();
 				}
 
 				[Fact]
@@ -52,7 +60,11 @@ public async Task Functions_Are_Not_Invoked()
 
 					// Act
 					_ = await input.IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
+					_ = await input.IfAsync(fTest, async x => fTrue(x), fFalse);
+					_ = await input.IfAsync(fTest, fTrue, async x => fFalse(x));
 					_ = await input.AsTask().IfAsync(fTest, fTrue, fFalse);
+					_ = await input.AsTask().IfAsync(fTest, async x => fTrue(x), fFalse);
+					_ = await input.AsTask().IfAsync(fTest, fTrue, async x => fFalse(x));
 					_ = await input.AsTask().IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
 
 					// Assert
@@ -73,13 +85,21 @@ public async Task Returns_None()
 
 					// Act
 					var r0 = await input.IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
-					var r1 = await input.AsTask().IfAsync(fTest, fTrue, fFalse);
-					var r2 = await input.AsTask().IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
+					var r1 = await input.IfAsync(fTest, async x => fTrue(x), fFalse);
+					var r2 = await input.IfAsync(fTest, fTrue, async x => fFalse(x));
+					var r3 = await input.AsTask().IfAsync(fTest, fTrue, fFalse);
+					var r4 = await input.AsTask().IfAsync(fTest, async x => fTrue(x), fFalse);
+					var r5 = await input.AsTask().IfAsync(fTest, fTrue, async x => fFalse(x));
+					var r6 = await input.AsTask().IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
 
 					// Assert
 					r0.AssertNone();
 					r1.AssertNone();
 					r2.AssertNone();
+					r3.AssertNone();
+					r4.AssertNone();
+					r5.AssertNone();
+					r6.AssertNone();
 				}
 
 				[Fact]
@@ -91,7 +111,11 @@ public async Task Functions_Are_Not_Invoked()
 
 					// Act
 					_ = await input.IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
+					_ = await input.IfAsync(fTest, async x => fTrue(x), fFalse);
+					_ = await input.IfAsync(fTest, fTrue, async x => fFalse(x));
 					_ = await input.AsTask().IfAsync(fTest, fTrue, fFalse);
+					_ = await input.AsTask().IfAsync(fTest, async x => fTrue(x), fFalse);
+					_ = await input.AsTask().IfAsync(fTest, fTrue, async x => fFalse(x));
 					_ = await input.AsTask().IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
 
 					// Assert
@@ -117,13 +141,21 @@ public async Task Returns_Result_From_FFalse()
 
 					// Act
 					var r0 = await input.IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
-					var r1 = await input.AsTask().IfAsync(fTest, fTrue, fFalse);
-					var r2 = await input.AsTask().IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
+					var r1 = await input.IfAsync(fTest, async x => fTrue(x), fFalse);
+					var r2 = await input.IfAsync(fTest, fTrue, async x => fFalse(x));
+					var r3 = await input.AsTask().IfAsync(fTest, fTrue, fFalse);
+					var r4 = await input.AsTask().IfAsync(fTest, async x => fTrue(x), fFalse);
+					var r5 = await input.AsTask().IfAsync(fTest, fTrue, async x => fFalse(x));
+					var r6 = await input.AsTask().IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
 
 					// Assert
 					r0.AssertSome(falseValue);
 					r1.AssertSome(falseValue);
 					r2.AssertSome(falseValue);
+					r3.AssertSome(falseValue);
+					r4.AssertSome(falseValue);
+					r5.AssertSome(falseValue);
+					r6.AssertSome(falseValue);
 				}
 
 				[Fact]
@@ -136,12 +168,16 @@ public async Task Calls_FTest_And_FFalse()
 
 					// Act
 					_ = await input.IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
+					_ = await input.IfAsync(fTest, async x => fTrue(x), fFalse);
+					_ = await input.IfAsync(fTest, fTrue, async x => fFalse(x));
 					_ = await input.AsTask().IfAsync(fTest, fTrue, fFalse);
+					_ = await input.AsTask().IfAsync(fTest, async x => fTrue(x), fFalse);
+					_ = await input.AsTask().IfAsync(fTest, fTrue, async x => fFalse(x));
 					_ = await input.AsTask().IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
 
 					// Assert
-					fTest.Received(3).Invoke(value);
-					fFalse.Received(3).Invoke(value);
+					fTest.Received(7).Invoke(value);
+					fFalse.Received(7).Invoke(value);
 					fTrue.DidNotReceiveWithAnyArgs().Invoke(Arg.Any<string>());
 				}
 			}
@@ -159,13 +195,21 @@ public async Task Returns_Result_From_FTrue()
 
 					// Act
 					var r0 = await input.IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
-					var r1 = await input.AsTask().IfAsync(fTest, fTrue, fFalse);
-					var r2 = await input.AsTask().IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
+					var r1 = await input.IfAsync(fTest, async x => fTrue(x), fFalse);
+					var r2 = await input.IfAsync(fTest, fTrue, async x => fFalse(x));
+					var r3 = await input.AsTask().IfAsync(fTest, fTrue, fFalse);
+					var r4 = await input.AsTask().IfAsync(fTest, async x => fTrue(x), fFalse);
+					var r5 = await input.AsTask().IfAsync(fTest, fTrue, async x => fFalse(x));
+					var r6 = await input.AsTask().IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
 
 					// Assert
 					r0.AssertSome(trueValue);
 					r1.AssertSome(trueValue);
 					r2.AssertSome(trueValue);
+					r3.AssertSome(trueValue);
+					r4.AssertSome(trueValue);
+					r5.AssertSome(trueValue);
+					r6.AssertSome(trueValue);
 				}
 
 				[Fact]
@@ -178,12 +222,16 @@ public async Task Calls_FTest_And_FTrue()
 
 					// Act
 					_ = await input.IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
+					_ = await input.IfAsync(fTest, async x => fTrue(x), fFalse);
+					_ = await input.IfAsync(fTest, fTrue, async x => fFalse(x));
 					_ = await input.AsTask().IfAsync(fTest, fTrue, fFalse);
+					_ = await input.AsTask().IfAsync(fTest, async x => fTrue(x), fFalse);
+					_ = await input.AsTask().IfAsync(fTest, fTrue, async x => fFalse(x));
 					_ = await input.AsTask().IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
 
 					// Assert
-					fTest.Received(3).Invoke(value);
-					fTrue.Received(3).Invoke(value);
+					fTest.Received(7).Invoke(value);
+					fTrue.Received(7).Invoke(value);
 					fFalse.DidNotReceiveWithAnyArgs().Invoke(Arg.Any<string>());
 				}
 			}
diff --git a/tests/Tests.All/Extensions/ResultExtensions/IfAsync_Tests.cs b/tests/Tests.All/Extensions/ResultExtensions/IfAsync_Tests.cs
index ee37150f..c4bd1da5 100644
--- a/tests/Tests.All/Extensions/ResultExtensions/IfAsync_Tests.cs
+++ b/tests/Tests.All/Extensions/ResultExtensions/IfAsync_Tests.cs
@@ -26,13 +26,21 @@ public async Task Returns_Failure()
 
 			// Act
 			var r0 = await input.IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
-			var r1 = await input.AsTask().IfAsync(fTest, fTrue, fFalse);
-			var r2 = await input.AsTask().IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
+			var r1 = await input.IfAsync(fTest, async x => fTrue(x), fFalse);
+			var r2 = await input.IfAsync(fTest, fTrue, async x => fFalse(x));
+			var r3 = await input.AsTask().IfAsync(fTest, fTrue, fFalse);
+			var r4 = await input.AsTask().IfAsync(fTest, async x => fTrue(x), fFalse);
+			var r5 = await input.AsTask().IfAsync(fTest, fTrue, async x => fFalse(x));
+			var r6 = await input.AsTask().IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
 
 			// Assert
 			r0.AssertFailure(value);
 			r1.AssertFailure(value);
 			r2.AssertFailure(value);
+			r3.AssertFailure(value);
+			r4.AssertFailure(value);
+			r5.AssertFailure(value);
+			r6.AssertFailure(value);
 		}
 	}
 
@@ -51,13 +59,21 @@ public async Task Returns_fFalse_Result()
 
 				// Act
 				var r0 = await input.IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
-				var r1 = await input.AsTask().IfAsync(fTest, fTrue, fFalse);
-				var r2 = await input.AsTask().IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
+				var r1 = await input.IfAsync(fTest, async x => fTrue(x), fFalse);
+				var r2 = await input.IfAsync(fTest, fTrue, async x => fFalse(x));
+				var r3 = await input.AsTask().IfAsync(fTest, fTrue, fFalse);
+				var r4 = await input.AsTask().IfAsync(fTest, async x => fTrue(x), fFalse);
+				var r5 = await input.AsTask().IfAsync(fTest, fTrue, async x => fFalse(x));
+				var r6 = await input.AsTask().IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
 
 				// Assert
 				r0.AssertOk(value);
 				r1.AssertOk(value);
 				r2.AssertOk(value);
+				r3.AssertOk(value);
+				r4.AssertOk(value);
+				r5.AssertOk(value);
+				r6.AssertOk(value);
 			}
 		}
 
@@ -74,13 +90,21 @@ public async Task Returns_fTrue_Result()
 
 				// Act
 				var r0 = await input.IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
-				var r1 = await input.AsTask().IfAsync(fTest, fTrue, fFalse);
-				var r2 = await input.AsTask().IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
+				var r1 = await input.IfAsync(fTest, async x => fTrue(x), fFalse);
+				var r2 = await input.IfAsync(fTest, fTrue, async x => fFalse(x));
+				var r3 = await input.AsTask().IfAsync(fTest, fTrue, fFalse);
+				var r4 = await input.AsTask().IfAsync(fTest, async x => fTrue(x), fFalse);
+				var r5 = await input.AsTask().IfAsync(fTest, fTrue, async x => fFalse(x));
+				var r6 = await input.AsTask().IfAsync(fTest, async x => fTrue(x), async x => fFalse(x));
 
 				// Assert
 				r0.AssertOk(value);
 				r1.AssertOk(value);
 				r2.AssertOk(value);
+				r3.AssertOk(value);
+				r4.AssertOk(value);
+				r5.AssertOk(value);
+				r6.AssertOk(value);
 			}
 		}
 	}
@@ -98,12 +122,13 @@ public async Task Returns_Original_Value()
 				var input = R.Wrap(value);
 				var fTest = Substitute.For<Func<int, bool>>();
 				fTest.Invoke(Arg.Any<int>()).Returns(false);
-				var fThen = Substitute.For<Func<int, Task<Result<int>>>>();
+				var fThen = Substitute.For<Func<int, Result<int>>>();
+				var fThenAsync = Substitute.For<Func<int, Task<Result<int>>>>();
 
 				// Act
-				var r0 = await input.IfAsync(fTest, fThen);
-				var r1 = await input.AsTask().IfAsync(fTest, x => fThen(x));
-				var r2 = await input.AsTask().IfAsync(fTest, fThen);
+				var r0 = await input.IfAsync(fTest, fThenAsync);
+				var r1 = await input.AsTask().IfAsync(fTest, fThen);
+				var r2 = await input.AsTask().IfAsync(fTest, fThenAsync);
 
 				// Assert
 				r0.AssertOk(value);
@@ -122,13 +147,15 @@ public async Task Returns_fThen_Result()
 				var input = R.Wrap(Rnd.Int);
 				var fTest = Substitute.For<Func<int, bool>>();
 				fTest.Invoke(Arg.Any<int>()).Returns(true);
-				var fThen = Substitute.For<Func<int, Task<Result<int>>>>();
-				fThen.Invoke(Arg.Any<int>()).Returns(Task.FromResult<Result<int>>(value));
+				var fThen = Substitute.For<Func<int, Result<int>>>();
+				fThen.Invoke(Arg.Any<int>()).Returns(value);
+				var fThenAsync = Substitute.For<Func<int, Task<Result<int>>>>();
+				fThenAsync.Invoke(Arg.Any<int>()).Returns(Task.FromResult<Result<int>>(value));
 
 				// Act
-				var r0 = await input.IfAsync(fTest, fThen);
-				var r1 = await input.AsTask().IfAsync(fTest, x => fThen(x));
-				var r2 = await input.AsTask().IfAsync(fTest, fThen);
+				var r0 = await input.IfAsync(fTest, fThenAsync);
+				var r1 = await input.AsTask().IfAsync(fTest, fThen);
+				var r2 = await input.AsTask().IfAsync(fTest, fThenAsync);
 
 				// Assert
 				r0.AssertOk(value);

From 93918e32cf4983cda14245d379601a072db87895 Mon Sep 17 00:00:00 2001
From: bfren <bf@bfren.dev>
Date: Fri, 27 Feb 2026 11:33:22 +0000
Subject: [PATCH 15/18] Adding direct implementations of Audit functions - #61

---
 .../Extensions/Maybe/MaybeExtensions.Audit.cs | 92 ++++++++++++++++---
 .../Maybe/MaybeExtensions.IfNone.cs           |  4 +-
 .../Maybe/MaybeExtensions.IfSome.cs           |  4 +-
 .../Result/ResultExtensions.Audit.cs          | 78 ++++++++++++++--
 4 files changed, 151 insertions(+), 27 deletions(-)

diff --git a/src/All/Extensions/Maybe/MaybeExtensions.Audit.cs b/src/All/Extensions/Maybe/MaybeExtensions.Audit.cs
index d15df340..9ce19735 100644
--- a/src/All/Extensions/Maybe/MaybeExtensions.Audit.cs
+++ b/src/All/Extensions/Maybe/MaybeExtensions.Audit.cs
@@ -75,8 +75,26 @@ public static Task<Maybe<T>> AuditAsync<T>(this Maybe<T> @this, Func<T, Task> fS
 		AuditAsync(@this, null, fSome);
 
 	/// <inheritdoc cref="Audit{T}(Maybe{T}, Action?, Action{T}?)"/>
-	public static Task<Maybe<T>> AuditAsync<T>(this Maybe<T> @this, Func<Task>? fNone, Func<T, Task>? fSome) =>
-		AuditAsync(@this.AsTask(), fNone, fSome);
+	public static async Task<Maybe<T>> AuditAsync<T>(this Maybe<T> @this, Func<Task>? fNone, Func<T, Task>? fSome)
+	{
+		try
+		{
+			if (@this is Maybe<T>.NoneImpl && fNone is not null)
+			{
+				await fNone();
+			}
+			else if (@this is Some<T> x && fSome is not null)
+			{
+				await fSome(x.Value);
+			}
+		}
+		catch (Exception ex)
+		{
+			F.LogException?.Invoke(ex);
+		}
+
+		return @this;
+	}
 
 	/// <inheritdoc cref="Audit{T}(Maybe{T}, Action?, Action{T}?)"/>
 	public static Task<Maybe<T>> AuditAsync<T>(this Task<Maybe<T>> @this, Action fNone) =>
@@ -87,8 +105,28 @@ public static Task<Maybe<T>> AuditAsync<T>(this Task<Maybe<T>> @this, Action<T>
 		AuditAsync(@this, null, fSome);
 
 	/// <inheritdoc cref="Audit{T}(Maybe{T}, Action?, Action{T}?)"/>
-	public static Task<Maybe<T>> AuditAsync<T>(this Task<Maybe<T>> @this, Action? fNone, Action<T>? fSome) =>
-		AuditAsync(@this, async () => fNone?.Invoke(), async x => fSome?.Invoke(x));
+	public static async Task<Maybe<T>> AuditAsync<T>(this Task<Maybe<T>> @this, Action? fNone, Action<T>? fSome)
+	{
+		var maybe = await @this;
+
+		try
+		{
+			if (maybe is Maybe<T>.NoneImpl && fNone is not null)
+			{
+				fNone();
+			}
+			else if (maybe is Some<T> x && fSome is not null)
+			{
+				fSome(x.Value);
+			}
+		}
+		catch (Exception ex)
+		{
+			F.LogException?.Invoke(ex);
+		}
+
+		return maybe;
+	}
 
 	/// <inheritdoc cref="Audit{T}(Maybe{T}, Action?, Action{T}?)"/>
 	public static Task<Maybe<T>> AuditAsync<T>(this Task<Maybe<T>> @this, Func<Task> fNone) =>
@@ -101,15 +139,15 @@ public static Task<Maybe<T>> AuditAsync<T>(this Task<Maybe<T>> @this, Func<T, Ta
 	/// <inheritdoc cref="Audit{T}(Maybe{T}, Action?, Action{T}?)"/>
 	public static async Task<Maybe<T>> AuditAsync<T>(this Task<Maybe<T>> @this, Func<Task>? fNone, Func<T, Task>? fSome)
 	{
-		var result = await @this;
+		var maybe = await @this;
 
 		try
 		{
-			if (result is Maybe<T>.NoneImpl && fNone is not null)
+			if (maybe is Maybe<T>.NoneImpl && fNone is not null)
 			{
 				await fNone();
 			}
-			else if (result is Some<T> x && fSome is not null)
+			else if (maybe is Some<T> x && fSome is not null)
 			{
 				await fSome(x.Value);
 			}
@@ -119,31 +157,55 @@ public static async Task<Maybe<T>> AuditAsync<T>(this Task<Maybe<T>> @this, Func
 			F.LogException?.Invoke(ex);
 		}
 
-		return result;
+		return maybe;
 	}
 
 	/// <inheritdoc cref="Audit{T}(Maybe{T}, Action{Maybe{T}})"/>
-	public static Task<Maybe<T>> AuditAsync<T>(this Maybe<T> @this, Func<Maybe<T>, Task> either) =>
-		AuditAsync(@this.AsTask(), either);
+	public static async Task<Maybe<T>> AuditAsync<T>(this Maybe<T> @this, Func<Maybe<T>, Task> either)
+	{
+		try
+		{
+			await either(@this);
+		}
+		catch (Exception ex)
+		{
+			F.LogException?.Invoke(ex);
+		}
+
+		return @this;
+	}
 
 	/// <inheritdoc cref="Audit{T}(Maybe{T}, Action{Maybe{T}})"/>
-	public static Task<Maybe<T>> AuditAsync<T>(this Task<Maybe<T>> @this, Action<Maybe<T>> either) =>
-		AuditAsync(@this, either: async x => either(x));
+	public static async Task<Maybe<T>> AuditAsync<T>(this Task<Maybe<T>> @this, Action<Maybe<T>> either)
+	{
+		var maybe = await @this;
+
+		try
+		{
+			either(maybe);
+		}
+		catch (Exception ex)
+		{
+			F.LogException?.Invoke(ex);
+		}
+
+		return maybe;
+	}
 
 	/// <inheritdoc cref="Audit{T}(Maybe{T}, Action{Maybe{T}})"/>
 	public static async Task<Maybe<T>> AuditAsync<T>(this Task<Maybe<T>> @this, Func<Maybe<T>, Task> either)
 	{
-		var result = await @this;
+		var maybe = await @this;
 
 		try
 		{
-			await either(result);
+			await either(maybe);
 		}
 		catch (Exception ex)
 		{
 			F.LogException?.Invoke(ex);
 		}
 
-		return result;
+		return maybe;
 	}
 }
diff --git a/src/All/Extensions/Maybe/MaybeExtensions.IfNone.cs b/src/All/Extensions/Maybe/MaybeExtensions.IfNone.cs
index a4883a24..f4504f85 100644
--- a/src/All/Extensions/Maybe/MaybeExtensions.IfNone.cs
+++ b/src/All/Extensions/Maybe/MaybeExtensions.IfNone.cs
@@ -20,11 +20,11 @@ public static Maybe<T> IfNone<T>(this Maybe<T> @this, Action f) =>
 
 	/// <inheritdoc cref="IfNone{T}(Maybe{T}, Action)"/>
 	public static Task<Maybe<T>> IfNoneAsync<T>(this Maybe<T> @this, Func<Task> f) =>
-		IfNoneAsync(@this.AsTask(), f);
+		@this.AuditAsync(fNone: f);
 
 	/// <inheritdoc cref="IfNone{T}(Maybe{T}, Action)"/>
 	public static Task<Maybe<T>> IfNoneAsync<T>(this Task<Maybe<T>> @this, Action f) =>
-		IfNoneAsync(@this, async () => f());
+		@this.AuditAsync(fNone: f);
 
 	/// <inheritdoc cref="IfNone{T}(Maybe{T}, Action)"/>
 	public static Task<Maybe<T>> IfNoneAsync<T>(this Task<Maybe<T>> @this, Func<Task> f) =>
diff --git a/src/All/Extensions/Maybe/MaybeExtensions.IfSome.cs b/src/All/Extensions/Maybe/MaybeExtensions.IfSome.cs
index faa3e94a..e152d3f2 100644
--- a/src/All/Extensions/Maybe/MaybeExtensions.IfSome.cs
+++ b/src/All/Extensions/Maybe/MaybeExtensions.IfSome.cs
@@ -20,11 +20,11 @@ public static Maybe<T> IfSome<T>(this Maybe<T> @this, Action<T> f) =>
 
 	/// <inheritdoc cref="IfSome{T}(Maybe{T}, Action{T})"/>
 	public static Task<Maybe<T>> IfSomeAsync<T>(this Maybe<T> @this, Func<T, Task> f) =>
-		IfSomeAsync(@this.AsTask(), f);
+		@this.AuditAsync(fSome: f);
 
 	/// <inheritdoc cref="IfSome{T}(Maybe{T}, Action{T})"/>
 	public static Task<Maybe<T>> IfSomeAsync<T>(this Task<Maybe<T>> @this, Action<T> f) =>
-		IfSomeAsync(@this, async x => f(x));
+		@this.AuditAsync(fSome: f);
 
 	/// <inheritdoc cref="IfSome{T}(Maybe{T}, Action{T})"/>
 	public static Task<Maybe<T>> IfSomeAsync<T>(this Task<Maybe<T>> @this, Func<T, Task> f) =>
diff --git a/src/All/Extensions/Result/ResultExtensions.Audit.cs b/src/All/Extensions/Result/ResultExtensions.Audit.cs
index d74fcd83..c933a954 100644
--- a/src/All/Extensions/Result/ResultExtensions.Audit.cs
+++ b/src/All/Extensions/Result/ResultExtensions.Audit.cs
@@ -75,8 +75,26 @@ public static Task<Result<T>> AuditAsync<T>(this Result<T> @this, Func<T, Task>
 		AuditAsync(@this, null, fOk);
 
 	/// <inheritdoc cref="Audit{T}(Result{T}, Action{FailureValue}?, Action{T}?)"/>
-	public static Task<Result<T>> AuditAsync<T>(this Result<T> @this, Func<FailureValue, Task>? fFail, Func<T, Task>? fOk) =>
-		AuditAsync(@this.AsTask(), fFail: fFail, fOk: fOk);
+	public static async Task<Result<T>> AuditAsync<T>(this Result<T> @this, Func<FailureValue, Task>? fFail, Func<T, Task>? fOk)
+	{
+		try
+		{
+			if (@this is Result<T>.FailureImpl y && fFail is not null)
+			{
+				await fFail(y.Value);
+			}
+			else if (@this is Ok<T> x && fOk is not null)
+			{
+				await fOk(x.Value);
+			}
+		}
+		catch (Exception ex)
+		{
+			F.LogException?.Invoke(ex);
+		}
+
+		return @this;
+	}
 
 	/// <inheritdoc cref="Audit{T}(Result{T}, Action{FailureValue}?, Action{T}?)"/>
 	public static Task<Result<T>> AuditAsync<T>(this Task<Result<T>> @this, Action<FailureValue> fFail) =>
@@ -87,8 +105,28 @@ public static Task<Result<T>> AuditAsync<T>(this Task<Result<T>> @this, Action<T
 		AuditAsync(@this, null, fOk);
 
 	/// <inheritdoc cref="Audit{T}(Result{T}, Action{FailureValue}?, Action{T}?)"/>
-	public static Task<Result<T>> AuditAsync<T>(this Task<Result<T>> @this, Action<FailureValue>? fFail, Action<T>? fOk) =>
-		AuditAsync(@this, fFail: async x => fFail?.Invoke(x), fOk: async x => fOk?.Invoke(x));
+	public static async Task<Result<T>> AuditAsync<T>(this Task<Result<T>> @this, Action<FailureValue>? fFail, Action<T>? fOk)
+	{
+		var result = await @this;
+
+		try
+		{
+			if (result is Result<T>.FailureImpl y && fFail is not null)
+			{
+				fFail(y.Value);
+			}
+			else if (result is Ok<T> x && fOk is not null)
+			{
+				fOk(x.Value);
+			}
+		}
+		catch (Exception ex)
+		{
+			F.LogException?.Invoke(ex);
+		}
+
+		return result;
+	}
 
 	/// <inheritdoc cref="Audit{T}(Result{T}, Action{FailureValue}?, Action{T}?)"/>
 	public static Task<Result<T>> AuditAsync<T>(this Task<Result<T>> @this, Func<FailureValue, Task> fFail) =>
@@ -123,12 +161,36 @@ public static async Task<Result<T>> AuditAsync<T>(this Task<Result<T>> @this, Fu
 	}
 
 	/// <inheritdoc cref="Audit{T}(Result{T}, Action{Result{T}})"/>
-	public static Task<Result<T>> AuditAsync<T>(this Result<T> @this, Func<Result<T>, Task> either) =>
-		AuditAsync(@this.AsTask(), either: either);
+	public static async Task<Result<T>> AuditAsync<T>(this Result<T> @this, Func<Result<T>, Task> either)
+	{
+		try
+		{
+			await either(@this);
+		}
+		catch (Exception ex)
+		{
+			F.LogException?.Invoke(ex);
+		}
+
+		return @this;
+	}
 
 	/// <inheritdoc cref="Audit{T}(Result{T}, Action{Result{T}})"/>
-	public static Task<Result<T>> AuditAsync<T>(this Task<Result<T>> @this, Action<Result<T>> either) =>
-		AuditAsync(@this, either: async x => either(x));
+	public static async Task<Result<T>> AuditAsync<T>(this Task<Result<T>> @this, Action<Result<T>> either)
+	{
+		var result = await @this;
+
+		try
+		{
+			either(result);
+		}
+		catch (Exception ex)
+		{
+			F.LogException?.Invoke(ex);
+		}
+
+		return result;
+	}
 
 	/// <inheritdoc cref="Audit{T}(Result{T}, Action{Result{T}})"/>
 	public static async Task<Result<T>> AuditAsync<T>(this Task<Result<T>> @this, Func<Result<T>, Task> either)

From 1d67ef02757844d16d263fb725d1826f2ad29b5e Mon Sep 17 00:00:00 2001
From: bfren <bf@bfren.dev>
Date: Fri, 27 Feb 2026 11:41:08 +0000
Subject: [PATCH 16/18] Calling MatchAsync directly to avoid Task.FromResult -
 #61

---
 .../Maybe/MaybeExtensions.MatchIf.cs          | 405 ++++++++++++------
 .../Result/ResultExtensions.MatchIf.cs        | 405 ++++++++++++------
 2 files changed, 550 insertions(+), 260 deletions(-)

diff --git a/src/All/Extensions/Maybe/MaybeExtensions.MatchIf.cs b/src/All/Extensions/Maybe/MaybeExtensions.MatchIf.cs
index 5fa7378d..b7b20984 100644
--- a/src/All/Extensions/Maybe/MaybeExtensions.MatchIf.cs
+++ b/src/All/Extensions/Maybe/MaybeExtensions.MatchIf.cs
@@ -44,11 +44,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Maybe<T> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
-			fNone: async () => fNone(),
-			fTest: async x => fTest(x),
-			fFalse: fFalse,
-			fTrue: async x => fTrue(x)
+		MatchAsync(@this,
+			fNone: fNone,
+			fSome: async x => fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -58,11 +63,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Maybe<T> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
-			fNone: async () => fNone(),
-			fTest: async x => fTest(x),
-			fFalse: async x => fFalse(x),
-			fTrue: fTrue
+		MatchAsync(@this,
+			fNone: fNone,
+			fSome: async x => fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -72,11 +82,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Maybe<T> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
-			fNone: async () => fNone(),
-			fTest: async x => fTest(x),
-			fFalse: fFalse,
-			fTrue: fTrue
+		MatchAsync(@this,
+			fNone: fNone,
+			fSome: async x => fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -86,11 +101,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Maybe<T> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
-			fNone: async () => fNone(),
-			fTest: fTest,
-			fFalse: async x => fFalse(x),
-			fTrue: async x => fTrue(x)
+		MatchAsync(@this,
+			fNone: fNone,
+			fSome: async x => await fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -100,11 +120,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Maybe<T> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
-			fNone: async () => fNone(),
-			fTest: fTest,
-			fFalse: fFalse,
-			fTrue: async x => fTrue(x)
+		MatchAsync(@this,
+			fNone: fNone,
+			fSome: async x => await fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -114,11 +139,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Maybe<T> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
-			fNone: async () => fNone(),
-			fTest: fTest,
-			fFalse: async x => fFalse(x),
-			fTrue: fTrue
+		MatchAsync(@this,
+			fNone: fNone,
+			fSome: async x => await fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -128,11 +158,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Maybe<T> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
-			fNone: async () => fNone(),
-			fTest: fTest,
-			fFalse: fFalse,
-			fTrue: fTrue
+		MatchAsync(@this,
+			fNone: fNone,
+			fSome: async x => await fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -142,11 +177,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Maybe<T>> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(@this,
-			fNone: async () => fNone(),
-			fTest: async x => fTest(x),
-			fFalse: async x => fFalse(x),
-			fTrue: async x => fTrue(x)
+		MatchAsync(@this,
+			fNone: fNone,
+			fSome: x => fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -156,11 +196,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Maybe<T>> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(@this,
-			fNone: async () => fNone(),
-			fTest: async x => fTest(x),
-			fFalse: fFalse,
-			fTrue: async x => fTrue(x)
+		MatchAsync(@this,
+			fNone: fNone,
+			fSome: async x => fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -170,11 +215,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Maybe<T>> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(@this,
-			fNone: async () => fNone(),
-			fTest: async x => fTest(x),
-			fFalse: async x => fFalse(x),
-			fTrue: fTrue
+		MatchAsync(@this,
+			fNone: fNone,
+			fSome: async x => fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -184,11 +234,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Maybe<T>> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(@this,
-			fNone: async () => fNone(),
-			fTest: async x => fTest(x),
-			fFalse: fFalse,
-			fTrue: fTrue
+		MatchAsync(@this,
+			fNone: fNone,
+			fSome: async x => fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -198,11 +253,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Maybe<T>> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(@this,
-			fNone: async () => fNone(),
-			fTest: fTest,
-			fFalse: async x => fFalse(x),
-			fTrue: async x => fTrue(x)
+		MatchAsync(@this,
+			fNone: fNone,
+			fSome: async x => await fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -212,11 +272,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Maybe<T>> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(@this,
-			fNone: async () => fNone(),
-			fTest: fTest,
-			fFalse: fFalse,
-			fTrue: async x => fTrue(x)
+		MatchAsync(@this,
+			fNone: fNone,
+			fSome: async x => await fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -226,11 +291,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Maybe<T>> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(@this,
-			fNone: async () => fNone(),
-			fTest: fTest,
-			fFalse: async x => fFalse(x),
-			fTrue: fTrue
+		MatchAsync(@this,
+			fNone: fNone,
+			fSome: async x => await fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -240,11 +310,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Maybe<T> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
+		MatchAsync(@this,
 			fNone: fNone,
-			fTest: async x => fTest(x),
-			fFalse: async x => fFalse(x),
-			fTrue: async x => fTrue(x)
+			fSome: x => fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -254,11 +329,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Maybe<T> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
+		MatchAsync(@this,
 			fNone: fNone,
-			fTest: async x => fTest(x),
-			fFalse: fFalse,
-			fTrue: async x => fTrue(x)
+			fSome: async x => fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -268,11 +348,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Maybe<T> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
+		MatchAsync(@this,
 			fNone: fNone,
-			fTest: async x => fTest(x),
-			fFalse: async x => fFalse(x),
-			fTrue: fTrue
+			fSome: async x => fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -282,11 +367,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Maybe<T> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
+		MatchAsync(@this,
 			fNone: fNone,
-			fTest: async x => fTest(x),
-			fFalse: fFalse,
-			fTrue: fTrue
+			fSome: async x => fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -296,11 +386,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Maybe<T> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
+		MatchAsync(@this,
 			fNone: fNone,
-			fTest: fTest,
-			fFalse: async x => fFalse(x),
-			fTrue: async x => fTrue(x)
+			fSome: async x => await fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -310,11 +405,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Maybe<T> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
+		MatchAsync(@this,
 			fNone: fNone,
-			fTest: fTest,
-			fFalse: fFalse,
-			fTrue: async x => fTrue(x)
+			fSome: async x => await fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -324,11 +424,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Maybe<T> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
+		MatchAsync(@this,
 			fNone: fNone,
-			fTest: fTest,
-			fFalse: async x => fFalse(x),
-			fTrue: fTrue
+			fSome: async x => await fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -338,11 +443,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Maybe<T> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
+		MatchAsync(@this,
 			fNone: fNone,
-			fTest: fTest,
-			fFalse: fFalse,
-			fTrue: fTrue
+			fSome: async x => await fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -352,11 +462,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Maybe<T>> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(@this,
+		MatchAsync(@this,
 			fNone: fNone,
-			fTest: async x => fTest(x),
-			fFalse: async x => fFalse(x),
-			fTrue: async x => fTrue(x)
+			fSome: x => fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -366,11 +481,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Maybe<T>> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(@this,
+		MatchAsync(@this,
 			fNone: fNone,
-			fTest: async x => fTest(x),
-			fFalse: fFalse,
-			fTrue: async x => fTrue(x)
+			fSome: async x => fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -380,11 +500,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Maybe<T>> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(@this,
+		MatchAsync(@this,
 			fNone: fNone,
-			fTest: async x => fTest(x),
-			fFalse: async x => fFalse(x),
-			fTrue: fTrue
+			fSome: async x => fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -394,11 +519,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Maybe<T>> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(@this,
+		MatchAsync(@this,
 			fNone: fNone,
-			fTest: async x => fTest(x),
-			fFalse: fFalse,
-			fTrue: fTrue
+			fSome: async x => fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -408,11 +538,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Maybe<T>> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(@this,
+		MatchAsync(@this,
 			fNone: fNone,
-			fTest: fTest,
-			fFalse: async x => fFalse(x),
-			fTrue: async x => fTrue(x)
+			fSome: async x => await fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -422,11 +557,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Maybe<T>> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(@this,
+		MatchAsync(@this,
 			fNone: fNone,
-			fTest: fTest,
-			fFalse: fFalse,
-			fTrue: async x => fTrue(x)
+			fSome: async x => await fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -436,11 +576,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Maybe<T>> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(@this,
+		MatchAsync(@this,
 			fNone: fNone,
-			fTest: fTest,
-			fFalse: async x => fFalse(x),
-			fTrue: fTrue
+			fSome: async x => await fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Maybe{T}, Func{TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
diff --git a/src/All/Extensions/Result/ResultExtensions.MatchIf.cs b/src/All/Extensions/Result/ResultExtensions.MatchIf.cs
index 436181c1..cfd39a93 100644
--- a/src/All/Extensions/Result/ResultExtensions.MatchIf.cs
+++ b/src/All/Extensions/Result/ResultExtensions.MatchIf.cs
@@ -44,11 +44,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Result<T> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
-			fFail: async f => fFail(f),
-			fTest: async x => fTest(x),
-			fFalse: fFalse,
-			fTrue: async x => fTrue(x)
+		MatchAsync(@this,
+			fFail: fFail,
+			fOk: async x => fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -58,11 +63,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Result<T> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
-			fFail: async f => fFail(f),
-			fTest: async x => fTest(x),
-			fFalse: async x => fFalse(x),
-			fTrue: fTrue
+		MatchAsync(@this,
+			fFail: fFail,
+			fOk: async x => fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -72,11 +82,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Result<T> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
-			fFail: async f => fFail(f),
-			fTest: async x => fTest(x),
-			fFalse: fFalse,
-			fTrue: fTrue
+		MatchAsync(@this,
+			fFail: fFail,
+			fOk: async x => fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -86,11 +101,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Result<T> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
-			fFail: async f => fFail(f),
-			fTest: fTest,
-			fFalse: async x => fFalse(x),
-			fTrue: async x => fTrue(x)
+		MatchAsync(@this,
+			fFail: fFail,
+			fOk: async x => await fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -100,11 +120,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Result<T> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
-			fFail: async f => fFail(f),
-			fTest: fTest,
-			fFalse: fFalse,
-			fTrue: async x => fTrue(x)
+		MatchAsync(@this,
+			fFail: fFail,
+			fOk: async x => await fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -114,11 +139,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Result<T> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
-			fFail: async f => fFail(f),
-			fTest: fTest,
-			fFalse: async x => fFalse(x),
-			fTrue: fTrue
+		MatchAsync(@this,
+			fFail: fFail,
+			fOk: async x => await fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -128,11 +158,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Result<T> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
-			fFail: async f => fFail(f),
-			fTest: fTest,
-			fFalse: fFalse,
-			fTrue: fTrue
+		MatchAsync(@this,
+			fFail: fFail,
+			fOk: async x => await fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -142,11 +177,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Result<T>> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(@this,
-			fFail: async f => fFail(f),
-			fTest: async x => fTest(x),
-			fFalse: async x => fFalse(x),
-			fTrue: async x => fTrue(x)
+		MatchAsync(@this,
+			fFail: fFail,
+			fOk: x => fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -156,11 +196,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Result<T>> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(@this,
-			fFail: async f => fFail(f),
-			fTest: async x => fTest(x),
-			fFalse: fFalse,
-			fTrue: async x => fTrue(x)
+		MatchAsync(@this,
+			fFail: fFail,
+			fOk: async x => fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -170,11 +215,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Result<T>> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(@this,
-			fFail: async f => fFail(f),
-			fTest: async x => fTest(x),
-			fFalse: async x => fFalse(x),
-			fTrue: fTrue
+		MatchAsync(@this,
+			fFail: fFail,
+			fOk: async x => fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -184,11 +234,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Result<T>> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(@this,
-			fFail: async f => fFail(f),
-			fTest: async x => fTest(x),
-			fFalse: fFalse,
-			fTrue: fTrue
+		MatchAsync(@this,
+			fFail: fFail,
+			fOk: async x => fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -198,11 +253,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Result<T>> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(@this,
-			fFail: async f => fFail(f),
-			fTest: fTest,
-			fFalse: async x => fFalse(x),
-			fTrue: async x => fTrue(x)
+		MatchAsync(@this,
+			fFail: fFail,
+			fOk: async x => await fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -212,11 +272,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Result<T>> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(@this,
-			fFail: async f => fFail(f),
-			fTest: fTest,
-			fFalse: fFalse,
-			fTrue: async x => fTrue(x)
+		MatchAsync(@this,
+			fFail: fFail,
+			fOk: async x => await fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -226,11 +291,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Result<T>> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(@this,
-			fFail: async f => fFail(f),
-			fTest: fTest,
-			fFalse: async x => fFalse(x),
-			fTrue: fTrue
+		MatchAsync(@this,
+			fFail: fFail,
+			fOk: async x => await fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -240,11 +310,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Result<T> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
+		MatchAsync(@this,
 			fFail: fFail,
-			fTest: async x => fTest(x),
-			fFalse: async x => fFalse(x),
-			fTrue: async x => fTrue(x)
+			fOk: x => fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -254,11 +329,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Result<T> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
+		MatchAsync(@this,
 			fFail: fFail,
-			fTest: async x => fTest(x),
-			fFalse: fFalse,
-			fTrue: async x => fTrue(x)
+			fOk: async x => fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -268,11 +348,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Result<T> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
+		MatchAsync(@this,
 			fFail: fFail,
-			fTest: async x => fTest(x),
-			fFalse: async x => fFalse(x),
-			fTrue: fTrue
+			fOk: async x => fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -282,11 +367,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Result<T> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
+		MatchAsync(@this,
 			fFail: fFail,
-			fTest: async x => fTest(x),
-			fFalse: fFalse,
-			fTrue: fTrue
+			fOk: async x => fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -296,11 +386,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Result<T> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
+		MatchAsync(@this,
 			fFail: fFail,
-			fTest: fTest,
-			fFalse: async x => fFalse(x),
-			fTrue: async x => fTrue(x)
+			fOk: async x => await fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -310,11 +405,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Result<T> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
+		MatchAsync(@this,
 			fFail: fFail,
-			fTest: fTest,
-			fFalse: fFalse,
-			fTrue: async x => fTrue(x)
+			fOk: async x => await fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -324,11 +424,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Result<T> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
+		MatchAsync(@this,
 			fFail: fFail,
-			fTest: fTest,
-			fFalse: async x => fFalse(x),
-			fTrue: fTrue
+			fOk: async x => await fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -338,11 +443,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Result<T> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(Task.FromResult(@this),
+		MatchAsync(@this,
 			fFail: fFail,
-			fTest: fTest,
-			fFalse: fFalse,
-			fTrue: fTrue
+			fOk: async x => await fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -352,11 +462,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Result<T>> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(@this,
+		MatchAsync(@this,
 			fFail: fFail,
-			fTest: async x => fTest(x),
-			fFalse: async x => fFalse(x),
-			fTrue: async x => fTrue(x)
+			fOk: x => fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -366,11 +481,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Result<T>> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(@this,
+		MatchAsync(@this,
 			fFail: fFail,
-			fTest: async x => fTest(x),
-			fFalse: fFalse,
-			fTrue: async x => fTrue(x)
+			fOk: async x => fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -380,11 +500,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Result<T>> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(@this,
+		MatchAsync(@this,
 			fFail: fFail,
-			fTest: async x => fTest(x),
-			fFalse: async x => fFalse(x),
-			fTrue: fTrue
+			fOk: async x => fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -394,11 +519,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Result<T>> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(@this,
+		MatchAsync(@this,
 			fFail: fFail,
-			fTest: async x => fTest(x),
-			fFalse: fFalse,
-			fTrue: fTrue
+			fOk: async x => fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -408,11 +538,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Result<T>> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(@this,
+		MatchAsync(@this,
 			fFail: fFail,
-			fTest: fTest,
-			fFalse: async x => fFalse(x),
-			fTrue: async x => fTrue(x)
+			fOk: async x => await fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -422,11 +557,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Result<T>> @this,
 		Func<T, Task<TReturn>> fFalse,
 		Func<T, TReturn> fTrue
 	) =>
-		MatchIfAsync(@this,
+		MatchAsync(@this,
 			fFail: fFail,
-			fTest: fTest,
-			fFalse: fFalse,
-			fTrue: async x => fTrue(x)
+			fOk: async x => await fTest(x) switch
+			{
+				false =>
+					await fFalse(x),
+
+				true =>
+					fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>
@@ -436,11 +576,16 @@ public static Task<TReturn> MatchIfAsync<T, TReturn>(this Task<Result<T>> @this,
 		Func<T, TReturn> fFalse,
 		Func<T, Task<TReturn>> fTrue
 	) =>
-		MatchIfAsync(@this,
+		MatchAsync(@this,
 			fFail: fFail,
-			fTest: fTest,
-			fFalse: async x => fFalse(x),
-			fTrue: fTrue
+			fOk: async x => await fTest(x) switch
+			{
+				false =>
+					fFalse(x),
+
+				true =>
+					await fTrue(x)
+			}
 		);
 
 	/// <inheritdoc cref="MatchIf{T, TReturn}(Result{T}, Func{FailureValue, TReturn}, Func{T, bool}, Func{T, TReturn}, Func{T, TReturn})"/>

From e8b236626d2fb296ad548f6d1a974956af83c825 Mon Sep 17 00:00:00 2001
From: bfren <bf@bfren.dev>
Date: Fri, 27 Feb 2026 11:44:32 +0000
Subject: [PATCH 17/18] Using IfAsync directly instead of overloads - #61

---
 src/All/Extensions/Maybe/MaybeExtensions.BindIf.cs   | 6 +++---
 src/All/Extensions/Result/ResultExtensions.BindIf.cs | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/All/Extensions/Maybe/MaybeExtensions.BindIf.cs b/src/All/Extensions/Maybe/MaybeExtensions.BindIf.cs
index e0c889e4..668e8482 100644
--- a/src/All/Extensions/Maybe/MaybeExtensions.BindIf.cs
+++ b/src/All/Extensions/Maybe/MaybeExtensions.BindIf.cs
@@ -22,13 +22,13 @@ public static Maybe<TReturn> BindIf<T, TReturn>(this Maybe<T> @this, Func<T, boo
 
 	/// <inheritdoc cref="BindIf{T, TReturn}(Maybe{T}, Func{T, bool}, Func{T, Maybe{TReturn}})"/>
 	public static Task<Maybe<TReturn>> BindIfAsync<T, TReturn>(this Maybe<T> @this, Func<T, bool> fTest, Func<T, Task<Maybe<TReturn>>> f) =>
-		BindIfAsync(@this.AsTask(), fTest, f);
+		IfAsync(@this, fTest, f, _ => M.None);
 
 	/// <inheritdoc cref="BindIf{T, TReturn}(Maybe{T}, Func{T, bool}, Func{T, Maybe{TReturn}})"/>
 	public static Task<Maybe<TReturn>> BindIfAsync<T, TReturn>(this Task<Maybe<T>> @this, Func<T, bool> fTest, Func<T, Maybe<TReturn>> f) =>
-		BindIfAsync(@this, fTest, async x => f(x));
+		IfAsync(@this, fTest, f, _ => M.None);
 
 	/// <inheritdoc cref="BindIf{T, TReturn}(Maybe{T}, Func{T, bool}, Func{T, Maybe{TReturn}})"/>
 	public static Task<Maybe<TReturn>> BindIfAsync<T, TReturn>(this Task<Maybe<T>> @this, Func<T, bool> fTest, Func<T, Task<Maybe<TReturn>>> f) =>
-		IfAsync(@this, fTest, f, async _ => M.None);
+		IfAsync(@this, fTest, f, _ => M.None);
 }
diff --git a/src/All/Extensions/Result/ResultExtensions.BindIf.cs b/src/All/Extensions/Result/ResultExtensions.BindIf.cs
index 60102a13..8a843889 100644
--- a/src/All/Extensions/Result/ResultExtensions.BindIf.cs
+++ b/src/All/Extensions/Result/ResultExtensions.BindIf.cs
@@ -22,13 +22,13 @@ public static Result<TReturn> BindIf<T, TReturn>(this Result<T> @this, Func<T, b
 
 	/// <inheritdoc cref="BindIf{T, TReturn}(Result{T}, Func{T, bool}, Func{T, Result{TReturn}})"/>
 	public static Task<Result<TReturn>> BindIfAsync<T, TReturn>(this Result<T> @this, Func<T, bool> fTest, Func<T, Task<Result<TReturn>>> f) =>
-		BindIfAsync(@this.AsTask(), fTest, f);
+		IfAsync(@this, fTest, f, _ => R.Fail(C.TestFalseMessage).Ctx(nameof(ResultExtensions), nameof(BindIfAsync)));
 
 	/// <inheritdoc cref="BindIf{T, TReturn}(Result{T}, Func{T, bool}, Func{T, Result{TReturn}})"/>
 	public static Task<Result<TReturn>> BindIfAsync<T, TReturn>(this Task<Result<T>> @this, Func<T, bool> fTest, Func<T, Result<TReturn>> f) =>
-		BindIfAsync(@this, fTest, async x => f(x));
+		IfAsync(@this, fTest, f, _ => R.Fail(C.TestFalseMessage).Ctx(nameof(ResultExtensions), nameof(BindIfAsync)));
 
 	/// <inheritdoc cref="BindIf{T, TReturn}(Result{T}, Func{T, bool}, Func{T, Result{TReturn}})"/>
 	public static Task<Result<TReturn>> BindIfAsync<T, TReturn>(this Task<Result<T>> @this, Func<T, bool> fTest, Func<T, Task<Result<TReturn>>> f) =>
-		IfAsync(@this, fTest, f, async _ => R.Fail(C.TestFalseMessage).Ctx(nameof(ResultExtensions), nameof(BindIfAsync)));
+		IfAsync(@this, fTest, f, _ => R.Fail(C.TestFalseMessage).Ctx(nameof(ResultExtensions), nameof(BindIfAsync)));
 }

From 52e7f8eafde7420a07326dfbf767ebf4971a84f9 Mon Sep 17 00:00:00 2001
From: bfren <bf@bfren.dev>
Date: Fri, 27 Feb 2026 11:48:12 +0000
Subject: [PATCH 18/18] Using IfAsync directly instead of via overloads - #61

---
 src/All/Extensions/Maybe/MaybeExtensions.MapIf.cs   | 6 +++---
 src/All/Extensions/Result/ResultExtensions.MapIf.cs | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/All/Extensions/Maybe/MaybeExtensions.MapIf.cs b/src/All/Extensions/Maybe/MaybeExtensions.MapIf.cs
index a1fa2a35..0884b23c 100644
--- a/src/All/Extensions/Maybe/MaybeExtensions.MapIf.cs
+++ b/src/All/Extensions/Maybe/MaybeExtensions.MapIf.cs
@@ -22,13 +22,13 @@ public static Maybe<TReturn> MapIf<T, TReturn>(this Maybe<T> @this, Func<T, bool
 
 	/// <inheritdoc cref="MapIf{T, TReturn}(Maybe{T}, Func{T, bool}, Func{T, TReturn})"/>
 	public static Task<Maybe<TReturn>> MapIfAsync<T, TReturn>(this Maybe<T> @this, Func<T, bool> fTest, Func<T, Task<TReturn>> f) =>
-		MapIfAsync(@this.AsTask(), fTest, f);
+		IfAsync(@this, fTest, async x => M.Wrap(await f(x)), _ => M.None);
 
 	/// <inheritdoc cref="MapIf{T, TReturn}(Maybe{T}, Func{T, bool}, Func{T, TReturn})"/>
 	public static Task<Maybe<TReturn>> MapIfAsync<T, TReturn>(this Task<Maybe<T>> @this, Func<T, bool> fTest, Func<T, TReturn> f) =>
-		MapIfAsync(@this, fTest, async x => f(x));
+		IfAsync(@this, fTest, x => M.Wrap(f(x)), _ => M.None);
 
 	/// <inheritdoc cref="MapIf{T, TReturn}(Maybe{T}, Func{T, bool}, Func{T, TReturn})"/>
 	public static Task<Maybe<TReturn>> MapIfAsync<T, TReturn>(this Task<Maybe<T>> @this, Func<T, bool> fTest, Func<T, Task<TReturn>> f) =>
-		IfAsync(@this, fTest, async x => M.Wrap(await f(x)), async _ => M.None);
+		IfAsync(@this, fTest, async x => M.Wrap(await f(x)), _ => M.None);
 }
diff --git a/src/All/Extensions/Result/ResultExtensions.MapIf.cs b/src/All/Extensions/Result/ResultExtensions.MapIf.cs
index 16dfd8b2..fb896bbd 100644
--- a/src/All/Extensions/Result/ResultExtensions.MapIf.cs
+++ b/src/All/Extensions/Result/ResultExtensions.MapIf.cs
@@ -22,13 +22,13 @@ public static Result<TReturn> MapIf<T, TReturn>(this Result<T> @this, Func<T, bo
 
 	/// <inheritdoc cref="MapIf{T, TReturn}(Result{T}, Func{T, bool}, Func{T, TReturn})"/>
 	public static Task<Result<TReturn>> MapIfAsync<T, TReturn>(this Result<T> @this, Func<T, bool> fTest, Func<T, Task<TReturn>> f) =>
-		MapIfAsync(@this.AsTask(), fTest, f);
+		IfAsync(@this, fTest, async x => R.Wrap(await f(x)), _ => R.Fail(C.TestFalseMessage).Ctx(nameof(ResultExtensions), nameof(MapIfAsync)));
 
 	/// <inheritdoc cref="MapIf{T, TReturn}(Result{T}, Func{T, bool}, Func{T, TReturn})"/>
 	public static Task<Result<TReturn>> MapIfAsync<T, TReturn>(this Task<Result<T>> @this, Func<T, bool> fTest, Func<T, TReturn> f) =>
-		MapIfAsync(@this, fTest, async x => f(x));
+		IfAsync(@this, fTest, x => R.Wrap(f(x)), _ => R.Fail(C.TestFalseMessage).Ctx(nameof(ResultExtensions), nameof(MapIfAsync)));
 
 	/// <inheritdoc cref="MapIf{T, TReturn}(Result{T}, Func{T, bool}, Func{T, TReturn})"/>
 	public static Task<Result<TReturn>> MapIfAsync<T, TReturn>(this Task<Result<T>> @this, Func<T, bool> fTest, Func<T, Task<TReturn>> f) =>
-		IfAsync(@this, fTest, x => R.TryAsync(async () => await f(x)), async _ => R.Fail(C.TestFalseMessage).Ctx(nameof(ResultExtensions), nameof(MapIfAsync)));
+		IfAsync(@this, fTest, async x => R.Wrap(await f(x)), _ => R.Fail(C.TestFalseMessage).Ctx(nameof(ResultExtensions), nameof(MapIfAsync)));
 }