diff --git a/RegExtract.Test/RegExtract.Test.csproj b/RegExtract.Test/RegExtract.Test.csproj
index be9a6c4..67540f9 100644
--- a/RegExtract.Test/RegExtract.Test.csproj
+++ b/RegExtract.Test/RegExtract.Test.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>netcoreapp3.1;net452</TargetFrameworks>
+    <TargetFrameworks>netcoreapp8.0;netcoreapp3.1;net452</TargetFrameworks>
     <Nullable>enable</Nullable>
     <IsPackable>false</IsPackable>
     <LangVersion>latest</LangVersion>
diff --git a/RegExtract/ExtractionPlan.cs b/RegExtract/ExtractionPlan.cs
index c028c0f..cf7d8e1 100644
--- a/RegExtract/ExtractionPlan.cs
+++ b/RegExtract/ExtractionPlan.cs
@@ -116,7 +116,7 @@ ExtractionPlanNode BindTupleConstructorPlan(string name, IEnumerable<RegexCaptur
             {
                 if (idx < 7)
                 {
-                    groups.Add(BindConstructorPlan(node, tupleType, idx, typeArgs.Length));
+                    groups.Add(BindConstructorPlan(node, tupleType, idx, typeArgs?.Length ?? 0));
                 }
                 else
                 {
@@ -156,7 +156,7 @@ private ExtractionPlanNode AssignTypesToTree(RegexCaptureGroupNode tree, Extract
                     return AssignTypesToTree(tree.children.Single(), type);
                 }
 
-                if (typeParams.Length < 2 && !(typeParams.Length > 0 && ExtractionPlanTypeWrapper.Wrap(typeParams.First()).IsInitializableCollection))
+                if ((typeParams?.Length ?? 0) < 2 && !((typeParams?.Length ?? 0) > 0 && ExtractionPlanTypeWrapper.Wrap(typeParams.First()).IsInitializableCollection))
                 {
                     return ExtractionPlanNode.Bind(tree.name, type, new[] { BindConstructorPlan(tree, type, 0, 1) }, new ExtractionPlanNode[0]);
                 }
diff --git a/RegExtract/ExtractionPlanNode.cs b/RegExtract/ExtractionPlanNode.cs
index 75fc5a3..9edaaf5 100644
--- a/RegExtract/ExtractionPlanNode.cs
+++ b/RegExtract/ExtractionPlanNode.cs
@@ -15,7 +15,7 @@ public string ShowPlanTree()
         {
             StringBuilder builder = new();
 
-            builder.Append(this.GetType().Name.Replace("Node","")).Append("<").Append(string.Join(",",FriendlyTypeName(type))).Append(">[").Append(int.TryParse(groupName, out var _) ? groupName : "\"" + groupName + "\"").Append("] (");
+            builder.Append(this.GetType().Name.Replace("Node","")).Append("<").Append(string.Join(",",FriendlyTypeName(type.Type))).Append(">[").Append(int.TryParse(groupName, out var _) ? groupName : '"' + groupName + '"').Append("] (");
             if (constructorParams.Any())
             {
                 builder.Append("\n");
@@ -36,9 +36,9 @@ public string ShowPlanTree()
             return builder.ToString();
         }
 
-        string FriendlyTypeName(ExtractionPlanTypeWrapper type)
+        string FriendlyTypeName(Type type)
         {
-            var keyword = type.Type.Name switch
+            var keyword = type.Name switch
             {
                 "Byte" => "byte",
                 "SByte" => "sbyte",
@@ -58,18 +58,18 @@ string FriendlyTypeName(ExtractionPlanTypeWrapper type)
 
             if (keyword is not null) return keyword;
 
-            if (type.IsNullable) return FriendlyTypeName(type.NonNullableType) + "?";
+            if (Nullable.GetUnderlyingType(type) is Type nonNullableType) return FriendlyTypeName(nonNullableType) + "?";
 
-            var args = type.GenericArguments;
+            var args = type.GetGenericArguments();
 
-            if (type.IsTuple) return "(" + String.Join(",", args.Select(arg => ExtractionPlanTypeWrapper.Wrap(arg))) + ")";
+            if (type.FullName.StartsWith(VALUETUPLE_TYPENAME)) return "(" + String.Join(",", args.Select(arg => FriendlyTypeName(arg))) + ")";
 
             if (args.Any())
             {
-                return type.Type.Name.Split('`')[0] + "<" + String.Join(",", args.Select(arg => ExtractionPlanTypeWrapper.Wrap(arg))) + ">";
+                return type.Name.Split('`')[0] + "<" + String.Join(",", args.Select(arg => FriendlyTypeName(arg))) + ">";
             }
 
-            else return type.Type.Name;
+            else return type.Name;
         }
 
         internal static ExtractionPlanNode Bind(string groupName, ExtractionPlanTypeWrapper type, ExtractionPlanNode[] constructorParams, ExtractionPlanNode[] propertySetters)
diff --git a/RegExtract/ExtractionPlanNodeTypes.cs b/RegExtract/ExtractionPlanNodeTypes.cs
index 71c5bb4..b002af4 100644
--- a/RegExtract/ExtractionPlanNodeTypes.cs
+++ b/RegExtract/ExtractionPlanNodeTypes.cs
@@ -27,13 +27,13 @@ internal record CollectionInitializerNode(string groupName, ExtractionPlanTypeWr
             var vals = Activator.CreateInstance(type.Type);
             var addMethod = type.Type.GetMethod("Add");
 
-            object?[] itemVals = new object[genericArgs.Length];
+            object?[] itemVals = new object[genericArgs?.Length ?? 0];
 
             var rangeArray = constructorParams.Select(c => Ranges(match, groupName, captureStart, captureLength, cache).GetEnumerator()).ToArray();
 
             do
             {
-                for (int i = 0; i < genericArgs.Length; i++)
+                for (int i = 0; i < genericArgs?.Length; i++)
                 {
                     if (rangeArray[i].MoveNext())
                     {
diff --git a/RegExtract/ExtractionPlanTypeWrapper.cs b/RegExtract/ExtractionPlanTypeWrapper.cs
index 2695913..f2c04dc 100644
--- a/RegExtract/ExtractionPlanTypeWrapper.cs
+++ b/RegExtract/ExtractionPlanTypeWrapper.cs
@@ -12,10 +12,11 @@ internal class ExtractionPlanTypeWrapper
     {
         private static Dictionary<Type, ExtractionPlanTypeWrapper> _typeWrappers = new();
 
-        public static ExtractionPlanTypeWrapper Wrap(Type type)
+        public static ExtractionPlanTypeWrapper Wrap(Type? type)
         {
-            if (_typeWrappers.ContainsKey(type))
-                return _typeWrappers[type];
+            type ??= typeof(void);
+            if (_typeWrappers.TryGetValue(type, out var wrap))
+                return wrap;
             else
                 return (_typeWrappers[type] = new ExtractionPlanTypeWrapper(type));
         }