From 717116b2a6f16c5a6f4d46e85499e74014add66f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Anta=CC=83o=20Almada?= <antao.almada@farfetch.com>
Date: Mon, 4 Dec 2023 22:15:40 +0000
Subject: [PATCH] Add README

---
 .../ActionWrapper.cs                          |  27 +-
 .../AsyncFunctionWrapper.cs                   |  77 ++---
 .../AsyncValueEnumerable.cs                   |   5 +-
 .../FunctionWrapper.cs                        |  83 ++---
 NetFabric.Hyperlinq.Abstractions/IAction.cs   | 325 +++++++++---------
 .../IAsyncFunction.cs                         |   5 +-
 .../IValueEnumerable.cs                       |  44 ++-
 .../IVectorAction.cs                          |  50 ++-
 .../NetFabric.Hyperlinq.Abstractions.csproj   |   4 +-
 NetFabric.Hyperlinq.Abstractions/README.md    |  65 ++++
 10 files changed, 377 insertions(+), 308 deletions(-)
 create mode 100644 NetFabric.Hyperlinq.Abstractions/README.md

diff --git a/NetFabric.Hyperlinq.Abstractions/ActionWrapper.cs b/NetFabric.Hyperlinq.Abstractions/ActionWrapper.cs
index 61f950a8..9d985146 100644
--- a/NetFabric.Hyperlinq.Abstractions/ActionWrapper.cs
+++ b/NetFabric.Hyperlinq.Abstractions/ActionWrapper.cs
@@ -17,7 +17,8 @@ namespace NetFabric.Hyperlinq;
 public readonly struct ActionWrapper<T>(Action<T> action) 
     : IAction<T>
 {
-    readonly Action<T> action = action ?? Throw.ArgumentNullException<Action<T>>(nameof(action));
+    readonly Action<T> action 
+        = action ?? Throw.ArgumentNullException<Action<T>>(nameof(action));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     void IAction<T>.Invoke(ref readonly T arg)
@@ -42,7 +43,8 @@ void IAction<T>.Invoke(ref readonly T arg)
 public readonly struct ActionWrapper<T1, T2>(Action<T1, T2> action) 
     : IAction<T1, T2>
 {
-    readonly Action<T1, T2> action = action ?? Throw.ArgumentNullException<Action<T1, T2>>(nameof(action));
+    readonly Action<T1, T2> action 
+        = action ?? Throw.ArgumentNullException<Action<T1, T2>>(nameof(action));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     void IAction<T1, T2>.Invoke(ref readonly T1 arg1, ref readonly T2 arg2)
@@ -68,7 +70,8 @@ void IAction<T>.Invoke(ref readonly T arg)
 public readonly struct ActionWrapper<T1, T2, T3>(Action<T1, T2, T3> action) 
     : IAction<T1, T2, T3>
 {
-    readonly Action<T1, T2, T3> action = action ?? Throw.ArgumentNullException<Action<T1, T2, T3>>(nameof(action));
+    readonly Action<T1, T2, T3> action 
+        = action ?? Throw.ArgumentNullException<Action<T1, T2, T3>>(nameof(action));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     void IAction<T1, T2, T3>.Invoke(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3)
@@ -95,7 +98,8 @@ void IAction<T>.Invoke(ref readonly T arg)
 public readonly struct ActionWrapper<T1, T2, T3, T4>(Action<T1, T2, T3, T4> action) 
     : IAction<T1, T2, T3, T4>
 {
-    readonly Action<T1, T2, T3, T4> action = action ?? Throw.ArgumentNullException<Action<T1, T2, T3, T4>>(nameof(action));
+    readonly Action<T1, T2, T3, T4> action 
+        = action ?? Throw.ArgumentNullException<Action<T1, T2, T3, T4>>(nameof(action));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     void IAction<T1, T2, T3, T4>.Invoke(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3, ref readonly T4 arg4)
@@ -123,7 +127,8 @@ void IAction<T>.Invoke(ref readonly T arg)
 public readonly struct ActionWrapper<T1, T2, T3, T4, T5>(Action<T1, T2, T3, T4, T5> action) 
     : IAction<T1, T2, T3, T4, T5>
 {
-    readonly Action<T1, T2, T3, T4, T5> action = action ?? Throw.ArgumentNullException<Action<T1, T2, T3, T4, T5>>(nameof(action));
+    readonly Action<T1, T2, T3, T4, T5> action 
+        = action ?? Throw.ArgumentNullException<Action<T1, T2, T3, T4, T5>>(nameof(action));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     void IAction<T1, T2, T3, T4, T5>.Invoke(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3, ref readonly T4 arg4, ref readonly T5 arg5)
@@ -152,7 +157,8 @@ void IAction<T>.Invoke(ref readonly T arg)
 public readonly struct ActionWrapper<T1, T2, T3, T4, T5, T6>(Action<T1, T2, T3, T4, T5, T6> action) 
     : IAction<T1, T2, T3, T4, T5, T6>
 {
-    readonly Action<T1, T2, T3, T4, T5, T6> action = action ?? Throw.ArgumentNullException<Action<T1, T2, T3, T4, T5, T6>>(nameof(action));
+    readonly Action<T1, T2, T3, T4, T5, T6> action 
+        = action ?? Throw.ArgumentNullException<Action<T1, T2, T3, T4, T5, T6>>(nameof(action));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     void IAction<T1, T2, T3, T4, T5, T6>.Invoke(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3, ref readonly T4 arg4, ref readonly T5 arg5, ref readonly T6 arg6)
@@ -182,7 +188,8 @@ void IAction<T>.Invoke(ref readonly T arg)
 public readonly struct ActionWrapper<T1, T2, T3, T4, T5, T6, T7>(Action<T1, T2, T3, T4, T5, T6, T7> action) 
     : IAction<T1, T2, T3, T4, T5, T6, T7>
 {
-    readonly Action<T1, T2, T3, T4, T5, T6, T7> action = action ?? Throw.ArgumentNullException<Action<T1, T2, T3, T4, T5, T6, T7>>(nameof(action));
+    readonly Action<T1, T2, T3, T4, T5, T6, T7> action 
+        = action ?? Throw.ArgumentNullException<Action<T1, T2, T3, T4, T5, T6, T7>>(nameof(action));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     void IAction<T1, T2, T3, T4, T5, T6, T7>.Invoke(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3, ref readonly T4 arg4, ref readonly T5 arg5, ref readonly T6 arg6, ref readonly T7 arg7)
@@ -213,7 +220,8 @@ void IAction<T>.Invoke(ref readonly T arg)
 public readonly struct ActionWrapper<T1, T2, T3, T4, T5, T6, T7, T8>(Action<T1, T2, T3, T4, T5, T6, T7, T8> action) 
     : IAction<T1, T2, T3, T4, T5, T6, T7, T8>
 {
-    readonly Action<T1, T2, T3, T4, T5, T6, T7, T8> action = action ?? Throw.ArgumentNullException<Action<T1, T2, T3, T4, T5, T6, T7, T8>>(nameof(action));
+    readonly Action<T1, T2, T3, T4, T5, T6, T7, T8> action 
+        = action ?? Throw.ArgumentNullException<Action<T1, T2, T3, T4, T5, T6, T7, T8>>(nameof(action));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     void IAction<T1, T2, T3, T4, T5, T6, T7, T8>.Invoke(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3, ref readonly T4 arg4, ref readonly T5 arg5, ref readonly T6 arg6, ref readonly T7 arg7, ref readonly T8 arg8)
@@ -245,7 +253,8 @@ void IAction<T>.Invoke(ref readonly T arg)
 public readonly struct ActionWrapper<T1, T2, T3, T4, T5, T6, T7, T8, T9>(Action<T1, T2, T3, T4, T5, T6, T7, T8, T9> action) 
     : IAction<T1, T2, T3, T4, T5, T6, T7, T8, T9>
 {
-    readonly Action<T1, T2, T3, T4, T5, T6, T7, T8, T9> action = action ?? Throw.ArgumentNullException<Action<T1, T2, T3, T4, T5, T6, T7, T8, T9>>(nameof(action));
+    readonly Action<T1, T2, T3, T4, T5, T6, T7, T8, T9> action 
+        = action ?? Throw.ArgumentNullException<Action<T1, T2, T3, T4, T5, T6, T7, T8, T9>>(nameof(action));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     void IAction<T1, T2, T3, T4, T5, T6, T7, T8, T9>.Invoke(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3, ref readonly T4 arg4, ref readonly T5 arg5, ref readonly T6 arg6, ref readonly T7 arg7, ref readonly T8 arg8, ref readonly T9 arg9)
diff --git a/NetFabric.Hyperlinq.Abstractions/AsyncFunctionWrapper.cs b/NetFabric.Hyperlinq.Abstractions/AsyncFunctionWrapper.cs
index 9d031d2c..ab9c8644 100644
--- a/NetFabric.Hyperlinq.Abstractions/AsyncFunctionWrapper.cs
+++ b/NetFabric.Hyperlinq.Abstractions/AsyncFunctionWrapper.cs
@@ -1,19 +1,14 @@
-using System;
-using System.Runtime.CompilerServices;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace NetFabric.Hyperlinq;
 
 [StructLayout(LayoutKind.Auto)]
-public readonly struct AsyncFunctionWrapper<T, TResult>
+public readonly struct AsyncFunctionWrapper<T, TResult>(Func<T, CancellationToken, ValueTask<TResult>> function)
     : IAsyncFunction<T, TResult>
 {
-    readonly Func<T, CancellationToken, ValueTask<TResult>> function;
-
-    public AsyncFunctionWrapper(Func<T, CancellationToken, ValueTask<TResult>> function)
-        => this.function = function ?? throw new ArgumentNullException(nameof(function));
+    readonly Func<T, CancellationToken, ValueTask<TResult>> function 
+        = function ?? throw new ArgumentNullException(nameof(function));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ValueTask<TResult> InvokeAsync(ref readonly T arg, CancellationToken cancellationToken)
@@ -24,13 +19,11 @@ public ValueTask<TResult> InvokeAsync(ref readonly T arg, CancellationToken canc
 }
 
 [StructLayout(LayoutKind.Auto)]
-public readonly struct AsyncFunctionWrapper<T1, T2, TResult>
+public readonly struct AsyncFunctionWrapper<T1, T2, TResult>(Func<T1, T2, CancellationToken, ValueTask<TResult>> function)
     : IAsyncFunction<T1, T2, TResult>
 {
-    readonly Func<T1, T2, CancellationToken, ValueTask<TResult>> function;
-
-    public AsyncFunctionWrapper(Func<T1, T2, CancellationToken, ValueTask<TResult>> function)
-        => this.function = function ?? throw new ArgumentNullException(nameof(function));
+    readonly Func<T1, T2, CancellationToken, ValueTask<TResult>> function 
+        = function ?? throw new ArgumentNullException(nameof(function));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ValueTask<TResult> InvokeAsync(ref readonly T1 arg1, ref readonly T2 arg2, CancellationToken cancellationToken)
@@ -41,13 +34,11 @@ public ValueTask<TResult> InvokeAsync(ref readonly T1 arg1, ref readonly T2 arg2
 }
 
 [StructLayout(LayoutKind.Auto)]
-public readonly struct AsyncFunctionWrapper<T1, T2, T3, TResult>
+public readonly struct AsyncFunctionWrapper<T1, T2, T3, TResult>(Func<T1, T2, T3, CancellationToken, ValueTask<TResult>> function)
     : IAsyncFunction<T1, T2, T3, TResult>
 {
-    readonly Func<T1, T2, T3, CancellationToken, ValueTask<TResult>> function;
-
-    public AsyncFunctionWrapper(Func<T1, T2, T3, CancellationToken, ValueTask<TResult>> function)
-        => this.function = function ?? throw new ArgumentNullException(nameof(function));
+    readonly Func<T1, T2, T3, CancellationToken, ValueTask<TResult>> function 
+        = function ?? throw new ArgumentNullException(nameof(function));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ValueTask<TResult> InvokeAsync(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3, CancellationToken cancellationToken)
@@ -58,13 +49,11 @@ public ValueTask<TResult> InvokeAsync(ref readonly T1 arg1, ref readonly T2 arg2
 }
 
 [StructLayout(LayoutKind.Auto)]
-public readonly struct AsyncFunctionWrapper<T1, T2, T3, T4, TResult>
+public readonly struct AsyncFunctionWrapper<T1, T2, T3, T4, TResult>(Func<T1, T2, T3, T4, CancellationToken, ValueTask<TResult>> function)
     : IAsyncFunction<T1, T2, T3, T4, TResult>
 {
-    readonly Func<T1, T2, T3, T4, CancellationToken, ValueTask<TResult>> function;
-
-    public AsyncFunctionWrapper(Func<T1, T2, T3, T4, CancellationToken, ValueTask<TResult>> function)
-        => this.function = function ?? throw new ArgumentNullException(nameof(function));
+    readonly Func<T1, T2, T3, T4, CancellationToken, ValueTask<TResult>> function 
+        = function ?? throw new ArgumentNullException(nameof(function));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ValueTask<TResult> InvokeAsync(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3, ref readonly T4 arg4, CancellationToken cancellationToken)
@@ -75,13 +64,11 @@ public ValueTask<TResult> InvokeAsync(ref readonly T1 arg1, ref readonly T2 arg2
 }
 
 [StructLayout(LayoutKind.Auto)]
-public readonly struct AsyncFunctionWrapper<T1, T2, T3, T4, T5, TResult>
+public readonly struct AsyncFunctionWrapper<T1, T2, T3, T4, T5, TResult>(Func<T1, T2, T3, T4, T5, CancellationToken, ValueTask<TResult>> function)
     : IAsyncFunction<T1, T2, T3, T4, T5, TResult>
 {
-    readonly Func<T1, T2, T3, T4, T5, CancellationToken, ValueTask<TResult>> function;
-
-    public AsyncFunctionWrapper(Func<T1, T2, T3, T4, T5, CancellationToken, ValueTask<TResult>> function)
-        => this.function = function ?? throw new ArgumentNullException(nameof(function));
+    readonly Func<T1, T2, T3, T4, T5, CancellationToken, ValueTask<TResult>> function 
+        = function ?? throw new ArgumentNullException(nameof(function));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ValueTask<TResult> InvokeAsync(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3, ref readonly T4 arg4, ref readonly T5 arg5, CancellationToken cancellationToken)
@@ -92,13 +79,11 @@ public ValueTask<TResult> InvokeAsync(ref readonly T1 arg1, ref readonly T2 arg2
 }
 
 [StructLayout(LayoutKind.Auto)]
-public readonly struct AsyncFunctionWrapper<T1, T2, T3, T4, T5, T6, TResult>
+public readonly struct AsyncFunctionWrapper<T1, T2, T3, T4, T5, T6, TResult>(Func<T1, T2, T3, T4, T5, T6, CancellationToken, ValueTask<TResult>> function)
     : IAsyncFunction<T1, T2, T3, T4, T5, T6, TResult>
 {
-    readonly Func<T1, T2, T3, T4, T5, T6, CancellationToken, ValueTask<TResult>> function;
-
-    public AsyncFunctionWrapper(Func<T1, T2, T3, T4, T5, T6, CancellationToken, ValueTask<TResult>> function)
-        => this.function = function ?? throw new ArgumentNullException(nameof(function));
+    readonly Func<T1, T2, T3, T4, T5, T6, CancellationToken, ValueTask<TResult>> function 
+        = function ?? throw new ArgumentNullException(nameof(function));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ValueTask<TResult> InvokeAsync(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3, ref readonly T4 arg4, ref readonly T5 arg5, ref readonly T6 arg6, CancellationToken cancellationToken)
@@ -109,13 +94,11 @@ public ValueTask<TResult> InvokeAsync(ref readonly T1 arg1, ref readonly T2 arg2
 }
 
 [StructLayout(LayoutKind.Auto)]
-public readonly struct AsyncFunctionWrapper<T1, T2, T3, T4, T5, T6, T7, TResult>
+public readonly struct AsyncFunctionWrapper<T1, T2, T3, T4, T5, T6, T7, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, CancellationToken, ValueTask<TResult>> function)
     : IAsyncFunction<T1, T2, T3, T4, T5, T6, T7, TResult>
 {
-    readonly Func<T1, T2, T3, T4, T5, T6, T7, CancellationToken, ValueTask<TResult>> function;
-
-    public AsyncFunctionWrapper(Func<T1, T2, T3, T4, T5, T6, T7, CancellationToken, ValueTask<TResult>> function)
-        => this.function = function ?? throw new ArgumentNullException(nameof(function));
+    readonly Func<T1, T2, T3, T4, T5, T6, T7, CancellationToken, ValueTask<TResult>> function 
+        = function ?? throw new ArgumentNullException(nameof(function));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ValueTask<TResult> InvokeAsync(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3, ref readonly T4 arg4, ref readonly T5 arg5, ref readonly T6 arg6, ref readonly T7 arg7, CancellationToken cancellationToken)
@@ -126,13 +109,11 @@ public ValueTask<TResult> InvokeAsync(ref readonly T1 arg1, ref readonly T2 arg2
 }
 
 [StructLayout(LayoutKind.Auto)]
-public readonly struct AsyncFunctionWrapper<T1, T2, T3, T4, T5, T6, T7, T8, TResult>
+public readonly struct AsyncFunctionWrapper<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, CancellationToken, ValueTask<TResult>> function)
     : IAsyncFunction<T1, T2, T3, T4, T5, T6, T7, T8, TResult>
 {
-    readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, CancellationToken, ValueTask<TResult>> function;
-
-    public AsyncFunctionWrapper(Func<T1, T2, T3, T4, T5, T6, T7, T8, CancellationToken, ValueTask<TResult>> function)
-        => this.function = function ?? throw new ArgumentNullException(nameof(function));
+    readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, CancellationToken, ValueTask<TResult>> function 
+        = function ?? throw new ArgumentNullException(nameof(function));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ValueTask<TResult> InvokeAsync(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3, ref readonly T4 arg4, ref readonly T5 arg5, ref readonly T6 arg6, ref readonly T7 arg7, ref readonly T8 arg8, CancellationToken cancellationToken)
@@ -143,13 +124,11 @@ public ValueTask<TResult> InvokeAsync(ref readonly T1 arg1, ref readonly T2 arg2
 }
 
 [StructLayout(LayoutKind.Auto)]
-public readonly struct AsyncFunctionWrapper<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>
+public readonly struct AsyncFunctionWrapper<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, CancellationToken, ValueTask<TResult>> function)
     : IAsyncFunction<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>
 {
-    readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, CancellationToken, ValueTask<TResult>> function;
-
-    public AsyncFunctionWrapper(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, CancellationToken, ValueTask<TResult>> function)
-        => this.function = function ?? throw new ArgumentNullException(nameof(function));
+    readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, CancellationToken, ValueTask<TResult>> function 
+        = function ?? throw new ArgumentNullException(nameof(function));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ValueTask<TResult> InvokeAsync(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3, ref readonly T4 arg4, ref readonly T5 arg5, ref readonly T6 arg6, ref readonly T7 arg7, ref readonly T8 arg8, ref readonly T9 arg9, CancellationToken cancellationToken)
diff --git a/NetFabric.Hyperlinq.Abstractions/AsyncValueEnumerable.cs b/NetFabric.Hyperlinq.Abstractions/AsyncValueEnumerable.cs
index 554f6825..632693f1 100644
--- a/NetFabric.Hyperlinq.Abstractions/AsyncValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Abstractions/AsyncValueEnumerable.cs
@@ -1,7 +1,4 @@
-using System.Collections.Generic;
-using System.Threading;
-
-namespace NetFabric.Hyperlinq;
+namespace NetFabric.Hyperlinq;
 
 public interface IAsyncValueEnumerable<out T, out TEnumerator>
     : IAsyncEnumerable<T>
diff --git a/NetFabric.Hyperlinq.Abstractions/FunctionWrapper.cs b/NetFabric.Hyperlinq.Abstractions/FunctionWrapper.cs
index 62716c9b..2960455b 100644
--- a/NetFabric.Hyperlinq.Abstractions/FunctionWrapper.cs
+++ b/NetFabric.Hyperlinq.Abstractions/FunctionWrapper.cs
@@ -1,17 +1,14 @@
-using System;
-using System.Runtime.CompilerServices;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
 namespace NetFabric.Hyperlinq;
 
 [StructLayout(LayoutKind.Auto)]
-public readonly struct FunctionWrapper<TResult>
+public readonly struct FunctionWrapper<TResult>(Func<TResult> function)
     : IFunction<TResult>
 {
-    readonly Func<TResult> function;
-
-    public FunctionWrapper(Func<TResult> function)
-        => this.function = function ?? throw new ArgumentNullException(nameof(function));
+    readonly Func<TResult> function 
+        = function ?? throw new ArgumentNullException(nameof(function));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public TResult Invoke()
@@ -22,13 +19,11 @@ public TResult Invoke()
 }
 
 [StructLayout(LayoutKind.Auto)]
-public readonly struct FunctionWrapper<T, TResult>
+public readonly struct FunctionWrapper<T, TResult>(Func<T, TResult> function)
     : IFunction<T, TResult>
 {
-    readonly Func<T, TResult> function;
-
-    public FunctionWrapper(Func<T, TResult> function)
-        => this.function = function ?? throw new ArgumentNullException(nameof(function));
+    readonly Func<T, TResult> function 
+        = function ?? throw new ArgumentNullException(nameof(function));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public TResult Invoke(T arg)
@@ -39,13 +34,11 @@ public TResult Invoke(T arg)
 }
 
 [StructLayout(LayoutKind.Auto)]
-public readonly struct FunctionWrapper<T1, T2, TResult>
+public readonly struct FunctionWrapper<T1, T2, TResult>(Func<T1, T2, TResult> function)
     : IFunction<T1, T2, TResult>
 {
-    readonly Func<T1, T2, TResult> function;
-
-    public FunctionWrapper(Func<T1, T2, TResult> function)
-        => this.function = function ?? throw new ArgumentNullException(nameof(function));
+    readonly Func<T1, T2, TResult> function 
+        = function ?? throw new ArgumentNullException(nameof(function));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public TResult Invoke(T1 arg1, T2 arg2)
@@ -56,13 +49,11 @@ public TResult Invoke(T1 arg1, T2 arg2)
 }
 
 [StructLayout(LayoutKind.Auto)]
-public readonly struct FunctionWrapper<T1, T2, T3, TResult>
+public readonly struct FunctionWrapper<T1, T2, T3, TResult>(Func<T1, T2, T3, TResult> function)
     : IFunction<T1, T2, T3, TResult>
 {
-    readonly Func<T1, T2, T3, TResult> function;
-
-    public FunctionWrapper(Func<T1, T2, T3, TResult> function)
-        => this.function = function ?? throw new ArgumentNullException(nameof(function));
+    readonly Func<T1, T2, T3, TResult> function 
+        = function ?? throw new ArgumentNullException(nameof(function));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public TResult Invoke(T1 arg1, T2 arg2, T3 arg3)
@@ -73,13 +64,11 @@ public TResult Invoke(T1 arg1, T2 arg2, T3 arg3)
 }
 
 [StructLayout(LayoutKind.Auto)]
-public readonly struct FunctionWrapper<T1, T2, T3, T4, TResult>
+public readonly struct FunctionWrapper<T1, T2, T3, T4, TResult>(Func<T1, T2, T3, T4, TResult> function)
     : IFunction<T1, T2, T3, T4, TResult>
 {
-    readonly Func<T1, T2, T3, T4, TResult> function;
-
-    public FunctionWrapper(Func<T1, T2, T3, T4, TResult> function)
-        => this.function = function ?? throw new ArgumentNullException(nameof(function));
+    readonly Func<T1, T2, T3, T4, TResult> function 
+        = function ?? throw new ArgumentNullException(nameof(function));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public TResult Invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4)
@@ -90,13 +79,11 @@ public TResult Invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4)
 }
 
 [StructLayout(LayoutKind.Auto)]
-public readonly struct FunctionWrapper<T1, T2, T3, T4, T5, TResult>
+public readonly struct FunctionWrapper<T1, T2, T3, T4, T5, TResult>(Func<T1, T2, T3, T4, T5, TResult> function)
     : IFunction<T1, T2, T3, T4, T5, TResult>
 {
-    readonly Func<T1, T2, T3, T4, T5, TResult> function;
-
-    public FunctionWrapper(Func<T1, T2, T3, T4, T5, TResult> function)
-        => this.function = function ?? throw new ArgumentNullException(nameof(function));
+    readonly Func<T1, T2, T3, T4, T5, TResult> function 
+        = function ?? throw new ArgumentNullException(nameof(function));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public TResult Invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
@@ -107,13 +94,11 @@ public TResult Invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
 }
 
 [StructLayout(LayoutKind.Auto)]
-public readonly struct FunctionWrapper<T1, T2, T3, T4, T5, T6, TResult>
+public readonly struct FunctionWrapper<T1, T2, T3, T4, T5, T6, TResult>(Func<T1, T2, T3, T4, T5, T6, TResult> function)
     : IFunction<T1, T2, T3, T4, T5, T6, TResult>
 {
-    readonly Func<T1, T2, T3, T4, T5, T6, TResult> function;
-
-    public FunctionWrapper(Func<T1, T2, T3, T4, T5, T6, TResult> function)
-        => this.function = function ?? throw new ArgumentNullException(nameof(function));
+    readonly Func<T1, T2, T3, T4, T5, T6, TResult> function
+        = function ?? throw new ArgumentNullException(nameof(function));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public TResult Invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
@@ -124,13 +109,11 @@ public TResult Invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
 }
 
 [StructLayout(LayoutKind.Auto)]
-public readonly struct FunctionWrapper<T1, T2, T3, T4, T5, T6, T7, TResult>
+public readonly struct FunctionWrapper<T1, T2, T3, T4, T5, T6, T7, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, TResult> function)
     : IFunction<T1, T2, T3, T4, T5, T6, T7, TResult>
 {
-    readonly Func<T1, T2, T3, T4, T5, T6, T7, TResult> function;
-
-    public FunctionWrapper(Func<T1, T2, T3, T4, T5, T6, T7, TResult> function)
-        => this.function = function ?? throw new ArgumentNullException(nameof(function));
+    readonly Func<T1, T2, T3, T4, T5, T6, T7, TResult> function 
+        = function ?? throw new ArgumentNullException(nameof(function));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public TResult Invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
@@ -141,13 +124,11 @@ public TResult Invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 a
 }
 
 [StructLayout(LayoutKind.Auto)]
-public readonly struct FunctionWrapper<T1, T2, T3, T4, T5, T6, T7, T8, TResult>
+public readonly struct FunctionWrapper<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> function)
     : IFunction<T1, T2, T3, T4, T5, T6, T7, T8, TResult>
 {
-    readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> function;
-
-    public FunctionWrapper(Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> function)
-        => this.function = function ?? throw new ArgumentNullException(nameof(function));
+    readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> function 
+        = function ?? throw new ArgumentNullException(nameof(function));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public TResult Invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
@@ -158,13 +139,11 @@ public TResult Invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 a
 }
 
 [StructLayout(LayoutKind.Auto)]
-public readonly struct FunctionWrapper<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>
+public readonly struct FunctionWrapper<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> function)
     : IFunction<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>
 {
-    readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> function;
-
-    public FunctionWrapper(Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> function)
-        => this.function = function ?? throw new ArgumentNullException(nameof(function));
+    readonly Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> function 
+        = function ?? throw new ArgumentNullException(nameof(function));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public TResult Invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
diff --git a/NetFabric.Hyperlinq.Abstractions/IAction.cs b/NetFabric.Hyperlinq.Abstractions/IAction.cs
index d9a2b95d..3cdaa8d2 100644
--- a/NetFabric.Hyperlinq.Abstractions/IAction.cs
+++ b/NetFabric.Hyperlinq.Abstractions/IAction.cs
@@ -1,193 +1,190 @@
-using System.Numerics;
+namespace NetFabric.Hyperlinq;
 
-namespace NetFabric.Hyperlinq
+/// <summary>
+/// Defines an interface for a generic action that can be invoked with a readonly reference to an argument of type <typeparamref name="T"/>.
+/// </summary>
+/// <typeparam name="T">The type of the argument to be passed when invoking the action.</typeparam>
+public interface IAction<T>
 {
     /// <summary>
-    /// Defines an interface for a generic action that can be invoked with a readonly reference to an argument of type <typeparamref name="T"/>.
+    /// Invokes the action with a readonly reference to the specified argument of type <typeparamref name="T"/>.
     /// </summary>
-    /// <typeparam name="T">The type of the argument to be passed when invoking the action.</typeparam>
-    public interface IAction<T>
-    {
-        /// <summary>
-        /// Invokes the action with a readonly reference to the specified argument of type <typeparamref name="T"/>.
-        /// </summary>
-        /// <param name="arg">The readonly reference to the argument to be passed to the action.</param>
-        void Invoke(ref readonly T arg);
-    }
+    /// <param name="arg">The readonly reference to the argument to be passed to the action.</param>
+    void Invoke(ref readonly T arg);
+}
 
+/// <summary>
+/// Defines an interface for a generic action that can be invoked with readonly references to two arguments of type <typeparamref name="T1"/> and <typeparamref name="T2"/>.
+/// </summary>
+/// <typeparam name="T1">The type of the first argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T2">The type of the second argument to be passed when invoking the action.</typeparam>
+public interface IAction<T1, T2>
+{
     /// <summary>
-    /// Defines an interface for a generic action that can be invoked with readonly references to two arguments of type <typeparamref name="T1"/> and <typeparamref name="T2"/>.
+    /// Invokes the action with readonly references to the specified arguments of type <typeparamref name="T1"/> and <typeparamref name="T2"/>.
     /// </summary>
-    /// <typeparam name="T1">The type of the first argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T2">The type of the second argument to be passed when invoking the action.</typeparam>
-    public interface IAction<T1, T2>
-    {
-        /// <summary>
-        /// Invokes the action with readonly references to the specified arguments of type <typeparamref name="T1"/> and <typeparamref name="T2"/>.
-        /// </summary>
-        /// <param name="arg1">The readonly reference to the first argument to be passed to the action.</param>
-        /// <param name="arg2">The readonly reference to the second argument to be passed to the action.</param>
-        void Invoke(ref readonly T1 arg1, ref readonly T2 arg2);
-    }
+    /// <param name="arg1">The readonly reference to the first argument to be passed to the action.</param>
+    /// <param name="arg2">The readonly reference to the second argument to be passed to the action.</param>
+    void Invoke(ref readonly T1 arg1, ref readonly T2 arg2);
+}
 
+/// <summary>
+/// Defines an interface for a generic action that can be invoked with readonly references to three arguments of type <typeparamref name="T1"/>, <typeparamref name="T2"/>, and <typeparamref name="T3"/>.
+/// </summary>
+/// <typeparam name="T1">The type of the first argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T2">The type of the second argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T3">The type of the third argument to be passed when invoking the action.</typeparam>
+public interface IAction<T1, T2, T3>
+{
     /// <summary>
-    /// Defines an interface for a generic action that can be invoked with readonly references to three arguments of type <typeparamref name="T1"/>, <typeparamref name="T2"/>, and <typeparamref name="T3"/>.
+    /// Invokes the action with readonly references to the specified arguments of type <typeparamref name="T1"/>, <typeparamref name="T2"/>, and <typeparamref name="T3"/>.
     /// </summary>
-    /// <typeparam name="T1">The type of the first argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T2">The type of the second argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T3">The type of the third argument to be passed when invoking the action.</typeparam>
-    public interface IAction<T1, T2, T3>
-    {
-        /// <summary>
-        /// Invokes the action with readonly references to the specified arguments of type <typeparamref name="T1"/>, <typeparamref name="T2"/>, and <typeparamref name="T3"/>.
-        /// </summary>
-        /// <param name="arg1">The readonly reference to the first argument to be passed to the action.</param>
-        /// <param name="arg2">The readonly reference to the second argument to be passed to the action.</param>
-        /// <param name="arg3">The readonly reference to the third argument to be passed to the action.</param>
-        void Invoke(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3);
-    }
+    /// <param name="arg1">The readonly reference to the first argument to be passed to the action.</param>
+    /// <param name="arg2">The readonly reference to the second argument to be passed to the action.</param>
+    /// <param name="arg3">The readonly reference to the third argument to be passed to the action.</param>
+    void Invoke(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3);
+}
 
+/// <summary>
+/// Defines an interface for a generic action that can be invoked with readonly references to nine arguments of types <typeparamref name="T1"/> to <typeparamref name="T9"/>.
+/// </summary>
+/// <typeparam name="T1">The type of the first argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T2">The type of the second argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T3">The type of the third argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T4">The type of the fourth argument to be passed when invoking the action.</typeparam>
+public interface IAction<T1, T2, T3, T4>
+{
     /// <summary>
-    /// Defines an interface for a generic action that can be invoked with readonly references to nine arguments of types <typeparamref name="T1"/> to <typeparamref name="T9"/>.
+    /// Invokes the action with readonly references to the specified arguments of types <typeparamref name="T1"/> to <typeparamref name="T4"/>.
     /// </summary>
-    /// <typeparam name="T1">The type of the first argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T2">The type of the second argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T3">The type of the third argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T4">The type of the fourth argument to be passed when invoking the action.</typeparam>
-    public interface IAction<T1, T2, T3, T4>
-    {
-        /// <summary>
-        /// Invokes the action with readonly references to the specified arguments of types <typeparamref name="T1"/> to <typeparamref name="T4"/>.
-        /// </summary>
-        /// <param name="arg1">The readonly reference to the first argument to be passed to the action.</param>
-        /// <param name="arg2">The readonly reference to the second argument to be passed to the action.</param>
-        /// <param name="arg3">The readonly reference to the third argument to be passed to the action.</param>
-        /// <param name="arg4">The readonly reference to the fourth argument to be passed to the action.</param>
-        void Invoke(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3, ref readonly T4 arg4);
-    }
+    /// <param name="arg1">The readonly reference to the first argument to be passed to the action.</param>
+    /// <param name="arg2">The readonly reference to the second argument to be passed to the action.</param>
+    /// <param name="arg3">The readonly reference to the third argument to be passed to the action.</param>
+    /// <param name="arg4">The readonly reference to the fourth argument to be passed to the action.</param>
+    void Invoke(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3, ref readonly T4 arg4);
+}
 
+/// <summary>
+/// Defines an interface for a generic action that can be invoked with readonly references to nine arguments of types <typeparamref name="T1"/> to <typeparamref name="T5"/>.
+/// </summary>
+/// <typeparam name="T1">The type of the first argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T2">The type of the second argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T3">The type of the third argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T4">The type of the fourth argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T5">The type of the fifth argument to be passed when invoking the action.</typeparam>
+public interface IAction<T1, T2, T3, T4, T5>
+{
     /// <summary>
-    /// Defines an interface for a generic action that can be invoked with readonly references to nine arguments of types <typeparamref name="T1"/> to <typeparamref name="T5"/>.
+    /// Invokes the action with readonly references to the specified arguments of types <typeparamref name="T1"/> to <typeparamref name="T6"/>.
     /// </summary>
-    /// <typeparam name="T1">The type of the first argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T2">The type of the second argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T3">The type of the third argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T4">The type of the fourth argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T5">The type of the fifth argument to be passed when invoking the action.</typeparam>
-    public interface IAction<T1, T2, T3, T4, T5>
-    {
-        /// <summary>
-        /// Invokes the action with readonly references to the specified arguments of types <typeparamref name="T1"/> to <typeparamref name="T6"/>.
-        /// </summary>
-        /// <param name="arg1">The readonly reference to the first argument to be passed to the action.</param>
-        /// <param name="arg2">The readonly reference to the second argument to be passed to the action.</param>
-        /// <param name="arg3">The readonly reference to the third argument to be passed to the action.</param>
-        /// <param name="arg4">The readonly reference to the fourth argument to be passed to the action.</param>
-        /// <param name="arg5">The readonly reference to the fifth argument to be passed to the action.</param>
-        void Invoke(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3, ref readonly T4 arg4, ref readonly T5 arg5);
-    }
+    /// <param name="arg1">The readonly reference to the first argument to be passed to the action.</param>
+    /// <param name="arg2">The readonly reference to the second argument to be passed to the action.</param>
+    /// <param name="arg3">The readonly reference to the third argument to be passed to the action.</param>
+    /// <param name="arg4">The readonly reference to the fourth argument to be passed to the action.</param>
+    /// <param name="arg5">The readonly reference to the fifth argument to be passed to the action.</param>
+    void Invoke(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3, ref readonly T4 arg4, ref readonly T5 arg5);
+}
 
+/// <summary>
+/// Defines an interface for a generic action that can be invoked with readonly references to nine arguments of types <typeparamref name="T1"/> to <typeparamref name="T7"/>.
+/// </summary>
+/// <typeparam name="T1">The type of the first argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T2">The type of the second argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T3">The type of the third argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T4">The type of the fourth argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T5">The type of the fifth argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T6">The type of the sixth argument to be passed when invoking the action.</typeparam>
+public interface IAction<T1, T2, T3, T4, T5, T6>
+{
     /// <summary>
-    /// Defines an interface for a generic action that can be invoked with readonly references to nine arguments of types <typeparamref name="T1"/> to <typeparamref name="T7"/>.
+    /// Invokes the action with readonly references to the specified arguments of types <typeparamref name="T1"/> to <typeparamref name="T8"/>.
     /// </summary>
-    /// <typeparam name="T1">The type of the first argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T2">The type of the second argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T3">The type of the third argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T4">The type of the fourth argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T5">The type of the fifth argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T6">The type of the sixth argument to be passed when invoking the action.</typeparam>
-    public interface IAction<T1, T2, T3, T4, T5, T6>
-    {
-        /// <summary>
-        /// Invokes the action with readonly references to the specified arguments of types <typeparamref name="T1"/> to <typeparamref name="T8"/>.
-        /// </summary>
-        /// <param name="arg1">The readonly reference to the first argument to be passed to the action.</param>
-        /// <param name="arg2">The readonly reference to the second argument to be passed to the action.</param>
-        /// <param name="arg3">The readonly reference to the third argument to be passed to the action.</param>
-        /// <param name="arg4">The readonly reference to the fourth argument to be passed to the action.</param>
-        /// <param name="arg5">The readonly reference to the fifth argument to be passed to the action.</param>
-        /// <param name="arg6">The readonly reference to the sixth argument to be passed to the action.</param>
-        void Invoke(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3, ref readonly T4 arg4, ref readonly T5 arg5, ref readonly T6 arg6);
-    }
+    /// <param name="arg1">The readonly reference to the first argument to be passed to the action.</param>
+    /// <param name="arg2">The readonly reference to the second argument to be passed to the action.</param>
+    /// <param name="arg3">The readonly reference to the third argument to be passed to the action.</param>
+    /// <param name="arg4">The readonly reference to the fourth argument to be passed to the action.</param>
+    /// <param name="arg5">The readonly reference to the fifth argument to be passed to the action.</param>
+    /// <param name="arg6">The readonly reference to the sixth argument to be passed to the action.</param>
+    void Invoke(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3, ref readonly T4 arg4, ref readonly T5 arg5, ref readonly T6 arg6);
+}
 
+/// <summary>
+/// Defines an interface for a generic action that can be invoked with readonly references to nine arguments of types <typeparamref name="T1"/> to <typeparamref name="T9"/>.
+/// </summary>
+/// <typeparam name="T1">The type of the first argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T2">The type of the second argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T3">The type of the third argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T4">The type of the fourth argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T5">The type of the fifth argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T6">The type of the sixth argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T7">The type of the seventh argument to be passed when invoking the action.</typeparam>
+public interface IAction<T1, T2, T3, T4, T5, T6, T7>
+{
     /// <summary>
-    /// Defines an interface for a generic action that can be invoked with readonly references to nine arguments of types <typeparamref name="T1"/> to <typeparamref name="T9"/>.
+    /// Invokes the action with readonly references to the specified arguments of types <typeparamref name="T1"/> to <typeparamref name="T9"/>.
     /// </summary>
-    /// <typeparam name="T1">The type of the first argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T2">The type of the second argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T3">The type of the third argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T4">The type of the fourth argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T5">The type of the fifth argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T6">The type of the sixth argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T7">The type of the seventh argument to be passed when invoking the action.</typeparam>
-    public interface IAction<T1, T2, T3, T4, T5, T6, T7>
-    {
-        /// <summary>
-        /// Invokes the action with readonly references to the specified arguments of types <typeparamref name="T1"/> to <typeparamref name="T9"/>.
-        /// </summary>
-        /// <param name="arg1">The readonly reference to the first argument to be passed to the action.</param>
-        /// <param name="arg2">The readonly reference to the second argument to be passed to the action.</param>
-        /// <param name="arg3">The readonly reference to the third argument to be passed to the action.</param>
-        /// <param name="arg4">The readonly reference to the fourth argument to be passed to the action.</param>
-        /// <param name="arg5">The readonly reference to the fifth argument to be passed to the action.</param>
-        /// <param name="arg6">The readonly reference to the sixth argument to be passed to the action.</param>
-        /// <param name="arg7">The readonly reference to the seventh argument to be passed to the action.</param>
-        void Invoke(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3, ref readonly T4 arg4, ref readonly T5 arg5, ref readonly T6 arg6, ref readonly T7 arg7);
-    }
+    /// <param name="arg1">The readonly reference to the first argument to be passed to the action.</param>
+    /// <param name="arg2">The readonly reference to the second argument to be passed to the action.</param>
+    /// <param name="arg3">The readonly reference to the third argument to be passed to the action.</param>
+    /// <param name="arg4">The readonly reference to the fourth argument to be passed to the action.</param>
+    /// <param name="arg5">The readonly reference to the fifth argument to be passed to the action.</param>
+    /// <param name="arg6">The readonly reference to the sixth argument to be passed to the action.</param>
+    /// <param name="arg7">The readonly reference to the seventh argument to be passed to the action.</param>
+    void Invoke(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3, ref readonly T4 arg4, ref readonly T5 arg5, ref readonly T6 arg6, ref readonly T7 arg7);
+}
 
+/// <summary>
+/// Defines an interface for a generic action that can be invoked with readonly references to nine arguments of types <typeparamref name="T1"/> to <typeparamref name="T9"/>.
+/// </summary>
+/// <typeparam name="T1">The type of the first argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T2">The type of the second argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T3">The type of the third argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T4">The type of the fourth argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T5">The type of the fifth argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T6">The type of the sixth argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T7">The type of the seventh argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T8">The type of the eighth argument to be passed when invoking the action.</typeparam>
+public interface IAction<T1, T2, T3, T4, T5, T6, T7, T8>
+{
     /// <summary>
-    /// Defines an interface for a generic action that can be invoked with readonly references to nine arguments of types <typeparamref name="T1"/> to <typeparamref name="T9"/>.
+    /// Invokes the action with readonly references to the specified arguments of types <typeparamref name="T1"/> to <typeparamref name="T9"/>.
     /// </summary>
-    /// <typeparam name="T1">The type of the first argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T2">The type of the second argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T3">The type of the third argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T4">The type of the fourth argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T5">The type of the fifth argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T6">The type of the sixth argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T7">The type of the seventh argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T8">The type of the eighth argument to be passed when invoking the action.</typeparam>
-    public interface IAction<T1, T2, T3, T4, T5, T6, T7, T8>
-    {
-        /// <summary>
-        /// Invokes the action with readonly references to the specified arguments of types <typeparamref name="T1"/> to <typeparamref name="T9"/>.
-        /// </summary>
-        /// <param name="arg1">The readonly reference to the first argument to be passed to the action.</param>
-        /// <param name="arg2">The readonly reference to the second argument to be passed to the action.</param>
-        /// <param name="arg3">The readonly reference to the third argument to be passed to the action.</param>
-        /// <param name="arg4">The readonly reference to the fourth argument to be passed to the action.</param>
-        /// <param name="arg5">The readonly reference to the fifth argument to be passed to the action.</param>
-        /// <param name="arg6">The readonly reference to the sixth argument to be passed to the action.</param>
-        /// <param name="arg7">The readonly reference to the seventh argument to be passed to the action.</param>
-        /// <param name="arg8">The readonly reference to the eighth argument to be passed to the action.</param>
-        void Invoke(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3, ref readonly T4 arg4, ref readonly T5 arg5, ref readonly T6 arg6, ref readonly T7 arg7, ref readonly T8 arg8);
-    }
+    /// <param name="arg1">The readonly reference to the first argument to be passed to the action.</param>
+    /// <param name="arg2">The readonly reference to the second argument to be passed to the action.</param>
+    /// <param name="arg3">The readonly reference to the third argument to be passed to the action.</param>
+    /// <param name="arg4">The readonly reference to the fourth argument to be passed to the action.</param>
+    /// <param name="arg5">The readonly reference to the fifth argument to be passed to the action.</param>
+    /// <param name="arg6">The readonly reference to the sixth argument to be passed to the action.</param>
+    /// <param name="arg7">The readonly reference to the seventh argument to be passed to the action.</param>
+    /// <param name="arg8">The readonly reference to the eighth argument to be passed to the action.</param>
+    void Invoke(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3, ref readonly T4 arg4, ref readonly T5 arg5, ref readonly T6 arg6, ref readonly T7 arg7, ref readonly T8 arg8);
+}
 
+/// <summary>
+/// Defines an interface for a generic action that can be invoked with readonly references to nine arguments of types <typeparamref name="T1"/> to <typeparamref name="T9"/>.
+/// </summary>
+/// <typeparam name="T1">The type of the first argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T2">The type of the second argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T3">The type of the third argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T4">The type of the fourth argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T5">The type of the fifth argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T6">The type of the sixth argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T7">The type of the seventh argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T8">The type of the eighth argument to be passed when invoking the action.</typeparam>
+/// <typeparam name="T9">The type of the ninth argument to be passed when invoking the action.</typeparam>
+public interface IAction<T1, T2, T3, T4, T5, T6, T7, T8, T9>
+{
     /// <summary>
-    /// Defines an interface for a generic action that can be invoked with readonly references to nine arguments of types <typeparamref name="T1"/> to <typeparamref name="T9"/>.
+    /// Invokes the action with readonly references to the specified arguments of types <typeparamref name="T1"/> to <typeparamref name="T9"/>.
     /// </summary>
-    /// <typeparam name="T1">The type of the first argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T2">The type of the second argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T3">The type of the third argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T4">The type of the fourth argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T5">The type of the fifth argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T6">The type of the sixth argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T7">The type of the seventh argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T8">The type of the eighth argument to be passed when invoking the action.</typeparam>
-    /// <typeparam name="T9">The type of the ninth argument to be passed when invoking the action.</typeparam>
-    public interface IAction<T1, T2, T3, T4, T5, T6, T7, T8, T9>
-    {
-        /// <summary>
-        /// Invokes the action with readonly references to the specified arguments of types <typeparamref name="T1"/> to <typeparamref name="T9"/>.
-        /// </summary>
-        /// <param name="arg1">The readonly reference to the first argument to be passed to the action.</param>
-        /// <param name="arg2">The readonly reference to the second argument to be passed to the action.</param>
-        /// <param name="arg3">The readonly reference to the third argument to be passed to the action.</param>
-        /// <param name="arg4">The readonly reference to the fourth argument to be passed to the action.</param>
-        /// <param name="arg5">The readonly reference to the fifth argument to be passed to the action.</param>
-        /// <param name="arg6">The readonly reference to the sixth argument to be passed to the action.</param>
-        /// <param name="arg7">The readonly reference to the seventh argument to be passed to the action.</param>
-        /// <param name="arg8">The readonly reference to the eighth argument to be passed to the action.</param>
-        /// <param name="arg9">The readonly reference to the ninth argument to be passed to the action.</param>
-        void Invoke(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3, ref readonly T4 arg4, ref readonly T5 arg5, ref readonly T6 arg6, ref readonly T7 arg7, ref readonly T8 arg8, ref readonly T9 arg9);
-    }
+    /// <param name="arg1">The readonly reference to the first argument to be passed to the action.</param>
+    /// <param name="arg2">The readonly reference to the second argument to be passed to the action.</param>
+    /// <param name="arg3">The readonly reference to the third argument to be passed to the action.</param>
+    /// <param name="arg4">The readonly reference to the fourth argument to be passed to the action.</param>
+    /// <param name="arg5">The readonly reference to the fifth argument to be passed to the action.</param>
+    /// <param name="arg6">The readonly reference to the sixth argument to be passed to the action.</param>
+    /// <param name="arg7">The readonly reference to the seventh argument to be passed to the action.</param>
+    /// <param name="arg8">The readonly reference to the eighth argument to be passed to the action.</param>
+    /// <param name="arg9">The readonly reference to the ninth argument to be passed to the action.</param>
+    void Invoke(ref readonly T1 arg1, ref readonly T2 arg2, ref readonly T3 arg3, ref readonly T4 arg4, ref readonly T5 arg5, ref readonly T6 arg6, ref readonly T7 arg7, ref readonly T8 arg8, ref readonly T9 arg9);
 }
diff --git a/NetFabric.Hyperlinq.Abstractions/IAsyncFunction.cs b/NetFabric.Hyperlinq.Abstractions/IAsyncFunction.cs
index 2fc0aa6e..2303ce80 100644
--- a/NetFabric.Hyperlinq.Abstractions/IAsyncFunction.cs
+++ b/NetFabric.Hyperlinq.Abstractions/IAsyncFunction.cs
@@ -1,7 +1,4 @@
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace NetFabric.Hyperlinq;
+namespace NetFabric.Hyperlinq;
 
 public interface IAsyncFunction<T, TResult>
 {
diff --git a/NetFabric.Hyperlinq.Abstractions/IValueEnumerable.cs b/NetFabric.Hyperlinq.Abstractions/IValueEnumerable.cs
index 92f6c3ae..18bc4b96 100644
--- a/NetFabric.Hyperlinq.Abstractions/IValueEnumerable.cs
+++ b/NetFabric.Hyperlinq.Abstractions/IValueEnumerable.cs
@@ -1,28 +1,26 @@
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics.CodeAnalysis;
 
-namespace NetFabric.Hyperlinq
+namespace NetFabric.Hyperlinq;
+
+/// <summary>
+/// Represents a read-only collection of values with a non-boxing enumerator,
+/// providing an alternative to <see cref="IEnumerable{T}"/> for improved performance.
+/// </summary>
+/// <typeparam name="T">The type of elements in the collection.</typeparam>
+/// <typeparam name="TEnumerator">The type of the enumerator.</typeparam>
+/// <remarks>
+/// This interface is designed to offer improved performance over <see cref="IEnumerable{T}"/>
+/// by avoiding the boxing of the enumerator. It maintains backward compatibility by deriving from
+/// <see cref="IEnumerable{T}"/>.
+/// </remarks>
+public interface IValueEnumerable<out T, out TEnumerator> 
+    : IEnumerable<T>
+    where TEnumerator : struct, IEnumerator<T>
 {
     /// <summary>
-    /// Represents a read-only collection of values with a non-boxing enumerator,
-    /// providing an alternative to <see cref="IEnumerable{T}"/> for improved performance.
+    /// Returns an enumerator instance.
     /// </summary>
-    /// <typeparam name="T">The type of elements in the collection.</typeparam>
-    /// <typeparam name="TEnumerator">The type of the enumerator.</typeparam>
-    /// <remarks>
-    /// This interface is designed to offer improved performance over <see cref="IEnumerable{T}"/>
-    /// by avoiding the boxing of the enumerator. It maintains backward compatibility by deriving from
-    /// <see cref="IEnumerable{T}"/>.
-    /// </remarks>
-    public interface IValueEnumerable<out T, out TEnumerator> 
-        : IEnumerable<T>
-        where TEnumerator : struct, IEnumerator<T>
-    {
-        /// <summary>
-        /// Returns an enumerator instance.
-        /// </summary>
-        /// <returns>An enumerator instance.</returns>
-        [return: NotNull] 
-        new TEnumerator GetEnumerator();
-    }
+    /// <returns>An enumerator instance.</returns>
+    [return: NotNull] 
+    new TEnumerator GetEnumerator();
 }
diff --git a/NetFabric.Hyperlinq.Abstractions/IVectorAction.cs b/NetFabric.Hyperlinq.Abstractions/IVectorAction.cs
index 9872806f..41b4742b 100644
--- a/NetFabric.Hyperlinq.Abstractions/IVectorAction.cs
+++ b/NetFabric.Hyperlinq.Abstractions/IVectorAction.cs
@@ -2,7 +2,7 @@
 
 namespace NetFabric.Hyperlinq;
 
-#if NETSTANDARD2_1_OR_GREATER
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP1_0_OR_GREATER
 
 /// <summary>
 /// Represents an interface for a generic action that can be invoked with a readonly reference to a <see cref="Vector{T}"/> argument of type <typeparamref name="T"/>.
@@ -17,7 +17,8 @@ namespace NetFabric.Hyperlinq;
 /// The <see cref="IAction{T}.Invoke(T)"/> method is used instead in scenarios where vectorization is not available or on elements
 /// that don't fit in a <see cref="Vector{T}"/>. 
 /// </remarks>
-public interface IVectorAction<T> : IAction<T>
+public interface IVectorAction<T> 
+    : IAction<T>
     where T : struct
 {
     /// <summary>
@@ -98,4 +99,49 @@ public interface IVectorAction4D<T>
     void Invoke(ref readonly Vector<T> arg);
 }
 
+// <summary>
+/// Represents an interface for a generic 5D action that can be invoked with a readonly reference to a <see cref="Vector{T}"/> argument of type <typeparamref name="T"/>.
+/// </summary>
+/// <typeparam name="T">The type of the elements in the <see cref="Vector{T}"/> argument.</typeparam>
+/// <remarks>
+/// This interface extends the <see cref="IAction{T1, T2, T3, T4, T5}"/> interface to support 2D vectorized operations. It allows actions to be invoked
+/// with a readonly reference to a <see cref="Vector{T}"/> argument, making it suitable for scenarios where 2D vectorization can be applied
+/// for improved performance in numerical or computational tasks.
+/// </remarks>
+/// <remarks>
+/// The <see cref="IAction{T1, T2, T3, T4, T5}.Invoke(T1, T2, T3, T4, T5)"/> method is used instead in scenarios where vectorization is not available or on elements
+/// that don't fit in a <see cref="Vector{T}"/>.
+/// </remarks>
+public interface IVectorAction5D<T> : IAction<T, T, T, T, T> where T : struct
+{
+    /// <summary>
+    /// Invokes the action with a readonly reference to the specified <see cref="Vector{T}"/> argument of type <typeparamref name="T"/>.
+    /// </summary>
+    /// <param name="arg">The readonly reference to the <see cref="Vector{T}"/> argument.</param>
+    void Invoke(in Vector<T> arg);
+}
+
+// <summary>
+/// Represents an interface for a generic 6D action that can be invoked with a readonly reference to a <see cref="Vector{T}"/> argument of type <typeparamref name="T"/>.
+/// </summary>
+/// <typeparam name="T">The type of the elements in the <see cref="Vector{T}"/> argument.</typeparam>
+/// <remarks>
+/// This interface extends the <see cref="IAction{T1, T2, T3, T4, T5, T6}"/> interface to support 2D vectorized operations. It allows actions to be invoked
+/// with a readonly reference to a <see cref="Vector{T}"/> argument, making it suitable for scenarios where 2D vectorization can be applied
+/// for improved performance in numerical or computational tasks.
+/// </remarks>
+/// <remarks>
+/// The <see cref="IAction{T1, T2, T3, T4, T5, T6}.Invoke(T1, T2, T3, T4, T5, T6)"/> method is used instead in scenarios where vectorization is not available or on elements
+/// that don't fit in a <see cref="Vector{T}"/>.
+/// </remarks>
+public interface IVectorAction6D<T> : IAction<T, T, T, T, T, T> where T : struct
+{
+    /// <summary>
+    /// Invokes the action with a readonly reference to the specified <see cref="Vector{T}"/> argument of type <typeparamref name="T"/>.
+    /// </summary>
+    /// <param name="arg">The readonly reference to the <see cref="Vector{T}"/> argument.</param>
+    void Invoke(in Vector<T> arg);
+}
+
+
 #endif
diff --git a/NetFabric.Hyperlinq.Abstractions/NetFabric.Hyperlinq.Abstractions.csproj b/NetFabric.Hyperlinq.Abstractions/NetFabric.Hyperlinq.Abstractions.csproj
index 71f8966b..3cc482b1 100644
--- a/NetFabric.Hyperlinq.Abstractions/NetFabric.Hyperlinq.Abstractions.csproj
+++ b/NetFabric.Hyperlinq.Abstractions/NetFabric.Hyperlinq.Abstractions.csproj
@@ -8,6 +8,7 @@
     <Version>2.0.0</Version>
     <PackageIcon>Icon.png</PackageIcon>
     <PackageLicenseFile>LICENSE</PackageLicenseFile>
+    <PackageReadmeFile>README.md</PackageReadmeFile>
     <PackageTags>netfabric, hyperlinq, abstractions, linq, enumeration, performance</PackageTags>
     <PublishRepositoryUrl>true</PublishRepositoryUrl>
     <IncludeSymbols>true</IncludeSymbols>
@@ -18,10 +19,11 @@
   <ItemGroup>
     <None Include="..\Icon.png" Pack="true" PackagePath="" />
     <None Include="..\LICENSE" Pack="true" PackagePath="" />
+    <None Include=".\README.md" Pack="true" PackagePath="" />
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="NetFabric" Version="1.4.2" />
+    <PackageReference Include="NetFabric" Version="1.5.0" />
     <PackageReference Include="Nullable" Version="1.3.1">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
diff --git a/NetFabric.Hyperlinq.Abstractions/README.md b/NetFabric.Hyperlinq.Abstractions/README.md
new file mode 100644
index 00000000..d3e9863e
--- /dev/null
+++ b/NetFabric.Hyperlinq.Abstractions/README.md
@@ -0,0 +1,65 @@
+# NetFabric.Hyperlinq.Abstractions
+
+This library provides abstractions for optimizing the performance of enumerations.
+
+## IValueEnumerable Interface
+
+In this package, you'll find the `IValueEnumerable<out T, out TEnumerator>` interface. It's designed for collections that want a value type enumerator for better performance, avoiding the enumerator boxing present in `IEnumerable` and `IEnumerable<T>`.
+
+## Value Delegates
+
+In C#, the commonly used predefined delegates [Func<T>](https://github.com/dotnet/dotnet/blob/57e423d62059914d1b92854b656abecdc120e538/src/runtime/src/libraries/System.Private.CoreLib/src/System/Function.cs#L6) and [Action<T>](https://github.com/dotnet/dotnet/blob/57e423d62059914d1b92854b656abecdc120e538/src/runtime/src/libraries/System.Private.CoreLib/src/System/Action.cs#L9) can lead to performance issues due to heap allocation and virtual calls. Value delegates address this by providing optimized performance for resource-intensive scenarios.
+
+It's worth noting that value delegates aren't automatically supported by the compiler and need explicit implementation.
+
+The package introduces interfaces like `IAction<T>`, `IFunction<T, TResult>`, `IAsyncFunction<T, TResult>`, and `IVectorAction<T>`. These interfaces define a method `Invoke()` that can be implemented by a value type. Instances of this value type can replace traditional delegates as parameters and can also hold state, similar to the reference type generated by the compiler when using delegates.
+
+Here's an example of a value type, `SumValueAction<T>`, implementing `IAction<T>` for calculating the sum:
+
+```csharp
+public struct SumValueAction<T> : IAction<T>
+    where T : struct, IAdditiveIdentity<T, T>, IAdditionOperators<T, T, T>
+{
+    T sum;
+
+    public SumValueAction()
+    {
+        sum = T.AdditiveIdentity;
+    }
+
+    public readonly T Result
+        => sum;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    void IAction<T>.Invoke(ref readonly T item) 
+        => sum += item;
+}
+```
+
+Here's an example of a method implementation that's support the use of a value delegate:
+
+```csharp
+public static void ForEachEx<T, TAction>(this IEnumerable<T> source, ref TAction action)
+    where TAction : struct, IAction<T>
+{
+    foreach (var item in source)
+        action.Invoke(in item);
+}
+```
+
+The use of the interface as a constraint avoids the boxing of the value delegate.
+
+These can be used as follow to calculate the sum of the elements of a collection:
+
+```csharp
+var action = new SumValueAction<int>();
+collection.ForEachEx(ref action);
+console.WriteLine(action.Result);
+```
+
+The package also includes wrappers enabling the use of delegates, along with implicit cast operators converting a delegate to a value delegate.
+
+References:
+
+- ["An interface for value-type enumerators, a proposal"](https://www.linkedin.com/pulse/interface-value-type-enumerators-proposal-ant%25C3%25A3o-almada/)
+- ["The Battle of Loops: foreach vs. ForEach in C#"](https://www.linkedin.com/pulse/battle-loops-foreach-vs-c-ant%25C3%25A3o-almada/)
\ No newline at end of file