From 0043e9c0dc888c071885a88954fbabc772e96238 Mon Sep 17 00:00:00 2001
From: Laicasaane <laicasaane@outlook.com>
Date: Sat, 20 Feb 2021 19:34:54 +0700
Subject: [PATCH] Improve and add more value delegates functionality

---
 System.Delegates/Action/IAction.cs            |  37 ++-
 System.Delegates/Action/IActionIn.cs          |  35 ++-
 System.Delegates/Action/IActionRef.cs         |  35 ++-
 System.Delegates/Func/IFunc.cs                |  39 ++-
 System.Delegates/Func/IFuncIn.cs              |  25 ++
 System.Delegates/Func/IFuncRef.cs             |  37 ++-
 System.Delegates/Predicate/IPredicate.cs      |  37 ++-
 System.Delegates/Predicate/IPredicateIn.cs    |  35 ++-
 System.Delegates/Predicate/IPredicateRef.cs   |  35 ++-
 .../Action/ValueAction.Action.cs              | 114 ++++++-
 .../Action/ValueAction.ActionIn.cs            | 122 +++++++-
 .../Action/ValueAction.ActionRef.cs           | 122 +++++++-
 System.ValueDelegates/Action/ValueAction.cs   |  18 --
 .../Delegate/ValueDelegate.Action.cs          |   6 +-
 .../Delegate/ValueDelegate.ActionArgIn.cs     | 277 ++++++++++++++++++
 .../ValueDelegate.ActionArgIn.cs.meta         |  11 +
 .../Delegate/ValueDelegate.FuncArgIn.cs       | 277 ++++++++++++++++++
 .../Delegate/ValueDelegate.FuncArgIn.cs.meta  |  11 +
 .../Delegate/ValueDelegate.PredicateArgIn.cs  | 277 ++++++++++++++++++
 .../ValueDelegate.PredicateArgIn.cs.meta      |  11 +
 System.ValueDelegates/Func/ValueFunc.Func.cs  | 114 ++++++-
 .../Func/ValueFunc.FuncIn.cs                  | 122 +++++++-
 .../Func/ValueFunc.FuncRef.cs                 | 122 +++++++-
 System.ValueDelegates/Func/ValueFunc.cs       |  12 -
 .../Predicate/ValuePredicate.Predicate.cs     | 114 ++++++-
 .../Predicate/ValuePredicate.PredicateIn.cs   | 122 +++++++-
 .../Predicate/ValuePredicate.PredicateRef.cs  | 122 +++++++-
 .../Predicate/ValuePredicate.cs               |  12 -
 28 files changed, 2163 insertions(+), 138 deletions(-)
 create mode 100644 System.ValueDelegates/Delegate/ValueDelegate.ActionArgIn.cs
 create mode 100644 System.ValueDelegates/Delegate/ValueDelegate.ActionArgIn.cs.meta
 create mode 100644 System.ValueDelegates/Delegate/ValueDelegate.FuncArgIn.cs
 create mode 100644 System.ValueDelegates/Delegate/ValueDelegate.FuncArgIn.cs.meta
 create mode 100644 System.ValueDelegates/Delegate/ValueDelegate.PredicateArgIn.cs
 create mode 100644 System.ValueDelegates/Delegate/ValueDelegate.PredicateArgIn.cs.meta

diff --git a/System.Delegates/Action/IAction.cs b/System.Delegates/Action/IAction.cs
index 49fbbf5..e3a2712 100644
--- a/System.Delegates/Action/IAction.cs
+++ b/System.Delegates/Action/IAction.cs
@@ -5,33 +5,58 @@ public interface IAction
         void Invoke();
     }
 
-    public interface IAction<TClosure>
+    public interface IAction<in TClosure>
     {
         void Invoke(TClosure closure);
     }
 
-    public interface IAction<TClosure, T> : IAction<TClosure>
+    public interface IAction<in TClosure, in T> : IAction<TClosure>
     {
         void SetArguments(T arg);
     }
 
-    public interface IAction<TClosure, T1, T2> : IAction<TClosure>
+    public interface IAction<in TClosure, in T1, in T2> : IAction<TClosure>
     {
         void SetArguments(T1 arg1, T2 arg2);
     }
 
-    public interface IAction<TClosure, T1, T2, T3> : IAction<TClosure>
+    public interface IAction<in TClosure, in T1, in T2, in T3> : IAction<TClosure>
     {
         void SetArguments(T1 arg1, T2 arg2, T3 arg3);
     }
 
-    public interface IAction<TClosure, T1, T2, T3, T4> : IAction<TClosure>
+    public interface IAction<in TClosure, in T1, in T2, in T3, in T4> : IAction<TClosure>
     {
         void SetArguments(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
     }
 
-    public interface IAction<TClosure, T1, T2, T3, T4, T5> : IAction<TClosure>
+    public interface IAction<in TClosure, in T1, in T2, in T3, in T4, in T5> : IAction<TClosure>
     {
         void SetArguments(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
     }
+
+    public interface IActionArgIn<in TClosure, T> : IAction<TClosure>
+    {
+        void SetArguments(in T arg);
+    }
+
+    public interface IActionArgIn<in TClosure, T1, T2> : IAction<TClosure>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2);
+    }
+
+    public interface IActionArgIn<in TClosure, T1, T2, T3> : IAction<TClosure>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2, in T3 arg3);
+    }
+
+    public interface IActionArgIn<in TClosure, T1, T2, T3, T4> : IAction<TClosure>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4);
+    }
+
+    public interface IActionArgIn<in TClosure, T1, T2, T3, T4, T5> : IAction<TClosure>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5);
+    }
 }
\ No newline at end of file
diff --git a/System.Delegates/Action/IActionIn.cs b/System.Delegates/Action/IActionIn.cs
index 6aab396..623af9e 100644
--- a/System.Delegates/Action/IActionIn.cs
+++ b/System.Delegates/Action/IActionIn.cs
@@ -5,28 +5,53 @@ public interface IActionIn<TClosure>
         void Invoke(in TClosure closure);
     }
 
-    public interface IActionIn<TClosure, T> : IActionIn<TClosure>
+    public interface IActionIn<TClosure, in T> : IActionIn<TClosure>
     {
         void SetArguments(T arg);
     }
 
-    public interface IActionIn<TClosure, T1, T2> : IActionIn<TClosure>
+    public interface IActionIn<TClosure, in T1, in T2> : IActionIn<TClosure>
     {
         void SetArguments(T1 arg1, T2 arg2);
     }
 
-    public interface IActionIn<TClosure, T1, T2, T3> : IActionIn<TClosure>
+    public interface IActionIn<TClosure, in T1, in T2, in T3> : IActionIn<TClosure>
     {
         void SetArguments(T1 arg1, T2 arg2, T3 arg3);
     }
 
-    public interface IActionIn<TClosure, T1, T2, T3, T4> : IActionIn<TClosure>
+    public interface IActionIn<TClosure, in T1, in T2, in T3, in T4> : IActionIn<TClosure>
     {
         void SetArguments(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
     }
 
-    public interface IActionIn<TClosure, T1, T2, T3, T4, T5> : IActionIn<TClosure>
+    public interface IActionIn<TClosure, in T1, in T2, in T3, in T4, in T5> : IActionIn<TClosure>
     {
         void SetArguments(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
     }
+
+    public interface IActionInArgIn<TClosure, T> : IActionIn<TClosure>
+    {
+        void SetArguments(in T arg);
+    }
+
+    public interface IActionInArgIn<TClosure, T1, T2> : IActionIn<TClosure>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2);
+    }
+
+    public interface IActionInArgIn<TClosure, T1, T2, T3> : IActionIn<TClosure>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2, in T3 arg3);
+    }
+
+    public interface IActionInArgIn<TClosure, T1, T2, T3, T4> : IActionIn<TClosure>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4);
+    }
+
+    public interface IActionInArgIn<TClosure, T1, T2, T3, T4, T5> : IActionIn<TClosure>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5);
+    }
 }
\ No newline at end of file
diff --git a/System.Delegates/Action/IActionRef.cs b/System.Delegates/Action/IActionRef.cs
index ef612db..0b36440 100644
--- a/System.Delegates/Action/IActionRef.cs
+++ b/System.Delegates/Action/IActionRef.cs
@@ -5,28 +5,53 @@ public interface IActionRef<TClosure>
         void Invoke(ref TClosure closure);
     }
 
-    public interface IActionRef<TClosure, T> : IActionRef<TClosure>
+    public interface IActionRef<TClosure, in T> : IActionRef<TClosure>
     {
         void SetArguments(T arg);
     }
 
-    public interface IActionRef<TClosure, T1, T2> : IActionRef<TClosure>
+    public interface IActionRef<TClosure, in T1, in T2> : IActionRef<TClosure>
     {
         void SetArguments(T1 arg1, T2 arg2);
     }
 
-    public interface IActionRef<TClosure, T1, T2, T3> : IActionRef<TClosure>
+    public interface IActionRef<TClosure, in T1, in T2, in T3> : IActionRef<TClosure>
     {
         void SetArguments(T1 arg1, T2 arg2, T3 arg3);
     }
 
-    public interface IActionRef<TClosure, T1, T2, T3, T4> : IActionRef<TClosure>
+    public interface IActionRef<TClosure, in T1, in T2, in T3, in T4> : IActionRef<TClosure>
     {
         void SetArguments(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
     }
 
-    public interface IActionRef<TClosure, T1, T2, T3, T4, T5> : IActionRef<TClosure>
+    public interface IActionRef<TClosure, in T1, in T2, in T3, in T4, in T5> : IActionRef<TClosure>
     {
         void SetArguments(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
     }
+
+    public interface IActionRefArgIn<TClosure, T> : IActionRef<TClosure>
+    {
+        void SetArguments(in T arg);
+    }
+
+    public interface IActionRefArgIn<TClosure, T1, T2> : IActionRef<TClosure>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2);
+    }
+
+    public interface IActionRefArgIn<TClosure, T1, T2, T3> : IActionRef<TClosure>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2, in T3 arg3);
+    }
+
+    public interface IActionRefArgIn<TClosure, T1, T2, T3, T4> : IActionRef<TClosure>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4);
+    }
+
+    public interface IActionRefArgIn<TClosure, T1, T2, T3, T4, T5> : IActionRef<TClosure>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5);
+    }
 }
\ No newline at end of file
diff --git a/System.Delegates/Func/IFunc.cs b/System.Delegates/Func/IFunc.cs
index fb728e8..2af43d7 100644
--- a/System.Delegates/Func/IFunc.cs
+++ b/System.Delegates/Func/IFunc.cs
@@ -1,37 +1,62 @@
 namespace System.Delegates
 {
-    public interface IFunc<TResult>
+    public interface IFunc<out TResult>
     {
         TResult Invoke();
     }
 
-    public interface IFunc<TClosure, TResult>
+    public interface IFunc<in TClosure, out TResult>
     {
         TResult Invoke(TClosure closure);
     }
 
-    public interface IFunc<TClosure, T, TResult> : IFunc<TClosure, TResult>
+    public interface IFunc<in TClosure, in T, out TResult> : IFunc<TClosure, TResult>
     {
         void SetArguments(T arg);
     }
 
-    public interface IFunc<TClosure, T1, T2, TResult> : IFunc<TClosure, TResult>
+    public interface IFunc<in TClosure, in T1, in T2, out TResult> : IFunc<TClosure, TResult>
     {
         void SetArguments(T1 arg1, T2 arg2);
     }
 
-    public interface IFunc<TClosure, T1, T2, T3, TResult> : IFunc<TClosure, TResult>
+    public interface IFunc<in TClosure, in T1, in T2, in T3, out TResult> : IFunc<TClosure, TResult>
     {
         void SetArguments(T1 arg1, T2 arg2, T3 arg3);
     }
 
-    public interface IFunc<TClosure, T1, T2, T3, T4, TResult> : IFunc<TClosure, TResult>
+    public interface IFunc<in TClosure, in T1, in T2, in T3, in T4, out TResult> : IFunc<TClosure, TResult>
     {
         void SetArguments(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
     }
 
-    public interface IFunc<TClosure, T1, T2, T3, T4, T5, TResult> : IFunc<TClosure, TResult>
+    public interface IFunc<in TClosure, in T1, in T2, in T3, in T4, in T5, out TResult> : IFunc<TClosure, TResult>
     {
         void SetArguments(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
     }
+
+    public interface IFuncArgIn<in TClosure, T, out TResult> : IFunc<TClosure, TResult>
+    {
+        void SetArguments(in T arg);
+    }
+
+    public interface IFuncArgIn<in TClosure, T1, T2, out TResult> : IFunc<TClosure, TResult>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2);
+    }
+
+    public interface IFuncArgIn<in TClosure, T1, T2, T3, out TResult> : IFunc<TClosure, TResult>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2, in T3 arg3);
+    }
+
+    public interface IFuncArgIn<in TClosure, T1, T2, T3, T4, out TResult> : IFunc<TClosure, TResult>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4);
+    }
+
+    public interface IFuncArgIn<in TClosure, T1, T2, T3, T4, T5, out TResult> : IFunc<TClosure, TResult>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5);
+    }
 }
\ No newline at end of file
diff --git a/System.Delegates/Func/IFuncIn.cs b/System.Delegates/Func/IFuncIn.cs
index 701e2c9..f569f69 100644
--- a/System.Delegates/Func/IFuncIn.cs
+++ b/System.Delegates/Func/IFuncIn.cs
@@ -29,4 +29,29 @@ public interface IFuncIn<TClosure, T1, T2, T3, T4, T5, TResult> : IFuncIn<TClosu
     {
         void SetArguments(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
     }
+
+    public interface IFuncInArgIn<TClosure, T, TResult> : IFuncIn<TClosure, TResult>
+    {
+        void SetArguments(in T arg);
+    }
+
+    public interface IFuncInArgIn<TClosure, T1, T2, TResult> : IFuncIn<TClosure, TResult>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2);
+    }
+
+    public interface IFuncInArgIn<TClosure, T1, T2, T3, TResult> : IFuncIn<TClosure, TResult>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2, in T3 arg3);
+    }
+
+    public interface IFuncInArgIn<TClosure, T1, T2, T3, T4, TResult> : IFuncIn<TClosure, TResult>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4);
+    }
+
+    public interface IFuncInArgIn<TClosure, T1, T2, T3, T4, T5, TResult> : IFuncIn<TClosure, TResult>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5);
+    }
 }
\ No newline at end of file
diff --git a/System.Delegates/Func/IFuncRef.cs b/System.Delegates/Func/IFuncRef.cs
index f7bb485..1d7db38 100644
--- a/System.Delegates/Func/IFuncRef.cs
+++ b/System.Delegates/Func/IFuncRef.cs
@@ -1,32 +1,57 @@
 namespace System.Delegates
 {
-    public interface IFuncRef<TClosure, TResult>
+    public interface IFuncRef<TClosure, out TResult>
     {
         TResult Invoke(ref TClosure closure);
     }
 
-    public interface IFuncRef<TClosure, T, TResult> : IFuncRef<TClosure, TResult>
+    public interface IFuncRef<TClosure, in T, out TResult> : IFuncRef<TClosure, TResult>
     {
         void SetArguments(T arg);
     }
 
-    public interface IFuncRef<TClosure, T1, T2, TResult> : IFuncRef<TClosure, TResult>
+    public interface IFuncRef<TClosure, in T1, in T2, out TResult> : IFuncRef<TClosure, TResult>
     {
         void SetArguments(T1 arg1, T2 arg2);
     }
 
-    public interface IFuncRef<TClosure, T1, T2, T3, TResult> : IFuncRef<TClosure, TResult>
+    public interface IFuncRef<TClosure, in T1, in T2, in T3, out TResult> : IFuncRef<TClosure, TResult>
     {
         void SetArguments(T1 arg1, T2 arg2, T3 arg3);
     }
 
-    public interface IFuncRef<TClosure, T1, T2, T3, T4, TResult> : IFuncRef<TClosure, TResult>
+    public interface IFuncRef<TClosure, in T1, in T2, in T3, in T4, out TResult> : IFuncRef<TClosure, TResult>
     {
         void SetArguments(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
     }
 
-    public interface IFuncRef<TClosure, T1, T2, T3, T4, T5, TResult> : IFuncRef<TClosure, TResult>
+    public interface IFuncRef<TClosure, in T1, in T2, in T3, in T4, in T5, out TResult> : IFuncRef<TClosure, TResult>
     {
         void SetArguments(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
     }
+
+    public interface IFuncRefArgIn<TClosure, T, out TResult> : IFuncRef<TClosure, TResult>
+    {
+        void SetArguments(in T arg);
+    }
+
+    public interface IFuncRefArgIn<TClosure, T1, T2, out TResult> : IFuncRef<TClosure, TResult>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2);
+    }
+
+    public interface IFuncRefArgIn<TClosure, T1, T2, T3, out TResult> : IFuncRef<TClosure, TResult>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2, in T3 arg3);
+    }
+
+    public interface IFuncRefArgIn<TClosure, T1, T2, T3, T4, out TResult> : IFuncRef<TClosure, TResult>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4);
+    }
+
+    public interface IFuncRefArgIn<TClosure, T1, T2, T3, T4, T5, out TResult> : IFuncRef<TClosure, TResult>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5);
+    }
 }
\ No newline at end of file
diff --git a/System.Delegates/Predicate/IPredicate.cs b/System.Delegates/Predicate/IPredicate.cs
index c8c7558..6aeaff7 100644
--- a/System.Delegates/Predicate/IPredicate.cs
+++ b/System.Delegates/Predicate/IPredicate.cs
@@ -5,33 +5,58 @@ public interface IPredicate
         bool Invoke();
     }
 
-    public interface IPredicate<TClosure>
+    public interface IPredicate<in TClosure>
     {
         bool Invoke(TClosure closure);
     }
 
-    public interface IPredicate<TClosure, T> : IPredicate<TClosure>
+    public interface IPredicate<in TClosure, in T> : IPredicate<TClosure>
     {
         void SetArguments(T arg);
     }
 
-    public interface IPredicate<TClosure, T1, T2> : IPredicate<TClosure>
+    public interface IPredicate<in TClosure, in T1, in T2> : IPredicate<TClosure>
     {
         void SetArguments(T1 arg1, T2 arg2);
     }
 
-    public interface IPredicate<TClosure, T1, T2, T3> : IPredicate<TClosure>
+    public interface IPredicate<in TClosure, in T1, in T2, in T3> : IPredicate<TClosure>
     {
         void SetArguments(T1 arg1, T2 arg2, T3 arg3);
     }
 
-    public interface IPredicate<TClosure, T1, T2, T3, T4> : IPredicate<TClosure>
+    public interface IPredicate<in TClosure, in T1, in T2, in T3, in T4> : IPredicate<TClosure>
     {
         void SetArguments(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
     }
 
-    public interface IPredicate<TClosure, T1, T2, T3, T4, T5> : IPredicate<TClosure>
+    public interface IPredicate<in TClosure, in T1, in T2, in T3, in T4, in T5> : IPredicate<TClosure>
     {
         void SetArguments(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
     }
+
+    public interface IPredicateArgIn<in TClosure, T> : IPredicate<TClosure>
+    {
+        void SetArguments(in T arg);
+    }
+
+    public interface IPredicateArgIn<in TClosure, T1, T2> : IPredicate<TClosure>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2);
+    }
+
+    public interface IPredicateArgIn<in TClosure, T1, T2, T3> : IPredicate<TClosure>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2, in T3 arg3);
+    }
+
+    public interface IPredicateArgIn<in TClosure, T1, T2, T3, T4> : IPredicate<TClosure>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4);
+    }
+
+    public interface IPredicateArgIn<in TClosure, T1, T2, T3, T4, T5> : IPredicate<TClosure>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5);
+    }
 }
\ No newline at end of file
diff --git a/System.Delegates/Predicate/IPredicateIn.cs b/System.Delegates/Predicate/IPredicateIn.cs
index 8062891..d7baed6 100644
--- a/System.Delegates/Predicate/IPredicateIn.cs
+++ b/System.Delegates/Predicate/IPredicateIn.cs
@@ -5,28 +5,53 @@ public interface IPredicateIn<TClosure>
         bool Invoke(in TClosure closure);
     }
 
-    public interface IPredicateIn<TClosure, T> : IPredicateIn<TClosure>
+    public interface IPredicateIn<TClosure, in T> : IPredicateIn<TClosure>
     {
         void SetArguments(T arg);
     }
 
-    public interface IPredicateIn<TClosure, T1, T2> : IPredicateIn<TClosure>
+    public interface IPredicateIn<TClosure, in T1, in T2> : IPredicateIn<TClosure>
     {
         void SetArguments(T1 arg1, T2 arg2);
     }
 
-    public interface IPredicateIn<TClosure, T1, T2, T3> : IPredicateIn<TClosure>
+    public interface IPredicateIn<TClosure, in T1, in T2, in T3> : IPredicateIn<TClosure>
     {
         void SetArguments(T1 arg1, T2 arg2, T3 arg3);
     }
 
-    public interface IPredicateIn<TClosure, T1, T2, T3, T4> : IPredicateIn<TClosure>
+    public interface IPredicateIn<TClosure, in T1, in T2, in T3, in T4> : IPredicateIn<TClosure>
     {
         void SetArguments(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
     }
 
-    public interface IPredicateIn<TClosure, T1, T2, T3, T4, T5> : IPredicateIn<TClosure>
+    public interface IPredicateIn<TClosure, in T1, in T2, in T3, in T4, in T5> : IPredicateIn<TClosure>
     {
         void SetArguments(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
     }
+
+    public interface IPredicateInArgIn<TClosure, T> : IPredicateIn<TClosure>
+    {
+        void SetArguments(in T arg);
+    }
+
+    public interface IPredicateInArgIn<TClosure, T1, T2> : IPredicateIn<TClosure>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2);
+    }
+
+    public interface IPredicateInArgIn<TClosure, T1, T2, T3> : IPredicateIn<TClosure>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2, in T3 arg3);
+    }
+
+    public interface IPredicateInArgIn<TClosure, T1, T2, T3, T4> : IPredicateIn<TClosure>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4);
+    }
+
+    public interface IPredicateInArgIn<TClosure, T1, T2, T3, T4, T5> : IPredicateIn<TClosure>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5);
+    }
 }
\ No newline at end of file
diff --git a/System.Delegates/Predicate/IPredicateRef.cs b/System.Delegates/Predicate/IPredicateRef.cs
index d40bd54..95c0caf 100644
--- a/System.Delegates/Predicate/IPredicateRef.cs
+++ b/System.Delegates/Predicate/IPredicateRef.cs
@@ -5,28 +5,53 @@ public interface IPredicateRef<TClosure>
         bool Invoke(ref TClosure closure);
     }
 
-    public interface IPredicateRef<TClosure, T> : IPredicateRef<TClosure>
+    public interface IPredicateRef<TClosure, in T> : IPredicateRef<TClosure>
     {
         void SetArguments(T arg);
     }
 
-    public interface IPredicateRef<TClosure, T1, T2> : IPredicateRef<TClosure>
+    public interface IPredicateRef<TClosure, in T1, in T2> : IPredicateRef<TClosure>
     {
         void SetArguments(T1 arg1, T2 arg2);
     }
 
-    public interface IPredicateRef<TClosure, T1, T2, T3> : IPredicateRef<TClosure>
+    public interface IPredicateRef<TClosure, in T1, in T2, in T3> : IPredicateRef<TClosure>
     {
         void SetArguments(T1 arg1, T2 arg2, T3 arg3);
     }
 
-    public interface IPredicateRef<TClosure, T1, T2, T3, T4> : IPredicateRef<TClosure>
+    public interface IPredicateRef<TClosure, in T1, in T2, in T3, in T4> : IPredicateRef<TClosure>
     {
         void SetArguments(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
     }
 
-    public interface IPredicateRef<TClosure, T1, T2, T3, T4, T5> : IPredicateRef<TClosure>
+    public interface IPredicateRef<TClosure, in T1, in T2, in T3, in T4, in T5> : IPredicateRef<TClosure>
     {
         void SetArguments(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
     }
+
+    public interface IPredicateRefArgIn<TClosure, T> : IPredicateRef<TClosure>
+    {
+        void SetArguments(in T arg);
+    }
+
+    public interface IPredicateRefArgIn<TClosure, T1, T2> : IPredicateRef<TClosure>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2);
+    }
+
+    public interface IPredicateRefArgIn<TClosure, T1, T2, T3> : IPredicateRef<TClosure>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2, in T3 arg3);
+    }
+
+    public interface IPredicateRefArgIn<TClosure, T1, T2, T3, T4> : IPredicateRef<TClosure>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4);
+    }
+
+    public interface IPredicateRefArgIn<TClosure, T1, T2, T3, T4, T5> : IPredicateRef<TClosure>
+    {
+        void SetArguments(in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5);
+    }
 }
\ No newline at end of file
diff --git a/System.ValueDelegates/Action/ValueAction.Action.cs b/System.ValueDelegates/Action/ValueAction.Action.cs
index 0952e2c..bf6f737 100644
--- a/System.ValueDelegates/Action/ValueAction.Action.cs
+++ b/System.ValueDelegates/Action/ValueAction.Action.cs
@@ -4,10 +4,6 @@ namespace System.ValueDelegates
 {
     public static partial class ValueAction
     {
-        public static void Invoke<TAction>()
-            where TAction : struct, IAction
-            => new TAction().Invoke();
-
         public static void Invoke<TAction, TClosure, T>(this TAction action, TClosure closure, T arg)
             where TAction : struct, IAction<TClosure, T>
         {
@@ -121,5 +117,115 @@ public static void Invoke<TAction, TClosure, T1, T2, T3, T4, T5>(this TClosure c
             action.SetArguments(arg1, arg2, arg3, arg4, arg5);
             action.Invoke(closure);
         }
+
+        public static void Invoke<TAction, TClosure, T>(this TAction action, TClosure closure, in T arg)
+            where TAction : struct, IActionArgIn<TClosure, T>
+        {
+            action.SetArguments(in arg);
+            action.Invoke(closure);
+        }
+
+        public static void Invoke<TAction, TClosure, T1, T2>(this TAction action, TClosure closure, in T1 arg1, in T2 arg2)
+            where TAction : struct, IActionArgIn<TClosure, T1, T2>
+        {
+            action.SetArguments(in arg1, in arg2);
+            action.Invoke(closure);
+        }
+
+        public static void Invoke<TAction, TClosure, T1, T2, T3>(this TAction action, TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TAction : struct, IActionArgIn<TClosure, T1, T2, T3>
+        {
+            action.SetArguments(in arg1, in arg2, in arg3);
+            action.Invoke(closure);
+        }
+
+        public static void Invoke<TAction, TClosure, T1, T2, T3, T4>(this TAction action, TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TAction : struct, IActionArgIn<TClosure, T1, T2, T3, T4>
+        {
+            action.SetArguments(in arg1, in arg2, in arg3, in arg4);
+            action.Invoke(closure);
+        }
+
+        public static void Invoke<TAction, TClosure, T1, T2, T3, T4, T5>(this TAction action, TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TAction : struct, IActionArgIn<TClosure, T1, T2, T3, T4, T5>
+        {
+            action.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+            action.Invoke(closure);
+        }
+
+        public static void Invoke<TAction, TClosure, T>(in TAction action, TClosure closure, in T arg)
+            where TAction : struct, IActionArgIn<TClosure, T>
+        {
+            action.SetArguments(in arg);
+            action.Invoke(closure);
+        }
+
+        public static void Invoke<TAction, TClosure, T1, T2>(in TAction action, TClosure closure, in T1 arg1, in T2 arg2)
+            where TAction : struct, IActionArgIn<TClosure, T1, T2>
+        {
+            action.SetArguments(in arg1, in arg2);
+            action.Invoke(closure);
+        }
+
+        public static void Invoke<TAction, TClosure, T1, T2, T3>(in TAction action, TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TAction : struct, IActionArgIn<TClosure, T1, T2, T3>
+        {
+            action.SetArguments(in arg1, in arg2, in arg3);
+            action.Invoke(closure);
+        }
+
+        public static void Invoke<TAction, TClosure, T1, T2, T3, T4>(in TAction action, TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TAction : struct, IActionArgIn<TClosure, T1, T2, T3, T4>
+        {
+            action.SetArguments(arg1, arg2, arg3, arg4);
+            action.Invoke(closure);
+        }
+
+        public static void Invoke<TAction, TClosure, T1, T2, T3, T4, T5>(in TAction action, TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TAction : struct, IActionArgIn<TClosure, T1, T2, T3, T4, T5>
+        {
+            action.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+            action.Invoke(closure);
+        }
+
+        public static void Invoke<TAction, TClosure, T>(this TClosure closure, in T arg)
+            where TAction : struct, IActionArgIn<TClosure, T>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg);
+            action.Invoke(closure);
+        }
+
+        public static void Invoke<TAction, TClosure, T1, T2>(this TClosure closure, in T1 arg1, in T2 arg2)
+            where TAction : struct, IActionArgIn<TClosure, T1, T2>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2);
+            action.Invoke(closure);
+        }
+
+        public static void Invoke<TAction, TClosure, T1, T2, T3>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TAction : struct, IActionArgIn<TClosure, T1, T2, T3>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2, in arg3);
+            action.Invoke(closure);
+        }
+
+        public static void Invoke<TAction, TClosure, T1, T2, T3, T4>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TAction : struct, IActionArgIn<TClosure, T1, T2, T3, T4>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2, in arg3, in arg4);
+            action.Invoke(closure);
+        }
+
+        public static void Invoke<TAction, TClosure, T1, T2, T3, T4, T5>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TAction : struct, IActionArgIn<TClosure, T1, T2, T3, T4, T5>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+            action.Invoke(closure);
+        }
     }
 }
\ No newline at end of file
diff --git a/System.ValueDelegates/Action/ValueAction.ActionIn.cs b/System.ValueDelegates/Action/ValueAction.ActionIn.cs
index 0e390f6..f387a1e 100644
--- a/System.ValueDelegates/Action/ValueAction.ActionIn.cs
+++ b/System.ValueDelegates/Action/ValueAction.ActionIn.cs
@@ -4,11 +4,11 @@ namespace System.ValueDelegates
 {
     public static partial class ValueAction
     {
-        public static void Invoke<TAction, TClosure>(in TClosure closure)
+        public static void InvokeIn<TAction, TClosure>(this TClosure closure)
             where TAction : struct, IActionIn<TClosure>
             => new TAction().Invoke(in closure);
 
-        public static void Invoke<TAction, TClosure, T>(in TClosure closure, T arg)
+        public static void InvokeIn<TAction, TClosure, T>(this TClosure closure, T arg)
             where TAction : struct, IActionIn<TClosure, T>
         {
             var action = new TAction();
@@ -16,7 +16,7 @@ public static void Invoke<TAction, TClosure, T>(in TClosure closure, T arg)
             action.Invoke(in closure);
         }
 
-        public static void Invoke<TAction, TClosure, T1, T2>(in TClosure closure, T1 arg1, T2 arg2)
+        public static void InvokeIn<TAction, TClosure, T1, T2>(this TClosure closure, T1 arg1, T2 arg2)
             where TAction : struct, IActionIn<TClosure, T1, T2>
         {
             var action = new TAction();
@@ -24,7 +24,7 @@ public static void Invoke<TAction, TClosure, T1, T2>(in TClosure closure, T1 arg
             action.Invoke(in closure);
         }
 
-        public static void Invoke<TAction, TClosure, T1, T2, T3>(in TClosure closure, T1 arg1, T2 arg2, T3 arg3)
+        public static void InvokeIn<TAction, TClosure, T1, T2, T3>(this TClosure closure, T1 arg1, T2 arg2, T3 arg3)
             where TAction : struct, IActionIn<TClosure, T1, T2, T3>
         {
             var action = new TAction();
@@ -32,7 +32,7 @@ public static void Invoke<TAction, TClosure, T1, T2, T3>(in TClosure closure, T1
             action.Invoke(in closure);
         }
 
-        public static void Invoke<TAction, TClosure, T1, T2, T3, T4>(in TClosure closure, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+        public static void InvokeIn<TAction, TClosure, T1, T2, T3, T4>(this TClosure closure, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
             where TAction : struct, IActionIn<TClosure, T1, T2, T3, T4>
         {
             var action = new TAction();
@@ -40,7 +40,7 @@ public static void Invoke<TAction, TClosure, T1, T2, T3, T4>(in TClosure closure
             action.Invoke(in closure);
         }
 
-        public static void Invoke<TAction, TClosure, T1, T2, T3, T4, T5>(in TClosure closure, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
+        public static void InvokeIn<TAction, TClosure, T1, T2, T3, T4, T5>(this TClosure closure, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
             where TAction : struct, IActionIn<TClosure, T1, T2, T3, T4, T5>
         {
             var action = new TAction();
@@ -117,5 +117,115 @@ public static void Invoke<TAction, TClosure, T1, T2, T3, T4, T5>(in TAction acti
             action.SetArguments(arg1, arg2, arg3, arg4, arg5);
             action.Invoke(in closure);
         }
+
+        public static void Invoke<TAction, TClosure, T>(this TAction action, in TClosure closure, in T arg)
+            where TAction : struct, IActionInArgIn<TClosure, T>
+        {
+            action.SetArguments(in arg);
+            action.Invoke(in closure);
+        }
+
+        public static void Invoke<TAction, TClosure, T1, T2>(this TAction action, in TClosure closure, in T1 arg1, in T2 arg2)
+            where TAction : struct, IActionInArgIn<TClosure, T1, T2>
+        {
+            action.SetArguments(in arg1, in arg2);
+            action.Invoke(in closure);
+        }
+
+        public static void Invoke<TAction, TClosure, T1, T2, T3>(this TAction action, in TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TAction : struct, IActionInArgIn<TClosure, T1, T2, T3>
+        {
+            action.SetArguments(in arg1, in arg2, in arg3);
+            action.Invoke(in closure);
+        }
+
+        public static void Invoke<TAction, TClosure, T1, T2, T3, T4>(this TAction action, in TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TAction : struct, IActionInArgIn<TClosure, T1, T2, T3, T4>
+        {
+            action.SetArguments(in arg1, in arg2, in arg3, in arg4);
+            action.Invoke(in closure);
+        }
+
+        public static void Invoke<TAction, TClosure, T1, T2, T3, T4, T5>(this TAction action, in TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TAction : struct, IActionInArgIn<TClosure, T1, T2, T3, T4, T5>
+        {
+            action.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+            action.Invoke(in closure);
+        }
+
+        public static void Invoke<TAction, TClosure, T>(in TAction action, in TClosure closure, in T arg)
+            where TAction : struct, IActionInArgIn<TClosure, T>
+        {
+            action.SetArguments(in arg);
+            action.Invoke(in closure);
+        }
+
+        public static void Invoke<TAction, TClosure, T1, T2>(in TAction action, in TClosure closure, in T1 arg1, in T2 arg2)
+            where TAction : struct, IActionInArgIn<TClosure, T1, T2>
+        {
+            action.SetArguments(in arg1, in arg2);
+            action.Invoke(in closure);
+        }
+
+        public static void Invoke<TAction, TClosure, T1, T2, T3>(in TAction action, in TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TAction : struct, IActionInArgIn<TClosure, T1, T2, T3>
+        {
+            action.SetArguments(in arg1, in arg2, in arg3);
+            action.Invoke(in closure);
+        }
+
+        public static void Invoke<TAction, TClosure, T1, T2, T3, T4>(in TAction action, in TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TAction : struct, IActionInArgIn<TClosure, T1, T2, T3, T4>
+        {
+            action.SetArguments(arg1, arg2, arg3, arg4);
+            action.Invoke(in closure);
+        }
+
+        public static void Invoke<TAction, TClosure, T1, T2, T3, T4, T5>(in TAction action, in TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TAction : struct, IActionInArgIn<TClosure, T1, T2, T3, T4, T5>
+        {
+            action.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+            action.Invoke(in closure);
+        }
+
+        public static void InvokeIn<TAction, TClosure, T>(this TClosure closure, in T arg)
+            where TAction : struct, IActionInArgIn<TClosure, T>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg);
+            action.Invoke(in closure);
+        }
+
+        public static void InvokeIn<TAction, TClosure, T1, T2>(this TClosure closure, in T1 arg1, in T2 arg2)
+            where TAction : struct, IActionInArgIn<TClosure, T1, T2>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2);
+            action.Invoke(in closure);
+        }
+
+        public static void InvokeIn<TAction, TClosure, T1, T2, T3>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TAction : struct, IActionInArgIn<TClosure, T1, T2, T3>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2, in arg3);
+            action.Invoke(in closure);
+        }
+
+        public static void InvokeIn<TAction, TClosure, T1, T2, T3, T4>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TAction : struct, IActionInArgIn<TClosure, T1, T2, T3, T4>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2, in arg3, in arg4);
+            action.Invoke(in closure);
+        }
+
+        public static void InvokeIn<TAction, TClosure, T1, T2, T3, T4, T5>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TAction : struct, IActionInArgIn<TClosure, T1, T2, T3, T4, T5>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+            action.Invoke(in closure);
+        }
     }
 }
\ No newline at end of file
diff --git a/System.ValueDelegates/Action/ValueAction.ActionRef.cs b/System.ValueDelegates/Action/ValueAction.ActionRef.cs
index 3a0a3e4..3a87d85 100644
--- a/System.ValueDelegates/Action/ValueAction.ActionRef.cs
+++ b/System.ValueDelegates/Action/ValueAction.ActionRef.cs
@@ -4,11 +4,11 @@ namespace System.ValueDelegates
 {
     public static partial class ValueAction
     {
-        public static void InvokeRef<TAction, TClosure>(ref TClosure closure)
+        public static void InvokeRef<TAction, TClosure>(this TClosure closure)
             where TAction : struct, IActionRef<TClosure>
             => new TAction().Invoke(ref closure);
 
-        public static void InvokeRef<TAction, TClosure, T>(ref TClosure closure, T arg)
+        public static void InvokeRef<TAction, TClosure, T>(this TClosure closure, T arg)
             where TAction : struct, IActionRef<TClosure, T>
         {
             var action = new TAction();
@@ -16,7 +16,7 @@ public static void InvokeRef<TAction, TClosure, T>(ref TClosure closure, T arg)
             action.Invoke(ref closure);
         }
 
-        public static void InvokeRef<TAction, TClosure, T1, T2>(ref TClosure closure, T1 arg1, T2 arg2)
+        public static void InvokeRef<TAction, TClosure, T1, T2>(this TClosure closure, T1 arg1, T2 arg2)
             where TAction : struct, IActionRef<TClosure, T1, T2>
         {
             var action = new TAction();
@@ -24,7 +24,7 @@ public static void InvokeRef<TAction, TClosure, T1, T2>(ref TClosure closure, T1
             action.Invoke(ref closure);
         }
 
-        public static void InvokeRef<TAction, TClosure, T1, T2, T3>(ref TClosure closure, T1 arg1, T2 arg2, T3 arg3)
+        public static void InvokeRef<TAction, TClosure, T1, T2, T3>(this TClosure closure, T1 arg1, T2 arg2, T3 arg3)
             where TAction : struct, IActionRef<TClosure, T1, T2, T3>
         {
             var action = new TAction();
@@ -32,7 +32,7 @@ public static void InvokeRef<TAction, TClosure, T1, T2, T3>(ref TClosure closure
             action.Invoke(ref closure);
         }
 
-        public static void InvokeRef<TAction, TClosure, T1, T2, T3, T4>(ref TClosure closure, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+        public static void InvokeRef<TAction, TClosure, T1, T2, T3, T4>(this TClosure closure, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
             where TAction : struct, IActionRef<TClosure, T1, T2, T3, T4>
         {
             var action = new TAction();
@@ -40,7 +40,7 @@ public static void InvokeRef<TAction, TClosure, T1, T2, T3, T4>(ref TClosure clo
             action.Invoke(ref closure);
         }
 
-        public static void InvokeRef<TAction, TClosure, T1, T2, T3, T4, T5>(ref TClosure closure, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
+        public static void InvokeRef<TAction, TClosure, T1, T2, T3, T4, T5>(this TClosure closure, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
             where TAction : struct, IActionRef<TClosure, T1, T2, T3, T4, T5>
         {
             var action = new TAction();
@@ -117,5 +117,115 @@ public static void InvokeRef<TAction, TClosure, T1, T2, T3, T4, T5>(in TAction a
             action.SetArguments(arg1, arg2, arg3, arg4, arg5);
             action.Invoke(ref closure);
         }
+
+        public static void InvokeRef<TAction, TClosure, T>(this TAction action, ref TClosure closure, in T arg)
+            where TAction : struct, IActionRefArgIn<TClosure, T>
+        {
+            action.SetArguments(in arg);
+            action.Invoke(ref closure);
+        }
+
+        public static void InvokeRef<TAction, TClosure, T1, T2>(this TAction action, ref TClosure closure, in T1 arg1, in T2 arg2)
+            where TAction : struct, IActionRefArgIn<TClosure, T1, T2>
+        {
+            action.SetArguments(in arg1, in arg2);
+            action.Invoke(ref closure);
+        }
+
+        public static void InvokeRef<TAction, TClosure, T1, T2, T3>(this TAction action, ref TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TAction : struct, IActionRefArgIn<TClosure, T1, T2, T3>
+        {
+            action.SetArguments(in arg1, in arg2, in arg3);
+            action.Invoke(ref closure);
+        }
+
+        public static void InvokeRef<TAction, TClosure, T1, T2, T3, T4>(this TAction action, ref TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TAction : struct, IActionRefArgIn<TClosure, T1, T2, T3, T4>
+        {
+            action.SetArguments(in arg1, in arg2, in arg3, in arg4);
+            action.Invoke(ref closure);
+        }
+
+        public static void InvokeRef<TAction, TClosure, T1, T2, T3, T4, T5>(this TAction action, ref TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TAction : struct, IActionRefArgIn<TClosure, T1, T2, T3, T4, T5>
+        {
+            action.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+            action.Invoke(ref closure);
+        }
+
+        public static void InvokeRef<TAction, TClosure, T>(in TAction action, ref TClosure closure, in T arg)
+            where TAction : struct, IActionRefArgIn<TClosure, T>
+        {
+            action.SetArguments(in arg);
+            action.Invoke(ref closure);
+        }
+
+        public static void InvokeRef<TAction, TClosure, T1, T2>(in TAction action, ref TClosure closure, in T1 arg1, in T2 arg2)
+            where TAction : struct, IActionRefArgIn<TClosure, T1, T2>
+        {
+            action.SetArguments(in arg1, in arg2);
+            action.Invoke(ref closure);
+        }
+
+        public static void InvokeRef<TAction, TClosure, T1, T2, T3>(in TAction action, ref TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TAction : struct, IActionRefArgIn<TClosure, T1, T2, T3>
+        {
+            action.SetArguments(in arg1, in arg2, in arg3);
+            action.Invoke(ref closure);
+        }
+
+        public static void InvokeRef<TAction, TClosure, T1, T2, T3, T4>(in TAction action, ref TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TAction : struct, IActionRefArgIn<TClosure, T1, T2, T3, T4>
+        {
+            action.SetArguments(arg1, arg2, arg3, arg4);
+            action.Invoke(ref closure);
+        }
+
+        public static void InvokeRef<TAction, TClosure, T1, T2, T3, T4, T5>(in TAction action, ref TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TAction : struct, IActionRefArgIn<TClosure, T1, T2, T3, T4, T5>
+        {
+            action.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+            action.Invoke(ref closure);
+        }
+
+        public static void InvokeRef<TAction, TClosure, T>(this TClosure closure, in T arg)
+            where TAction : struct, IActionRefArgIn<TClosure, T>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg);
+            action.Invoke(ref closure);
+        }
+
+        public static void InvokeRef<TAction, TClosure, T1, T2>(this TClosure closure, in T1 arg1, in T2 arg2)
+            where TAction : struct, IActionRefArgIn<TClosure, T1, T2>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2);
+            action.Invoke(ref closure);
+        }
+
+        public static void InvokeRef<TAction, TClosure, T1, T2, T3>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TAction : struct, IActionRefArgIn<TClosure, T1, T2, T3>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2, in arg3);
+            action.Invoke(ref closure);
+        }
+
+        public static void InvokeRef<TAction, TClosure, T1, T2, T3, T4>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TAction : struct, IActionRefArgIn<TClosure, T1, T2, T3, T4>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2, in arg3, in arg4);
+            action.Invoke(ref closure);
+        }
+
+        public static void InvokeRef<TAction, TClosure, T1, T2, T3, T4, T5>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TAction : struct, IActionRefArgIn<TClosure, T1, T2, T3, T4, T5>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+            action.Invoke(ref closure);
+        }
     }
 }
\ No newline at end of file
diff --git a/System.ValueDelegates/Action/ValueAction.cs b/System.ValueDelegates/Action/ValueAction.cs
index 0f2de2d..5822802 100644
--- a/System.ValueDelegates/Action/ValueAction.cs
+++ b/System.ValueDelegates/Action/ValueAction.cs
@@ -14,12 +14,6 @@ public ValueAction(TClosure closure)
             this.closure = closure;
         }
 
-        public ValueAction(in TClosure closure)
-        {
-            this.action = new TAction();
-            this.closure = closure;
-        }
-
         public ValueAction(TAction action, TClosure closure)
         {
             this.action = action;
@@ -32,18 +26,6 @@ public ValueAction(in TAction action, TClosure closure)
             this.closure = closure;
         }
 
-        public ValueAction(TAction action, in TClosure closure)
-        {
-            this.action = action;
-            this.closure = closure;
-        }
-
-        public ValueAction(in TAction action, in TClosure closure)
-        {
-            this.action = action;
-            this.closure = closure;
-        }
-
         public void Invoke()
             => this.action.Invoke(this.closure);
     }
diff --git a/System.ValueDelegates/Delegate/ValueDelegate.Action.cs b/System.ValueDelegates/Delegate/ValueDelegate.Action.cs
index 0665f9f..136db79 100644
--- a/System.ValueDelegates/Delegate/ValueDelegate.Action.cs
+++ b/System.ValueDelegates/Delegate/ValueDelegate.Action.cs
@@ -50,12 +50,12 @@ public static ValueAction<TAction, object> ValueAction<TAction, T1, T2, T3, T4,
             var action = new TAction();
             action.SetArguments(arg1, arg2, arg3, arg4, arg5);
 
-            return new ValueAction<TAction, object>(in action, in closure);
+            return new ValueAction<TAction, object>(in action, closure);
         }
 
         public static ValueActionIn<TAction, object> ValueActionIn<TAction>(this object closure)
             where TAction : struct, IActionIn<object>
-            => new ValueActionIn<TAction, object>(new TAction(), closure);
+            => new ValueActionIn<TAction, object>(new TAction(), in closure);
 
         public static ValueActionIn<TAction, object> ValueActionIn<TAction, T>(this object closure, T arg)
             where TAction : struct, IActionIn<object, T>
@@ -197,7 +197,7 @@ public static ValueAction<TAction, TClosure> ValueAction<TAction, TClosure, T1,
             var action = new TAction();
             action.SetArguments(arg1, arg2, arg3, arg4, arg5);
 
-            return new ValueAction<TAction, TClosure>(in action, in closure);
+            return new ValueAction<TAction, TClosure>(in action, closure);
         }
 
         public static ValueActionIn<TAction, TClosure> ValueActionIn<TAction, TClosure>(this TClosure closure)
diff --git a/System.ValueDelegates/Delegate/ValueDelegate.ActionArgIn.cs b/System.ValueDelegates/Delegate/ValueDelegate.ActionArgIn.cs
new file mode 100644
index 0000000..6126514
--- /dev/null
+++ b/System.ValueDelegates/Delegate/ValueDelegate.ActionArgIn.cs
@@ -0,0 +1,277 @@
+using System.Delegates;
+
+namespace System.ValueDelegates
+{
+    public static partial class ValueDelegate
+    {
+        public static ValueAction<TAction, object> ValueAction<TAction, T>(this object closure, in T arg)
+            where TAction : struct, IActionArgIn<object, T>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg);
+
+            return new ValueAction<TAction, object>(in action, closure);
+        }
+
+        public static ValueAction<TAction, object> ValueAction<TAction, T1, T2>(this object closure, in T1 arg1, in T2 arg2)
+            where TAction : struct, IActionArgIn<object, T1, T2>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2);
+
+            return new ValueAction<TAction, object>(in action, closure);
+        }
+
+        public static ValueAction<TAction, object> ValueAction<TAction, T1, T2, T3>(this object closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TAction : struct, IActionArgIn<object, T1, T2, T3>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2, in arg3);
+
+            return new ValueAction<TAction, object>(in action, closure);
+        }
+
+        public static ValueAction<TAction, object> ValueAction<TAction, T1, T2, T3, T4>(this object closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TAction : struct, IActionArgIn<object, T1, T2, T3, T4>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2, in arg3, in arg4);
+
+            return new ValueAction<TAction, object>(in action, closure);
+        }
+
+        public static ValueAction<TAction, object> ValueAction<TAction, T1, T2, T3, T4, T5>(this object closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TAction : struct, IActionArgIn<object, T1, T2, T3, T4, T5>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+
+            return new ValueAction<TAction, object>(in action, closure);
+        }
+
+        public static ValueActionIn<TAction, object> ValueActionIn<TAction, T>(this object closure, in T arg)
+            where TAction : struct, IActionInArgIn<object, T>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg);
+
+            return new ValueActionIn<TAction, object>(in action, in closure);
+        }
+
+        public static ValueActionIn<TAction, object> ValueActionIn<TAction, T1, T2>(this object closure, in T1 arg1, in T2 arg2)
+            where TAction : struct, IActionInArgIn<object, T1, T2>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2);
+
+            return new ValueActionIn<TAction, object>(in action, in closure);
+        }
+
+        public static ValueActionIn<TAction, object> ValueActionIn<TAction, T1, T2, T3>(this object closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TAction : struct, IActionInArgIn<object, T1, T2, T3>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2, in arg3);
+
+            return new ValueActionIn<TAction, object>(in action, in closure);
+        }
+
+        public static ValueActionIn<TAction, object> ValueActionIn<TAction, T1, T2, T3, T4>(this object closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TAction : struct, IActionInArgIn<object, T1, T2, T3, T4>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2, in arg3, in arg4);
+
+            return new ValueActionIn<TAction, object>(in action, in closure);
+        }
+
+        public static ValueActionIn<TAction, object> ValueActionIn<TAction, T1, T2, T3, T4, T5>(this object closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TAction : struct, IActionInArgIn<object, T1, T2, T3, T4, T5>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+
+            return new ValueActionIn<TAction, object>(in action, in closure);
+        }
+
+        public static ValueActionRef<TAction, object> ValueActionRef<TAction, T>(this object closure, in T arg)
+            where TAction : struct, IActionRefArgIn<object, T>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg);
+
+            return new ValueActionRef<TAction, object>(in action, ref closure);
+        }
+
+        public static ValueActionRef<TAction, object> ValueActionRef<TAction, T1, T2>(this object closure, in T1 arg1, in T2 arg2)
+            where TAction : struct, IActionRefArgIn<object, T1, T2>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2);
+
+            return new ValueActionRef<TAction, object>(in action, ref closure);
+        }
+
+        public static ValueActionRef<TAction, object> ValueActionRef<TAction, T1, T2, T3>(this object closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TAction : struct, IActionRefArgIn<object, T1, T2, T3>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2, in arg3);
+
+            return new ValueActionRef<TAction, object>(in action, ref closure);
+        }
+
+        public static ValueActionRef<TAction, object> ValueActionRef<TAction, T1, T2, T3, T4>(this object closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TAction : struct, IActionRefArgIn<object, T1, T2, T3, T4>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2, in arg3, in arg4);
+
+            return new ValueActionRef<TAction, object>(in action, ref closure);
+        }
+
+        public static ValueActionRef<TAction, object> ValueActionRef<TAction, T1, T2, T3, T4, T5>(this object closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TAction : struct, IActionRefArgIn<object, T1, T2, T3, T4, T5>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+
+            return new ValueActionRef<TAction, object>(in action, ref closure);
+        }
+
+        public static ValueAction<TAction, TClosure> ValueAction<TAction, TClosure, T>(this TClosure closure, in T arg)
+            where TAction : struct, IActionArgIn<TClosure, T>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg);
+
+            return new ValueAction<TAction, TClosure>(in action, closure);
+        }
+
+        public static ValueAction<TAction, TClosure> ValueAction<TAction, TClosure, T1, T2>(this TClosure closure, in T1 arg1, in T2 arg2)
+            where TAction : struct, IActionArgIn<TClosure, T1, T2>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2);
+
+            return new ValueAction<TAction, TClosure>(in action, closure);
+        }
+
+        public static ValueAction<TAction, TClosure> ValueAction<TAction, TClosure, T1, T2, T3>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TAction : struct, IActionArgIn<TClosure, T1, T2, T3>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2, in arg3);
+
+            return new ValueAction<TAction, TClosure>(in action, closure);
+        }
+
+        public static ValueAction<TAction, TClosure> ValueAction<TAction, TClosure, T1, T2, T3, T4>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TAction : struct, IActionArgIn<TClosure, T1, T2, T3, T4>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2, in arg3, in arg4);
+
+            return new ValueAction<TAction, TClosure>(in action, closure);
+        }
+
+        public static ValueAction<TAction, TClosure> ValueAction<TAction, TClosure, T1, T2, T3, T4, T5>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TAction : struct, IActionArgIn<TClosure, T1, T2, T3, T4, T5>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+
+            return new ValueAction<TAction, TClosure>(in action, closure);
+        }
+
+        public static ValueActionIn<TAction, TClosure> ValueActionIn<TAction, TClosure, T>(this TClosure closure, in T arg)
+            where TAction : struct, IActionInArgIn<TClosure, T>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg);
+
+            return new ValueActionIn<TAction, TClosure>(in action, in closure);
+        }
+
+        public static ValueActionIn<TAction, TClosure> ValueActionIn<TAction, TClosure, T1, T2>(this TClosure closure, in T1 arg1, in T2 arg2)
+            where TAction : struct, IActionInArgIn<TClosure, T1, T2>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2);
+
+            return new ValueActionIn<TAction, TClosure>(in action, in closure);
+        }
+
+        public static ValueActionIn<TAction, TClosure> ValueActionIn<TAction, TClosure, T1, T2, T3>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TAction : struct, IActionInArgIn<TClosure, T1, T2, T3>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2, in arg3);
+
+            return new ValueActionIn<TAction, TClosure>(in action, in closure);
+        }
+
+        public static ValueActionIn<TAction, TClosure> ValueActionIn<TAction, TClosure, T1, T2, T3, T4>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TAction : struct, IActionInArgIn<TClosure, T1, T2, T3, T4>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2, in arg3, in arg4);
+
+            return new ValueActionIn<TAction, TClosure>(in action, in closure);
+        }
+
+        public static ValueActionIn<TAction, TClosure> ValueActionIn<TAction, TClosure, T1, T2, T3, T4, T5>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TAction : struct, IActionInArgIn<TClosure, T1, T2, T3, T4, T5>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+
+            return new ValueActionIn<TAction, TClosure>(in action, in closure);
+        }
+
+        public static ValueActionRef<TAction, TClosure> ValueActionRef<TAction, TClosure, T>(this TClosure closure, in T arg)
+            where TAction : struct, IActionRefArgIn<TClosure, T>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg);
+
+            return new ValueActionRef<TAction, TClosure>(in action, ref closure);
+        }
+
+        public static ValueActionRef<TAction, TClosure> ValueActionRef<TAction, TClosure, T1, T2>(this TClosure closure, in T1 arg1, in T2 arg2)
+            where TAction : struct, IActionRefArgIn<TClosure, T1, T2>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2);
+
+            return new ValueActionRef<TAction, TClosure>(in action, ref closure);
+        }
+
+        public static ValueActionRef<TAction, TClosure> ValueActionRef<TAction, TClosure, T1, T2, T3>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TAction : struct, IActionRefArgIn<TClosure, T1, T2, T3>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2, in arg3);
+
+            return new ValueActionRef<TAction, TClosure>(in action, ref closure);
+        }
+
+        public static ValueActionRef<TAction, TClosure> ValueActionRef<TAction, TClosure, T1, T2, T3, T4>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TAction : struct, IActionRefArgIn<TClosure, T1, T2, T3, T4>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2, in arg3, in arg4);
+
+            return new ValueActionRef<TAction, TClosure>(in action, ref closure);
+        }
+
+        public static ValueActionRef<TAction, TClosure> ValueActionRef<TAction, TClosure, T1, T2, T3, T4, T5>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TAction : struct, IActionRefArgIn<TClosure, T1, T2, T3, T4, T5>
+        {
+            var action = new TAction();
+            action.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+
+            return new ValueActionRef<TAction, TClosure>(in action, ref closure);
+        }
+    }
+}
\ No newline at end of file
diff --git a/System.ValueDelegates/Delegate/ValueDelegate.ActionArgIn.cs.meta b/System.ValueDelegates/Delegate/ValueDelegate.ActionArgIn.cs.meta
new file mode 100644
index 0000000..23a01e7
--- /dev/null
+++ b/System.ValueDelegates/Delegate/ValueDelegate.ActionArgIn.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 86a81c6471183ff46a5e89bc8f6f3070
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/System.ValueDelegates/Delegate/ValueDelegate.FuncArgIn.cs b/System.ValueDelegates/Delegate/ValueDelegate.FuncArgIn.cs
new file mode 100644
index 0000000..77a8e86
--- /dev/null
+++ b/System.ValueDelegates/Delegate/ValueDelegate.FuncArgIn.cs
@@ -0,0 +1,277 @@
+using System.Delegates;
+
+namespace System.ValueDelegates
+{
+    public static partial class ValueDelegate
+    {
+        public static ValueFunc<TFunc, object, TResult> ValueFunc<TFunc, T, TResult>(this object closure, in T arg)
+            where TFunc : struct, IFuncArgIn<object, T, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg);
+
+            return new ValueFunc<TFunc, object, TResult>(in func, closure);
+        }
+
+        public static ValueFunc<TFunc, object, TResult> ValueFunc<TFunc, T1, T2, TResult>(this object closure, in T1 arg1, in T2 arg2)
+            where TFunc : struct, IFuncArgIn<object, T1, T2, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2);
+
+            return new ValueFunc<TFunc, object, TResult>(in func, closure);
+        }
+
+        public static ValueFunc<TFunc, object, TResult> ValueFunc<TFunc, T1, T2, T3, TResult>(this object closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TFunc : struct, IFuncArgIn<object, T1, T2, T3, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2, in arg3);
+
+            return new ValueFunc<TFunc, object, TResult>(in func, closure);
+        }
+
+        public static ValueFunc<TFunc, object, TResult> ValueFunc<TFunc, T1, T2, T3, T4, TResult>(this object closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TFunc : struct, IFuncArgIn<object, T1, T2, T3, T4, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4);
+
+            return new ValueFunc<TFunc, object, TResult>(in func, closure);
+        }
+
+        public static ValueFunc<TFunc, object, TResult> ValueFunc<TFunc, T1, T2, T3, T4, T5, TResult>(this object closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TFunc : struct, IFuncArgIn<object, T1, T2, T3, T4, T5, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+
+            return new ValueFunc<TFunc, object, TResult>(in func, closure);
+        }
+
+        public static ValueFuncIn<TFunc, object, TResult> ValueFuncIn<TFunc, T, TResult>(this object closure, in T arg)
+            where TFunc : struct, IFuncInArgIn<object, T, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg);
+
+            return new ValueFuncIn<TFunc, object, TResult>(in func, in closure);
+        }
+
+        public static ValueFuncIn<TFunc, object, TResult> ValueFuncIn<TFunc, T1, T2, TResult>(this object closure, in T1 arg1, in T2 arg2)
+            where TFunc : struct, IFuncInArgIn<object, T1, T2, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2);
+
+            return new ValueFuncIn<TFunc, object, TResult>(in func, in closure);
+        }
+
+        public static ValueFuncIn<TFunc, object, TResult> ValueFuncIn<TFunc, T1, T2, T3, TResult>(this object closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TFunc : struct, IFuncInArgIn<object, T1, T2, T3, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2, in arg3);
+
+            return new ValueFuncIn<TFunc, object, TResult>(in func, in closure);
+        }
+
+        public static ValueFuncIn<TFunc, object, TResult> ValueFuncIn<TFunc, T1, T2, T3, T4, TResult>(this object closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TFunc : struct, IFuncInArgIn<object, T1, T2, T3, T4, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4);
+
+            return new ValueFuncIn<TFunc, object, TResult>(in func, in closure);
+        }
+
+        public static ValueFuncIn<TFunc, object, TResult> ValueFuncIn<TFunc, T1, T2, T3, T4, T5, TResult>(this object closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TFunc : struct, IFuncInArgIn<object, T1, T2, T3, T4, T5, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+
+            return new ValueFuncIn<TFunc, object, TResult>(in func, in closure);
+        }
+
+        public static ValueFuncRef<TFunc, object, TResult> ValueFuncRef<TFunc, T, TResult>(this object closure, in T arg)
+            where TFunc : struct, IFuncRefArgIn<object, T, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg);
+
+            return new ValueFuncRef<TFunc, object, TResult>(in func, ref closure);
+        }
+
+        public static ValueFuncRef<TFunc, object, TResult> ValueFuncRef<TFunc, T1, T2, TResult>(this object closure, in T1 arg1, in T2 arg2)
+            where TFunc : struct, IFuncRefArgIn<object, T1, T2, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2);
+
+            return new ValueFuncRef<TFunc, object, TResult>(in func, ref closure);
+        }
+
+        public static ValueFuncRef<TFunc, object, TResult> ValueFuncRef<TFunc, T1, T2, T3, TResult>(this object closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TFunc : struct, IFuncRefArgIn<object, T1, T2, T3, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2, in arg3);
+
+            return new ValueFuncRef<TFunc, object, TResult>(in func, ref closure);
+        }
+
+        public static ValueFuncRef<TFunc, object, TResult> ValueFuncRef<TFunc, T1, T2, T3, T4, TResult>(this object closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TFunc : struct, IFuncRefArgIn<object, T1, T2, T3, T4, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4);
+
+            return new ValueFuncRef<TFunc, object, TResult>(in func, ref closure);
+        }
+
+        public static ValueFuncRef<TFunc, object, TResult> ValueFuncRef<TFunc, T1, T2, T3, T4, T5, TResult>(this object closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TFunc : struct, IFuncRefArgIn<object, T1, T2, T3, T4, T5, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+
+            return new ValueFuncRef<TFunc, object, TResult>(in func, ref closure);
+        }
+
+        public static ValueFunc<TFunc, TClosure, TResult> ValueFunc<TFunc, TClosure, T, TResult>(this TClosure closure, in T arg)
+            where TFunc : struct, IFuncArgIn<TClosure, T, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg);
+
+            return new ValueFunc<TFunc, TClosure, TResult>(in func, closure);
+        }
+
+        public static ValueFunc<TFunc, TClosure, TResult> ValueFunc<TFunc, TClosure, T1, T2, TResult>(this TClosure closure, in T1 arg1, in T2 arg2)
+            where TFunc : struct, IFuncArgIn<TClosure, T1, T2, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2);
+
+            return new ValueFunc<TFunc, TClosure, TResult>(in func, closure);
+        }
+
+        public static ValueFunc<TFunc, TClosure, TResult> ValueFunc<TFunc, TClosure, T1, T2, T3, TResult>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TFunc : struct, IFuncArgIn<TClosure, T1, T2, T3, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2, in arg3);
+
+            return new ValueFunc<TFunc, TClosure, TResult>(in func, closure);
+        }
+
+        public static ValueFunc<TFunc, TClosure, TResult> ValueFunc<TFunc, TClosure, T1, T2, T3, T4, TResult>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TFunc : struct, IFuncArgIn<TClosure, T1, T2, T3, T4, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4);
+
+            return new ValueFunc<TFunc, TClosure, TResult>(in func, closure);
+        }
+
+        public static ValueFunc<TFunc, TClosure, TResult> ValueFunc<TFunc, TClosure, T1, T2, T3, T4, T5, TResult>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TFunc : struct, IFuncArgIn<TClosure, T1, T2, T3, T4, T5, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+
+            return new ValueFunc<TFunc, TClosure, TResult>(in func, closure);
+        }
+
+        public static ValueFuncIn<TFunc, TClosure, TResult> ValueFuncIn<TFunc, TClosure, T, TResult>(this TClosure closure, in T arg)
+            where TFunc : struct, IFuncInArgIn<TClosure, T, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg);
+
+            return new ValueFuncIn<TFunc, TClosure, TResult>(in func, in closure);
+        }
+
+        public static ValueFuncIn<TFunc, TClosure, TResult> ValueFuncIn<TFunc, TClosure, T1, T2, TResult>(this TClosure closure, in T1 arg1, in T2 arg2)
+            where TFunc : struct, IFuncInArgIn<TClosure, T1, T2, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2);
+
+            return new ValueFuncIn<TFunc, TClosure, TResult>(in func, in closure);
+        }
+
+        public static ValueFuncIn<TFunc, TClosure, TResult> ValueFuncIn<TFunc, TClosure, T1, T2, T3, TResult>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TFunc : struct, IFuncInArgIn<TClosure, T1, T2, T3, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2, in arg3);
+
+            return new ValueFuncIn<TFunc, TClosure, TResult>(in func, in closure);
+        }
+
+        public static ValueFuncIn<TFunc, TClosure, TResult> ValueFuncIn<TFunc, TClosure, T1, T2, T3, T4, TResult>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TFunc : struct, IFuncInArgIn<TClosure, T1, T2, T3, T4, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4);
+
+            return new ValueFuncIn<TFunc, TClosure, TResult>(in func, in closure);
+        }
+
+        public static ValueFuncIn<TFunc, TClosure, TResult> ValueFuncIn<TFunc, TClosure, T1, T2, T3, T4, T5, TResult>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TFunc : struct, IFuncInArgIn<TClosure, T1, T2, T3, T4, T5, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+
+            return new ValueFuncIn<TFunc, TClosure, TResult>(in func, in closure);
+        }
+
+        public static ValueFuncRef<TFunc, TClosure, TResult> ValueFuncRef<TFunc, TClosure, T, TResult>(this TClosure closure, in T arg)
+            where TFunc : struct, IFuncRefArgIn<TClosure, T, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg);
+
+            return new ValueFuncRef<TFunc, TClosure, TResult>(in func, ref closure);
+        }
+
+        public static ValueFuncRef<TFunc, TClosure, TResult> ValueFuncRef<TFunc, TClosure, T1, T2, TResult>(this TClosure closure, in T1 arg1, in T2 arg2)
+            where TFunc : struct, IFuncRefArgIn<TClosure, T1, T2, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2);
+
+            return new ValueFuncRef<TFunc, TClosure, TResult>(in func, ref closure);
+        }
+
+        public static ValueFuncRef<TFunc, TClosure, TResult> ValueFuncRef<TFunc, TClosure, T1, T2, T3, TResult>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TFunc : struct, IFuncRefArgIn<TClosure, T1, T2, T3, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2, in arg3);
+
+            return new ValueFuncRef<TFunc, TClosure, TResult>(in func, ref closure);
+        }
+
+        public static ValueFuncRef<TFunc, TClosure, TResult> ValueFuncRef<TFunc, TClosure, T1, T2, T3, T4, TResult>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TFunc : struct, IFuncRefArgIn<TClosure, T1, T2, T3, T4, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4);
+
+            return new ValueFuncRef<TFunc, TClosure, TResult>(in func, ref closure);
+        }
+
+        public static ValueFuncRef<TFunc, TClosure, TResult> ValueFuncRef<TFunc, TClosure, T1, T2, T3, T4, T5, TResult>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TFunc : struct, IFuncRefArgIn<TClosure, T1, T2, T3, T4, T5, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+
+            return new ValueFuncRef<TFunc, TClosure, TResult>(in func, ref closure);
+        }
+    }
+}
\ No newline at end of file
diff --git a/System.ValueDelegates/Delegate/ValueDelegate.FuncArgIn.cs.meta b/System.ValueDelegates/Delegate/ValueDelegate.FuncArgIn.cs.meta
new file mode 100644
index 0000000..74cdbd0
--- /dev/null
+++ b/System.ValueDelegates/Delegate/ValueDelegate.FuncArgIn.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1ee0eea985fca8949bb77615e546e41e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/System.ValueDelegates/Delegate/ValueDelegate.PredicateArgIn.cs b/System.ValueDelegates/Delegate/ValueDelegate.PredicateArgIn.cs
new file mode 100644
index 0000000..f6c74bc
--- /dev/null
+++ b/System.ValueDelegates/Delegate/ValueDelegate.PredicateArgIn.cs
@@ -0,0 +1,277 @@
+using System.Delegates;
+
+namespace System.ValueDelegates
+{
+    public static partial class ValueDelegate
+    {
+        public static ValuePredicate<TPredicate, object> ValuePredicate<TPredicate, T>(this object closure, in T arg)
+            where TPredicate : struct, IPredicateArgIn<object, T>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg);
+
+            return new ValuePredicate<TPredicate, object>(in predicate, closure);
+        }
+
+        public static ValuePredicate<TPredicate, object> ValuePredicate<TPredicate, T1, T2>(this object closure, in T1 arg1, in T2 arg2)
+            where TPredicate : struct, IPredicateArgIn<object, T1, T2>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2);
+
+            return new ValuePredicate<TPredicate, object>(in predicate, closure);
+        }
+
+        public static ValuePredicate<TPredicate, object> ValuePredicate<TPredicate, T1, T2, T3>(this object closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TPredicate : struct, IPredicateArgIn<object, T1, T2, T3>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2, in arg3);
+
+            return new ValuePredicate<TPredicate, object>(in predicate, closure);
+        }
+
+        public static ValuePredicate<TPredicate, object> ValuePredicate<TPredicate, T1, T2, T3, T4>(this object closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TPredicate : struct, IPredicateArgIn<object, T1, T2, T3, T4>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4);
+
+            return new ValuePredicate<TPredicate, object>(in predicate, closure);
+        }
+
+        public static ValuePredicate<TPredicate, object> ValuePredicate<TPredicate, T1, T2, T3, T4, T5>(this object closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TPredicate : struct, IPredicateArgIn<object, T1, T2, T3, T4, T5>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+
+            return new ValuePredicate<TPredicate, object>(in predicate, closure);
+        }
+
+        public static ValuePredicateIn<TPredicate, object> ValuePredicateIn<TPredicate, T>(this object closure, in T arg)
+            where TPredicate : struct, IPredicateInArgIn<object, T>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg);
+
+            return new ValuePredicateIn<TPredicate, object>(in predicate, in closure);
+        }
+
+        public static ValuePredicateIn<TPredicate, object> ValuePredicateIn<TPredicate, T1, T2>(this object closure, in T1 arg1, in T2 arg2)
+            where TPredicate : struct, IPredicateInArgIn<object, T1, T2>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2);
+
+            return new ValuePredicateIn<TPredicate, object>(in predicate, in closure);
+        }
+
+        public static ValuePredicateIn<TPredicate, object> ValuePredicateIn<TPredicate, T1, T2, T3>(this object closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TPredicate : struct, IPredicateInArgIn<object, T1, T2, T3>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2, in arg3);
+
+            return new ValuePredicateIn<TPredicate, object>(in predicate, in closure);
+        }
+
+        public static ValuePredicateIn<TPredicate, object> ValuePredicateIn<TPredicate, T1, T2, T3, T4>(this object closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TPredicate : struct, IPredicateInArgIn<object, T1, T2, T3, T4>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4);
+
+            return new ValuePredicateIn<TPredicate, object>(in predicate, in closure);
+        }
+
+        public static ValuePredicateIn<TPredicate, object> ValuePredicateIn<TPredicate, T1, T2, T3, T4, T5>(this object closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TPredicate : struct, IPredicateInArgIn<object, T1, T2, T3, T4, T5>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+
+            return new ValuePredicateIn<TPredicate, object>(in predicate, in closure);
+        }
+
+        public static ValuePredicateRef<TPredicate, object> ValuePredicateRef<TPredicate, T>(this object closure, in T arg)
+            where TPredicate : struct, IPredicateRefArgIn<object, T>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg);
+
+            return new ValuePredicateRef<TPredicate, object>(in predicate, ref closure);
+        }
+
+        public static ValuePredicateRef<TPredicate, object> ValuePredicateRef<TPredicate, T1, T2>(this object closure, in T1 arg1, in T2 arg2)
+            where TPredicate : struct, IPredicateRefArgIn<object, T1, T2>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2);
+
+            return new ValuePredicateRef<TPredicate, object>(in predicate, ref closure);
+        }
+
+        public static ValuePredicateRef<TPredicate, object> ValuePredicateRef<TPredicate, T1, T2, T3>(this object closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TPredicate : struct, IPredicateRefArgIn<object, T1, T2, T3>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2, in arg3);
+
+            return new ValuePredicateRef<TPredicate, object>(in predicate, ref closure);
+        }
+
+        public static ValuePredicateRef<TPredicate, object> ValuePredicateRef<TPredicate, T1, T2, T3, T4>(this object closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TPredicate : struct, IPredicateRefArgIn<object, T1, T2, T3, T4>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4);
+
+            return new ValuePredicateRef<TPredicate, object>(in predicate, ref closure);
+        }
+
+        public static ValuePredicateRef<TPredicate, object> ValuePredicateRef<TPredicate, T1, T2, T3, T4, T5>(this object closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TPredicate : struct, IPredicateRefArgIn<object, T1, T2, T3, T4, T5>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+
+            return new ValuePredicateRef<TPredicate, object>(in predicate, ref closure);
+        }
+
+        public static ValuePredicate<TPredicate, TClosure> ValuePredicate<TPredicate, TClosure, T>(this TClosure closure, in T arg)
+            where TPredicate : struct, IPredicateArgIn<TClosure, T>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg);
+
+            return new ValuePredicate<TPredicate, TClosure>(in predicate, closure);
+        }
+
+        public static ValuePredicate<TPredicate, TClosure> ValuePredicate<TPredicate, TClosure, T1, T2>(this TClosure closure, in T1 arg1, in T2 arg2)
+            where TPredicate : struct, IPredicateArgIn<TClosure, T1, T2>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2);
+
+            return new ValuePredicate<TPredicate, TClosure>(in predicate, closure);
+        }
+
+        public static ValuePredicate<TPredicate, TClosure> ValuePredicate<TPredicate, TClosure, T1, T2, T3>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TPredicate : struct, IPredicateArgIn<TClosure, T1, T2, T3>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2, in arg3);
+
+            return new ValuePredicate<TPredicate, TClosure>(in predicate, closure);
+        }
+
+        public static ValuePredicate<TPredicate, TClosure> ValuePredicate<TPredicate, TClosure, T1, T2, T3, T4>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TPredicate : struct, IPredicateArgIn<TClosure, T1, T2, T3, T4>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4);
+
+            return new ValuePredicate<TPredicate, TClosure>(in predicate, closure);
+        }
+
+        public static ValuePredicate<TPredicate, TClosure> ValuePredicate<TPredicate, TClosure, T1, T2, T3, T4, T5>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TPredicate : struct, IPredicateArgIn<TClosure, T1, T2, T3, T4, T5>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+
+            return new ValuePredicate<TPredicate, TClosure>(in predicate, closure);
+        }
+
+        public static ValuePredicateIn<TPredicate, TClosure> ValuePredicateIn<TPredicate, TClosure, T>(this TClosure closure, in T arg)
+            where TPredicate : struct, IPredicateInArgIn<TClosure, T>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg);
+
+            return new ValuePredicateIn<TPredicate, TClosure>(in predicate, in closure);
+        }
+
+        public static ValuePredicateIn<TPredicate, TClosure> ValuePredicateIn<TPredicate, TClosure, T1, T2>(this TClosure closure, in T1 arg1, in T2 arg2)
+            where TPredicate : struct, IPredicateInArgIn<TClosure, T1, T2>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2);
+
+            return new ValuePredicateIn<TPredicate, TClosure>(in predicate, in closure);
+        }
+
+        public static ValuePredicateIn<TPredicate, TClosure> ValuePredicateIn<TPredicate, TClosure, T1, T2, T3>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TPredicate : struct, IPredicateInArgIn<TClosure, T1, T2, T3>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2, in arg3);
+
+            return new ValuePredicateIn<TPredicate, TClosure>(in predicate, in closure);
+        }
+
+        public static ValuePredicateIn<TPredicate, TClosure> ValuePredicateIn<TPredicate, TClosure, T1, T2, T3, T4>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TPredicate : struct, IPredicateInArgIn<TClosure, T1, T2, T3, T4>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4);
+
+            return new ValuePredicateIn<TPredicate, TClosure>(in predicate, in closure);
+        }
+
+        public static ValuePredicateIn<TPredicate, TClosure> ValuePredicateIn<TPredicate, TClosure, T1, T2, T3, T4, T5>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TPredicate : struct, IPredicateInArgIn<TClosure, T1, T2, T3, T4, T5>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+
+            return new ValuePredicateIn<TPredicate, TClosure>(in predicate, in closure);
+        }
+
+        public static ValuePredicateRef<TPredicate, TClosure> ValuePredicateRef<TPredicate, TClosure, T>(this TClosure closure, in T arg)
+            where TPredicate : struct, IPredicateRefArgIn<TClosure, T>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg);
+
+            return new ValuePredicateRef<TPredicate, TClosure>(in predicate, ref closure);
+        }
+
+        public static ValuePredicateRef<TPredicate, TClosure> ValuePredicateRef<TPredicate, TClosure, T1, T2>(this TClosure closure, in T1 arg1, in T2 arg2)
+            where TPredicate : struct, IPredicateRefArgIn<TClosure, T1, T2>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2);
+
+            return new ValuePredicateRef<TPredicate, TClosure>(in predicate, ref closure);
+        }
+
+        public static ValuePredicateRef<TPredicate, TClosure> ValuePredicateRef<TPredicate, TClosure, T1, T2, T3>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TPredicate : struct, IPredicateRefArgIn<TClosure, T1, T2, T3>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2, in arg3);
+
+            return new ValuePredicateRef<TPredicate, TClosure>(in predicate, ref closure);
+        }
+
+        public static ValuePredicateRef<TPredicate, TClosure> ValuePredicateRef<TPredicate, TClosure, T1, T2, T3, T4>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TPredicate : struct, IPredicateRefArgIn<TClosure, T1, T2, T3, T4>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4);
+
+            return new ValuePredicateRef<TPredicate, TClosure>(in predicate, ref closure);
+        }
+
+        public static ValuePredicateRef<TPredicate, TClosure> ValuePredicateRef<TPredicate, TClosure, T1, T2, T3, T4, T5>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TPredicate : struct, IPredicateRefArgIn<TClosure, T1, T2, T3, T4, T5>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+
+            return new ValuePredicateRef<TPredicate, TClosure>(in predicate, ref closure);
+        }
+    }
+}
\ No newline at end of file
diff --git a/System.ValueDelegates/Delegate/ValueDelegate.PredicateArgIn.cs.meta b/System.ValueDelegates/Delegate/ValueDelegate.PredicateArgIn.cs.meta
new file mode 100644
index 0000000..d85f219
--- /dev/null
+++ b/System.ValueDelegates/Delegate/ValueDelegate.PredicateArgIn.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 94e7e034c4259154083fe9b000a6b281
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/System.ValueDelegates/Func/ValueFunc.Func.cs b/System.ValueDelegates/Func/ValueFunc.Func.cs
index 15b6470..997cc65 100644
--- a/System.ValueDelegates/Func/ValueFunc.Func.cs
+++ b/System.ValueDelegates/Func/ValueFunc.Func.cs
@@ -4,10 +4,6 @@ namespace System.ValueDelegates
 {
     public static partial class ValueFunc
     {
-        public static TResult Invoke<TFunc, TResult>()
-            where TFunc : struct, IFunc<TResult>
-            => new TFunc().Invoke();
-
         public static TResult Invoke<TFunc, TClosure, T, TResult>(this TFunc func, TClosure closure, T arg)
             where TFunc : struct, IFunc<TClosure, T, TResult>
         {
@@ -121,5 +117,115 @@ public static TResult Invoke<TFunc, TClosure, T1, T2, T3, T4, T5, TResult>(this
             func.SetArguments(arg1, arg2, arg3, arg4, arg5);
             return func.Invoke(closure);
         }
+
+        public static TResult Invoke<TFunc, TClosure, T, TResult>(this TFunc func, TClosure closure, in T arg)
+            where TFunc : struct, IFuncArgIn<TClosure, T, TResult>
+        {
+            func.SetArguments(in arg);
+            return func.Invoke(closure);
+        }
+
+        public static TResult Invoke<TFunc, TClosure, T1, T2, TResult>(this TFunc func, TClosure closure, in T1 arg1, in T2 arg2)
+            where TFunc : struct, IFuncArgIn<TClosure, T1, T2, TResult>
+        {
+            func.SetArguments(in arg1, in arg2);
+            return func.Invoke(closure);
+        }
+
+        public static TResult Invoke<TFunc, TClosure, T1, T2, T3, TResult>(this TFunc func, TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TFunc : struct, IFuncArgIn<TClosure, T1, T2, T3, TResult>
+        {
+            func.SetArguments(in arg1, in arg2, in arg3);
+            return func.Invoke(closure);
+        }
+
+        public static TResult Invoke<TFunc, TClosure, T1, T2, T3, T4, TResult>(this TFunc func, TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TFunc : struct, IFuncArgIn<TClosure, T1, T2, T3, T4, TResult>
+        {
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4);
+            return func.Invoke(closure);
+        }
+
+        public static TResult Invoke<TFunc, TClosure, T1, T2, T3, T4, T5, TResult>(this TFunc func, TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TFunc : struct, IFuncArgIn<TClosure, T1, T2, T3, T4, T5, TResult>
+        {
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+            return func.Invoke(closure);
+        }
+
+        public static TResult Invoke<TFunc, TClosure, T, TResult>(in TFunc func, TClosure closure, in T arg)
+            where TFunc : struct, IFuncArgIn<TClosure, T, TResult>
+        {
+            func.SetArguments(in arg);
+            return func.Invoke(closure);
+        }
+
+        public static TResult Invoke<TFunc, TClosure, T1, T2, TResult>(in TFunc func, TClosure closure, in T1 arg1, in T2 arg2)
+            where TFunc : struct, IFuncArgIn<TClosure, T1, T2, TResult>
+        {
+            func.SetArguments(in arg1, in arg2);
+            return func.Invoke(closure);
+        }
+
+        public static TResult Invoke<TFunc, TClosure, T1, T2, T3, TResult>(in TFunc func, TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TFunc : struct, IFuncArgIn<TClosure, T1, T2, T3, TResult>
+        {
+            func.SetArguments(in arg1, in arg2, in arg3);
+            return func.Invoke(closure);
+        }
+
+        public static TResult Invoke<TFunc, TClosure, T1, T2, T3, T4, TResult>(in TFunc func, TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TFunc : struct, IFuncArgIn<TClosure, T1, T2, T3, T4, TResult>
+        {
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4);
+            return func.Invoke(closure);
+        }
+
+        public static TResult Invoke<TFunc, TClosure, T1, T2, T3, T4, T5, TResult>(in TFunc func, TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TFunc : struct, IFuncArgIn<TClosure, T1, T2, T3, T4, T5, TResult>
+        {
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+            return func.Invoke(closure);
+        }
+
+        public static TResult Invoke<TFunc, TClosure, T, TResult>(this TClosure closure, in T arg)
+            where TFunc : struct, IFuncArgIn<TClosure, T, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg);
+            return func.Invoke(closure);
+        }
+
+        public static TResult Invoke<TFunc, TClosure, T1, T2, TResult>(this TClosure closure, in T1 arg1, in T2 arg2)
+            where TFunc : struct, IFuncArgIn<TClosure, T1, T2, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2);
+            return func.Invoke(closure);
+        }
+
+        public static TResult Invoke<TFunc, TClosure, T1, T2, T3, TResult>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TFunc : struct, IFuncArgIn<TClosure, T1, T2, T3, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2, in arg3);
+            return func.Invoke(closure);
+        }
+
+        public static TResult Invoke<TFunc, TClosure, T1, T2, T3, T4, TResult>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TFunc : struct, IFuncArgIn<TClosure, T1, T2, T3, T4, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4);
+            return func.Invoke(closure);
+        }
+
+        public static TResult Invoke<TFunc, TClosure, T1, T2, T3, T4, T5, TResult>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TFunc : struct, IFuncArgIn<TClosure, T1, T2, T3, T4, T5, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+            return func.Invoke(closure);
+        }
     }
 }
\ No newline at end of file
diff --git a/System.ValueDelegates/Func/ValueFunc.FuncIn.cs b/System.ValueDelegates/Func/ValueFunc.FuncIn.cs
index 2e4bb9f..ca713d7 100644
--- a/System.ValueDelegates/Func/ValueFunc.FuncIn.cs
+++ b/System.ValueDelegates/Func/ValueFunc.FuncIn.cs
@@ -4,11 +4,11 @@ namespace System.ValueDelegates
 {
     public static partial class ValueFunc
     {
-        public static TResult Invoke<TFunc, TClosure, TResult>(in TClosure closure)
+        public static TResult InvokeIn<TFunc, TClosure, TResult>(this TClosure closure)
             where TFunc : struct, IFuncIn<TClosure, TResult>
             => new TFunc().Invoke(in closure);
 
-        public static TResult Invoke<TFunc, TClosure, T, TResult>(in TClosure closure, T arg)
+        public static TResult InvokeIn<TFunc, TClosure, T, TResult>(this TClosure closure, T arg)
             where TFunc : struct, IFuncIn<TClosure, T, TResult>
         {
             var func = new TFunc();
@@ -16,7 +16,7 @@ public static TResult Invoke<TFunc, TClosure, T, TResult>(in TClosure closure, T
             return func.Invoke(in closure);
         }
 
-        public static TResult Invoke<TFunc, TClosure, T1, T2, TResult>(in TClosure closure, T1 arg1, T2 arg2)
+        public static TResult InvokeIn<TFunc, TClosure, T1, T2, TResult>(this TClosure closure, T1 arg1, T2 arg2)
             where TFunc : struct, IFuncIn<TClosure, T1, T2, TResult>
         {
             var func = new TFunc();
@@ -24,7 +24,7 @@ public static TResult Invoke<TFunc, TClosure, T1, T2, TResult>(in TClosure closu
             return func.Invoke(in closure);
         }
 
-        public static TResult Invoke<TFunc, TClosure, T1, T2, T3, TResult>(in TClosure closure, T1 arg1, T2 arg2, T3 arg3)
+        public static TResult InvokeIn<TFunc, TClosure, T1, T2, T3, TResult>(this TClosure closure, T1 arg1, T2 arg2, T3 arg3)
             where TFunc : struct, IFuncIn<TClosure, T1, T2, T3, TResult>
         {
             var func = new TFunc();
@@ -32,7 +32,7 @@ public static TResult Invoke<TFunc, TClosure, T1, T2, T3, TResult>(in TClosure c
             return func.Invoke(in closure);
         }
 
-        public static TResult Invoke<TFunc, TClosure, T1, T2, T3, T4, TResult>(in TClosure closure, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+        public static TResult InvokeIn<TFunc, TClosure, T1, T2, T3, T4, TResult>(this TClosure closure, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
             where TFunc : struct, IFuncIn<TClosure, T1, T2, T3, T4, TResult>
         {
             var func = new TFunc();
@@ -40,7 +40,7 @@ public static TResult Invoke<TFunc, TClosure, T1, T2, T3, T4, TResult>(in TClosu
             return func.Invoke(in closure);
         }
 
-        public static TResult Invoke<TFunc, TClosure, T1, T2, T3, T4, T5, TResult>(in TClosure closure, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
+        public static TResult InvokeIn<TFunc, TClosure, T1, T2, T3, T4, T5, TResult>(this TClosure closure, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
             where TFunc : struct, IFuncIn<TClosure, T1, T2, T3, T4, T5, TResult>
         {
             var func = new TFunc();
@@ -117,5 +117,115 @@ public static TResult Invoke<TFunc, TClosure, T1, T2, T3, T4, T5, TResult>(in TF
             func.SetArguments(arg1, arg2, arg3, arg4, arg5);
             return func.Invoke(in closure);
         }
+
+        public static TResult InvokeIn<TFunc, TClosure, T, TResult>(this TClosure closure, in T arg)
+            where TFunc : struct, IFuncInArgIn<TClosure, T, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg);
+            return func.Invoke(in closure);
+        }
+
+        public static TResult InvokeIn<TFunc, TClosure, T1, T2, TResult>(this TClosure closure, in T1 arg1, in T2 arg2)
+            where TFunc : struct, IFuncInArgIn<TClosure, T1, T2, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2);
+            return func.Invoke(in closure);
+        }
+
+        public static TResult InvokeIn<TFunc, TClosure, T1, T2, T3, TResult>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TFunc : struct, IFuncInArgIn<TClosure, T1, T2, T3, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2, in arg3);
+            return func.Invoke(in closure);
+        }
+
+        public static TResult InvokeIn<TFunc, TClosure, T1, T2, T3, T4, TResult>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TFunc : struct, IFuncInArgIn<TClosure, T1, T2, T3, T4, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4);
+            return func.Invoke(in closure);
+        }
+
+        public static TResult InvokeIn<TFunc, TClosure, T1, T2, T3, T4, T5, TResult>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TFunc : struct, IFuncInArgIn<TClosure, T1, T2, T3, T4, T5, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+            return func.Invoke(in closure);
+        }
+
+        public static TResult Invoke<TFunc, TClosure, T, TResult>(this TFunc func, in TClosure closure, in T arg)
+            where TFunc : struct, IFuncInArgIn<TClosure, T, TResult>
+        {
+            func.SetArguments(in arg);
+            return func.Invoke(in closure);
+        }
+
+        public static TResult Invoke<TFunc, TClosure, T1, T2, TResult>(this TFunc func, in TClosure closure, in T1 arg1, in T2 arg2)
+            where TFunc : struct, IFuncInArgIn<TClosure, T1, T2, TResult>
+        {
+            func.SetArguments(in arg1, in arg2);
+            return func.Invoke(in closure);
+        }
+
+        public static TResult Invoke<TFunc, TClosure, T1, T2, T3, TResult>(this TFunc func, in TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TFunc : struct, IFuncInArgIn<TClosure, T1, T2, T3, TResult>
+        {
+            func.SetArguments(in arg1, in arg2, in arg3);
+            return func.Invoke(in closure);
+        }
+
+        public static TResult Invoke<TFunc, TClosure, T1, T2, T3, T4, TResult>(this TFunc func, in TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TFunc : struct, IFuncInArgIn<TClosure, T1, T2, T3, T4, TResult>
+        {
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4);
+            return func.Invoke(in closure);
+        }
+
+        public static TResult Invoke<TFunc, TClosure, T1, T2, T3, T4, T5, TResult>(this TFunc func, in TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TFunc : struct, IFuncInArgIn<TClosure, T1, T2, T3, T4, T5, TResult>
+        {
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+            return func.Invoke(in closure);
+        }
+
+        public static TResult Invoke<TFunc, TClosure, T, TResult>(in TFunc func, in TClosure closure, in T arg)
+            where TFunc : struct, IFuncInArgIn<TClosure, T, TResult>
+        {
+            func.SetArguments(in arg);
+            return func.Invoke(in closure);
+        }
+
+        public static TResult Invoke<TFunc, TClosure, T1, T2, TResult>(in TFunc func, in TClosure closure, in T1 arg1, in T2 arg2)
+            where TFunc : struct, IFuncInArgIn<TClosure, T1, T2, TResult>
+        {
+            func.SetArguments(in arg1, in arg2);
+            return func.Invoke(in closure);
+        }
+
+        public static TResult Invoke<TFunc, TClosure, T1, T2, T3, TResult>(in TFunc func, in TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TFunc : struct, IFuncInArgIn<TClosure, T1, T2, T3, TResult>
+        {
+            func.SetArguments(in arg1, in arg2, in arg3);
+            return func.Invoke(in closure);
+        }
+
+        public static TResult Invoke<TFunc, TClosure, T1, T2, T3, T4, TResult>(in TFunc func, in TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TFunc : struct, IFuncInArgIn<TClosure, T1, T2, T3, T4, TResult>
+        {
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4);
+            return func.Invoke(in closure);
+        }
+
+        public static TResult Invoke<TFunc, TClosure, T1, T2, T3, T4, T5, TResult>(in TFunc func, in TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TFunc : struct, IFuncInArgIn<TClosure, T1, T2, T3, T4, T5, TResult>
+        {
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+            return func.Invoke(in closure);
+        }
     }
 }
\ No newline at end of file
diff --git a/System.ValueDelegates/Func/ValueFunc.FuncRef.cs b/System.ValueDelegates/Func/ValueFunc.FuncRef.cs
index 7daeb97..82eb850 100644
--- a/System.ValueDelegates/Func/ValueFunc.FuncRef.cs
+++ b/System.ValueDelegates/Func/ValueFunc.FuncRef.cs
@@ -4,11 +4,11 @@ namespace System.ValueDelegates
 {
     public static partial class ValueFunc
     {
-        public static TResult InvokeRef<TFunc, TClosure, TResult>(ref TClosure closure)
+        public static TResult InvokeRef<TFunc, TClosure, TResult>(this TClosure closure)
             where TFunc : struct, IFuncRef<TClosure, TResult>
             => new TFunc().Invoke(ref closure);
 
-        public static TResult InvokeRef<TFunc, TClosure, T, TResult>(ref TClosure closure, T arg)
+        public static TResult InvokeRef<TFunc, TClosure, T, TResult>(this TClosure closure, T arg)
             where TFunc : struct, IFuncRef<TClosure, T, TResult>
         {
             var func = new TFunc();
@@ -16,7 +16,7 @@ public static TResult InvokeRef<TFunc, TClosure, T, TResult>(ref TClosure closur
             return func.Invoke(ref closure);
         }
 
-        public static TResult InvokeRef<TFunc, TClosure, T1, T2, TResult>(ref TClosure closure, T1 arg1, T2 arg2)
+        public static TResult InvokeRef<TFunc, TClosure, T1, T2, TResult>(this TClosure closure, T1 arg1, T2 arg2)
             where TFunc : struct, IFuncRef<TClosure, T1, T2, TResult>
         {
             var func = new TFunc();
@@ -24,7 +24,7 @@ public static TResult InvokeRef<TFunc, TClosure, T1, T2, TResult>(ref TClosure c
             return func.Invoke(ref closure);
         }
 
-        public static TResult InvokeRef<TFunc, TClosure, T1, T2, T3, TResult>(ref TClosure closure, T1 arg1, T2 arg2, T3 arg3)
+        public static TResult InvokeRef<TFunc, TClosure, T1, T2, T3, TResult>(this TClosure closure, T1 arg1, T2 arg2, T3 arg3)
             where TFunc : struct, IFuncRef<TClosure, T1, T2, T3, TResult>
         {
             var func = new TFunc();
@@ -32,7 +32,7 @@ public static TResult InvokeRef<TFunc, TClosure, T1, T2, T3, TResult>(ref TClosu
             return func.Invoke(ref closure);
         }
 
-        public static TResult InvokeRef<TFunc, TClosure, T1, T2, T3, T4, TResult>(ref TClosure closure, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+        public static TResult InvokeRef<TFunc, TClosure, T1, T2, T3, T4, TResult>(this TClosure closure, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
             where TFunc : struct, IFuncRef<TClosure, T1, T2, T3, T4, TResult>
         {
             var func = new TFunc();
@@ -40,7 +40,7 @@ public static TResult InvokeRef<TFunc, TClosure, T1, T2, T3, T4, TResult>(ref TC
             return func.Invoke(ref closure);
         }
 
-        public static TResult InvokeRef<TFunc, TClosure, T1, T2, T3, T4, T5, TResult>(ref TClosure closure, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
+        public static TResult InvokeRef<TFunc, TClosure, T1, T2, T3, T4, T5, TResult>(this TClosure closure, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
             where TFunc : struct, IFuncRef<TClosure, T1, T2, T3, T4, T5, TResult>
         {
             var func = new TFunc();
@@ -117,5 +117,115 @@ public static TResult InvokeRef<TFunc, TClosure, T1, T2, T3, T4, T5, TResult>(in
             func.SetArguments(arg1, arg2, arg3, arg4, arg5);
             return func.Invoke(ref closure);
         }
+
+        public static TResult InvokeRef<TFunc, TClosure, T, TResult>(this TClosure closure, in T arg)
+            where TFunc : struct, IFuncRefArgIn<TClosure, T, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg);
+            return func.Invoke(ref closure);
+        }
+
+        public static TResult InvokeRef<TFunc, TClosure, T1, T2, TResult>(this TClosure closure, in T1 arg1, in T2 arg2)
+            where TFunc : struct, IFuncRefArgIn<TClosure, T1, T2, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2);
+            return func.Invoke(ref closure);
+        }
+
+        public static TResult InvokeRef<TFunc, TClosure, T1, T2, T3, TResult>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TFunc : struct, IFuncRefArgIn<TClosure, T1, T2, T3, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2, in arg3);
+            return func.Invoke(ref closure);
+        }
+
+        public static TResult InvokeRef<TFunc, TClosure, T1, T2, T3, T4, TResult>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TFunc : struct, IFuncRefArgIn<TClosure, T1, T2, T3, T4, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4);
+            return func.Invoke(ref closure);
+        }
+
+        public static TResult InvokeRef<TFunc, TClosure, T1, T2, T3, T4, T5, TResult>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TFunc : struct, IFuncRefArgIn<TClosure, T1, T2, T3, T4, T5, TResult>
+        {
+            var func = new TFunc();
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+            return func.Invoke(ref closure);
+        }
+
+        public static TResult InvokeRef<TFunc, TClosure, T, TResult>(this TFunc func, ref TClosure closure, in T arg)
+            where TFunc : struct, IFuncRefArgIn<TClosure, T, TResult>
+        {
+            func.SetArguments(in arg);
+            return func.Invoke(ref closure);
+        }
+
+        public static TResult InvokeRef<TFunc, TClosure, T1, T2, TResult>(this TFunc func, ref TClosure closure, in T1 arg1, in T2 arg2)
+            where TFunc : struct, IFuncRefArgIn<TClosure, T1, T2, TResult>
+        {
+            func.SetArguments(in arg1, in arg2);
+            return func.Invoke(ref closure);
+        }
+
+        public static TResult InvokeRef<TFunc, TClosure, T1, T2, T3, TResult>(this TFunc func, ref TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TFunc : struct, IFuncRefArgIn<TClosure, T1, T2, T3, TResult>
+        {
+            func.SetArguments(in arg1, in arg2, in arg3);
+            return func.Invoke(ref closure);
+        }
+
+        public static TResult InvokeRef<TFunc, TClosure, T1, T2, T3, T4, TResult>(this TFunc func, ref TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TFunc : struct, IFuncRefArgIn<TClosure, T1, T2, T3, T4, TResult>
+        {
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4);
+            return func.Invoke(ref closure);
+        }
+
+        public static TResult InvokeRef<TFunc, TClosure, T1, T2, T3, T4, T5, TResult>(this TFunc func, ref TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TFunc : struct, IFuncRefArgIn<TClosure, T1, T2, T3, T4, T5, TResult>
+        {
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+            return func.Invoke(ref closure);
+        }
+
+        public static TResult InvokeRef<TFunc, TClosure, T, TResult>(in TFunc func, ref TClosure closure, in T arg)
+            where TFunc : struct, IFuncRefArgIn<TClosure, T, TResult>
+        {
+            func.SetArguments(in arg);
+            return func.Invoke(ref closure);
+        }
+
+        public static TResult InvokeRef<TFunc, TClosure, T1, T2, TResult>(in TFunc func, ref TClosure closure, in T1 arg1, in T2 arg2)
+            where TFunc : struct, IFuncRefArgIn<TClosure, T1, T2, TResult>
+        {
+            func.SetArguments(in arg1, in arg2);
+            return func.Invoke(ref closure);
+        }
+
+        public static TResult InvokeRef<TFunc, TClosure, T1, T2, T3, TResult>(in TFunc func, ref TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TFunc : struct, IFuncRefArgIn<TClosure, T1, T2, T3, TResult>
+        {
+            func.SetArguments(in arg1, in arg2, in arg3);
+            return func.Invoke(ref closure);
+        }
+
+        public static TResult InvokeRef<TFunc, TClosure, T1, T2, T3, T4, TResult>(in TFunc func, ref TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TFunc : struct, IFuncRefArgIn<TClosure, T1, T2, T3, T4, TResult>
+        {
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4);
+            return func.Invoke(ref closure);
+        }
+
+        public static TResult InvokeRef<TFunc, TClosure, T1, T2, T3, T4, T5, TResult>(in TFunc func, ref TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TFunc : struct, IFuncRefArgIn<TClosure, T1, T2, T3, T4, T5, TResult>
+        {
+            func.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+            return func.Invoke(ref closure);
+        }
     }
 }
\ No newline at end of file
diff --git a/System.ValueDelegates/Func/ValueFunc.cs b/System.ValueDelegates/Func/ValueFunc.cs
index 37de13b..1b8708a 100644
--- a/System.ValueDelegates/Func/ValueFunc.cs
+++ b/System.ValueDelegates/Func/ValueFunc.cs
@@ -14,12 +14,6 @@ public ValueFunc(TClosure closure)
             this.closure = closure;
         }
 
-        public ValueFunc(in TClosure closure)
-        {
-            this.func = new TFunc();
-            this.closure = closure;
-        }
-
         public ValueFunc(TFunc action, TClosure closure)
         {
             this.func = action;
@@ -38,12 +32,6 @@ public ValueFunc(TFunc action, in TClosure closure)
             this.closure = closure;
         }
 
-        public ValueFunc(in TFunc action, in TClosure closure)
-        {
-            this.func = action;
-            this.closure = closure;
-        }
-
         public TResult Invoke()
             => this.func.Invoke(this.closure);
     }
diff --git a/System.ValueDelegates/Predicate/ValuePredicate.Predicate.cs b/System.ValueDelegates/Predicate/ValuePredicate.Predicate.cs
index 1285d99..9420c57 100644
--- a/System.ValueDelegates/Predicate/ValuePredicate.Predicate.cs
+++ b/System.ValueDelegates/Predicate/ValuePredicate.Predicate.cs
@@ -4,10 +4,6 @@ namespace System.ValueDelegates
 {
     public static partial class ValuePredicate
     {
-        public static bool Invoke<TPredicate>()
-            where TPredicate : struct, IPredicate
-            => new TPredicate().Invoke();
-
         public static bool Invoke<TPredicate, TClosure, T>(this TPredicate predicate, TClosure closure, T arg)
             where TPredicate : struct, IPredicate<TClosure, T>
         {
@@ -121,5 +117,115 @@ public static bool Invoke<TPredicate, TClosure, T1, T2, T3, T4, T5>(this TClosur
             predicate.SetArguments(arg1, arg2, arg3, arg4, arg5);
             return predicate.Invoke(closure);
         }
+
+        public static bool Invoke<TPredicate, TClosure, T>(this TPredicate predicate, TClosure closure, in T arg)
+            where TPredicate : struct, IPredicateArgIn<TClosure, T>
+        {
+            predicate.SetArguments(in arg);
+            return predicate.Invoke(closure);
+        }
+
+        public static bool Invoke<TPredicate, TClosure, T1, T2>(this TPredicate predicate, TClosure closure, in T1 arg1, in T2 arg2)
+            where TPredicate : struct, IPredicateArgIn<TClosure, T1, T2>
+        {
+            predicate.SetArguments(in arg1, in arg2);
+            return predicate.Invoke(closure);
+        }
+
+        public static bool Invoke<TPredicate, TClosure, T1, T2, T3>(this TPredicate predicate, TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TPredicate : struct, IPredicateArgIn<TClosure, T1, T2, T3>
+        {
+            predicate.SetArguments(in arg1, in arg2, in arg3);
+            return predicate.Invoke(closure);
+        }
+
+        public static bool Invoke<TPredicate, TClosure, T1, T2, T3, T4>(this TPredicate predicate, TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TPredicate : struct, IPredicateArgIn<TClosure, T1, T2, T3, T4>
+        {
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4);
+            return predicate.Invoke(closure);
+        }
+
+        public static bool Invoke<TPredicate, TClosure, T1, T2, T3, T4, T5>(this TPredicate predicate, TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TPredicate : struct, IPredicateArgIn<TClosure, T1, T2, T3, T4, T5>
+        {
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+            return predicate.Invoke(closure);
+        }
+
+        public static bool Invoke<TPredicate, TClosure, T>(in TPredicate predicate, TClosure closure, in T arg)
+            where TPredicate : struct, IPredicateArgIn<TClosure, T>
+        {
+            predicate.SetArguments(in arg);
+            return predicate.Invoke(closure);
+        }
+
+        public static bool Invoke<TPredicate, TClosure, T1, T2>(in TPredicate predicate, TClosure closure, in T1 arg1, in T2 arg2)
+            where TPredicate : struct, IPredicateArgIn<TClosure, T1, T2>
+        {
+            predicate.SetArguments(in arg1, in arg2);
+            return predicate.Invoke(closure);
+        }
+
+        public static bool Invoke<TPredicate, TClosure, T1, T2, T3>(in TPredicate predicate, TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TPredicate : struct, IPredicateArgIn<TClosure, T1, T2, T3>
+        {
+            predicate.SetArguments(in arg1, in arg2, in arg3);
+            return predicate.Invoke(closure);
+        }
+
+        public static bool Invoke<TPredicate, TClosure, T1, T2, T3, T4>(in TPredicate predicate, TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TPredicate : struct, IPredicateArgIn<TClosure, T1, T2, T3, T4>
+        {
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4);
+            return predicate.Invoke(closure);
+        }
+
+        public static bool Invoke<TPredicate, TClosure, T1, T2, T3, T4, T5>(in TPredicate predicate, TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TPredicate : struct, IPredicateArgIn<TClosure, T1, T2, T3, T4, T5>
+        {
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+            return predicate.Invoke(closure);
+        }
+
+        public static bool Invoke<TPredicate, TClosure, T>(this TClosure closure, in T arg)
+            where TPredicate : struct, IPredicateArgIn<TClosure, T>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg);
+            return predicate.Invoke(closure);
+        }
+
+        public static bool Invoke<TPredicate, TClosure, T1, T2>(this TClosure closure, in T1 arg1, in T2 arg2)
+            where TPredicate : struct, IPredicateArgIn<TClosure, T1, T2>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2);
+            return predicate.Invoke(closure);
+        }
+
+        public static bool Invoke<TPredicate, TClosure, T1, T2, T3>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TPredicate : struct, IPredicateArgIn<TClosure, T1, T2, T3>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2, in arg3);
+            return predicate.Invoke(closure);
+        }
+
+        public static bool Invoke<TPredicate, TClosure, T1, T2, T3, T4>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TPredicate : struct, IPredicateArgIn<TClosure, T1, T2, T3, T4>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4);
+            return predicate.Invoke(closure);
+        }
+
+        public static bool Invoke<TPredicate, TClosure, T1, T2, T3, T4, T5>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TPredicate : struct, IPredicateArgIn<TClosure, T1, T2, T3, T4, T5>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+            return predicate.Invoke(closure);
+        }
     }
 }
\ No newline at end of file
diff --git a/System.ValueDelegates/Predicate/ValuePredicate.PredicateIn.cs b/System.ValueDelegates/Predicate/ValuePredicate.PredicateIn.cs
index b2b11f5..dbc84dd 100644
--- a/System.ValueDelegates/Predicate/ValuePredicate.PredicateIn.cs
+++ b/System.ValueDelegates/Predicate/ValuePredicate.PredicateIn.cs
@@ -4,11 +4,11 @@ namespace System.ValueDelegates
 {
     public static partial class ValuePredicate
     {
-        public static bool Invoke<TPredicate, TClosure>(in TClosure closure)
+        public static bool InvokeIn<TPredicate, TClosure>(this TClosure closure)
             where TPredicate : struct, IPredicateIn<TClosure>
             => new TPredicate().Invoke(in closure);
 
-        public static bool Invoke<TPredicate, TClosure, T>(in TClosure closure, T arg)
+        public static bool InvokeIn<TPredicate, TClosure, T>(this TClosure closure, T arg)
             where TPredicate : struct, IPredicateIn<TClosure, T>
         {
             var predicate = new TPredicate();
@@ -16,7 +16,7 @@ public static bool Invoke<TPredicate, TClosure, T>(in TClosure closure, T arg)
             return predicate.Invoke(in closure);
         }
 
-        public static bool Invoke<TPredicate, TClosure, T1, T2>(in TClosure closure, T1 arg1, T2 arg2)
+        public static bool InvokeIn<TPredicate, TClosure, T1, T2>(this TClosure closure, T1 arg1, T2 arg2)
             where TPredicate : struct, IPredicateIn<TClosure, T1, T2>
         {
             var predicate = new TPredicate();
@@ -24,7 +24,7 @@ public static bool Invoke<TPredicate, TClosure, T1, T2>(in TClosure closure, T1
             return predicate.Invoke(in closure);
         }
 
-        public static bool Invoke<TPredicate, TClosure, T1, T2, T3>(in TClosure closure, T1 arg1, T2 arg2, T3 arg3)
+        public static bool InvokeIn<TPredicate, TClosure, T1, T2, T3>(this TClosure closure, T1 arg1, T2 arg2, T3 arg3)
             where TPredicate : struct, IPredicateIn<TClosure, T1, T2, T3>
         {
             var predicate = new TPredicate();
@@ -32,7 +32,7 @@ public static bool Invoke<TPredicate, TClosure, T1, T2, T3>(in TClosure closure,
             return predicate.Invoke(in closure);
         }
 
-        public static bool Invoke<TPredicate, TClosure, T1, T2, T3, T4>(in TClosure closure, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+        public static bool InvokeIn<TPredicate, TClosure, T1, T2, T3, T4>(this TClosure closure, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
             where TPredicate : struct, IPredicateIn<TClosure, T1, T2, T3, T4>
         {
             var predicate = new TPredicate();
@@ -40,7 +40,7 @@ public static bool Invoke<TPredicate, TClosure, T1, T2, T3, T4>(in TClosure clos
             return predicate.Invoke(in closure);
         }
 
-        public static bool Invoke<TPredicate, TClosure, T1, T2, T3, T4, T5>(in TClosure closure, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
+        public static bool InvokeIn<TPredicate, TClosure, T1, T2, T3, T4, T5>(this TClosure closure, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
             where TPredicate : struct, IPredicateIn<TClosure, T1, T2, T3, T4, T5>
         {
             var predicate = new TPredicate();
@@ -117,5 +117,115 @@ public static bool Invoke<TPredicate, TClosure, T1, T2, T3, T4, T5>(in TPredicat
             predicate.SetArguments(arg1, arg2, arg3, arg4, arg5);
             return predicate.Invoke(in closure);
         }
+
+        public static bool InvokeIn<TPredicate, TClosure, T>(this TClosure closure, in T arg)
+            where TPredicate : struct, IPredicateInArgIn<TClosure, T>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg);
+            return predicate.Invoke(in closure);
+        }
+
+        public static bool InvokeIn<TPredicate, TClosure, T1, T2>(this TClosure closure, in T1 arg1, in T2 arg2)
+            where TPredicate : struct, IPredicateInArgIn<TClosure, T1, T2>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2);
+            return predicate.Invoke(in closure);
+        }
+
+        public static bool InvokeIn<TPredicate, TClosure, T1, T2, T3>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TPredicate : struct, IPredicateInArgIn<TClosure, T1, T2, T3>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2, in arg3);
+            return predicate.Invoke(in closure);
+        }
+
+        public static bool InvokeIn<TPredicate, TClosure, T1, T2, T3, T4>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TPredicate : struct, IPredicateInArgIn<TClosure, T1, T2, T3, T4>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4);
+            return predicate.Invoke(in closure);
+        }
+
+        public static bool InvokeIn<TPredicate, TClosure, T1, T2, T3, T4, T5>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TPredicate : struct, IPredicateInArgIn<TClosure, T1, T2, T3, T4, T5>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+            return predicate.Invoke(in closure);
+        }
+
+        public static bool Invoke<TPredicate, TClosure, T>(this TPredicate predicate, in TClosure closure, in T arg)
+            where TPredicate : struct, IPredicateInArgIn<TClosure, T>
+        {
+            predicate.SetArguments(in arg);
+            return predicate.Invoke(in closure);
+        }
+
+        public static bool Invoke<TPredicate, TClosure, T1, T2>(this TPredicate predicate, in TClosure closure, in T1 arg1, in T2 arg2)
+            where TPredicate : struct, IPredicateInArgIn<TClosure, T1, T2>
+        {
+            predicate.SetArguments(in arg1, in arg2);
+            return predicate.Invoke(in closure);
+        }
+
+        public static bool Invoke<TPredicate, TClosure, T1, T2, T3>(this TPredicate predicate, in TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TPredicate : struct, IPredicateInArgIn<TClosure, T1, T2, T3>
+        {
+            predicate.SetArguments(in arg1, in arg2, in arg3);
+            return predicate.Invoke(in closure);
+        }
+
+        public static bool Invoke<TPredicate, TClosure, T1, T2, T3, T4>(this TPredicate predicate, in TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TPredicate : struct, IPredicateInArgIn<TClosure, T1, T2, T3, T4>
+        {
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4);
+            return predicate.Invoke(in closure);
+        }
+
+        public static bool Invoke<TPredicate, TClosure, T1, T2, T3, T4, T5>(this TPredicate predicate, in TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TPredicate : struct, IPredicateInArgIn<TClosure, T1, T2, T3, T4, T5>
+        {
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+            return predicate.Invoke(in closure);
+        }
+
+        public static bool Invoke<TPredicate, TClosure, T>(in TPredicate predicate, in TClosure closure, in T arg)
+            where TPredicate : struct, IPredicateInArgIn<TClosure, T>
+        {
+            predicate.SetArguments(in arg);
+            return predicate.Invoke(in closure);
+        }
+
+        public static bool Invoke<TPredicate, TClosure, T1, T2>(in TPredicate predicate, in TClosure closure, in T1 arg1, in T2 arg2)
+            where TPredicate : struct, IPredicateInArgIn<TClosure, T1, T2>
+        {
+            predicate.SetArguments(in arg1, in arg2);
+            return predicate.Invoke(in closure);
+        }
+
+        public static bool Invoke<TPredicate, TClosure, T1, T2, T3>(in TPredicate predicate, in TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TPredicate : struct, IPredicateInArgIn<TClosure, T1, T2, T3>
+        {
+            predicate.SetArguments(in arg1, in arg2, in arg3);
+            return predicate.Invoke(in closure);
+        }
+
+        public static bool Invoke<TPredicate, TClosure, T1, T2, T3, T4>(in TPredicate predicate, in TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TPredicate : struct, IPredicateInArgIn<TClosure, T1, T2, T3, T4>
+        {
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4);
+            return predicate.Invoke(in closure);
+        }
+
+        public static bool Invoke<TPredicate, TClosure, T1, T2, T3, T4, T5>(in TPredicate predicate, in TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TPredicate : struct, IPredicateInArgIn<TClosure, T1, T2, T3, T4, T5>
+        {
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+            return predicate.Invoke(in closure);
+        }
     }
 }
\ No newline at end of file
diff --git a/System.ValueDelegates/Predicate/ValuePredicate.PredicateRef.cs b/System.ValueDelegates/Predicate/ValuePredicate.PredicateRef.cs
index aa6a2fa..e20b310 100644
--- a/System.ValueDelegates/Predicate/ValuePredicate.PredicateRef.cs
+++ b/System.ValueDelegates/Predicate/ValuePredicate.PredicateRef.cs
@@ -4,11 +4,11 @@ namespace System.ValueDelegates
 {
     public static partial class ValuePredicate
     {
-        public static bool InvokeRef<TPredicate, TClosure>(ref TClosure closure)
+        public static bool InvokeRef<TPredicate, TClosure>(this TClosure closure)
             where TPredicate : struct, IPredicateRef<TClosure>
             => new TPredicate().Invoke(ref closure);
 
-        public static bool InvokeRef<TPredicate, TClosure, T>(ref TClosure closure, T arg)
+        public static bool InvokeRef<TPredicate, TClosure, T>(this TClosure closure, T arg)
             where TPredicate : struct, IPredicateRef<TClosure, T>
         {
             var predicate = new TPredicate();
@@ -16,7 +16,7 @@ public static bool InvokeRef<TPredicate, TClosure, T>(ref TClosure closure, T ar
             return predicate.Invoke(ref closure);
         }
 
-        public static bool InvokeRef<TPredicate, TClosure, T1, T2>(ref TClosure closure, T1 arg1, T2 arg2)
+        public static bool InvokeRef<TPredicate, TClosure, T1, T2>(this TClosure closure, T1 arg1, T2 arg2)
             where TPredicate : struct, IPredicateRef<TClosure, T1, T2>
         {
             var predicate = new TPredicate();
@@ -24,7 +24,7 @@ public static bool InvokeRef<TPredicate, TClosure, T1, T2>(ref TClosure closure,
             return predicate.Invoke(ref closure);
         }
 
-        public static bool InvokeRef<TPredicate, TClosure, T1, T2, T3>(ref TClosure closure, T1 arg1, T2 arg2, T3 arg3)
+        public static bool InvokeRef<TPredicate, TClosure, T1, T2, T3>(this TClosure closure, T1 arg1, T2 arg2, T3 arg3)
             where TPredicate : struct, IPredicateRef<TClosure, T1, T2, T3>
         {
             var predicate = new TPredicate();
@@ -32,7 +32,7 @@ public static bool InvokeRef<TPredicate, TClosure, T1, T2, T3>(ref TClosure clos
             return predicate.Invoke(ref closure);
         }
 
-        public static bool InvokeRef<TPredicate, TClosure, T1, T2, T3, T4>(ref TClosure closure, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+        public static bool InvokeRef<TPredicate, TClosure, T1, T2, T3, T4>(this TClosure closure, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
             where TPredicate : struct, IPredicateRef<TClosure, T1, T2, T3, T4>
         {
             var predicate = new TPredicate();
@@ -40,7 +40,7 @@ public static bool InvokeRef<TPredicate, TClosure, T1, T2, T3, T4>(ref TClosure
             return predicate.Invoke(ref closure);
         }
 
-        public static bool InvokeRef<TPredicate, TClosure, T1, T2, T3, T4, T5>(ref TClosure closure, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
+        public static bool InvokeRef<TPredicate, TClosure, T1, T2, T3, T4, T5>(this TClosure closure, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
             where TPredicate : struct, IPredicateRef<TClosure, T1, T2, T3, T4, T5>
         {
             var predicate = new TPredicate();
@@ -117,5 +117,115 @@ public static bool InvokeRef<TPredicate, TClosure, T1, T2, T3, T4, T5>(in TPredi
             predicate.SetArguments(arg1, arg2, arg3, arg4, arg5);
             return predicate.Invoke(ref closure);
         }
+
+        public static bool InvokeRef<TPredicate, TClosure, T>(this TClosure closure, in T arg)
+            where TPredicate : struct, IPredicateRefArgIn<TClosure, T>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg);
+            return predicate.Invoke(ref closure);
+        }
+
+        public static bool InvokeRef<TPredicate, TClosure, T1, T2>(this TClosure closure, in T1 arg1, in T2 arg2)
+            where TPredicate : struct, IPredicateRefArgIn<TClosure, T1, T2>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2);
+            return predicate.Invoke(ref closure);
+        }
+
+        public static bool InvokeRef<TPredicate, TClosure, T1, T2, T3>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TPredicate : struct, IPredicateRefArgIn<TClosure, T1, T2, T3>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2, in arg3);
+            return predicate.Invoke(ref closure);
+        }
+
+        public static bool InvokeRef<TPredicate, TClosure, T1, T2, T3, T4>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TPredicate : struct, IPredicateRefArgIn<TClosure, T1, T2, T3, T4>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4);
+            return predicate.Invoke(ref closure);
+        }
+
+        public static bool InvokeRef<TPredicate, TClosure, T1, T2, T3, T4, T5>(this TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TPredicate : struct, IPredicateRefArgIn<TClosure, T1, T2, T3, T4, T5>
+        {
+            var predicate = new TPredicate();
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+            return predicate.Invoke(ref closure);
+        }
+
+        public static bool InvokeRef<TPredicate, TClosure, T>(this TPredicate predicate, ref TClosure closure, in T arg)
+            where TPredicate : struct, IPredicateRefArgIn<TClosure, T>
+        {
+            predicate.SetArguments(in arg);
+            return predicate.Invoke(ref closure);
+        }
+
+        public static bool InvokeRef<TPredicate, TClosure, T1, T2>(this TPredicate predicate, ref TClosure closure, in T1 arg1, in T2 arg2)
+            where TPredicate : struct, IPredicateRefArgIn<TClosure, T1, T2>
+        {
+            predicate.SetArguments(in arg1, in arg2);
+            return predicate.Invoke(ref closure);
+        }
+
+        public static bool InvokeRef<TPredicate, TClosure, T1, T2, T3>(this TPredicate predicate, ref TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TPredicate : struct, IPredicateRefArgIn<TClosure, T1, T2, T3>
+        {
+            predicate.SetArguments(in arg1, in arg2, in arg3);
+            return predicate.Invoke(ref closure);
+        }
+
+        public static bool InvokeRef<TPredicate, TClosure, T1, T2, T3, T4>(this TPredicate predicate, ref TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TPredicate : struct, IPredicateRefArgIn<TClosure, T1, T2, T3, T4>
+        {
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4);
+            return predicate.Invoke(ref closure);
+        }
+
+        public static bool InvokeRef<TPredicate, TClosure, T1, T2, T3, T4, T5>(this TPredicate predicate, ref TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TPredicate : struct, IPredicateRefArgIn<TClosure, T1, T2, T3, T4, T5>
+        {
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+            return predicate.Invoke(ref closure);
+        }
+
+        public static bool InvokeRef<TPredicate, TClosure, T>(in TPredicate predicate, ref TClosure closure, in T arg)
+            where TPredicate : struct, IPredicateRefArgIn<TClosure, T>
+        {
+            predicate.SetArguments(in arg);
+            return predicate.Invoke(ref closure);
+        }
+
+        public static bool InvokeRef<TPredicate, TClosure, T1, T2>(in TPredicate predicate, ref TClosure closure, in T1 arg1, in T2 arg2)
+            where TPredicate : struct, IPredicateRefArgIn<TClosure, T1, T2>
+        {
+            predicate.SetArguments(in arg1, in arg2);
+            return predicate.Invoke(ref closure);
+        }
+
+        public static bool InvokeRef<TPredicate, TClosure, T1, T2, T3>(in TPredicate predicate, ref TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3)
+            where TPredicate : struct, IPredicateRefArgIn<TClosure, T1, T2, T3>
+        {
+            predicate.SetArguments(in arg1, in arg2, in arg3);
+            return predicate.Invoke(ref closure);
+        }
+
+        public static bool InvokeRef<TPredicate, TClosure, T1, T2, T3, T4>(in TPredicate predicate, ref TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4)
+            where TPredicate : struct, IPredicateRefArgIn<TClosure, T1, T2, T3, T4>
+        {
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4);
+            return predicate.Invoke(ref closure);
+        }
+
+        public static bool InvokeRef<TPredicate, TClosure, T1, T2, T3, T4, T5>(in TPredicate predicate, ref TClosure closure, in T1 arg1, in T2 arg2, in T3 arg3, in T4 arg4, in T5 arg5)
+            where TPredicate : struct, IPredicateRefArgIn<TClosure, T1, T2, T3, T4, T5>
+        {
+            predicate.SetArguments(in arg1, in arg2, in arg3, in arg4, in arg5);
+            return predicate.Invoke(ref closure);
+        }
     }
 }
\ No newline at end of file
diff --git a/System.ValueDelegates/Predicate/ValuePredicate.cs b/System.ValueDelegates/Predicate/ValuePredicate.cs
index 79321e6..7b96290 100644
--- a/System.ValueDelegates/Predicate/ValuePredicate.cs
+++ b/System.ValueDelegates/Predicate/ValuePredicate.cs
@@ -14,12 +14,6 @@ public ValuePredicate(TClosure closure)
             this.closure = closure;
         }
 
-        public ValuePredicate(in TClosure closure)
-        {
-            this.predicate = new TPredicate();
-            this.closure = closure;
-        }
-
         public ValuePredicate(TPredicate action, TClosure closure)
         {
             this.predicate = action;
@@ -38,12 +32,6 @@ public ValuePredicate(in TPredicate action, TClosure closure)
             this.closure = closure;
         }
 
-        public ValuePredicate(in TPredicate action, in TClosure closure)
-        {
-            this.predicate = action;
-            this.closure = closure;
-        }
-
         public bool Invoke()
             => this.predicate.Invoke(this.closure);
     }