diff --git a/.editorconfig b/.editorconfig
index 733ebd8..d49bcf8 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -218,5 +218,5 @@ dotnet_naming_style.underscore_camel.capitalization = camel_case
 dotnet_analyzer_diagnostic.category-Globalization.severity = none
 
 # CA2007: Consider calling ConfigureAwait on the awaited task
-# In almost all cases in dotnet core this is unnecessary as there is syncronization context
-dotnet_diagnostic.CA2007.severity = none
\ No newline at end of file
+# In almost all cases in dotnet core this is unnecessary as there is no synchronization context
+dotnet_diagnostic.CA2007.severity = none
diff --git a/wimm.Secundatives.UnitTests/Extensions/AsMaybe_Test.cs b/wimm.Secundatives.UnitTests/Extensions/AsMaybe_Test.cs
index 5e95879..59e75e2 100644
--- a/wimm.Secundatives.UnitTests/Extensions/AsMaybe_Test.cs
+++ b/wimm.Secundatives.UnitTests/Extensions/AsMaybe_Test.cs
@@ -55,7 +55,6 @@ public async Task AsMaybeTaskClass_Null_ReturnsNone()
             Assert.Equal(Maybe<string>.None, res);
         }
 
-
         [Fact]
         public async Task AsMaybeTaskClass_Value_ReturnsSome()
         {
@@ -85,7 +84,5 @@ public async Task AsMaybeTaskNullable_Value_ReturnsSome()
 
             Assert.Equal(25, res.Value);
         }
-
-
     }
 }
diff --git a/wimm.Secundatives.UnitTests/Extensions/Expect_Test.cs b/wimm.Secundatives.UnitTests/Extensions/Expect_Test.cs
index 0e0ae15..e8b35ff 100644
--- a/wimm.Secundatives.UnitTests/Extensions/Expect_Test.cs
+++ b/wimm.Secundatives.UnitTests/Extensions/Expect_Test.cs
@@ -25,7 +25,6 @@ public void ExpectMessage_WhiteSpaceMessage_Throws()
             Assert.Throws<ArgumentException>("message", () => underTest.Expect(" \t\r\n"));
         }
 
-
         [Fact]
         public void ExpectMessage_DoesNotExist_ThrowsWithMessage()
         {
@@ -85,8 +84,5 @@ public async Task ExpectTaskMessage_Value_ReturnsValue()
             var underTest = Task.FromResult(new Maybe<int>(10));
             Assert.Equal(10, await underTest.Expect(_message));
         }
-
-
-
     }
 }
diff --git a/wimm.Secundatives.UnitTests/Extensions/Flatten_Test.cs b/wimm.Secundatives.UnitTests/Extensions/Flatten_Test.cs
index d4c99d1..fed9a38 100644
--- a/wimm.Secundatives.UnitTests/Extensions/Flatten_Test.cs
+++ b/wimm.Secundatives.UnitTests/Extensions/Flatten_Test.cs
@@ -27,7 +27,6 @@ public void Flatten_InnerExistsAndIsValue_ReturnsValue()
             Assert.Equal(value, res.Value);
         }
 
-
         [Fact]
         public void Flatten_InnerExistsAndIsError_ReturnsError()
         {
diff --git a/wimm.Secundatives.UnitTests/Extensions/OkOr_Test.cs b/wimm.Secundatives.UnitTests/Extensions/OkOr_Test.cs
index b7a7d25..fcb71fb 100644
--- a/wimm.Secundatives.UnitTests/Extensions/OkOr_Test.cs
+++ b/wimm.Secundatives.UnitTests/Extensions/OkOr_Test.cs
@@ -25,7 +25,6 @@ public void OkOrFunc_None_ReturnsFuncResultAsError()
             Assert.Equal(TestingEnum.BadThingsHappened, result.Error);
         }
 
-
         [Fact]
         public void OkOrErrorValue_Value_ReturnsResultWithValue()
         {
@@ -46,7 +45,6 @@ public void OkOrErrorValue_None_ReturnsErrorValue()
             Assert.Equal(TestingEnum.BadThingsHappened, result.Error);
         }
 
-
         [Fact]
         public async Task OkOrErrorTaskFunc_Value_ReturnsResultWithValue()
         {
@@ -56,7 +54,6 @@ public async Task OkOrErrorTaskFunc_Value_ReturnsResultWithValue()
             Assert.Equal("doot", result.Value);
         }
 
-
         [Fact]
         public async Task OkOrErrorTaskFunc_None_ReturnsResultWithValue()
         {
@@ -67,7 +64,6 @@ public async Task OkOrErrorTaskFunc_None_ReturnsResultWithValue()
 
         }
 
-
         [Fact]
         public async Task OkOrErrorTaskValue_Value_ReturnsResultWithValue()
         {
@@ -123,12 +119,9 @@ public async Task OkOrErrorTaskFunc_ResultMemberIsNone_ReturnsInternalResult()
             Assert.Equal(TestingEnum.BadThingsHappened, result.Error);
         }
 
-
         public enum TestingEnum
         {
             BadThingsHappened
         }
-
-
     }
 }
diff --git a/wimm.Secundatives.UnitTests/Extensions/ResultMapping_Test.cs b/wimm.Secundatives.UnitTests/Extensions/ResultMapping_Test.cs
index 77d6b03..5c4fecd 100644
--- a/wimm.Secundatives.UnitTests/Extensions/ResultMapping_Test.cs
+++ b/wimm.Secundatives.UnitTests/Extensions/ResultMapping_Test.cs
@@ -64,7 +64,6 @@ public async Task MapTaskResult_IsErrorAndFuncReturnsValue_ReturnsError()
             Assert.Equal(TestError.Sadness, res.Error);
         }
 
-
         [Fact]
         public async Task MapTaskResult_IsSuccessAndFuncReturnsTask_ReturnsResultOfFunc()
         {
@@ -133,7 +132,6 @@ public void MapErrorValue_IsErrorAndFuncReturnsValue_ReturnsResultOfFunc()
             Assert.Equal(OtherError.OtherSadness, res.Error);
         }
 
-
         [Fact]
         public void MapErrorValue_IsSuccessAndFuncReturnsValue_ReturnsValue()
         {
@@ -203,7 +201,6 @@ private static Result<T, TestError> ConstructWith<T>(T value)
             return new Result<T, TestError>(value);
         }
 
-
         private enum TestError
         {
             Sadness
@@ -213,6 +210,5 @@ private enum OtherError
         {
             OtherSadness
         }
-
     }
 }
diff --git a/wimm.Secundatives.UnitTests/Extensions/UnwrapOr_Test.cs b/wimm.Secundatives.UnitTests/Extensions/UnwrapOr_Test.cs
index 8515d9f..bbffc70 100644
--- a/wimm.Secundatives.UnitTests/Extensions/UnwrapOr_Test.cs
+++ b/wimm.Secundatives.UnitTests/Extensions/UnwrapOr_Test.cs
@@ -9,8 +9,17 @@ public class UnwrapOr_Test
     {
         private const string _valid = "doot";
         private const string _default = "tood";
-        private readonly Func<string> _defaultFunc = () => { _set = true; return _default; };
-        private readonly Func<Task<string>> _defaultAsyncFunc = async () => { _set = true; ; return await Task.FromResult(_default); };
+        private readonly Func<string> _defaultFunc = () =>
+        {
+            _set = true;
+            return _default;
+        };
+        private readonly Func<Task<string>> _defaultAsyncFunc = async () =>
+        {
+            _set = true; 
+            return await Task.FromResult(_default);
+        };
+
         private static bool _set = false;
 
         public UnwrapOr_Test()
@@ -40,7 +49,6 @@ public void UnwrawpOrFunc_NoValue_ExecutesFunction()
             Assert.Equal(_default, underTest.UnwrapOr(_defaultFunc));
         }
 
-
         [Fact]
         public void UnwrapOr_NoValue_ReturnsDefaultParam()
         {
diff --git a/wimm.Secundatives.UnitTests/Maybe_Test.cs b/wimm.Secundatives.UnitTests/Maybe_Test.cs
index c64c0ce..cca64ae 100644
--- a/wimm.Secundatives.UnitTests/Maybe_Test.cs
+++ b/wimm.Secundatives.UnitTests/Maybe_Test.cs
@@ -6,7 +6,6 @@ namespace wimm.Secundatives.UnitTests
     public class Maybe_Test
     {
 
-
         [Fact]
         public void Construct_ValueTypeDefault_EqualsNone()
         {
@@ -349,7 +348,5 @@ public void GetHashCode_ValueMaybe_Throws()
 
             Assert.Throws<InvalidOperationException>(() => underTest.GetHashCode());
         }
-
-
     }
 }
diff --git a/wimm.Secundatives.UnitTests/Result_Test.cs b/wimm.Secundatives.UnitTests/Result_Test.cs
index 82fc807..129c8c4 100644
--- a/wimm.Secundatives.UnitTests/Result_Test.cs
+++ b/wimm.Secundatives.UnitTests/Result_Test.cs
@@ -5,7 +5,7 @@ namespace wimm.Secundatives.UnitTests
 {
     public class Result_Test
     {
-        private readonly Error _err = new Error("BadDoot");
+        private readonly Error _err = new("BadDoot");
 
         [Fact]
         public void Error_ContainsValue_Throws()
@@ -14,7 +14,6 @@ public void Error_ContainsValue_Throws()
             Assert.Throws<InvalidOperationException>(() => underTest.Error);
         }
 
-
         [Fact]
         public void Value_ContainsError_Throws()
         {
@@ -29,7 +28,6 @@ public void Error_ContainsError_ReturnsError()
             Assert.Equal(_err, underTest.Error);
         }
 
-
         [Fact]
         public void Value_ContainsValue_ReturnsValue()
         {
@@ -92,9 +90,7 @@ public void Ok_ContainsError_ReturnsNone()
             var underTest = ConstructErr();
             Assert.False(underTest.Ok().Exists);
         }
-
-
-        private Result<int> ConstructInt()
+        private static Result<int> ConstructInt()
         {
             return 42;
         }
@@ -103,6 +99,5 @@ private Result<int> ConstructErr()
         {
             return _err;
         }
-
     }
 }
diff --git a/wimm.Secundatives.UnitTests/TestHelpers.cs b/wimm.Secundatives.UnitTests/TestHelpers.cs
index 9d70dfe..5926372 100644
--- a/wimm.Secundatives.UnitTests/TestHelpers.cs
+++ b/wimm.Secundatives.UnitTests/TestHelpers.cs
@@ -8,7 +8,6 @@ public class TestHelpers
     {
         private static readonly List<string> _stringControls = new() { "\t", "\r", "\n", " " };
 
-
         public static void AssertThrowsIfWhitespace(Action<string> action)
         {
             foreach (var control in _stringControls)
@@ -16,5 +15,13 @@ public static void AssertThrowsIfWhitespace(Action<string> action)
                 Assert.Throws<ArgumentException>(() => action(control));
             }
         }
+
+        public static void AssertThrowsIfWhitespace<T>(Func<string, T> action)
+        {
+            foreach (var control in _stringControls)
+            {
+                Assert.Throws<ArgumentException>(() => action(control));
+            }
+        }
     }
 }
diff --git a/wimm.Secundatives.UnitTests/Variant_Test.cs b/wimm.Secundatives.UnitTests/Variant_Test.cs
index 9662069..52820e4 100644
--- a/wimm.Secundatives.UnitTests/Variant_Test.cs
+++ b/wimm.Secundatives.UnitTests/Variant_Test.cs
@@ -90,11 +90,8 @@ private static Variant<int, string> ConstructInt()
             return new Variant<int, string>(42);
         }
 
-
-
         class Base { }
         class Derived : Base { }
         class OtherDerived : Base { }
-
     }
 }
diff --git a/wimm.Secundatives.UnitTests/wimm.Secundatives.UnitTests.csproj b/wimm.Secundatives.UnitTests/wimm.Secundatives.UnitTests.csproj
index e10f72c..845aa9c 100644
--- a/wimm.Secundatives.UnitTests/wimm.Secundatives.UnitTests.csproj
+++ b/wimm.Secundatives.UnitTests/wimm.Secundatives.UnitTests.csproj
@@ -2,7 +2,6 @@
 
   <PropertyGroup>
     <TargetFramework>net6.0</TargetFramework>
-
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
diff --git a/wimm.Secundatives/ApplyFunctionsExtensions/ApplyFunctionsExtensions.cs b/wimm.Secundatives/ApplyFunctionsExtensions/ApplyFunctionsExtensions.cs
index 2964779..4e17d83 100644
--- a/wimm.Secundatives/ApplyFunctionsExtensions/ApplyFunctionsExtensions.cs
+++ b/wimm.Secundatives/ApplyFunctionsExtensions/ApplyFunctionsExtensions.cs
@@ -28,8 +28,10 @@ public static class ApplyFunctionsExtensions
         /// </exception>
         public static TFunc Apply<TArg, TFunc>(this TArg target, Func<TArg, TFunc> fn, bool allowNull = false)
         {
-            if (target == null && !allowNull) throw new ArgumentNullException(nameof(target));
-            if (fn == null) throw new ArgumentNullException(nameof(fn));
+            if (target == null && !allowNull)
+                throw new ArgumentNullException(nameof(target));
+            if (fn == null)
+                throw new ArgumentNullException(nameof(fn));
             return fn(target);
         }
 
@@ -53,8 +55,10 @@ public static TFunc Apply<TArg, TFunc>(this TArg target, Func<TArg, TFunc> fn, b
         /// </exception>
         public static bool In<T>(this T target, IEnumerable<T> enumerable, bool allowNull = false)
         {
-            if (target == null && !allowNull) throw new ArgumentNullException(nameof(target));
-            if (enumerable == null) throw new ArgumentNullException(nameof(enumerable));
+            if (target == null && !allowNull)
+                throw new ArgumentNullException(nameof(target));
+            if (enumerable == null)
+                throw new ArgumentNullException(nameof(enumerable));
             return enumerable.Contains(target, EqualityComparer<T>.Default);
         }
     }
diff --git a/wimm.Secundatives/Extensions/FlattenExtensions.cs b/wimm.Secundatives/Extensions/FlattenExtensions.cs
index 0cad7e3..027cd5f 100644
--- a/wimm.Secundatives/Extensions/FlattenExtensions.cs
+++ b/wimm.Secundatives/Extensions/FlattenExtensions.cs
@@ -17,6 +17,8 @@ public static class FlattenExtensions
         /// The un-nested result of inspecting the outer result for error and returning it if it exists or the nested result itself otherwise 
         /// </returns>
         public static Result<TValue, TErr> Flatten<TValue, TErr>(this Result<Result<TValue, TErr>, TErr> result)
+            where TValue : notnull
+            where TErr : notnull
         {
             return result.IsValue ? result.Value : result.Error;
         }
@@ -31,6 +33,8 @@ public static Result<TValue, TErr> Flatten<TValue, TErr>(this Result<Result<TVal
         /// A task containing the un-nested result of inspecting the outer result for error and returning it if it exists or the nested result itself otherwise 
         /// </returns>
         public static async Task<Result<TValue, TErr>> Flatten<TValue, TErr>(this Task<Result<Result<TValue, TErr>, TErr>> res)
+            where TValue : notnull
+            where TErr : notnull
         {
             var result = await res;
             return result.IsValue ? result.Value : result.Error;
diff --git a/wimm.Secundatives/Extensions/MaybeExtensions.cs b/wimm.Secundatives/Extensions/MaybeExtensions.cs
index 96f1471..89687ce 100644
--- a/wimm.Secundatives/Extensions/MaybeExtensions.cs
+++ b/wimm.Secundatives/Extensions/MaybeExtensions.cs
@@ -20,7 +20,6 @@ public static class MaybeExtensions
         /// <returns> The <typeparamref name="T"/> held within <paramref name="maybe"/> if it exists. </returns>
         public static T Expect<T>(this Maybe<T> maybe) => maybe.Expect($"Expected value in {nameof(Maybe<T>)}");
 
-
         /// Extension to indicate that a value missing from a <see cref="Maybe{T}"/> is unrecoverable. 
         /// Unwraps the <see cref="Maybe{T}"/> if it exists or throws a <see cref="ExpectException"/>
         /// with a custom message.
@@ -54,7 +53,6 @@ public static async Task<T> Expect<T>(this Task<Maybe<T>> maybeTask, string mess
             return (await maybeTask).Expect(message);
         }
 
-
         /// <summary>
         /// Helper function to apply <see cref="Expect{T}(Maybe{T})"/> in async contexts. Awaits the task containing the <see cref="Maybe{T}"/>
         /// and then applies the <see cref="Expect{T}(Maybe{T})"/> function to it.
@@ -68,7 +66,6 @@ public static async Task<T> Expect<T>(this Task<Maybe<T>> maybeTask)
             return (await maybeTask).Expect();
         }
 
-
         /// <summary>
         /// Unwraps the <see cref="Maybe{T}"/> if possible and returns a provided default otherwise
         /// </summary>
@@ -80,7 +77,6 @@ public static async Task<T> Expect<T>(this Task<Maybe<T>> maybeTask)
         /// <paramref name="defaultValue"/> </returns>
         public static T UnwrapOr<T>(this Maybe<T> maybe, T defaultValue) => maybe.Exists ? maybe.Value : defaultValue;
 
-
         /// <summary>
         /// Unwraps the <see cref="Maybe{T}"/> if possible and returns the results of a provided function otherwise
         /// </summary>
@@ -103,7 +99,6 @@ public static async Task<T> Expect<T>(this Task<Maybe<T>> maybeTask)
         /// the result of awaiting the execution of <paramref name="func"/> </returns>
         public static async Task<T> UnwrapOr<T>(this Maybe<T> maybe, Func<Task<T>> func) => maybe.Exists ? maybe.Value : await func();
 
-
         /// <summary>
         /// Unwraps the <see cref="Maybe{T}"/> that results from the <see cref="Task"/> if possible and returns the results of awaiting the provided async function otherwise
         /// </summary>
@@ -160,7 +155,6 @@ public static Maybe<T> AsMaybe<T>(this T? value) where T : struct
             return value.HasValue ? new Maybe<T>(value.Value) : Maybe<T>.None;
         }
 
-
         /// <summary>
         /// Helper function that awaits a <see cref="Task{T}"/>'s result and converts it into a <see cref="Maybe{T}"/>
         /// </summary>
@@ -175,7 +169,6 @@ public static async Task<Maybe<T>> AsMaybe<T>(this Task<T> value) where T : clas
             return (await value).AsMaybe();
         }
 
-
         /// <summary>
         /// Helper function that awaits a <see cref="Task{T}"/>'s nullable result and converts it into a <see cref="Maybe{T}"/>
         /// </summary>
diff --git a/wimm.Secundatives/Extensions/OkOrExtensions.cs b/wimm.Secundatives/Extensions/OkOrExtensions.cs
index 6af815a..839265e 100644
--- a/wimm.Secundatives/Extensions/OkOrExtensions.cs
+++ b/wimm.Secundatives/Extensions/OkOrExtensions.cs
@@ -23,6 +23,8 @@ public static class OkOrExtensions
         /// contains the result of executing <paramref name="func"/>
         /// </returns>
         public static Result<T, TError> OkOr<T, TError>(this Maybe<T> value, Func<TError> func)
+            where T : notnull
+            where TError : notnull
         {
             if (value.Exists)
                 return value.Value;
@@ -30,7 +32,6 @@ public static Result<T, TError> OkOr<T, TError>(this Maybe<T> value, Func<TError
             return func();
         }
 
-
         /// <summary>
         /// Maps a <see cref="Maybe{T}"/> into a <see cref="Result{T, TError}"/> by returning a default value <paramref name="error"/> if
         /// <paramref name="value"/> is None. In the case where <paramref name="value"/> contains a value returns a <see cref="Result{T, TError}"/>
@@ -44,6 +45,8 @@ public static Result<T, TError> OkOr<T, TError>(this Maybe<T> value, Func<TError
         /// contains <paramref name="error"/>
         /// </returns>
         public static Result<T, TError> OkOr<T, TError>(this Maybe<T> value, TError error)
+            where T : notnull
+            where TError : notnull
         {
             if (value.Exists)
                 return value.Value;
@@ -51,7 +54,6 @@ public static Result<T, TError> OkOr<T, TError>(this Maybe<T> value, TError erro
             return error;
         }
 
-
         /// <summary>
         /// Maps a <see cref="Task{T}"/> containing a <see cref="Maybe{T}"/> into a <see cref="Result{T, TError}"/> by returning a default value <paramref name="error"/> if
         /// <paramref name="value"/> is None. In the case where <paramref name="value"/> contains a value returns a <see cref="Result{T, TError}"/>
@@ -65,12 +67,13 @@ public static Result<T, TError> OkOr<T, TError>(this Maybe<T> value, TError erro
         /// contains <paramref name="error"/>
         /// </returns>
         public static async Task<Result<T, TError>> OkOr<T, TError>(this Task<Maybe<T>> value, TError error)
+            where T : notnull
+            where TError : notnull
         {
             var v = await value;
             return v.OkOr(error);
         }
 
-
         /// <summary>
         /// Maps a <see cref="Task{T}"/> containing a <see cref="Maybe{T}"/> into a <see cref="Result{T, TError}"/> by executing <paramref name="func"/> if
         /// <paramref name="value"/> is None. In the case where <paramref name="value"/> contains a value returns a <see cref="Result{T, TError}"/>
@@ -84,13 +87,14 @@ public static async Task<Result<T, TError>> OkOr<T, TError>(this Task<Maybe<T>>
         /// contains the result of executing <paramref name="func"/>
         /// </returns>
         public static async Task<Result<T, TError>> OkOr<T, TError>(this Task<Maybe<T>> value, Func<TError> func)
+            where T : notnull
+            where TError : notnull
         {
             var v = await value;
             return v.OkOr(func);
 
         }
 
-
         /// <summary>
         /// Collapsing mapping of a  <see cref="Task{T}"/> containing a <see cref="Maybe{T}"/> that may hold a <see cref="Result{T,TErr}"/>
         /// into a <see cref="Result{T, TError}"/> 
@@ -103,12 +107,13 @@ public static async Task<Result<T, TError>> OkOr<T, TError>(this Task<Maybe<T>>
         /// <returns> A <see cref="Result{T, TError}"/> either contained by <paramref name="value"/> if it exists or created
         /// from <paramref name="error"/> if it is None</returns>
         public static async Task<Result<T, TError>> OkOr<T, TError>(this Task<Maybe<Result<T, TError>>> value, TError error)
+            where T : notnull
+            where TError : notnull
         {
             var res = await value;
             return res.UnwrapOr(error);
         }
 
-
         /// <summary>
         /// Collapsing mapping of a  <see cref="Task{T}"/> containing a <see cref="Maybe{T}"/> that may hold a <see cref="Result{T,TErr}"/>
         /// into a <see cref="Result{T, TError}"/> 
@@ -121,6 +126,8 @@ public static async Task<Result<T, TError>> OkOr<T, TError>(this Task<Maybe<Resu
         /// <returns> A <see cref="Result{T, TError}"/> either contained by <paramref name="value"/> if it exists or created
         /// from the results of calling <paramref name="func"/> if it is None</returns>
         public static async Task<Result<T, TError>> OkOr<T, TError>(this Task<Maybe<Result<T, TError>>> value, Func<TError> func)
+            where T : notnull
+            where TError : notnull
         {
             var res = await value;
             return res.UnwrapOr(func());
diff --git a/wimm.Secundatives/Extensions/ResultMappingExtensions.cs b/wimm.Secundatives/Extensions/ResultMappingExtensions.cs
index f5d8647..7abedee 100644
--- a/wimm.Secundatives/Extensions/ResultMappingExtensions.cs
+++ b/wimm.Secundatives/Extensions/ResultMappingExtensions.cs
@@ -26,6 +26,9 @@ public static class ResultMappingExtensions
         /// if it exists. Otherwise returns a <see cref="Result{U, TError}"/> containing the <typeparamref name="TError"/> contained within 
         /// <paramref name="result"/></returns>
         public static Result<U, TError> Map<T, U, TError>(this Result<T, TError> result, Func<T, U> func)
+            where T : notnull
+            where U : notnull
+            where TError : notnull
         {
             if (result.IsValue)
                 return func(result.Value);
@@ -33,7 +36,6 @@ public static Result<U, TError> Map<T, U, TError>(this Result<T, TError> result,
             return result.Error;
         }
 
-
         /// <summary>
         /// Transforms a <see cref="Result{T, TError}"/> into a <see cref="Result{U, TError}"/> by applying an async  function if the mapped
         /// <see cref="Result{T, TError}"/> contains a value otherwise by constructing a new <see cref="Result{U, TError}"/> from the 
@@ -51,6 +53,9 @@ public static Result<U, TError> Map<T, U, TError>(this Result<T, TError> result,
         /// if it exists. Otherwise returns a <see cref="Result{U, TError}"/> containing the <typeparamref name="TError"/> contained within 
         /// <paramref name="result"/></returns>
         public static async Task<Result<U, TError>> Map<T, U, TError>(this Result<T, TError> result, Func<T, Task<U>> func)
+            where T : notnull
+            where U : notnull
+            where TError : notnull
         {
             if (result.IsValue)
                 return await func(result.Value);
@@ -73,12 +78,14 @@ public static async Task<Result<U, TError>> Map<T, U, TError>(this Result<T, TEr
         /// <paramref name="result"/>if it exists. Otherwise returns a <see cref="Result{U, TError}"/> containing the 
         /// <typeparamref name="TError"/> contained within <paramref name="result"/></returns>
         public static async Task<Result<U, TError>> Map<T, U, TError>(this Task<Result<T, TError>> result, Func<T, U> func)
+            where T : notnull
+            where U : notnull
+            where TError : notnull
         {
             var val = await result;
             return val.Map(func);
         }
 
-
         /// <summary>
         /// Asynchronously transforms a <see cref="Result{T, TError}"/> into a <see cref="Result{U, TError}"/> by applying an async function and collapsing
         /// the result if the mapped  <see cref="Result{T, TError}"/> contains a value otherwise by constructing a new 
@@ -95,13 +102,15 @@ public static async Task<Result<U, TError>> Map<T, U, TError>(this Task<Result<T
         /// obtained by awaiting <paramref name="result"/> if it exists. Otherwise returns a <see cref="Result{U, TError}"/> containing the
         /// <typeparamref name="TError"/> contained within  <paramref name="result"/></returns>
         public static async Task<Result<U, TError>> Map<T, U, TError>(this Task<Result<T, TError>> result, Func<T, Task<U>> func)
+            where T : notnull
+            where U : notnull
+            where TError : notnull
         {
 
             var res = await result;
             return await res.Map(func);
         }
 
-
         /// <summary>
         /// Asynchronously transforms a <see cref="Result{T, TError}"/> into a <see cref="Result{U, TError}"/> by applying an async function and collapsing
         /// the result if the mapped  <see cref="Result{T, TError}"/> contains a value otherwise by constructing a new 
@@ -119,6 +128,9 @@ public static async Task<Result<U, TError>> Map<T, U, TError>(this Task<Result<T
         /// if it exists. Otherwise returns a <see cref="Result{U, TError}"/> containing the <typeparamref name="TError"/> contained within 
         /// <paramref name="result"/></returns>
         public static async Task<Result<U, TError>> Map<T, U, TError>(this Result<T, TError> result, Func<T, Task<Result<U, TError>>> func)
+            where T : notnull
+            where U : notnull
+            where TError : notnull
         {
             if (result.IsValue)
                 return await func(result.Value);
@@ -126,7 +138,6 @@ public static async Task<Result<U, TError>> Map<T, U, TError>(this Result<T, TEr
             return result.Error;
         }
 
-
         /// <summary>
         /// Asynchronously transforms a <see cref="Result{T, TError}"/> into a <see cref="Result{U, TError}"/> by applying an async function and collapsing
         /// the result if the mapped  <see cref="Result{T, TError}"/> contains a value otherwise by constructing a new 
@@ -144,6 +155,9 @@ public static async Task<Result<U, TError>> Map<T, U, TError>(this Result<T, TEr
         /// if it exists. Otherwise returns a <see cref="Result{U, TError}"/> containing the <typeparamref name="TError"/> contained within 
         /// <paramref name="result"/></returns>
         public static async Task<Result<U, TError>> Map<T, U, TError>(this Task<Result<T, TError>> result, Func<T, Task<Result<U, TError>>> func)
+            where T : notnull
+            where U : notnull
+            where TError : notnull
         {
             var res = await result;
             if (res.IsValue)
@@ -152,7 +166,6 @@ public static async Task<Result<U, TError>> Map<T, U, TError>(this Task<Result<T
             return res.Error;
         }
 
-
         /// <summary>
         /// Transforms a <see cref="Result{T, TError}"/> into a <see cref="Result{T, UError}"/> by applying a function if the mapped 
         /// <see cref="Result{T, TError}"/> contains a <typeparamref name="UError"/>. Otherwise constructs a new 
@@ -169,6 +182,9 @@ public static async Task<Result<U, TError>> Map<T, U, TError>(this Task<Result<T
         /// <typeparamref name="TError"/> of <paramref name="result"/> if it exists. Otherwise returns a <see cref="Result{T, UError}"/> 
         /// containing the <typeparamref name="T"/> contained within <paramref name="result"/></returns>
         public static Result<T, UError> MapError<T, TError, UError>(this Result<T, TError> result, Func<TError, UError> func)
+            where T : notnull
+            where TError : notnull
+            where UError : notnull
         {
             if (result.IsError)
                 return func(result.Error);
@@ -176,7 +192,6 @@ public static Result<T, UError> MapError<T, TError, UError>(this Result<T, TErro
             return result.Value;
         }
 
-
         /// <summary>
         /// Asynchronously transforms a <see cref="Result{T, TError}"/> into a <see cref="Result{T, UError}"/> by applying a function if the mapped 
         /// <see cref="Result{T, TError}"/> contains a <typeparamref name="UError"/>. Otherwise constructs a new 
@@ -193,6 +208,9 @@ public static Result<T, UError> MapError<T, TError, UError>(this Result<T, TErro
         /// <typeparamref name="TError"/> of <paramref name="result"/> if it exists. Otherwise returns a <see cref="Result{T, UError}"/> 
         /// containing the <typeparamref name="T"/> contained within <paramref name="result"/></returns>
         public static async Task<Result<T, UError>> MapError<T, TError, UError>(this Task<Result<T, TError>> result, Func<TError, UError> func)
+            where T : notnull
+            where TError : notnull
+            where UError : notnull
         {
             var val = await result;
             return val.MapError(func);
@@ -214,6 +232,9 @@ public static async Task<Result<T, UError>> MapError<T, TError, UError>(this Tas
         /// name="result"/> or by calling <paramref name="errorFunc"/> on the error from <paramref name="result"/>
         /// </returns>
         public static U MapOr<T, U, TError>(this Result<T, TError> result, Func<T, U> valueFunc, Func<TError, U> errorFunc)
+            where T : notnull
+            where U : notnull
+            where TError : notnull
         {
             return result.IsValue ? valueFunc(result.Value) : errorFunc(result.Error);
         }
@@ -234,6 +255,9 @@ public static U MapOr<T, U, TError>(this Result<T, TError> result, Func<T, U> va
         /// name="result"/> or by calling <paramref name="errorFunc"/> on the error from <paramref name="result"/>
         /// </returns>
         public static async Task<U> MapOr<T, U, TError>(this Task<Result<T, TError>> result, Func<T, U> valueFunc, Func<TError, U> errorFunc)
+            where T : notnull
+            where U : notnull
+            where TError : notnull
         {
             var res = await result;
             return res.IsValue ? valueFunc(res.Value) : errorFunc(res.Error);
diff --git a/wimm.Secundatives/Extensions/VariantExtensions.cs b/wimm.Secundatives/Extensions/VariantExtensions.cs
index d8acad0..99cbd1c 100644
--- a/wimm.Secundatives/Extensions/VariantExtensions.cs
+++ b/wimm.Secundatives/Extensions/VariantExtensions.cs
@@ -24,8 +24,11 @@ public static class VariantExtensions
         /// contains a value of type <typeparamref name="U"/>
         /// </returns>
         public static W MapValue<T, U, W>(this Variant<T, U> variant, Func<T, W> tMapping, Func<U, W> uMapping)
-            => variant.Is<T>() ? tMapping(variant.Get<T>()) : uMapping(variant.Get<U>());
+            where T : notnull
+            where U : notnull
+            where W : notnull
 
+            => variant.Is<T>() ? tMapping(variant.Get<T>()) : uMapping(variant.Get<U>());
 
         /// <summary>
         /// Maps the contents of a variant to an action taking that type. Executes the function matching the type of the value
@@ -42,6 +45,8 @@ public static W MapValue<T, U, W>(this Variant<T, U> variant, Func<T, W> tMappin
         /// is <typeparamref name="U"/>
         /// </param>
         public static void MapAction<T, U>(this Variant<T, U> variant, Action<T> tAction, Action<U> uAction)
+            where T : notnull
+            where U : notnull
         {
             if (variant.Is<T>())
                 tAction(variant.Get<T>());
diff --git a/wimm.Secundatives/Maybe.cs b/wimm.Secundatives/Maybe.cs
index 20006e2..85495a7 100644
--- a/wimm.Secundatives/Maybe.cs
+++ b/wimm.Secundatives/Maybe.cs
@@ -11,7 +11,7 @@ public static class Maybe
         /// <summary>
         /// A static instance of None to reduce memory pressure and to facilitate simple conversions
         /// </summary>
-        public static readonly None None = new None();
+        public static readonly None None = new();
     }
 
     /// <summary>
@@ -63,9 +63,9 @@ public Maybe(T value)
 
         public static bool operator !=(Maybe<T> left, Maybe<T> right) => !left.Equals(right);
 
-        public override bool Equals(object obj)
+        public override bool Equals(object? obj)
         {
-            if (!(obj is Maybe<T> maybe))
+            if (obj is not Maybe<T> maybe)
                 return false;
 
             return Equals(maybe);
@@ -77,9 +77,9 @@ public bool Equals(Maybe<T> other)
                 && EqualityComparer<T>.Default.Equals(_value, other._value);
         }
 
-        public static implicit operator Maybe<T>(T value) => new Maybe<T>(value);
+        public static implicit operator Maybe<T>(T value) => new(value);
 
-        public static implicit operator Maybe<T>(None _) => new Maybe<T>();
+        public static implicit operator Maybe<T>(None _) => new();
 
 #pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
 
diff --git a/wimm.Secundatives/NaturalRange.cs b/wimm.Secundatives/NaturalRange.cs
index 8545f54..1494820 100644
--- a/wimm.Secundatives/NaturalRange.cs
+++ b/wimm.Secundatives/NaturalRange.cs
@@ -11,7 +11,6 @@ public class NaturalRange : IRange<int>
         private const string _outOfRangeMessage = "Must be greater than or equal to zero.";
         private readonly Range<int> _range;
 
-
         /// <summary>
         /// <see cref="Range{T}.Max"/>
         /// </summary>
@@ -41,8 +40,10 @@ public NaturalRange(int max) : this(0, max) { }
         /// </exception>
         public NaturalRange(int min, int max)
         {
-            if (min < 0) throw new ArgumentOutOfRangeException(nameof(min), _outOfRangeMessage);
-            if (max < 0) throw new ArgumentOutOfRangeException(nameof(max), _outOfRangeMessage);
+            if (min < 0) 
+                throw new ArgumentOutOfRangeException(nameof(min), _outOfRangeMessage);
+            if (max < 0) 
+                throw new ArgumentOutOfRangeException(nameof(max), _outOfRangeMessage);
 
             if (max < min)
                 throw new ArgumentException(
diff --git a/wimm.Secundatives/Range.cs b/wimm.Secundatives/Range.cs
index 60e2e45..87600f8 100644
--- a/wimm.Secundatives/Range.cs
+++ b/wimm.Secundatives/Range.cs
@@ -26,8 +26,8 @@ public class Range<T> : IRange<T> where T : IComparable<T>
         /// </exception>
         public Range(T min, T max)
         {
-            Min = Require(min, nameof(min));
-            Max = Require(max, nameof(max));
+            Min = Range<T>.Require(min, nameof(min));
+            Max = Range<T>.Require(max, nameof(max));
 
             if (max.CompareTo(min) < 0)
                 throw new ArgumentException(
@@ -41,14 +41,15 @@ public Range(T min, T max)
         /// <returns> <c>true</c> if <paramref name="value"/> is greater than <see cref="Max"/> and less than <see cref="Max"/> </returns>
         public bool Includes(T value)
         {
-            Require(value, nameof(value));
+            Range<T>.Require(value, nameof(value));
 
             return !(Min.CompareTo(value) > 0 || Max.CompareTo(value) < 0);
         }
 
-        private T Require(T value, string name)
+        private static T Require(T value, string name)
         {
-            if (value == null) throw new ArgumentNullException(name);
+            if (value == null) 
+                throw new ArgumentNullException(name);
             return value;
         }
     }
diff --git a/wimm.Secundatives/Result.cs b/wimm.Secundatives/Result.cs
index 78396a8..b110456 100644
--- a/wimm.Secundatives/Result.cs
+++ b/wimm.Secundatives/Result.cs
@@ -9,6 +9,8 @@ namespace wimm.Secundatives
     /// <typeparam name="T"></typeparam>
     /// <typeparam name="TError"></typeparam>
     public class Result<T, TError> : Variant<T, TError>
+        where T : notnull
+        where TError : notnull
     {
         /// <summary> A value indicating whether the operation resulted in an error type </summary>
         public bool IsError => Is<TError>();
@@ -16,7 +18,6 @@ public class Result<T, TError> : Variant<T, TError>
         /// <summary> A value indicating if the operation successfully returned a value </summary>
         public bool IsValue => Is<T>();
 
-
         /// <summary> Gets the value contained in the result. </summary>
         /// <exception cref="InvalidOperationException"> The result contains no value - operation failed </exception>
         public T Value => Get<T>();
@@ -47,19 +48,18 @@ public Result(TError err) : base(err)
 
         //CN(justification): These operators are trivial and their documentation would just be code bloat
 #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
-        public static implicit operator Result<T, TError>(T value) => new Result<T, TError>(value);
-        public static implicit operator Result<T, TError>(TError error) => new Result<T, TError>(error);
+        public static implicit operator Result<T, TError>(T value) => new(value);
+        public static implicit operator Result<T, TError>(TError error) => new(error);
 #pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
     }
 
-
-
     /// <summary>
     /// A basic Result class that handles operations with a possibility of failure that uses a special error class to 
     /// report failure
     /// </summary>
     /// <typeparam name="T"> The type to be returned on success </typeparam>
     public class Result<T> : Result<T, Error>
+        where T : notnull
     {
 
         /// <summary>
@@ -78,9 +78,8 @@ public Result(Error err) : base(err)
 
         //CN(justification): These operators are trivial and their documentation would just be code bloat
 #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
-        public static implicit operator Result<T>(T value) => new Result<T>(value);
-        public static implicit operator Result<T>(Error error) => new Result<T>(error);
+        public static implicit operator Result<T>(T value) => new(value);
+        public static implicit operator Result<T>(Error error) => new(error);
 #pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
     }
-
 }
diff --git a/wimm.Secundatives/Variant.cs b/wimm.Secundatives/Variant.cs
index 67ebc94..4028fca 100644
--- a/wimm.Secundatives/Variant.cs
+++ b/wimm.Secundatives/Variant.cs
@@ -6,7 +6,9 @@ namespace wimm.Secundatives
     /// <summary>
     /// A typesafe union that contains either a <typeparamref name="T"/> or a <typeparamref name="U"/>
     /// </summary>
-    public class Variant<T, U>
+    public class Variant<T, U> 
+        where T : notnull
+        where U : notnull
     {
         /// <summary>
         /// Ensures that <typeparamref name="U"/> and <typeparamref name="T"/> are not within the same
@@ -41,7 +43,7 @@ public bool Is<W>()
         {
             var wType = typeof(W);
 
-            if (!IsAssignableFromMemberType(wType))
+            if (!Variant<T, U>.IsAssignableFromMemberType(wType))
                 throw UnsupportedType(wType, new List<Type> { typeof(T), typeof(U) });
 
             return _value is W;
@@ -80,12 +82,11 @@ public Variant(U value)
 
         //CN(justification): These operators are trivial and their documentation would just be code bloat
 #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
-        public static implicit operator Variant<T, U>(T val) => new Variant<T, U>(val);
-        public static implicit operator Variant<T, U>(U val) => new Variant<T, U>(val);
+        public static implicit operator Variant<T, U>(T val) => new(val);
+        public static implicit operator Variant<T, U>(U val) => new(val);
 #pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
 
-
-        private bool IsAssignableFromMemberType(Type type)
+        private static bool IsAssignableFromMemberType(Type type)
         {
             return typeof(U).IsAssignableFrom(type) || typeof(T).IsAssignableFrom(type);
         }
@@ -101,10 +102,5 @@ private static NotSupportedException UnsupportedType(Type expected, IEnumerable<
             return new NotSupportedException(
                 $"Variant was checked for type it cannot contain:\nRequested:{expected}\nAvailable: {string.Join("\n", available)}");
         }
-
-
-
     }
-
-
 }
diff --git a/wimm.Secundatives/wimm.Secundatives.csproj b/wimm.Secundatives/wimm.Secundatives.csproj
index 7616ed5..eabca77 100644
--- a/wimm.Secundatives/wimm.Secundatives.csproj
+++ b/wimm.Secundatives/wimm.Secundatives.csproj
@@ -11,16 +11,7 @@
     <RepositoryUrl>https://github.com/wareismymind/secundatives</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
     <IncludeSymbols>true</IncludeSymbols>
+	<TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+	  <Nullable>enable</Nullable>
   </PropertyGroup>
-
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
-    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-    <NoWarn>1591</NoWarn>
-    <WarningsAsErrors />
-  </PropertyGroup>
-
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
-    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-  </PropertyGroup>
-
 </Project>