diff --git a/SuccincT/Functional/ConsListBuilderEnumerator.cs b/SuccincT/Functional/ConsListBuilderEnumerator.cs
index bd08b22..ad717fe 100644
--- a/SuccincT/Functional/ConsListBuilderEnumerator.cs
+++ b/SuccincT/Functional/ConsListBuilderEnumerator.cs
@@ -5,13 +5,12 @@
 
 namespace SuccincT.Functional
 {
-    internal sealed class ConsListBuilderEnumerator<TConsNode, T> : IEnumerator<TConsNode> where
-        TConsNode : ConsNode<T>, new()
+    internal sealed class ConsListBuilderEnumerator<T> : IEnumerator<ConsNode<T>>
     {
         private readonly IEnumerator<T> _enumerator;
-        private TConsNode _node;
+        private ConsNode<T> _node;
 
-        internal ConsListBuilderEnumerator(TConsNode node)
+        internal ConsListBuilderEnumerator(ConsNode<T> node)
         {
             _enumerator = node.Enumeration.GetEnumerator();
         }
@@ -20,7 +19,7 @@ public bool MoveNext()
         {
             if (!_enumerator.MoveNext()) return false;
 
-            _node = new TConsNode
+            _node = new ConsNode<T>
             {
                 Value = _enumerator.Current,
                 State = HasValue
@@ -31,7 +30,7 @@ public bool MoveNext()
 
         public void Reset() { throw new NotSupportedException(); }
 
-        public TConsNode Current => _node;
+        public ConsNode<T> Current => _node;
 
         object IEnumerator.Current => Current;
 
diff --git a/SuccincT/Functional/ConsNode.cs b/SuccincT/Functional/ConsNode.cs
index 230c1f7..7672098 100644
--- a/SuccincT/Functional/ConsNode.cs
+++ b/SuccincT/Functional/ConsNode.cs
@@ -2,7 +2,7 @@
 
 namespace SuccincT.Functional
 {
-    internal class ConsNode<T>
+    internal sealed class ConsNode<T>
     {
         internal ConsNodeState State { get; set; }
         internal IEnumerable<T> Enumeration { get; set; }
diff --git a/SuccincT/Functional/ConsNodeEnumerator.cs b/SuccincT/Functional/ConsNodeEnumerator.cs
index ca5d251..70c9a2d 100644
--- a/SuccincT/Functional/ConsNodeEnumerator.cs
+++ b/SuccincT/Functional/ConsNodeEnumerator.cs
@@ -20,7 +20,7 @@ public bool MoveNext()
 
             if (_node.State == HasEnumeration)
             {
-                _node.Enumerating(new ConsListBuilderEnumerator<ConsNode<T>, T>(_node));
+                _node.Enumerating(new ConsListBuilderEnumerator<T>(_node));
             }
 
             if (_node.State == HasValue) return true;
diff --git a/SuccincT/PatternMatchers/EitherTuple.cs b/SuccincT/PatternMatchers/EitherTuple.cs
index b6338be..2fed2a8 100644
--- a/SuccincT/PatternMatchers/EitherTuple.cs
+++ b/SuccincT/PatternMatchers/EitherTuple.cs
@@ -1,41 +1,23 @@
-namespace SuccincT.PatternMatchers
+using SuccincT.Unions;
+
+namespace SuccincT.PatternMatchers
 {
     internal static class EitherTuple
     {
-        public static EitherTuple<T1, T2> Create<T1, T2>(T1 value1, T2 value2) => 
-            new EitherTuple<T1, T2>(value1, value2);
-
-        public static EitherTuple<T1, T2> Create<T1, T2>(Any value1, T2 value2) =>
-            new EitherTuple<T1, T2>(value1, value2);
-
-        public static EitherTuple<T1, T2> Create<T1, T2>(T1 value1, Any value2) =>
+        public static EitherTuple<T1, T2> Create<T1, T2>(Either<T1, Any> value1,
+                                                                 Either<T2, Any> value2) =>
             new EitherTuple<T1, T2>(value1, value2);
 
-        public static EitherTuple<T1, T2> Create<T1, T2>(Any value1, Any value2) =>
-            new EitherTuple<T1, T2>(value1, value2);
-
-        public static EitherTuple<T1, T2, T3> Create<T1, T2, T3>(T1 value1, T2 value2, T3 value3) =>
-            new EitherTuple<T1, T2, T3>(value1, value2, value3);
-
-        public static EitherTuple<T1, T2, T3> Create<T1, T2, T3>(Any value1, T2 value2, T3 value3) =>
-            new EitherTuple<T1, T2, T3>(value1, value2, value3);
 
-        public static EitherTuple<T1, T2, T3> Create<T1, T2, T3>(T1 value1, Any value2, T3 value3) =>
+        public static EitherTuple<T1, T2, T3> Create<T1, T2, T3>(Either<T1, Any> value1,
+                                                                 Either<T2, Any> value2,
+                                                                 Either<T3, Any> value3) =>
             new EitherTuple<T1, T2, T3>(value1, value2, value3);
 
-        public static EitherTuple<T1, T2, T3> Create<T1, T2, T3>(T1 value1, T2 value2, Any value3) =>
-            new EitherTuple<T1, T2, T3>(value1, value2, value3);
-
-        public static EitherTuple<T1, T2, T3> Create<T1, T2, T3>(Any value1, Any value2, T3 value3) =>
-            new EitherTuple<T1, T2, T3>(value1, value2, value3);
-
-        public static EitherTuple<T1, T2, T3> Create<T1, T2, T3>(Any value1, T2 value2, Any value3) =>
-            new EitherTuple<T1, T2, T3>(value1, value2, value3);
-
-        public static EitherTuple<T1, T2, T3> Create<T1, T2, T3>(T1 value1, Any value2, Any value3) =>
-            new EitherTuple<T1, T2, T3>(value1, value2, value3);
-
-        public static EitherTuple<T1, T2, T3> Create<T1, T2, T3>(Any value1, Any value2, Any value3) =>
-            new EitherTuple<T1, T2, T3>(value1, value2, value3);
+        public static EitherTuple<T1, T2, T3, T4> Create<T1, T2, T3, T4>(Either<T1, Any> value1,
+                                                                         Either<T2, Any> value2,
+                                                                         Either<T3, Any> value3,
+                                                                         Either<T4, Any> value4) =>
+            new EitherTuple<T1, T2, T3, T4>(value1, value2, value3, value4);
     }
 }
\ No newline at end of file
diff --git a/SuccincT/PatternMatchers/EitherTuple{T1,T2,T3,T4}.cs b/SuccincT/PatternMatchers/EitherTuple{T1,T2,T3,T4}.cs
new file mode 100644
index 0000000..9c2d446
--- /dev/null
+++ b/SuccincT/PatternMatchers/EitherTuple{T1,T2,T3,T4}.cs
@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using SuccincT.Unions;
+
+namespace SuccincT.PatternMatchers
+{
+    internal struct EitherTuple<T1, T2, T3, T4>
+    {
+        private readonly Either<T1, Any> _value1;
+        private readonly Either<T2, Any> _value2;
+        private readonly Either<T3, Any> _value3;
+        private readonly Either<T4, Any> _value4;
+
+        internal EitherTuple(Either<T1, Any> value1,
+                             Either<T2, Any> value2,
+                             Either<T3, Any> value3,
+                             Either<T4, Any> value4)
+        {
+            _value1 = value1;
+            _value2 = value2;
+            _value3 = value3;
+            _value4 = value4;
+        }
+
+        public bool MatchesTuple(Tuple<T1, T2, T3, T4> tuple) =>
+            (!_value1.IsLeft || EqualityComparer<T1>.Default.Equals(_value1.Left, tuple.Item1)) &&
+            (!_value2.IsLeft || EqualityComparer<T2>.Default.Equals(_value2.Left, tuple.Item2)) &&
+            (!_value3.IsLeft || EqualityComparer<T3>.Default.Equals(_value3.Left, tuple.Item3)) &&
+            (!_value4.IsLeft || EqualityComparer<T4>.Default.Equals(_value4.Left, tuple.Item4));
+    }
+}
diff --git a/SuccincT/PatternMatchers/EitherTuple{T1,T2,T3}.cs b/SuccincT/PatternMatchers/EitherTuple{T1,T2,T3}.cs
index b963502..5c6b6c6 100644
--- a/SuccincT/PatternMatchers/EitherTuple{T1,T2,T3}.cs
+++ b/SuccincT/PatternMatchers/EitherTuple{T1,T2,T3}.cs
@@ -1,69 +1,22 @@
 using System;
 using System.Collections.Generic;
-using SuccincT.Functional;
+using SuccincT.Unions;
 
 namespace SuccincT.PatternMatchers
 {
     internal struct EitherTuple<T1, T2, T3>
     {
-        private Either<T1, Any> _value1;
-        private Either<T2, Any> _value2;
-        private Either<T3, Any> _value3;
+        private readonly Either<T1, Any> _value1;
+        private readonly Either<T2, Any> _value2;
+        private readonly Either<T3, Any> _value3;
 
-        public EitherTuple(T1 value1, T2 value2, T3 value3)
+        public EitherTuple(Either<T1, Any> value1,
+                           Either<T2, Any> value2,
+                           Either<T3, Any> value3)
         {
-            _value1 = new Either<T1, Any>(value1);
-            _value2 = new Either<T2, Any>(value2);
-            _value3 = new Either<T3, Any>(value3);
-        }
-
-        public EitherTuple(Any value1, T2 value2, T3 value3)
-        {
-            _value1 = new Either<T1, Any>(value1);
-            _value2 = new Either<T2, Any>(value2);
-            _value3 = new Either<T3, Any>(value3);
-        }
-
-        public EitherTuple(T1 value1, Any value2, T3 value3)
-        {
-            _value1 = new Either<T1, Any>(value1);
-            _value2 = new Either<T2, Any>(value2);
-            _value3 = new Either<T3, Any>(value3);
-        }
-
-        public EitherTuple(T1 value1, T2 value2, Any value3)
-        {
-            _value1 = new Either<T1, Any>(value1);
-            _value2 = new Either<T2, Any>(value2);
-            _value3 = new Either<T3, Any>(value3);
-        }
-
-        public EitherTuple(Any value1, Any value2, T3 value3)
-        {
-            _value1 = new Either<T1, Any>(value1);
-            _value2 = new Either<T2, Any>(value2);
-            _value3 = new Either<T3, Any>(value3);
-        }
-
-        public EitherTuple(Any value1, T2 value2, Any value3)
-        {
-            _value1 = new Either<T1, Any>(value1);
-            _value2 = new Either<T2, Any>(value2);
-            _value3 = new Either<T3, Any>(value3);
-        }
-
-        public EitherTuple(T1 value1, Any value2, Any value3)
-        {
-            _value1 = new Either<T1, Any>(value1);
-            _value2 = new Either<T2, Any>(value2);
-            _value3 = new Either<T3, Any>(value3);
-        }
-
-        public EitherTuple(Any value1, Any value2, Any value3)
-        {
-            _value1 = new Either<T1, Any>(value1);
-            _value2 = new Either<T2, Any>(value2);
-            _value3 = new Either<T3, Any>(value3);
+            _value1 = value1;
+            _value2 = value2;
+            _value3 = value3;
         }
 
         public bool MatchesTuple(Tuple<T1, T2, T3> tuple) =>
diff --git a/SuccincT/PatternMatchers/EitherTuple{T1,T2}.cs b/SuccincT/PatternMatchers/EitherTuple{T1,T2}.cs
index 03873ea..4ddb82b 100644
--- a/SuccincT/PatternMatchers/EitherTuple{T1,T2}.cs
+++ b/SuccincT/PatternMatchers/EitherTuple{T1,T2}.cs
@@ -1,36 +1,18 @@
 using System;
 using System.Collections.Generic;
-using SuccincT.Functional;
+using SuccincT.Unions;
 
 namespace SuccincT.PatternMatchers
 {
     internal struct EitherTuple<T1, T2>
     {
-        private Either<T1, Any> _value1;
-        private Either<T2, Any> _value2;
+        private readonly Either<T1, Any> _value1;
+        private readonly Either<T2, Any> _value2;
 
-        public EitherTuple(T1 value1, T2 value2)
+        public EitherTuple(Either<T1, Any> value1, Either<T2, Any> value2)
         {
-            _value1 = new Either<T1, Any>(value1);
-            _value2 = new Either<T2, Any>(value2);
-        }
-
-        public EitherTuple(Any value1, T2 value2)
-        {
-            _value1 = new Either<T1, Any>(value1);
-            _value2 = new Either<T2, Any>(value2);
-        }
-
-        public EitherTuple(T1 value1, Any value2)
-        {
-            _value1 = new Either<T1, Any>(value1);
-            _value2 = new Either<T2, Any>(value2);
-        }
-
-        public EitherTuple(Any value1, Any value2)
-        {
-            _value1 = new Either<T1, Any>(value1);
-            _value2 = new Either<T2, Any>(value2);
+            _value1 = value1;
+            _value2 = value2;
         }
 
         public bool MatchesTuple(Tuple<T1, T2> tuple) =>
diff --git a/SuccincT/PatternMatchers/IActionMatcher{T1,T2,T3,T4}.cs b/SuccincT/PatternMatchers/IActionMatcher{T1,T2,T3,T4}.cs
index 593ad55..6830ea2 100644
--- a/SuccincT/PatternMatchers/IActionMatcher{T1,T2,T3,T4}.cs
+++ b/SuccincT/PatternMatchers/IActionMatcher{T1,T2,T3,T4}.cs
@@ -1,10 +1,14 @@
 using System;
+using SuccincT.Unions;
 
 namespace SuccincT.PatternMatchers
 {
     public interface IActionMatcher<T1, T2, T3, T4>
     {
-        IActionWithHandler<IActionMatcher<T1, T2, T3, T4>, T1, T2, T3, T4> With(T1 value1, T2 value2, T3 value3, T4 value4);
+        IActionWithHandler<IActionMatcher<T1, T2, T3, T4>, T1, T2, T3, T4> With(Either<T1, Any> value1,
+                                                                                Either<T2, Any> value2,
+                                                                                Either<T3, Any> value3,
+                                                                                Either<T4, Any> value4);
         IActionWhereHandler<IActionMatcher<T1, T2, T3, T4>, T1, T2, T3, T4> Where(Func<T1, T2, T3, T4, bool> expression);
         IActionMatcherAfterElse Else(Action<T1, T2, T3, T4> action);
         IActionMatcherAfterElse IgnoreElse();
diff --git a/SuccincT/PatternMatchers/IActionMatcher{T1,T2,T3}.cs b/SuccincT/PatternMatchers/IActionMatcher{T1,T2,T3}.cs
index 463aa8f..a6b6f76 100644
--- a/SuccincT/PatternMatchers/IActionMatcher{T1,T2,T3}.cs
+++ b/SuccincT/PatternMatchers/IActionMatcher{T1,T2,T3}.cs
@@ -1,17 +1,14 @@
 using System;
+using SuccincT.Unions;
 
 namespace SuccincT.PatternMatchers
 {
     public interface IActionMatcher<T1, T2, T3>
     {
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> With(T1 value1, T2 value2, T3 value3);
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> With(Any value1, T2 value2, T3 value3);
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> With(T1 value1, Any value2, T3 value3);
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> With(T1 value1, T2 value2, Any value3);
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> With(Any value1, Any value2, T3 value3);
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> With(Any value1, T2 value2, Any value3);
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> With(T1 value1, Any value2, Any value3);
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> With(Any value1, Any value2, Any value3);
+        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> With(Either<T1, Any> value1,
+                                                                        Either<T2, Any> value2,
+                                                                        Either<T3, Any> value3);
+
         IActionWhereHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> Where(Func<T1, T2, T3, bool> expression);
 
         IActionMatcherAfterElse Else(Action<T1, T2, T3> action);
diff --git a/SuccincT/PatternMatchers/IActionMatcher{T1,T2}.cs b/SuccincT/PatternMatchers/IActionMatcher{T1,T2}.cs
index b0181ba..a3bce57 100644
--- a/SuccincT/PatternMatchers/IActionMatcher{T1,T2}.cs
+++ b/SuccincT/PatternMatchers/IActionMatcher{T1,T2}.cs
@@ -1,13 +1,11 @@
 using System;
+using SuccincT.Unions;
 
 namespace SuccincT.PatternMatchers
 {
     public interface IActionMatcher<T1, T2>
     {
-        IActionWithHandler<IActionMatcher<T1, T2>, T1, T2> With(T1 value1, T2 value2);
-        IActionWithHandler<IActionMatcher<T1, T2>, T1, T2> With(Any value1, T2 value2);
-        IActionWithHandler<IActionMatcher<T1, T2>, T1, T2> With(T1 value1, Any value2);
-        IActionWithHandler<IActionMatcher<T1, T2>, T1, T2> With(Any value1, Any value2);
+        IActionWithHandler<IActionMatcher<T1, T2>, T1, T2> With(Either<T1, Any> value1, Either<T2, Any> value2);
         IActionWhereHandler<IActionMatcher<T1, T2>, T1, T2> Where(Func<T1, T2, bool> expression);
         IActionMatcherAfterElse Else(Action<T1, T2> action);
         IActionMatcherAfterElse IgnoreElse();
diff --git a/SuccincT/PatternMatchers/IActionWithHandler{TM,T1,T2,T3,T4}.cs b/SuccincT/PatternMatchers/IActionWithHandler{TM,T1,T2,T3,T4}.cs
index 116f51b..72ca764 100644
--- a/SuccincT/PatternMatchers/IActionWithHandler{TM,T1,T2,T3,T4}.cs
+++ b/SuccincT/PatternMatchers/IActionWithHandler{TM,T1,T2,T3,T4}.cs
@@ -1,10 +1,14 @@
 using System;
+using SuccincT.Unions;
 
 namespace SuccincT.PatternMatchers
 {
     public interface IActionWithHandler<out TMatcher, T1, T2, T3, T4>
     {
-        IActionWithHandler<TMatcher, T1, T2, T3, T4> Or(T1 value1, T2 value2, T3 value3, T4 value4);
+        IActionWithHandler<TMatcher, T1, T2, T3, T4> Or(Either<T1, Any> value1,
+                                                        Either<T2, Any> value2,
+                                                        Either<T3, Any> value3,
+                                                        Either<T4, Any> value4);
 
         TMatcher Do(Action<T1, T2, T3, T4> action);
     }
diff --git a/SuccincT/PatternMatchers/IActionWithHandler{TM,T1,T2,T3}.cs b/SuccincT/PatternMatchers/IActionWithHandler{TM,T1,T2,T3}.cs
index 700e54a..647bf84 100644
--- a/SuccincT/PatternMatchers/IActionWithHandler{TM,T1,T2,T3}.cs
+++ b/SuccincT/PatternMatchers/IActionWithHandler{TM,T1,T2,T3}.cs
@@ -1,17 +1,13 @@
 using System;
+using SuccincT.Unions;
 
 namespace SuccincT.PatternMatchers
 {
     public interface IActionWithHandler<out TMatcher, T1, T2, T3>
     {
-        IActionWithHandler<TMatcher, T1, T2, T3> Or(T1 value1, T2 value2, T3 value3);
-        IActionWithHandler<TMatcher, T1, T2, T3> Or(Any value1, T2 value2, T3 value3);
-        IActionWithHandler<TMatcher, T1, T2, T3> Or(T1 value1, Any value2, T3 value3);
-        IActionWithHandler<TMatcher, T1, T2, T3> Or(T1 value1, T2 value2, Any value3);
-        IActionWithHandler<TMatcher, T1, T2, T3> Or(Any value1, Any value2, T3 value3);
-        IActionWithHandler<TMatcher, T1, T2, T3> Or(Any value1, T2 value2, Any value3);
-        IActionWithHandler<TMatcher, T1, T2, T3> Or(T1 value1, Any value2, Any value3);
-        IActionWithHandler<TMatcher, T1, T2, T3> Or(Any value1, Any value2, Any value3);
+        IActionWithHandler<TMatcher, T1, T2, T3> Or(Either<T1, Any> value1,
+                                                    Either<T2, Any> value2,
+                                                    Either<T3, Any> value3);
 
         TMatcher Do(Action<T1, T2, T3> action);
     }
diff --git a/SuccincT/PatternMatchers/IActionWithHandler{TM,T1,T2}.cs b/SuccincT/PatternMatchers/IActionWithHandler{TM,T1,T2}.cs
index 8bbfea7..7447f92 100644
--- a/SuccincT/PatternMatchers/IActionWithHandler{TM,T1,T2}.cs
+++ b/SuccincT/PatternMatchers/IActionWithHandler{TM,T1,T2}.cs
@@ -1,13 +1,11 @@
 using System;
+using SuccincT.Unions;
 
 namespace SuccincT.PatternMatchers
 {
     public interface IActionWithHandler<out TMatcher, T1, T2>
     {
-        IActionWithHandler<TMatcher, T1, T2> Or(T1 value1, T2 value2);
-        IActionWithHandler<TMatcher, T1, T2> Or(T1 value1, Any value2);
-        IActionWithHandler<TMatcher, T1, T2> Or(Any value1, T2 value2);
-        IActionWithHandler<TMatcher, T1, T2> Or(Any value1, Any value2);
+        IActionWithHandler<TMatcher, T1, T2> Or(Either<T1, Any> value1, Either<T2, Any> value2);
 
         TMatcher Do(Action<T1, T2> action);
     }
diff --git a/SuccincT/PatternMatchers/IFuncMatcher{T1,T2,T3,T4,TR}.cs b/SuccincT/PatternMatchers/IFuncMatcher{T1,T2,T3,T4,TR}.cs
index 5ef8f12..b493670 100644
--- a/SuccincT/PatternMatchers/IFuncMatcher{T1,T2,T3,T4,TR}.cs
+++ b/SuccincT/PatternMatchers/IFuncMatcher{T1,T2,T3,T4,TR}.cs
@@ -1,13 +1,14 @@
 using System;
+using SuccincT.Unions;
 
 namespace SuccincT.PatternMatchers
 {
     public interface IFuncMatcher<T1, T2, T3, T4, TResult>
     {
-        IFuncWithHandler<IFuncMatcher<T1, T2, T3, T4, TResult>, T1, T2, T3, T4, TResult> With(T1 value1,
-                                                                                              T2 value2,
-                                                                                              T3 value3,
-                                                                                              T4 value4);
+        IFuncWithHandler<IFuncMatcher<T1, T2, T3, T4, TResult>, T1, T2, T3, T4, TResult> With(Either<T1, Any> value1,
+                                                                                              Either<T2, Any> value2,
+                                                                                              Either<T3, Any> value3,
+                                                                                              Either<T4, Any> value4);
 
         IFuncWhereHandler<IFuncMatcher<T1, T2, T3, T4, TResult>, T1, T2, T3, T4, TResult> Where(
             Func<T1, T2, T3, T4, bool> expression);
diff --git a/SuccincT/PatternMatchers/IFuncMatcher{T1,T2,T3,TR}.cs b/SuccincT/PatternMatchers/IFuncMatcher{T1,T2,T3,TR}.cs
index f664c5f..6a6371d 100644
--- a/SuccincT/PatternMatchers/IFuncMatcher{T1,T2,T3,TR}.cs
+++ b/SuccincT/PatternMatchers/IFuncMatcher{T1,T2,T3,TR}.cs
@@ -1,17 +1,13 @@
 using System;
+using SuccincT.Unions;
 
 namespace SuccincT.PatternMatchers
 {
     public interface IFuncMatcher<T1, T2, T3, TResult>
     {
-        IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult> With(T1 value1, T2 value2, T3 value3);
-        IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult> With(Any value1, T2 value2, T3 value3);
-        IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult> With(T1 value1, Any value2, T3 value3);
-        IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult> With(T1 value1, T2 value2, Any value3);
-        IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult> With(Any value1, Any value2, T3 value3);
-        IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult> With(Any value1, T2 value2, Any value3);
-        IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult> With(T1 value1, Any value2, Any value3);
-        IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult> With(Any value1, Any value2, Any value3);
+        IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult> With(Either<T1, Any> value1,
+                                                                                      Either<T2, Any> value2,
+                                                                                      Either<T3, Any> value3);
 
         IFuncWhereHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult> Where(
             Func<T1, T2, T3, bool> expression);
diff --git a/SuccincT/PatternMatchers/IFuncMatcher{T1,T2,TR}.cs b/SuccincT/PatternMatchers/IFuncMatcher{T1,T2,TR}.cs
index 8dde2ce..532a5de 100644
--- a/SuccincT/PatternMatchers/IFuncMatcher{T1,T2,TR}.cs
+++ b/SuccincT/PatternMatchers/IFuncMatcher{T1,T2,TR}.cs
@@ -1,13 +1,12 @@
 using System;
+using SuccincT.Unions;
 
 namespace SuccincT.PatternMatchers
 {
     public interface IFuncMatcher<T1, T2, TResult>
     {
-        IFuncWithHandler<IFuncMatcher<T1, T2, TResult>, T1, T2, TResult> With(T1 value1, T2 value2);
-        IFuncWithHandler<IFuncMatcher<T1, T2, TResult>, T1, T2, TResult> With(Any value1, T2 value2);
-        IFuncWithHandler<IFuncMatcher<T1, T2, TResult>, T1, T2, TResult> With(T1 value1, Any value2);
-        IFuncWithHandler<IFuncMatcher<T1, T2, TResult>, T1, T2, TResult> With(Any value1, Any value2);
+        IFuncWithHandler<IFuncMatcher<T1, T2, TResult>, T1, T2, TResult> With(Either<T1, Any> value1,
+                                                                              Either<T2, Any> value2);
 
         IFuncWhereHandler<IFuncMatcher<T1, T2, TResult>, T1, T2, TResult> Where(Func<T1, T2, bool> expression);
         IFuncMatcherAfterElse<TResult> Else(Func<T1, T2, TResult> function);
diff --git a/SuccincT/PatternMatchers/IFuncWithHandler{TM,T1,T2,T3,T4,TR}.cs b/SuccincT/PatternMatchers/IFuncWithHandler{TM,T1,T2,T3,T4,TR}.cs
index f8589e5..60226df 100644
--- a/SuccincT/PatternMatchers/IFuncWithHandler{TM,T1,T2,T3,T4,TR}.cs
+++ b/SuccincT/PatternMatchers/IFuncWithHandler{TM,T1,T2,T3,T4,TR}.cs
@@ -1,10 +1,14 @@
 using System;
+using SuccincT.Unions;
 
 namespace SuccincT.PatternMatchers
 {
     public interface IFuncWithHandler<out TMatcher, T1, T2, T3, T4, in TResult>
     {
-        IFuncWithHandler<TMatcher, T1, T2, T3, T4, TResult> Or(T1 value1, T2 value2, T3 value3, T4 value4);
+        IFuncWithHandler<TMatcher, T1, T2, T3, T4, TResult> Or(Either<T1, Any> value1,
+                                                               Either<T2, Any> value2,
+                                                               Either<T3, Any> value3,
+                                                               Either<T4, Any> value4);
 
         TMatcher Do(Func<T1, T2, T3, T4, TResult> function);
 
diff --git a/SuccincT/PatternMatchers/IFuncWithHandler{TM,T1,T2,T3,TR}.cs b/SuccincT/PatternMatchers/IFuncWithHandler{TM,T1,T2,T3,TR}.cs
index ca6155e..bde1830 100644
--- a/SuccincT/PatternMatchers/IFuncWithHandler{TM,T1,T2,T3,TR}.cs
+++ b/SuccincT/PatternMatchers/IFuncWithHandler{TM,T1,T2,T3,TR}.cs
@@ -1,17 +1,13 @@
 using System;
+using SuccincT.Unions;
 
 namespace SuccincT.PatternMatchers
 {
     public interface IFuncWithHandler<out TMatcher, T1, T2, T3, in TResult>
     {
-        IFuncWithHandler<TMatcher, T1, T2, T3, TResult> Or(T1 value1, T2 value2, T3 value3);
-        IFuncWithHandler<TMatcher, T1, T2, T3, TResult> Or(Any value1, T2 value2, T3 value3);
-        IFuncWithHandler<TMatcher, T1, T2, T3, TResult> Or(T1 value1, Any value2, T3 value3);
-        IFuncWithHandler<TMatcher, T1, T2, T3, TResult> Or(T1 value1, T2 value2, Any value3);
-        IFuncWithHandler<TMatcher, T1, T2, T3, TResult> Or(Any value1, Any value2, T3 value3);
-        IFuncWithHandler<TMatcher, T1, T2, T3, TResult> Or(Any value1, T2 value2, Any value3);
-        IFuncWithHandler<TMatcher, T1, T2, T3, TResult> Or(T1 value1, Any value2, Any value3);
-        IFuncWithHandler<TMatcher, T1, T2, T3, TResult> Or(Any value1, Any value2, Any value3);
+        IFuncWithHandler<TMatcher, T1, T2, T3, TResult> Or(Either<T1, Any> value1,
+                                                           Either<T2, Any> value2,
+                                                           Either<T3, Any> value3);
 
         TMatcher Do(Func<T1, T2, T3, TResult> function);
 
diff --git a/SuccincT/PatternMatchers/IFuncWithHandler{TM,T1,T2,TR}.cs b/SuccincT/PatternMatchers/IFuncWithHandler{TM,T1,T2,TR}.cs
index 288b9e1..240a761 100644
--- a/SuccincT/PatternMatchers/IFuncWithHandler{TM,T1,T2,TR}.cs
+++ b/SuccincT/PatternMatchers/IFuncWithHandler{TM,T1,T2,TR}.cs
@@ -1,13 +1,11 @@
 using System;
+using SuccincT.Unions;
 
 namespace SuccincT.PatternMatchers
 {
     public interface IFuncWithHandler<out TMatcher, T1, T2, in TResult>
     {
-        IFuncWithHandler<TMatcher, T1, T2, TResult> Or(T1 value1, T2 value2);
-        IFuncWithHandler<TMatcher, T1, T2, TResult> Or(T1 value1, Any value2);
-        IFuncWithHandler<TMatcher, T1, T2, TResult> Or(Any value1, T2 value2);
-        IFuncWithHandler<TMatcher, T1, T2, TResult> Or(Any value1, Any value2);
+        IFuncWithHandler<TMatcher, T1, T2, TResult> Or(Either<T1, Any> value1, Either<T2, Any> value2);
 
         TMatcher Do(Func<T1, T2, TResult> function);
 
diff --git a/SuccincT/PatternMatchers/IMatcher{T1,T2,T3,T4}.cs b/SuccincT/PatternMatchers/IMatcher{T1,T2,T3,T4}.cs
index e26cdbb..2d6e071 100644
--- a/SuccincT/PatternMatchers/IMatcher{T1,T2,T3,T4}.cs
+++ b/SuccincT/PatternMatchers/IMatcher{T1,T2,T3,T4}.cs
@@ -1,13 +1,14 @@
 using System;
+using SuccincT.Unions;
 
 namespace SuccincT.PatternMatchers
 {
     public interface IMatcher<T1, T2, T3, T4>
     {
-        IActionWithHandler<IActionMatcher<T1, T2, T3, T4>, T1, T2, T3, T4> With(T1 value1,
-                                                                                T2 value2,
-                                                                                T3 value3,
-                                                                                T4 value4);
+        IActionWithHandler<IActionMatcher<T1, T2, T3, T4>, T1, T2, T3, T4> With(Either<T1, Any> value1,
+                                                                                Either<T2, Any> value2,
+                                                                                Either<T3, Any> value3,
+                                                                                Either<T4, Any> value4);
 
         IActionWhereHandler<IActionMatcher<T1, T2, T3, T4>, T1, T2, T3, T4> Where(Func<T1, T2, T3, T4, bool> function);
         IFuncMatcher<T1, T2, T3, T4, TR> To<TR>();
diff --git a/SuccincT/PatternMatchers/IMatcher{T1,T2,T3}.cs b/SuccincT/PatternMatchers/IMatcher{T1,T2,T3}.cs
index 41b29d2..03bc4e4 100644
--- a/SuccincT/PatternMatchers/IMatcher{T1,T2,T3}.cs
+++ b/SuccincT/PatternMatchers/IMatcher{T1,T2,T3}.cs
@@ -1,17 +1,13 @@
 using System;
+using SuccincT.Unions;
 
 namespace SuccincT.PatternMatchers
 {
     public interface IMatcher<T1, T2, T3>
     {
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> With(T1 value1, T2 value2, T3 value3);
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> With(Any value1, T2 value2, T3 value3);
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> With(T1 value1, Any value2, T3 value3);
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> With(T1 value1, T2 value2, Any value3);
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> With(Any value1, Any value2, T3 value3);
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> With(Any value1, T2 value2, Any value3);
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> With(T1 value1, Any value2, Any value3);
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> With(Any value1, Any value2, Any value3);
+        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> With(Either<T1, Any> value1,
+                                                                        Either<T2, Any> value2,
+                                                                        Either<T3, Any> value3);
 
         IActionWhereHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> Where(Func<T1, T2, T3, bool> function);
         IFuncMatcher<T1, T2, T3, TR> To<TR>();
diff --git a/SuccincT/PatternMatchers/IMatcher{T1,T2}.cs b/SuccincT/PatternMatchers/IMatcher{T1,T2}.cs
index c2cf1e0..88335d3 100644
--- a/SuccincT/PatternMatchers/IMatcher{T1,T2}.cs
+++ b/SuccincT/PatternMatchers/IMatcher{T1,T2}.cs
@@ -1,13 +1,11 @@
 using System;
+using SuccincT.Unions;
 
 namespace SuccincT.PatternMatchers
 {
     public interface IMatcher<T1,T2>
     {
-        IActionWithHandler<IActionMatcher<T1, T2>, T1, T2> With(T1 value1, T2 value2);
-        IActionWithHandler<IActionMatcher<T1, T2>, T1, T2> With(Any value1, T2 value2);
-        IActionWithHandler<IActionMatcher<T1, T2>, T1, T2> With(T1 value1, Any value2);
-        IActionWithHandler<IActionMatcher<T1, T2>, T1, T2> With(Any value1, Any value2);
+        IActionWithHandler<IActionMatcher<T1, T2>, T1, T2> With(Either<T1, Any> value1, Either<T2, Any> value2);
         IActionWhereHandler<IActionMatcher<T1, T2>, T1, T2> Where(Func<T1, T2, bool> function);
         IFuncMatcher<T1, T2, TR> To<TR>();
     }
diff --git a/SuccincT/PatternMatchers/Matcher{T1,T2,T3,T4,TR}.cs b/SuccincT/PatternMatchers/Matcher{T1,T2,T3,T4,TR}.cs
index 486a8c8..57a979d 100644
--- a/SuccincT/PatternMatchers/Matcher{T1,T2,T3,T4,TR}.cs
+++ b/SuccincT/PatternMatchers/Matcher{T1,T2,T3,T4,TR}.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using SuccincT.Unions;
 using static SuccincT.Functional.Unit;
 
 namespace SuccincT.PatternMatchers
@@ -16,42 +17,54 @@ internal sealed class Matcher<T1, T2, T3, T4, TResult> :
         IFuncWhereHandler<IFuncMatcher<T1, T2, T3, T4, TResult>, T1, T2, T3, T4, TResult>,
         IFuncMatcherAfterElse<TResult>
     {
-        private readonly MatchFunctionSelector<Tuple<T1, T2, T3, T4>, Tuple<T1, T2, T3, T4>, TResult> _functionSelector;
+        private readonly MatchFunctionSelector<Tuple<T1, T2, T3, T4>, EitherTuple<T1, T2, T3, T4>, TResult>
+            _functionSelector;
+
         private readonly Tuple<T1, T2, T3, T4> _item;
-        private IList<Tuple<T1, T2, T3, T4>> _withValues;
+        private IList<EitherTuple<T1, T2, T3, T4>> _withValues;
         private Func<Tuple<T1, T2, T3, T4>, bool> _whereExpression;
         private Func<Tuple<T1, T2, T3, T4>, TResult> _elseFunction;
 
         internal Matcher(Tuple<T1, T2, T3, T4> item)
         {
             _item = item;
-            _functionSelector = new MatchFunctionSelector<Tuple<T1, T2, T3, T4>, Tuple<T1, T2, T3, T4>, TResult>(x =>
-            {
-                throw new NoMatchException(
-                    $"No match action exists for value of ({_item.Item1}, {_item.Item2}, {_item.Item3}, {_item.Item4}");
-            });
+            _functionSelector =
+                new MatchFunctionSelector<Tuple<T1, T2, T3, T4>, EitherTuple<T1, T2, T3, T4>, TResult>(x =>
+                {
+                    throw new NoMatchException("No match action exists for value of " +
+                                               $"({_item.Item1}, {_item.Item2}, {_item.Item3}, {_item.Item4}");
+                });
         }
 
         IFuncMatcher<T1, T2, T3, T4, TR> IMatcher<T1, T2, T3, T4>.To<TR>() => new Matcher<T1, T2, T3, T4, TR>(_item);
 
         IActionWithHandler<IActionMatcher<T1, T2, T3, T4>, T1, T2, T3, T4> IMatcher<T1, T2, T3, T4>.With(
-            T1 value1, T2 value2, T3 value3, T4 value4)
+            Either<T1, Any> value1,
+            Either<T2, Any> value2,
+            Either<T3, Any> value3,
+            Either<T4, Any> value4)
         {
-            _withValues = new List<Tuple<T1, T2, T3, T4>> { Tuple.Create(value1, value2, value3, value4) };
+            _withValues = new List<EitherTuple<T1, T2, T3, T4>> {EitherTuple.Create(value1, value2, value3, value4)};
             return this;
         }
 
         IActionWithHandler<IActionMatcher<T1, T2, T3, T4>, T1, T2, T3, T4> IActionMatcher<T1, T2, T3, T4>.With(
-            T1 value1, T2 value2, T3 value3, T4 value4)
+            Either<T1, Any> value1,
+            Either<T2, Any> value2,
+            Either<T3, Any> value3,
+            Either<T4, Any> value4)
         {
-            _withValues = new List<Tuple<T1, T2, T3, T4>> { Tuple.Create(value1, value2, value3, value4) };
+            _withValues = new List<EitherTuple<T1, T2, T3, T4>> { EitherTuple.Create(value1, value2, value3, value4) };
             return this;
         }
 
         IFuncWithHandler<IFuncMatcher<T1, T2, T3, T4, TResult>, T1, T2, T3, T4, TResult>
-            IFuncMatcher<T1, T2, T3, T4, TResult>.With(T1 value1, T2 value2, T3 value3, T4 value4)
+            IFuncMatcher<T1, T2, T3, T4, TResult>.With(Either<T1, Any> value1,
+                                                       Either<T2, Any> value2,
+                                                       Either<T3, Any> value3,
+                                                       Either<T4, Any> value4)
         {
-            _withValues = new List<Tuple<T1, T2, T3, T4>> { Tuple.Create(value1, value2, value3, value4) };
+            _withValues = new List<EitherTuple<T1, T2, T3, T4>> {EitherTuple.Create(value1, value2, value3, value4)};
             return this;
         }
 
@@ -101,19 +114,19 @@ IFuncMatcherAfterElse<TResult> IFuncMatcher<T1, T2, T3, T4, TResult>.Else(TResul
         }
 
         IFuncWithHandler<IFuncMatcher<T1, T2, T3, T4, TResult>, T1, T2, T3, T4, TResult>
-            IFuncWithHandler<IFuncMatcher<T1, T2, T3, T4, TResult>, T1, T2, T3, T4, TResult>.Or(
-                T1 value1, T2 value2, T3 value3, T4 value4)
+            IFuncWithHandler<IFuncMatcher<T1, T2, T3, T4, TResult>, T1, T2, T3, T4, TResult>.Or(Either<T1, Any> value1,
+                                                                                                Either<T2, Any> value2,
+                                                                                                Either<T3, Any> value3,
+                                                                                                Either<T4, Any> value4)
         {
-            _withValues.Add(Tuple.Create(value1, value2, value3, value4));
+            _withValues.Add(EitherTuple.Create(value1, value2, value3, value4));
             return this;
         }
 
         IActionMatcher<T1, T2, T3, T4> IActionWithHandler<IActionMatcher<T1, T2, T3, T4>, T1, T2, T3, T4>.Do(
             Action<T1, T2, T3, T4> action)
         {
-            RecordFunction((x, y) => y.Any(v => EqualityComparer<Tuple<T1, T2, T3, T4>>.Default.Equals(x, v)),
-                           _withValues,
-                           ActionToFunc(action));
+            RecordFunction((x, y) => y.Any(v => v.MatchesTuple(x)), _withValues, ActionToFunc(action));
             return this;
         }
 
@@ -127,7 +140,7 @@ IActionMatcher<T1, T2, T3, T4> IActionWhereHandler<IActionMatcher<T1, T2, T3, T4
         IFuncMatcher<T1, T2, T3, T4, TResult> IFuncWithHandler<IFuncMatcher<T1, T2, T3, T4, TResult>, T1, T2, T3, T4, TResult>.Do(
             Func<T1, T2, T3, T4, TResult> function)
         {
-            RecordFunction((x, y) => y.Any(v => EqualityComparer<Tuple<T1, T2, T3, T4>>.Default.Equals(x, v)),
+            RecordFunction((x, y) => y.Any(v => v.MatchesTuple(x)),
                            _withValues,
                            x => function(x.Item1, x.Item2, x.Item3, x.Item4));
             return this;
@@ -136,9 +149,7 @@ IFuncMatcher<T1, T2, T3, T4, TResult> IFuncWithHandler<IFuncMatcher<T1, T2, T3,
         IFuncMatcher<T1, T2, T3, T4, TResult> IFuncWithHandler<IFuncMatcher<T1, T2, T3, T4, TResult>, T1, T2, T3, T4, TResult>.Do(
             TResult value)
         {
-            RecordFunction((x, y) => y.Any(v => EqualityComparer<Tuple<T1, T2, T3, T4>>.Default.Equals(x, v)),
-                           _withValues,
-                           x => value);
+            RecordFunction((x, y) => y.Any(v => v.MatchesTuple(x)), _withValues, x => value);
             return this;
         }
 
@@ -173,8 +184,8 @@ TResult IFuncMatcherAfterElse<TResult>.Result()
             return possibleResult.HasValue ? possibleResult.Value : _elseFunction(_item);
         }
 
-        private void RecordFunction(Func<Tuple<T1, T2, T3, T4>, IList<Tuple<T1, T2, T3, T4>>, bool> test,
-                                    IList<Tuple<T1, T2, T3, T4>> values,
+        private void RecordFunction(Func<Tuple<T1, T2, T3, T4>, IList<EitherTuple<T1, T2, T3, T4>>, bool> test,
+                                    IList<EitherTuple<T1, T2, T3, T4>> values,
                                     Func<Tuple<T1, T2, T3, T4>, TResult> function)
         {
             _functionSelector.AddTestAndAction(test, values, null, function);
@@ -191,10 +202,12 @@ private static Func<Tuple<T1, T2, T3, T4>, TResult> ActionToFunc(Action<T1, T2,
             };
 
         IActionWithHandler<IActionMatcher<T1, T2, T3, T4>, T1, T2, T3, T4>
-            IActionWithHandler<IActionMatcher<T1, T2, T3, T4>, T1, T2, T3, T4>.Or(
-                T1 value1, T2 value2, T3 value3, T4 value4)
+            IActionWithHandler<IActionMatcher<T1, T2, T3, T4>, T1, T2, T3, T4>.Or(Either<T1, Any> value1,
+                                                                                  Either<T2, Any> value2,
+                                                                                  Either<T3, Any> value3,
+                                                                                  Either<T4, Any> value4)
         {
-            _withValues.Add(Tuple.Create(value1, value2, value3, value4));
+            _withValues.Add(EitherTuple.Create(value1, value2, value3, value4));
             return this;
         }
     }
diff --git a/SuccincT/PatternMatchers/Matcher{T1,T2,T3,TR}.cs b/SuccincT/PatternMatchers/Matcher{T1,T2,T3,TR}.cs
index bf74c69..3506e31 100644
--- a/SuccincT/PatternMatchers/Matcher{T1,T2,T3,TR}.cs
+++ b/SuccincT/PatternMatchers/Matcher{T1,T2,T3,TR}.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using SuccincT.Unions;
 using static SuccincT.Functional.Unit;
 
 namespace SuccincT.PatternMatchers
@@ -34,206 +35,32 @@ internal Matcher(Tuple<T1, T2, T3> item)
 
         IFuncMatcher<T1, T2, T3, TR> IMatcher<T1, T2, T3>.To<TR>() => new Matcher<T1, T2, T3, TR>(_item);
 
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> IMatcher<T1, T2, T3>.With(T1 value1,
-                                                                                             T2 value2,
-                                                                                             T3 value3)
+        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> IMatcher<T1, T2, T3>.With(Either<T1, Any> value1,
+                                                                                Either<T2, Any> value2,
+                                                                                Either<T3, Any> value3)
         {
             _withValues = new List<EitherTuple<T1, T2, T3>> { EitherTuple.Create(value1, value2, value3) };
             return this;
         }
 
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> IMatcher<T1, T2, T3>.With(Any value1,
-                                                                                             T2 value2,
-                                                                                             T3 value3)
+        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> IActionMatcher<T1, T2, T3>.With(
+            Either<T1, Any> value1,
+            Either<T2, Any> value2,
+            Either<T3, Any> value3)
         {
-            _withValues = new List<EitherTuple<T1, T2, T3>> { EitherTuple.Create<T1, T2, T3>(value1, value2, value3) };
-            return this;
-        }
-
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> IMatcher<T1, T2, T3>.With(T1 value1,
-                                                                                             Any value2,
-                                                                                             T3 value3)
-        {
-            _withValues = new List<EitherTuple<T1, T2, T3>> { EitherTuple.Create<T1, T2, T3>(value1, value2, value3) };
-            return this;
-        }
-
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> IMatcher<T1, T2, T3>.With(T1 value1,
-                                                                                             T2 value2,
-                                                                                             Any value3)
-        {
-            _withValues = new List<EitherTuple<T1, T2, T3>> { EitherTuple.Create<T1, T2, T3>(value1, value2, value3) };
-            return this;
-        }
-
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> IActionMatcher<T1, T2, T3>.With(T1 value1,
-                                                                                                   T2 value2,
-                                                                                                   T3 value3)
-        {
-            _withValues = new List<EitherTuple<T1, T2, T3>> { EitherTuple.Create(value1, value2, value3) };
-            return this;
-        }
-
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> IActionMatcher<T1, T2, T3>.With(Any value1,
-                                                                                                   T2 value2,
-                                                                                                   T3 value3)
-        {
-            _withValues = new List<EitherTuple<T1, T2, T3>> { EitherTuple.Create<T1, T2, T3>(value1, value2, value3) };
-            return this;
-        }
-
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> IActionMatcher<T1, T2, T3>.With(T1 value1,
-                                                                                                   Any value2,
-                                                                                                   T3 value3)
-        {
-            _withValues = new List<EitherTuple<T1, T2, T3>> { EitherTuple.Create<T1, T2, T3>(value1, value2, value3) };
-            return this;
-        }
-
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> IActionMatcher<T1, T2, T3>.With(T1 value1,
-                                                                                                   T2 value2,
-                                                                                                   Any value3)
-        {
-            _withValues = new List<EitherTuple<T1, T2, T3>> { EitherTuple.Create<T1, T2, T3>(value1, value2, value3) };
-            return this;
-        }
-
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> IActionMatcher<T1, T2, T3>.With(Any value1,
-                                                                                                   Any value2,
-                                                                                                   T3 value3)
-        {
-            _withValues = new List<EitherTuple<T1, T2, T3>> { EitherTuple.Create<T1, T2, T3>(value1, value2, value3) };
-            return this;
-        }
-
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> IActionMatcher<T1, T2, T3>.With(Any value1,
-                                                                                                   T2 value2,
-                                                                                                   Any value3)
-        {
-            _withValues = new List<EitherTuple<T1, T2, T3>> { EitherTuple.Create<T1, T2, T3>(value1, value2, value3) };
-            return this;
-        }
-
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> IActionMatcher<T1, T2, T3>.With(T1 value1,
-                                                                                                   Any value2,
-                                                                                                   Any value3)
-        {
-            _withValues = new List<EitherTuple<T1, T2, T3>> { EitherTuple.Create<T1, T2, T3>(value1, value2, value3) };
-            return this;
-        }
-
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> IActionMatcher<T1, T2, T3>.With(Any value1,
-                                                                                                   Any value2,
-                                                                                                   Any value3)
-        {
-            _withValues = new List<EitherTuple<T1, T2, T3>> { EitherTuple.Create<T1, T2, T3>(value1, value2, value3) };
-            return this;
-        }
-
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> IMatcher<T1, T2, T3>.With(Any value1,
-                                                                                             Any value2,
-                                                                                             T3 value3)
-        {
-            _withValues = new List<EitherTuple<T1, T2, T3>> { EitherTuple.Create<T1, T2, T3>(value1, value2, value3) };
-            return this;
-        }
-
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> IMatcher<T1, T2, T3>.With(Any value1,
-                                                                                             T2 value2,
-                                                                                             Any value3)
-        {
-            _withValues = new List<EitherTuple<T1, T2, T3>> { EitherTuple.Create<T1, T2, T3>(value1, value2, value3) };
-            return this;
-        }
-
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> IMatcher<T1, T2, T3>.With(T1 value1,
-                                                                                             Any value2,
-                                                                                             Any value3)
-        {
-            _withValues = new List<EitherTuple<T1, T2, T3>> { EitherTuple.Create<T1, T2, T3>(value1, value2, value3) };
-            return this;
-        }
-
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> IMatcher<T1, T2, T3>.With(Any value1,
-                                                                                             Any value2,
-                                                                                             Any value3)
-        {
-            _withValues = new List<EitherTuple<T1, T2, T3>> { EitherTuple.Create<T1, T2, T3>(value1, value2, value3) };
+            _withValues = new List<EitherTuple<T1, T2, T3>> {EitherTuple.Create(value1, value2, value3)};
             return this;
         }
 
         IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult> IFuncMatcher<T1, T2, T3, TResult>.With(
-            T1 value1,
-            T2 value2,
-            T3 value3)
+            Either<T1, Any> value1,
+            Either<T2, Any> value2,
+            Either<T3, Any> value3)
         {
             _withValues = new List<EitherTuple<T1, T2, T3>> { EitherTuple.Create(value1, value2, value3) };
             return this;
         }
 
-        IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult> IFuncMatcher<T1, T2, T3, TResult>.With(
-            Any value1,
-            T2 value2,
-            T3 value3)
-        {
-            _withValues = new List<EitherTuple<T1, T2, T3>> { EitherTuple.Create<T1, T2, T3>(value1, value2, value3) };
-            return this;
-        }
-
-        IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult> IFuncMatcher<T1, T2, T3, TResult>.With(
-            T1 value1,
-            Any value2,
-            T3 value3)
-        {
-            _withValues = new List<EitherTuple<T1, T2, T3>> { EitherTuple.Create<T1, T2, T3>(value1, value2, value3) };
-            return this;
-        }
-
-        IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult> IFuncMatcher<T1, T2, T3, TResult>.With(
-            T1 value1,
-            T2 value2,
-            Any value3)
-        {
-            _withValues = new List<EitherTuple<T1, T2, T3>> { EitherTuple.Create<T1, T2, T3>(value1, value2, value3) };
-            return this;
-        }
-
-        IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult> IFuncMatcher<T1, T2, T3, TResult>.With(
-            Any value1,
-            Any value2,
-            T3 value3)
-        {
-            _withValues = new List<EitherTuple<T1, T2, T3>> { EitherTuple.Create<T1, T2, T3>(value1, value2, value3) };
-            return this;
-        }
-
-        IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult> IFuncMatcher<T1, T2, T3, TResult>.With(
-            Any value1,
-            T2 value2,
-            Any value3)
-        {
-            _withValues = new List<EitherTuple<T1, T2, T3>> { EitherTuple.Create<T1, T2, T3>(value1, value2, value3) };
-            return this;
-        }
-
-        IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult> IFuncMatcher<T1, T2, T3, TResult>.With(
-            T1 value1,
-            Any value2,
-            Any value3)
-        {
-            _withValues = new List<EitherTuple<T1, T2, T3>> { EitherTuple.Create<T1, T2, T3>(value1, value2, value3) };
-            return this;
-        }
-
-        IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult> IFuncMatcher<T1, T2, T3, TResult>.With(
-            Any value1,
-            Any value2,
-            Any value3)
-        {
-            _withValues = new List<EitherTuple<T1, T2, T3>> { EitherTuple.Create<T1, T2, T3>(value1, value2, value3) };
-            return this;
-        }
-
         IActionWhereHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3> IMatcher<T1, T2, T3>.Where(
             Func<T1, T2, T3, bool> function)
         {
@@ -280,61 +107,14 @@ IFuncMatcherAfterElse<TResult> IFuncMatcher<T1, T2, T3, TResult>.Else(TResult re
         }
 
         IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult>
-            IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult>.Or(T1 value1, T2 value2, T3 value3)
+            IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult>.Or(Either<T1, Any> value1,
+                                                                                        Either<T2, Any> value2,
+                                                                                        Either<T3, Any> value3)
         {
             _withValues.Add(EitherTuple.Create(value1, value2, value3));
             return this;
         }
 
-        IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult>
-            IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult>.Or(Any value1, T2 value2, T3 value3)
-        {
-            _withValues.Add(EitherTuple.Create<T1, T2, T3>(value1, value2, value3));
-            return this;
-        }
-
-        IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult>
-            IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult>.Or(T1 value1, Any value2, T3 value3)
-        {
-            _withValues.Add(EitherTuple.Create<T1, T2, T3>(value1, value2, value3));
-            return this;
-        }
-
-        IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult>
-            IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult>.Or(T1 value1, T2 value2, Any value3)
-        {
-            _withValues.Add(EitherTuple.Create<T1, T2, T3>(value1, value2, value3));
-            return this;
-        }
-
-        IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult>
-            IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult>.Or(Any value1, Any value2, T3 value3)
-        {
-            _withValues.Add(EitherTuple.Create<T1, T2, T3>(value1, value2, value3));
-            return this;
-        }
-
-        IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult>
-            IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult>.Or(Any value1, T2 value2, Any value3)
-        {
-            _withValues.Add(EitherTuple.Create<T1, T2, T3>(value1, value2, value3));
-            return this;
-        }
-
-        IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult>
-            IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult>.Or(T1 value1, Any value2, Any value3)
-        {
-            _withValues.Add(EitherTuple.Create<T1, T2, T3>(value1, value2, value3));
-            return this;
-        }
-
-        IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult>
-            IFuncWithHandler<IFuncMatcher<T1, T2, T3, TResult>, T1, T2, T3, TResult>.Or(Any value1, Any value2, Any value3)
-        {
-            _withValues.Add(EitherTuple.Create<T1, T2, T3>(value1, value2, value3));
-            return this;
-        }
-
         IActionMatcher<T1, T2, T3> IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3>.Do(
             Action<T1, T2, T3> action)
         {
@@ -418,59 +198,12 @@ private static Func<Tuple<T1, T2, T3>, TResult> ActionToFunc(Action<T1, T2, T3>
             };
 
         IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3>
-            IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3>.Or(T1 value1, T2 value2, T3 value3)
+            IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3>.Or(Either<T1, Any> value1,
+                                                                          Either<T2, Any> value2,
+                                                                          Either<T3, Any> value3)
         {
             _withValues.Add(EitherTuple.Create(value1, value2, value3));
             return this;
         }
-
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3>
-            IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3>.Or(Any value1, T2 value2, T3 value3)
-        {
-            _withValues.Add(EitherTuple.Create<T1, T2, T3>(value1, value2, value3));
-            return this;
-        }
-
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3>
-            IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3>.Or(T1 value1, Any value2, T3 value3)
-        {
-            _withValues.Add(EitherTuple.Create<T1, T2, T3>(value1, value2, value3));
-            return this;
-        }
-
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3>
-            IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3>.Or(T1 value1, T2 value2, Any value3)
-        {
-            _withValues.Add(EitherTuple.Create<T1, T2, T3>(value1, value2, value3));
-            return this;
-        }
-
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3>
-            IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3>.Or(Any value1, Any value2, T3 value3)
-        {
-            _withValues.Add(EitherTuple.Create<T1, T2, T3>(value1, value2, value3));
-            return this;
-        }
-
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3>
-            IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3>.Or(Any value1, T2 value2, Any value3)
-        {
-            _withValues.Add(EitherTuple.Create<T1, T2, T3>(value1, value2, value3));
-            return this;
-        }
-
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3>
-            IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3>.Or(T1 value1, Any value2, Any value3)
-        {
-            _withValues.Add(EitherTuple.Create<T1, T2, T3>(value1, value2, value3));
-            return this;
-        }
-
-        IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3>
-            IActionWithHandler<IActionMatcher<T1, T2, T3>, T1, T2, T3>.Or(Any value1, Any value2, Any value3)
-        {
-            _withValues.Add(EitherTuple.Create<T1, T2, T3>(value1, value2, value3));
-            return this;
-        }
     }
 }
\ No newline at end of file
diff --git a/SuccincT/PatternMatchers/Matcher{T1,T2,TR}.cs b/SuccincT/PatternMatchers/Matcher{T1,T2,TR}.cs
index cca2793..83509b8 100644
--- a/SuccincT/PatternMatchers/Matcher{T1,T2,TR}.cs
+++ b/SuccincT/PatternMatchers/Matcher{T1,T2,TR}.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using SuccincT.Unions;
 using static SuccincT.Functional.Unit;
 
 namespace SuccincT.PatternMatchers
@@ -33,79 +34,25 @@ internal Matcher(Tuple<T1, T2> item)
 
         IFuncMatcher<T1, T2, TR> IMatcher<T1, T2>.To<TR>() => new Matcher<T1, T2, TR>(_item);
 
-        IActionWithHandler<IActionMatcher<T1, T2>, T1, T2> IActionMatcher<T1, T2>.With(T1 value1, T2 value2)
+        IActionWithHandler<IActionMatcher<T1, T2>, T1, T2> IActionMatcher<T1, T2>.With(Either<T1, Any> value1,
+                                                                                       Either<T2, Any> value2)
         {
-            _withValues = new List<EitherTuple<T1, T2>> { EitherTuple.Create(value1, value2) };
+            _withValues = new List<EitherTuple<T1, T2>> {EitherTuple.Create(value1, value2)};
             return this;
         }
 
-        IActionWithHandler<IActionMatcher<T1, T2>, T1, T2> IActionMatcher<T1, T2>.With(Any value1, T2 value2)
+        IFuncWithHandler<IFuncMatcher<T1, T2, TResult>, T1, T2, TResult> IFuncMatcher<T1, T2, TResult>.With(
+            Either<T1, Any> value1,
+            Either<T2, Any> value2)
         {
-            _withValues = new List<EitherTuple<T1, T2>> { EitherTuple.Create<T1, T2>(value1, value2) };
+            _withValues = new List<EitherTuple<T1, T2>> {EitherTuple.Create(value1, value2)};
             return this;
         }
 
-        IActionWithHandler<IActionMatcher<T1, T2>, T1, T2> IActionMatcher<T1, T2>.With(T1 value1, Any value2)
+        IActionWithHandler<IActionMatcher<T1, T2>, T1, T2> IMatcher<T1, T2>.With(Either<T1, Any> value1,
+                                                                                 Either<T2, Any> value2)
         {
-            _withValues = new List<EitherTuple<T1, T2>> { EitherTuple.Create<T1, T2>(value1, value2) };
-            return this;
-        }
-
-        IActionWithHandler<IActionMatcher<T1, T2>, T1, T2> IActionMatcher<T1, T2>.With(Any value1, Any value2)
-        {
-            _withValues = new List<EitherTuple<T1, T2>> { EitherTuple.Create<T1, T2>(value1, value2) };
-            return this;
-        }
-
-        IFuncWithHandler<IFuncMatcher<T1, T2, TResult>, T1, T2, TResult> IFuncMatcher<T1, T2, TResult>.With(T1 value1,
-                                                                                                            T2 value2)
-        {
-            _withValues = new List<EitherTuple<T1, T2>> { EitherTuple.Create(value1, value2) };
-            return this;
-        }
-
-        IFuncWithHandler<IFuncMatcher<T1, T2, TResult>, T1, T2, TResult> IFuncMatcher<T1, T2, TResult>.With(Any value1,
-                                                                                                            T2 value2)
-        {
-            _withValues = new List<EitherTuple<T1, T2>> { EitherTuple.Create<T1, T2>(value1, value2) };
-            return this;
-        }
-
-        IFuncWithHandler<IFuncMatcher<T1, T2, TResult>, T1, T2, TResult> IFuncMatcher<T1, T2, TResult>.With(T1 value1,
-                                                                                                            Any value2)
-        {
-            _withValues = new List<EitherTuple<T1, T2>> { EitherTuple.Create<T1, T2>(value1, value2) };
-            return this;
-        }
-
-        IFuncWithHandler<IFuncMatcher<T1, T2, TResult>, T1, T2, TResult> IFuncMatcher<T1, T2, TResult>.With(Any value1,
-                                                                                                            Any value2)
-        {
-            _withValues = new List<EitherTuple<T1, T2>> { EitherTuple.Create<T1, T2>(value1, value2) };
-            return this;
-        }
-
-        IActionWithHandler<IActionMatcher<T1, T2>, T1, T2> IMatcher<T1, T2>.With(T1 value1, T2 value2)
-        {
-            _withValues = new List<EitherTuple<T1, T2>> { EitherTuple.Create(value1, value2) };
-            return this;
-        }
-
-        IActionWithHandler<IActionMatcher<T1, T2>, T1, T2> IMatcher<T1, T2>.With(Any value1, T2 value2)
-        {
-            _withValues = new List<EitherTuple<T1, T2>> { EitherTuple.Create<T1, T2>(value1, value2) };
-            return this;
-        }
-
-        IActionWithHandler<IActionMatcher<T1, T2>, T1, T2> IMatcher<T1, T2>.With(T1 value1, Any value2)
-        {
-            _withValues = new List<EitherTuple<T1, T2>> { EitherTuple.Create<T1, T2>(value1, value2) };
-            return this;
-        }
-
-        IActionWithHandler<IActionMatcher<T1, T2>, T1, T2> IMatcher<T1, T2>.With(Any value1, Any value2)
-        {
-            _withValues = new List<EitherTuple<T1, T2>> { EitherTuple.Create<T1, T2>(value1, value2) };
+            _withValues = new List<EitherTuple<T1, T2>> {EitherTuple.Create(value1, value2)};
             return this;
         }
 
@@ -153,65 +100,21 @@ IFuncMatcherAfterElse<TResult> IFuncMatcher<T1, T2, TResult>.Else(TResult result
         }
 
         IActionWithHandler<IActionMatcher<T1, T2>, T1, T2> IActionWithHandler<IActionMatcher<T1, T2>, T1, T2>.Or(
-            T1 value1,
-            T2 value2)
+            Either<T1, Any> value1,
+            Either<T2, Any> value2)
         {
             _withValues.Add(EitherTuple.Create(value1, value2));
             return this;
         }
 
-        IActionWithHandler<IActionMatcher<T1, T2>, T1, T2> IActionWithHandler<IActionMatcher<T1, T2>, T1, T2>.Or(
-            Any value1,
-            T2 value2)
-        {
-            _withValues.Add(EitherTuple.Create<T1, T2>(value1, value2));
-            return this;
-        }
-
-        IActionWithHandler<IActionMatcher<T1, T2>, T1, T2> IActionWithHandler<IActionMatcher<T1, T2>, T1, T2>.Or(
-            T1 value1,
-            Any value2)
-        {
-            _withValues.Add(EitherTuple.Create<T1, T2>(value1, value2));
-            return this;
-        }
-
-        IActionWithHandler<IActionMatcher<T1, T2>, T1, T2> IActionWithHandler<IActionMatcher<T1, T2>, T1, T2>.Or(
-            Any value1,
-            Any value2)
-        {
-            _withValues.Add(EitherTuple.Create<T1, T2>(value1, value2));
-            return this;
-        }
-
         IFuncWithHandler<IFuncMatcher<T1, T2, TResult>, T1, T2, TResult>
-            IFuncWithHandler<IFuncMatcher<T1, T2, TResult>, T1, T2, TResult>.Or(T1 value1, T2 value2)
+            IFuncWithHandler<IFuncMatcher<T1, T2, TResult>, T1, T2, TResult>.Or(Either<T1, Any> value1,
+                                                                                Either<T2, Any> value2)
         {
             _withValues.Add(EitherTuple.Create(value1, value2));
             return this;
         }
 
-        IFuncWithHandler<IFuncMatcher<T1, T2, TResult>, T1, T2, TResult>
-            IFuncWithHandler<IFuncMatcher<T1, T2, TResult>, T1, T2, TResult>.Or(Any value1, T2 value2)
-        {
-            _withValues.Add(EitherTuple.Create<T1, T2>(value1, value2));
-            return this;
-        }
-
-        IFuncWithHandler<IFuncMatcher<T1, T2, TResult>, T1, T2, TResult>
-            IFuncWithHandler<IFuncMatcher<T1, T2, TResult>, T1, T2, TResult>.Or(T1 value1, Any value2)
-        {
-            _withValues.Add(EitherTuple.Create<T1, T2>(value1, value2));
-            return this;
-        }
-
-        IFuncWithHandler<IFuncMatcher<T1, T2, TResult>, T1, T2, TResult>
-            IFuncWithHandler<IFuncMatcher<T1, T2, TResult>, T1, T2, TResult>.Or(Any value1, Any value2)
-        {
-            _withValues.Add(EitherTuple.Create<T1, T2>(value1, value2));
-            return this;
-        }
-
         IActionMatcher<T1, T2> IActionWithHandler<IActionMatcher<T1, T2>, T1, T2>.Do(Action<T1, T2> action)
         {
             RecordFunction((x, y) => y.Any(v => v.MatchesTuple(x)),
diff --git a/SuccincT/SuccincT.csproj b/SuccincT/SuccincT.csproj
index 2fb371e..2698029 100644
--- a/SuccincT/SuccincT.csproj
+++ b/SuccincT/SuccincT.csproj
@@ -59,7 +59,7 @@
     <Compile Include="CompilationTargetHandler.cs" />
     <Compile Include="Functional\ActionExtensions.cs" />
     <Compile Include="Functional\ConsExtensionsForIEnumerable.cs" />
-    <Compile Include="Functional\Either.cs" />
+    <Compile Include="Unions\Either.cs" />
     <Compile Include="Options\OptionExtensions.cs" />
     <Compile Include="Options\OptionExtensionsForDictionaryType.cs" />
     <Compile Include="Options\OptionExtensionsForGeneralTypes.cs" />
@@ -96,6 +96,7 @@
     <Compile Include="Options\ValueOrError.cs" />
     <Compile Include="Options\ValueOrErrorMatcher{TR}.cs" />
     <Compile Include="PatternMatchers\EitherTuple.cs" />
+    <Compile Include="PatternMatchers\EitherTuple{T1,T2,T3,T4}.cs" />
     <Compile Include="PatternMatchers\EitherTuple{T1,T2,T3}.cs" />
     <Compile Include="PatternMatchers\EitherTuple{T1,T2}.cs" />
     <Compile Include="PatternMatchers\GeneralMatcher\GeneralMatcherExtensions.cs" />
diff --git a/SuccincT/Functional/Either.cs b/SuccincT/Unions/Either.cs
similarity index 88%
rename from SuccincT/Functional/Either.cs
rename to SuccincT/Unions/Either.cs
index fe830d8..ba5aef7 100644
--- a/SuccincT/Functional/Either.cs
+++ b/SuccincT/Unions/Either.cs
@@ -1,7 +1,7 @@
-using SuccincT.Options;
-using System;
+using System;
+using SuccincT.Options;
 
-namespace SuccincT.Functional
+namespace SuccincT.Unions
 {
     public struct Either<TLeft, TRight>
     {
@@ -73,5 +73,8 @@ public override int GetHashCode()
         }
 
         public static bool operator !=(Either<TLeft, TRight> x, Either<TLeft, TRight> y) => !(x == y);
+
+        public static implicit operator Either<TLeft, TRight>(TLeft value) => new Either<TLeft, TRight>(value);
+        public static implicit operator Either<TLeft, TRight>(TRight value) => new Either<TLeft, TRight>(value);
     }
 }
diff --git a/SuccincTTests/SuccincT/Functional/EitherTests.cs b/SuccincTTests/SuccincT/Functional/EitherTests.cs
index 09770a1..0dd881e 100644
--- a/SuccincTTests/SuccincT/Functional/EitherTests.cs
+++ b/SuccincTTests/SuccincT/Functional/EitherTests.cs
@@ -1,6 +1,7 @@
 using System;
 using NUnit.Framework;
 using SuccincT.Functional;
+using SuccincT.Unions;
 using static NUnit.Framework.Assert;
 
 namespace SuccincTTests.SuccincT.Functional
diff --git a/SuccincTTests/SuccincT/Tuples/TupleExecTestsUsingAnyT1T2T3T4.cs b/SuccincTTests/SuccincT/Tuples/TupleExecTestsUsingAnyT1T2T3T4.cs
new file mode 100644
index 0000000..8076596
--- /dev/null
+++ b/SuccincTTests/SuccincT/Tuples/TupleExecTestsUsingAnyT1T2T3T4.cs
@@ -0,0 +1,180 @@
+using System;
+using NUnit.Framework;
+using SuccincT.PatternMatchers;
+using static SuccincT.PatternMatchers.Any;
+
+namespace SuccincTTests.SuccincT.Tuples
+{
+    [TestFixture]
+    public class TupleExecTestsUsingAnyT1T2T3T4
+    {
+        private enum Colors { Red, Green, Blue }
+        private enum Animals { Cow, Pig, Goat }
+
+        [Test]
+        public void Tuple_CanBeMatchedUsingAnyIntWithExec()
+        {
+            var tuple = Tuple.Create(1, "a", Colors.Red, Animals.Cow);
+            var result = false;
+            tuple.Match().With(any, "a", Colors.Red, Animals.Cow).Do((w, x, y, z) => result = true).Exec();
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void Tuple_CanBeMatchedUsingAnyStringWithExec()
+        {
+            var tuple = Tuple.Create(1, "a", Colors.Red, Animals.Cow);
+            var result = false;
+            tuple.Match().With(1, any, Colors.Red, Animals.Cow).Do((w, x, y, z) => result = true).Exec();
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void Tuple_CanBeMatchedUsingAnyColorWithExec()
+        {
+            var tuple = Tuple.Create(1, "a", Colors.Red, Animals.Cow);
+            var result = false;
+            tuple.Match().With(1, "a", any, Animals.Cow).Do((w, x, y, z) => result = true).Exec();
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void Tuple_CanBeMatchedUsingAnyAnimalWithExec()
+        {
+            var tuple = Tuple.Create(1, "a", Colors.Red, Animals.Cow);
+            var result = false;
+            tuple.Match().With(1, "a", Colors.Red, any).Do((w, x, y, z) => result = true).Exec();
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void Tuple_CanBeMatchedUsingFourAnysWithExec()
+        {
+            var tuple = Tuple.Create(1, "a", Colors.Red, Animals.Cow);
+            var result = false;
+            tuple.Match().With(any, any, any, any).Do((w, x, y, z) => result = true).Exec();
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void Tuple_CanBeMatchedViaOrUsingAnyIntWithExec()
+        {
+            var tuple = Tuple.Create(1, "a", Colors.Green, Animals.Cow);
+            var result = false;
+            tuple.Match().With(1, "a", Colors.Green, Animals.Goat)
+                         .Or(__, "a", Colors.Green, Animals.Cow).Do((w, x, y, z) => result = true)
+                         .Exec();
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void Tuple_CanBeMatchedViaOrUsingAnyStringWithExec()
+        {
+            var tuple = Tuple.Create(1, "a", Colors.Green, Animals.Cow);
+            var result = false;
+            tuple.Match().With(1, "a", Colors.Green, Animals.Goat)
+                         .Or(1, __, Colors.Green, Animals.Cow).Do((w, x, y, z) => result = true)
+                         .Exec();
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void Tuple_CanBeMatchedViaOrUsingAnyColorWithExec()
+        {
+            var tuple = Tuple.Create(1, "a", Colors.Green, Animals.Cow);
+            var result = false;
+            tuple.Match().With(1, "a", Colors.Green, Animals.Goat)
+                         .Or(1, "a", __, Animals.Cow).Do((w, x, y, z) => result = true)
+                         .Exec();
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void Tuple_CanBeMatchedViaOrUsingAnyAnimalWithExec()
+        {
+            var tuple = Tuple.Create(1, "a", Colors.Green, Animals.Cow);
+            var result = false;
+            tuple.Match().With(1, "a", Colors.Green, Animals.Goat)
+                         .Or(1, "a", Colors.Green, __).Do((w, x, y, z) => result = true)
+                         .Exec();
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void Tuple_CanBeMatchedViaOrUsingFourAnysWithExec()
+        {
+            var tuple = Tuple.Create(1, "a", Colors.Green, Animals.Cow);
+            var result = false;
+            tuple.Match().With(1, "a", Colors.Green, Animals.Goat)
+                         .Or(__, __, __, __).Do((w, x, y, z) => result = true)
+                         .Exec();
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void TupleWhenNoMatchDespiteAnyInt_ElseUsedWithExec()
+        {
+            var tuple = Tuple.Create(1, "a", Colors.Red, Animals.Cow);
+            var result = false;
+            tuple.Match().With(__, "a", Colors.Red, Animals.Goat).Do((w, x, y, z) => result = true)
+                         .Else((w, x, y, z) => result = false).Exec();
+            Assert.IsFalse(result);
+        }
+
+        [Test]
+        public void TupleWhenNoMatchDespiteAnyString_ElseUsedWithExec()
+        {
+            var tuple = Tuple.Create(1, "a", Colors.Red, Animals.Cow);
+            var result = false;
+            tuple.Match().With(1, __, Colors.Red, Animals.Goat).Do((w, x, y, z) => result = true)
+                         .Else((w, x, y, z) => result = false).Exec();
+            Assert.IsFalse(result);
+        }
+
+        [Test]
+        public void TupleWhenNoMatchDespiteAnyColor_ElseUsedWithExec()
+        {
+            var tuple = Tuple.Create(1, "a", Colors.Red, Animals.Cow);
+            var result = false;
+            tuple.Match().With(1, "a", __, Animals.Goat).Do((w, x, y, z) => result = true)
+                         .Else((w, x, y, z) => result = false).Exec();
+            Assert.IsFalse(result);
+        }
+
+        [Test]
+        public void TupleWhenNoMatchDespiteAnyAnimal_ElseUsedWithExec()
+        {
+            var tuple = Tuple.Create(1, "a", Colors.Red, Animals.Cow);
+            var result = false;
+            tuple.Match().With(1, "a", Colors.Blue, __).Do((w, x, y, z) => result = true)
+                         .Else((w, x, y, z) => result = false).Exec();
+            Assert.IsFalse(result);
+        }
+
+        [Test]
+        public void TupleWithAndWhereDefinedUsingAnyInt_WhereCorrectlyUsedWithExec()
+        {
+            var tuple = Tuple.Create(1, "a", Colors.Red, Animals.Cow);
+            var result = false;
+            tuple.Match().With(__, "a", Colors.Red, Animals.Goat)
+                         .Or(__, "a", Colors.Red, Animals.Pig).Do((w, x, y, z) => result = false)
+                         .Where((w, x, y, z) => w == 1 && x == "a" && y == Colors.Red && z == Animals.Cow)
+                         .Do((w, x, y, z) => result = true)
+                         .Exec();
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void TupleWithAndWhereDefinedUsingFourAnys_WithCorrectlyUsedWithExec()
+        {
+            var tuple = Tuple.Create(1, "a", Colors.Red, Animals.Cow);
+            var result = false;
+            tuple.Match()
+                 .Where((w, x, y, z) => z == Animals.Pig).Do((w, x, y, z) => result = true)
+                 .With(1, "a", Colors.Red, Animals.Goat).Or(__, __, __, __)
+                 .Do((w, x, y, z) => result = false)
+                 .Exec();
+            Assert.IsFalse(result);
+        }
+    }
+}
\ No newline at end of file
diff --git a/SuccincTTests/SuccincT/Tuples/TupleMatchableTestsUsingAnyT1T2T3T4.cs b/SuccincTTests/SuccincT/Tuples/TupleMatchableTestsUsingAnyT1T2T3T4.cs
new file mode 100644
index 0000000..c7d3fe7
--- /dev/null
+++ b/SuccincTTests/SuccincT/Tuples/TupleMatchableTestsUsingAnyT1T2T3T4.cs
@@ -0,0 +1,110 @@
+using System;
+using NUnit.Framework;
+using SuccincT.PatternMatchers;
+using SuccincT.Tuples;
+using static SuccincT.PatternMatchers.Any;
+
+namespace SuccincTTests.SuccincT.Tuples
+{
+    [TestFixture]
+    internal class TupleMatchableTestsUsingAnyT1T2T3T4
+    {
+        private enum Colors { Red, Green, Blue }
+        private enum Animals { Cow, Pig, Goat }
+
+        private class TestClass : ITupleMatchable<int, string, Colors, Animals>
+        {
+            public int A;
+            public string B;
+            public Colors C;
+            public Animals D;
+            public Tuple<int, string, Colors, Animals> PropertiesToMatch => Tuple.Create(A, B, C, D);
+        }
+
+        [Test]
+        public void Tuple_CanBeMatchedWithAnyInt()
+        {
+            var tuple = new TestClass { A = 1, B = "a", C = Colors.Red, D = Animals.Goat };
+            var result = tuple.Match().To<bool>()
+                              .With(any, "a", Colors.Red, Animals.Goat).Do((w, x, y, z) => true).Result();
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void Tuple_CanBeMatchedWithAnyString()
+        {
+            var tuple = new TestClass { A = 1, B = "a", C = Colors.Red, D = Animals.Goat };
+            var result = tuple.Match().To<bool>()
+                              .With(1, any, Colors.Red, Animals.Goat).Do((w, x, y, z) => true).Result();
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void Tuple_CanBeMatchedWithAnyColor()
+        {
+            var tuple = new TestClass { A = 1, B = "a", C = Colors.Red, D = Animals.Goat };
+            var result = tuple.Match().To<bool>()
+                              .With(1, "a", any, Animals.Goat).Do((w, x, y, z) => true).Result();
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void Tuple_CanBeMatchedWithAnyAnimal()
+        {
+            var tuple = new TestClass { A = 1, B = "a", C = Colors.Red, D = Animals.Goat };
+            var result = tuple.Match().To<bool>()
+                              .With(1, "a", Colors.Red, any).Do((w, x, y, z) => true).Result();
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void Tuple_CanBeMatchedViaOrWithAnyInt()
+        {
+            var tuple = new TestClass { A = 1, B = "a", C = Colors.Blue, D = Animals.Cow };
+            var result = tuple.Match().To<bool>().With(1, "a", Colors.Blue, Animals.Goat)
+                                                 .Or(__, "a", Colors.Blue, Animals.Cow).Do((w, x, y, z) => true)
+                                      .Result();
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void Tuple_CanBeMatchedViaOrWithAnyString()
+        {
+            var tuple = new TestClass { A = 1, B = "a", C = Colors.Blue, D = Animals.Cow };
+            var result = tuple.Match().To<bool>().With(1, "a", Colors.Blue, Animals.Goat)
+                                                 .Or(1, __, Colors.Blue, Animals.Cow).Do((w, x, y, z) => true)
+                                      .Result();
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void Tuple_CanBeMatchedViaOrWithAnyColor()
+        {
+            var tuple = new TestClass { A = 1, B = "a", C = Colors.Blue, D = Animals.Cow };
+            var result = tuple.Match().To<bool>().With(1, "a", Colors.Blue, Animals.Goat)
+                                                 .Or(1, "a", __, Animals.Cow).Do((w, x, y, z) => true)
+                                      .Result();
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void Tuple_CanBeMatchedViaOrWithAnyAnimal()
+        {
+            var tuple = new TestClass { A = 1, B = "a", C = Colors.Blue, D = Animals.Cow };
+            var result = tuple.Match().To<bool>().With(1, "a", Colors.Blue, Animals.Goat)
+                                                 .Or(1, "a", Colors.Blue, __).Do((w, x, y, z) => true)
+                                      .Result();
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void Tuple_CanBeMatchedViaOrWithFourAnys()
+        {
+            var tuple = new TestClass { A = 1, B = "a", C = Colors.Blue, D = Animals.Cow };
+            var result = tuple.Match().To<bool>().With(1, "a", Colors.Green, Animals.Pig)
+                                                 .Or(__, __, __, __).Do((w, x, y, z) => true)
+                                      .Result();
+            Assert.IsTrue(result);
+        }
+    }
+}
\ No newline at end of file
diff --git a/SuccincTTests/SuccincTTests.csproj b/SuccincTTests/SuccincTTests.csproj
index 323b71b..68a9672 100644
--- a/SuccincTTests/SuccincTTests.csproj
+++ b/SuccincTTests/SuccincTTests.csproj
@@ -112,11 +112,13 @@
     <Compile Include="SuccincT\PatternMatchers\ValueMatchExecTests.cs" />
     <Compile Include="SuccincT\PatternMatchers\ValueMatchTests.cs" />
     <Compile Include="SuccincT\Tuples\TupleExecTestsT1.cs" />
+    <Compile Include="SuccincT\Tuples\TupleExecTestsUsingAnyT1T2T3T4.cs" />
     <Compile Include="SuccincT\Tuples\TupleExecTestsUsingAnyT1T2T3.cs" />
     <Compile Include="SuccincT\Tuples\TupleExecTestsUsingAnyT1T2.cs" />
     <Compile Include="SuccincT\Tuples\TupleExecTestsT1T2T3T4.cs" />
     <Compile Include="SuccincT\Tuples\TupleExecTestsT1T2T3.cs" />
     <Compile Include="SuccincT\Tuples\TupleIgnoreElseTests.cs" />
+    <Compile Include="SuccincT\Tuples\TupleMatchableTestsUsingAnyT1T2T3T4.cs" />
     <Compile Include="SuccincT\Tuples\TupleMatchableTestsUsingAnyT1T2T3.cs" />
     <Compile Include="SuccincT\Tuples\TupleMatchableTestsUsingAnyT1T2.cs" />
     <Compile Include="SuccincT\Tuples\TupleMatchableTestsT1T2.cs" />