diff --git a/appveyor.yml b/appveyor.yml
index f742bab..4335e77 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -110,7 +110,6 @@ deploy:
     api_key:
       secure: H9AFeC6uNE88rUiZxmDQNt50bhQ0ilMCua/X9s1++dNB0wMHWrKY8xjfM/M2xFja
     on:
-      branch: master
       configuration: Release
       APPVEYOR_REPO_TAG: true
 # GitHub
@@ -124,6 +123,5 @@ deploy:
     prerelease: false
     force_update: true
     on:
-      branch: master
       configuration: Release
       APPVEYOR_REPO_TAG: true
\ No newline at end of file
diff --git a/src/Here/Either/Either.Constructor.cs b/src/Here/Either/Either.Constructor.cs
index aa0eb91..0576f81 100644
--- a/src/Here/Either/Either.Constructor.cs
+++ b/src/Here/Either/Either.Constructor.cs
@@ -20,7 +20,7 @@ public static class Either
         /// <returns>An <see cref="Either{TLeft, TRight}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="value"/> is null.</exception>
         [PublicAPI, Pure]
-        public static Either<TLeft, TRight> Left<TLeft, TRight>([NotNull] in TLeft value)
+        public static Either<TLeft, TRight> Left<TLeft, TRight>([NotNull] TLeft value)
         {
             return Either<TLeft, TRight>.Left(value);
         }
@@ -34,7 +34,7 @@ public static Either<TLeft, TRight> Left<TLeft, TRight>([NotNull] in TLeft value
         /// <returns>An <see cref="Either{TLeft, TRight}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="nullable"/> is null.</exception>
         [PublicAPI, Pure]
-        public static Either<TLeft, TRight> Left<TLeft, TRight>([NotNull] in TLeft? nullable)
+        public static Either<TLeft, TRight> Left<TLeft, TRight>([NotNull] TLeft? nullable)
             where TLeft : struct
         {
             if (nullable == null)
@@ -65,7 +65,7 @@ public static Either<TLeft, TRight> ToEither<TLeft, TRight>([NotNull] this TLeft
         /// <returns>An <see cref="Either{TLeft, TRight}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="nullable"/> is null.</exception>
         [PublicAPI, Pure]
-        public static Either<TLeft, TRight> ToEither<TLeft, TRight>([NotNull] in this TLeft? nullable)
+        public static Either<TLeft, TRight> ToEither<TLeft, TRight>([NotNull] this TLeft? nullable)
             where TLeft : struct
         {
             return Left<TLeft, TRight>(nullable);
@@ -79,7 +79,7 @@ public static Either<TLeft, TRight> ToEither<TLeft, TRight>([NotNull] in this TL
         /// <returns>An <see cref="EitherLeft{TLeft}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="value"/> is null.</exception>
         [PublicAPI, Pure]
-        public static EitherLeft<TLeft> Left<TLeft>([NotNull] in TLeft value)
+        public static EitherLeft<TLeft> Left<TLeft>([NotNull] TLeft value)
         {
             return new EitherLeft<TLeft>(value);
         }
@@ -92,7 +92,7 @@ public static EitherLeft<TLeft> Left<TLeft>([NotNull] in TLeft value)
         /// <returns>An <see cref="EitherLeft{TLeft}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="nullable"/> is null.</exception>
         [PublicAPI, Pure]
-        public static EitherLeft<TLeft> Left<TLeft>([NotNull] in TLeft? nullable)
+        public static EitherLeft<TLeft> Left<TLeft>([NotNull] TLeft? nullable)
             where TLeft : struct
         {
             if (nullable == null)
@@ -113,7 +113,7 @@ public static EitherLeft<TLeft> Left<TLeft>([NotNull] in TLeft? nullable)
         /// <returns>An <see cref="Either{TLeft, TRight}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="value"/> is null.</exception>
         [PublicAPI, Pure]
-        public static Either<TLeft, TRight> Right<TLeft, TRight>([NotNull] in TRight value)
+        public static Either<TLeft, TRight> Right<TLeft, TRight>([NotNull] TRight value)
         {
             return Either<TLeft, TRight>.Right(value);
         }
@@ -127,7 +127,7 @@ public static Either<TLeft, TRight> Right<TLeft, TRight>([NotNull] in TRight val
         /// <returns>An <see cref="Either{TLeft, TRight}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="nullable"/> is null.</exception>
         [PublicAPI, Pure]
-        public static Either<TLeft, TRight> Right<TLeft, TRight>([NotNull] in TRight? nullable)
+        public static Either<TLeft, TRight> Right<TLeft, TRight>([NotNull] TRight? nullable)
             where TRight : struct
         {
             if (nullable == null)
@@ -158,7 +158,7 @@ public static Either<TLeft, TRight> ToEither<TLeft, TRight>([NotNull] this TRigh
         /// <returns>An <see cref="Either{TLeft, TRight}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="nullable"/> is null.</exception>
         [PublicAPI, Pure]
-        public static Either<TLeft, TRight> ToEither<TLeft, TRight>([NotNull] in this TRight? nullable)
+        public static Either<TLeft, TRight> ToEither<TLeft, TRight>([NotNull] this TRight? nullable)
             where TRight : struct
         {
             return Right<TLeft, TRight>(nullable);
@@ -172,7 +172,7 @@ public static Either<TLeft, TRight> ToEither<TLeft, TRight>([NotNull] in this TR
         /// <returns>An <see cref="EitherRight{TRight}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="value"/> is null.</exception>
         [PublicAPI, Pure]
-        public static EitherRight<TRight> Right<TRight>([NotNull] in TRight value)
+        public static EitherRight<TRight> Right<TRight>([NotNull] TRight value)
         {
             return new EitherRight<TRight>(value);
         }
@@ -185,7 +185,7 @@ public static EitherRight<TRight> Right<TRight>([NotNull] in TRight value)
         /// <returns>An <see cref="EitherRight{TRight}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="nullable"/> is null.</exception>
         [PublicAPI, Pure]
-        public static EitherRight<TRight> Right<TRight>([NotNull] in TRight? nullable)
+        public static EitherRight<TRight> Right<TRight>([NotNull] TRight? nullable)
             where TRight : struct
         {
             if (nullable == null)
@@ -209,7 +209,7 @@ public static EitherRight<TRight> Right<TRight>([NotNull] in TRight? nullable)
         /// <returns>An <see cref="Either{TLeft, TRight}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="defaultLeftValue"/> is null.</exception>
         [PublicAPI, Pure]
-        public static Either<TLeft, TRight> ToEither<TLeft, TRight>([CanBeNull] this TRight value, [NotNull] in TLeft defaultLeftValue)
+        public static Either<TLeft, TRight> ToEither<TLeft, TRight>([CanBeNull] this TRight value, [NotNull] TLeft defaultLeftValue)
             where TRight : class
         {
             Throw.IfArgumentNull(defaultLeftValue, nameof(defaultLeftValue));
@@ -232,7 +232,7 @@ public static Either<TLeft, TRight> ToEither<TLeft, TRight>([CanBeNull] this TRi
         /// <exception cref="ArgumentNullException">If the <paramref name="leftValueFactory"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the value returned by the <paramref name="leftValueFactory"/> is null.</exception>
         [PublicAPI, Pure]
-        public static Either<TLeft, TRight> ToEither<TLeft, TRight>([CanBeNull] this TRight value, [NotNull, InstantHandle] in Func<TLeft> leftValueFactory)
+        public static Either<TLeft, TRight> ToEither<TLeft, TRight>([CanBeNull] this TRight value, [NotNull, InstantHandle] Func<TLeft> leftValueFactory)
             where TRight : class
         {
             Throw.IfArgumentNull(leftValueFactory, nameof(leftValueFactory));
@@ -254,7 +254,7 @@ public static Either<TLeft, TRight> ToEither<TLeft, TRight>([CanBeNull] this TRi
         /// <returns>An <see cref="Either{TLeft, TRight}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="defaultLeftValue"/> is null.</exception>
         [PublicAPI, Pure]
-        public static Either<TLeft, TRight> ToEither<TLeft, TRight>([CanBeNull] in this TRight? nullable, [NotNull] in TLeft defaultLeftValue)
+        public static Either<TLeft, TRight> ToEither<TLeft, TRight>([CanBeNull] this TRight? nullable, [NotNull] TLeft defaultLeftValue)
             where TRight : struct
         {
             Throw.IfArgumentNull(defaultLeftValue, nameof(defaultLeftValue));
@@ -277,7 +277,7 @@ public static Either<TLeft, TRight> ToEither<TLeft, TRight>([CanBeNull] in this
         /// <exception cref="ArgumentNullException">If the <paramref name="leftValueFactory"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the value returned by the <paramref name="leftValueFactory"/> is null.</exception>
         [PublicAPI, Pure]
-        public static Either<TLeft, TRight> ToEither<TLeft, TRight>([CanBeNull] in this TRight? nullable, [NotNull, InstantHandle] in Func<TLeft> leftValueFactory)
+        public static Either<TLeft, TRight> ToEither<TLeft, TRight>([CanBeNull] this TRight? nullable, [NotNull, InstantHandle] Func<TLeft> leftValueFactory)
             where TRight : struct
         {
             Throw.IfArgumentNull(leftValueFactory, nameof(leftValueFactory));
diff --git a/src/Here/Either/Either.Operations.cs b/src/Here/Either/Either.Operations.cs
index b9d7a85..3bf58b7 100644
--- a/src/Here/Either/Either.Operations.cs
+++ b/src/Here/Either/Either.Operations.cs
@@ -25,9 +25,9 @@ public partial struct Either<TLeft, TRight>
         /// <exception cref="InvalidOperationException">If this <see cref="Either{TLeft,TRight}"/> is in <see cref="EitherStates.None"/> state without providing a <paramref name="none"/> action.</exception>
         [PublicAPI, Pure]
         public Unit Match(
-            [NotNull, InstantHandle] in Action<TRight> onRight,
-            [NotNull, InstantHandle] in Action<TLeft> onLeft,
-            [CanBeNull, InstantHandle] in Action none = null)
+            [NotNull, InstantHandle] Action<TRight> onRight,
+            [NotNull, InstantHandle] Action<TLeft> onLeft,
+            [CanBeNull, InstantHandle] Action none = null)
         {
             Throw.IfArgumentNull(onRight, nameof(onRight));
             Throw.IfArgumentNull(onLeft, nameof(onLeft));
@@ -64,9 +64,9 @@ public Unit Match(
         /// <exception cref="InvalidOperationException">If this <see cref="Either{TLeft,TRight}"/> is in <see cref="EitherStates.None"/> state without providing a <paramref name="none"/> action.</exception>
         [PublicAPI, CanBeNull, Pure]
         public TOut MatchNullable<TOut>(
-            [NotNull, InstantHandle] in Func<TRight, TOut> onRight,
-            [NotNull, InstantHandle] in Func<TLeft, TOut> onLeft,
-            [CanBeNull, InstantHandle] in Func<TOut> none = null)
+            [NotNull, InstantHandle] Func<TRight, TOut> onRight,
+            [NotNull, InstantHandle] Func<TLeft, TOut> onLeft,
+            [CanBeNull, InstantHandle] Func<TOut> none = null)
         {
             Throw.IfArgumentNull(onRight, nameof(onRight));
             Throw.IfArgumentNull(onLeft, nameof(onLeft));
@@ -99,9 +99,9 @@ public TOut MatchNullable<TOut>(
         /// <exception cref="NullResultException">If the result of the match is null.</exception>
         [PublicAPI, NotNull, Pure]
         public TOut Match<TOut>(
-            [NotNull, InstantHandle] in Func<TRight, TOut> onRight,
-            [NotNull, InstantHandle] in Func<TLeft, TOut> onLeft,
-            [CanBeNull, InstantHandle] in Func<TOut> none = null)
+            [NotNull, InstantHandle] Func<TRight, TOut> onRight,
+            [NotNull, InstantHandle] Func<TLeft, TOut> onLeft,
+            [CanBeNull, InstantHandle] Func<TOut> none = null)
         {
             TOut result = MatchNullable(onRight, onLeft, none);
             return Throw.IfResultNull(result);
@@ -369,7 +369,7 @@ public TState BiFold<TState>(
         /// <returns>The result of the applied treatment.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onLeft"/> is null.</exception>
         [PublicAPI]
-        public Unit IfLeft([NotNull, InstantHandle] in Action<TLeft> onLeft)
+        public Unit IfLeft([NotNull, InstantHandle] Action<TLeft> onLeft)
         {
             return Match(DoNothing, onLeft, DoNothing);
         }
@@ -384,7 +384,7 @@ public Unit IfLeft([NotNull, InstantHandle] in Action<TLeft> onLeft)
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        public Unit IfFailure([NotNull, InstantHandle] in Action<TLeft> onFailure)
+        public Unit IfFailure([NotNull, InstantHandle] Action<TLeft> onFailure)
         {
             return IfLeft(onFailure);
         }
@@ -501,7 +501,7 @@ public TOut IfLeft<TOut>(
         /// <returns>This <see cref="Either{TLeft,TRight}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onLeft"/> is null.</exception>
         [PublicAPI]
-        public Either<TLeft, TRight> OnLeft([NotNull, InstantHandle] in Action<TLeft> onLeft)
+        public Either<TLeft, TRight> OnLeft([NotNull, InstantHandle] Action<TLeft> onLeft)
         {
             Throw.IfArgumentNull(onLeft, nameof(onLeft));
 
@@ -520,7 +520,7 @@ public Either<TLeft, TRight> OnLeft([NotNull, InstantHandle] in Action<TLeft> on
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        public Either<TLeft, TRight> OnFailure([NotNull, InstantHandle] in Action<TLeft> onFailure)
+        public Either<TLeft, TRight> OnFailure([NotNull, InstantHandle] Action<TLeft> onFailure)
         {
             return OnLeft(onFailure);
         }
@@ -536,7 +536,7 @@ public Either<TLeft, TRight> OnFailure([NotNull, InstantHandle] in Action<TLeft>
         /// <returns>A <see cref="Unit"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onRight"/> is null.</exception>
         [PublicAPI]
-        public Unit IfRight([NotNull, InstantHandle] in Action<TRight> onRight)
+        public Unit IfRight([NotNull, InstantHandle] Action<TRight> onRight)
         {
             return Match(onRight, DoNothing, DoNothing);
         }
@@ -551,7 +551,7 @@ public Unit IfRight([NotNull, InstantHandle] in Action<TRight> onRight)
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        public Unit IfSuccess([NotNull, InstantHandle] in Action<TRight> onSuccess)
+        public Unit IfSuccess([NotNull, InstantHandle] Action<TRight> onSuccess)
         {
             return IfRight(onSuccess);
         }
@@ -668,7 +668,7 @@ public TOut IfRight<TOut>(
         /// <returns>This <see cref="Either{TLeft,TRight}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onRight"/> is null.</exception>
         [PublicAPI]
-        public Either<TLeft, TRight> OnRight([NotNull, InstantHandle] in Action<TRight> onRight)
+        public Either<TLeft, TRight> OnRight([NotNull, InstantHandle] Action<TRight> onRight)
         {
             Throw.IfArgumentNull(onRight, nameof(onRight));
 
@@ -687,7 +687,7 @@ public Either<TLeft, TRight> OnRight([NotNull, InstantHandle] in Action<TRight>
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        public Either<TLeft, TRight> OnSuccess([NotNull, InstantHandle] in Action<TRight> onSuccess)
+        public Either<TLeft, TRight> OnSuccess([NotNull, InstantHandle] Action<TRight> onSuccess)
         {
             return OnRight(onSuccess);
         }
@@ -707,8 +707,8 @@ public Either<TLeft, TRight> OnSuccess([NotNull, InstantHandle] in Action<TRight
         /// <exception cref="ArgumentNullException">If the <paramref name="onLeft"/> is null.</exception>
         [PublicAPI]
         public Either<TLeft, TRight> OnRightOrLeft(
-            [NotNull, InstantHandle] in Action<TRight> onRight,
-            [NotNull, InstantHandle] in Action<TLeft> onLeft)
+            [NotNull, InstantHandle] Action<TRight> onRight,
+            [NotNull, InstantHandle] Action<TLeft> onLeft)
         {
             Throw.IfArgumentNull(onRight, nameof(onRight));
             Throw.IfArgumentNull(onLeft, nameof(onLeft));
@@ -739,8 +739,8 @@ public Either<TLeft, TRight> OnRightOrLeft(
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
         public Either<TLeft, TRight> OnSuccessOrFailure(
-            [NotNull, InstantHandle] in Action<TRight> onSuccess,
-            [NotNull, InstantHandle] in Action<TLeft> onFailure)
+            [NotNull, InstantHandle] Action<TRight> onSuccess,
+            [NotNull, InstantHandle] Action<TLeft> onFailure)
         {
             return OnRightOrLeft(onSuccess, onFailure);
         }
@@ -768,7 +768,7 @@ public TRight RightOrDefault()
         /// <returns>The either right value, otherwise the provided default value.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="defaultValue"/> is null.</exception>
         [PublicAPI, Pure, NotNull]
-        public TRight RightOr([NotNull] in TRight defaultValue)
+        public TRight RightOr([NotNull] TRight defaultValue)
         {
             Throw.IfArgumentNull(defaultValue, nameof(defaultValue));
 
@@ -790,7 +790,7 @@ public TRight RightOr([NotNull] in TRight defaultValue)
         /// <exception cref="ArgumentNullException">If the <paramref name="valueFactory"/> is null.</exception>
         /// <exception cref="NullResultException">If the result of the <paramref name="valueFactory"/> function is null.</exception>
         [PublicAPI, Pure, NotNull]
-        public TRight RightOr([NotNull, InstantHandle] in Func<TRight> valueFactory)
+        public TRight RightOr([NotNull, InstantHandle] Func<TRight> valueFactory)
         {
             Throw.IfArgumentNull(valueFactory, nameof(valueFactory));
 
@@ -823,7 +823,7 @@ public TLeft LeftOrDefault()
         /// <returns>The either left value, otherwise the provided default value.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="defaultValue"/> is null.</exception>
         [PublicAPI, Pure, NotNull]
-        public TLeft LeftOr([NotNull] in TLeft defaultValue)
+        public TLeft LeftOr([NotNull] TLeft defaultValue)
         {
             Throw.IfArgumentNull(defaultValue, nameof(defaultValue));
 
@@ -845,7 +845,7 @@ public TLeft LeftOr([NotNull] in TLeft defaultValue)
         /// <exception cref="ArgumentNullException">If the <paramref name="valueFactory"/> is null.</exception>
         /// <exception cref="NullResultException">If the result of the <paramref name="valueFactory"/> function is null.</exception>
         [PublicAPI, Pure, NotNull]
-        public TLeft LeftOr([NotNull, InstantHandle] in Func<TLeft> valueFactory)
+        public TLeft LeftOr([NotNull, InstantHandle] Func<TLeft> valueFactory)
         {
             Throw.IfArgumentNull(valueFactory, nameof(valueFactory));
 
diff --git a/src/Here/Either/Either.cs b/src/Here/Either/Either.cs
index 912db70..b20679c 100644
--- a/src/Here/Either/Either.cs
+++ b/src/Here/Either/Either.cs
@@ -16,7 +16,7 @@ namespace Here
     /// <typeparam name="TRight">Type of the value embedded as right value in the <see cref="Either{TLeft, TRight}"/>.</typeparam>
     [PublicAPI]
     [DebuggerDisplay("{\"Is\" + " + nameof(_state) + " + (" + nameof(IsNone) + " ? System.String.Empty : \", Value = \" + (" + nameof(IsLeft) + " ?" + nameof(_left) + ".ToString() : " + nameof(_right) + ".ToString()))}")]
-    public readonly partial struct Either<TLeft, TRight> :
+    public partial struct Either<TLeft, TRight> :
         IEither,
         IEquatable<TRight>,
         IEquatable<EitherRight<TRight>>,
@@ -102,14 +102,14 @@ public TRight RightValue
         /// </summary>
         /// <param name="value">Left value.</param>
         /// <exception cref="ArgumentNullException">If the <paramref name="value"/> is null.</exception>
-        private Either([NotNull] in TLeft value)
+        private Either([NotNull] TLeft value)
         {
             if (value == null)
                 throw new ArgumentNullException(nameof(value), "Cannot initialize an Either<TLeft, TRight> in Left state with a null value.");
 
             _state = EitherStates.Left;
             _left = value;
-            _right = default;
+            _right = default(TRight);
         }
 
         /// <summary>
@@ -117,13 +117,13 @@ private Either([NotNull] in TLeft value)
         /// </summary>
         /// <param name="value">Right value.</param>
         /// <exception cref="ArgumentNullException">If the <paramref name="value"/> is null.</exception>
-        private Either([NotNull] in TRight value)
+        private Either([NotNull] TRight value)
         {
             if (value == null)
                 throw new ArgumentNullException(nameof(value), "Cannot initialize an Either<TLeft, TRight> in Right with a null value.");
 
             _state = EitherStates.Right;
-            _left = default;
+            _left = default(TLeft);
             _right = value;
         }
 
@@ -134,7 +134,7 @@ private Either([NotNull] in TRight value)
         /// <returns>An <see cref="Either{TLeft,TRight}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="value"/> is null.</exception>
         [Pure]
-        internal static Either<TLeft, TRight> Left([NotNull] in TLeft value)
+        internal static Either<TLeft, TRight> Left([NotNull] TLeft value)
         {
             return new Either<TLeft, TRight>(value);
         }
@@ -146,7 +146,7 @@ internal static Either<TLeft, TRight> Left([NotNull] in TLeft value)
         /// <returns>An <see cref="Either{TLeft,TRight}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="value"/> is null.</exception>
         [Pure]
-        internal static Either<TLeft, TRight> Right([NotNull] in TRight value)
+        internal static Either<TLeft, TRight> Right([NotNull] TRight value)
         {
             return new Either<TLeft, TRight>(value);
         }
@@ -158,7 +158,7 @@ internal static Either<TLeft, TRight> Right([NotNull] in TRight value)
         /// <returns>The left value.</returns>
         /// <exception cref="InvalidCastException">If the either is casted to a left value while not being in <see cref="EitherStates.Left"/> state.</exception>
         [PublicAPI, Pure]
-        public static explicit operator TLeft(in Either<TLeft, TRight> either)
+        public static explicit operator TLeft(Either<TLeft, TRight> either)
         {
             return either.IsLeft
                 ? either._left
@@ -172,7 +172,7 @@ public static explicit operator TLeft(in Either<TLeft, TRight> either)
         /// <returns>The right value.</returns>
         /// <exception cref="InvalidCastException">If the either is casted to a left value while not being in <see cref="EitherStates.Right"/> state.</exception>
         [PublicAPI, Pure]
-        public static explicit operator TRight(in Either<TLeft, TRight> either)
+        public static explicit operator TRight(Either<TLeft, TRight> either)
         {
             return either.IsRight
                 ? either._right
@@ -236,7 +236,7 @@ public override bool Equals(object obj)
         /// <param name="either2">Second <see cref="Either{TLeft,TRight}"/> to compare.</param>
         /// <returns>True if both <see cref="Either{TLeft,TRight}"/> are equal, otherwise false.</returns>
         [Pure]
-        internal static bool AreEqual(in Either<TLeft, TRight> either1, in Either<TLeft, TRight> either2)
+        internal static bool AreEqual(Either<TLeft, TRight> either1, Either<TLeft, TRight> either2)
         {
             if (either1.IsLeft && either2.IsLeft)
                 return EqualityComparer<TLeft>.Default.Equals(either1._left, either2._left);
@@ -256,7 +256,7 @@ internal static bool AreEqual(in Either<TLeft, TRight> either1, in Either<TLeft,
         /// <param name="either1">First <see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <param name="either2">Second <see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <returns>True if both <see cref="Either{TLeft, TRight}"/> are equal, otherwise false.</returns>
-        public static bool operator ==(in Either<TLeft, TRight> either1, in Either<TLeft, TRight> either2)
+        public static bool operator ==(Either<TLeft, TRight> either1, Either<TLeft, TRight> either2)
         {
             return AreEqual(either1, either2);
         }
@@ -267,7 +267,7 @@ internal static bool AreEqual(in Either<TLeft, TRight> either1, in Either<TLeft,
         /// <param name="either1">First <see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <param name="either2">Second <see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <returns>True if both <see cref="Either{TLeft, TRight}"/> are not equal, otherwise false.</returns>
-        public static bool operator !=(in Either<TLeft, TRight> either1, in Either<TLeft, TRight> either2)
+        public static bool operator !=(Either<TLeft, TRight> either1, Either<TLeft, TRight> either2)
         {
             return !(either1 == either2);
         }
@@ -278,7 +278,7 @@ internal static bool AreEqual(in Either<TLeft, TRight> either1, in Either<TLeft,
         /// <param name="either"><see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <param name="eitherLeft"><see cref="EitherLeft{TLeft}"/> to compare.</param>
         /// <returns>True if <see cref="Either{TLeft, TRight}"/> and <see cref="EitherLeft{TLeft}"/> are equal, otherwise false.</returns>
-        public static bool operator ==(in Either<TLeft, TRight> either, in EitherLeft<TLeft> eitherLeft)
+        public static bool operator ==(Either<TLeft, TRight> either, EitherLeft<TLeft> eitherLeft)
         {
             return either.Equals(eitherLeft);
         }
@@ -289,7 +289,7 @@ internal static bool AreEqual(in Either<TLeft, TRight> either1, in Either<TLeft,
         /// <param name="either"><see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <param name="eitherLeft"><see cref="EitherLeft{TLeft}"/> to compare.</param>
         /// <returns>True if <see cref="Either{TLeft, TRight}"/> and <see cref="EitherLeft{TLeft}"/> are not equal, otherwise false.</returns>
-        public static bool operator !=(in Either<TLeft, TRight> either, in EitherLeft<TLeft> eitherLeft)
+        public static bool operator !=(Either<TLeft, TRight> either, EitherLeft<TLeft> eitherLeft)
         {
             return !(either == eitherLeft);
         }
@@ -300,7 +300,7 @@ internal static bool AreEqual(in Either<TLeft, TRight> either1, in Either<TLeft,
         /// <param name="eitherLeft"><see cref="EitherLeft{TLeft}"/> to compare.</param>
         /// <param name="either"><see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <returns>True if <see cref="Either{TLeft, TRight}"/> and <see cref="EitherLeft{TLeft}"/> are equal, otherwise false.</returns>
-        public static bool operator ==(in EitherLeft<TLeft> eitherLeft, in Either<TLeft, TRight> either)
+        public static bool operator ==(EitherLeft<TLeft> eitherLeft, Either<TLeft, TRight> either)
         {
             return either == eitherLeft;
         }
@@ -311,7 +311,7 @@ internal static bool AreEqual(in Either<TLeft, TRight> either1, in Either<TLeft,
         /// <param name="eitherLeft"><see cref="EitherLeft{TLeft}"/> to compare.</param>
         /// <param name="either"><see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <returns>True if <see cref="Either{TLeft, TRight}"/> and <see cref="EitherLeft{TLeft}"/> are not equal, otherwise false.</returns>
-        public static bool operator !=(in EitherLeft<TLeft> eitherLeft, in Either<TLeft, TRight> either)
+        public static bool operator !=(EitherLeft<TLeft> eitherLeft, Either<TLeft, TRight> either)
         {
             return !(either == eitherLeft);
         }
@@ -322,7 +322,7 @@ internal static bool AreEqual(in Either<TLeft, TRight> either1, in Either<TLeft,
         /// <param name="either"><see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <param name="eitherRight"><see cref="EitherRight{TRight}"/> to compare.</param>
         /// <returns>True if <see cref="Either{TLeft, TRight}"/> and <see cref="EitherRight{TRight}"/> are equal, otherwise false.</returns>
-        public static bool operator ==(in Either<TLeft, TRight> either, in EitherRight<TRight> eitherRight)
+        public static bool operator ==(Either<TLeft, TRight> either, EitherRight<TRight> eitherRight)
         {
             return either.Equals(eitherRight);
         }
@@ -333,7 +333,7 @@ internal static bool AreEqual(in Either<TLeft, TRight> either1, in Either<TLeft,
         /// <param name="either"><see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <param name="eitherRight"><see cref="EitherRight{TRight}"/> to compare.</param>
         /// <returns>True if <see cref="Either{TLeft, TRight}"/> and <see cref="EitherRight{TRight}"/> are not equal, otherwise false.</returns>
-        public static bool operator !=(in Either<TLeft, TRight> either, in EitherRight<TRight> eitherRight)
+        public static bool operator !=(Either<TLeft, TRight> either, EitherRight<TRight> eitherRight)
         {
             return !(either == eitherRight);
         }
@@ -344,7 +344,7 @@ internal static bool AreEqual(in Either<TLeft, TRight> either1, in Either<TLeft,
         /// <param name="eitherRight"><see cref="EitherRight{TRight}"/> to compare.</param>
         /// <param name="either"><see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <returns>True if <see cref="Either{TLeft, TRight}"/> and <see cref="EitherRight{TRight}"/> are equal, otherwise false.</returns>
-        public static bool operator ==(in EitherRight<TRight> eitherRight, in Either<TLeft, TRight> either)
+        public static bool operator ==(EitherRight<TRight> eitherRight, Either<TLeft, TRight> either)
         {
             return either == eitherRight;
         }
@@ -355,7 +355,7 @@ internal static bool AreEqual(in Either<TLeft, TRight> either1, in Either<TLeft,
         /// <param name="eitherRight"><see cref="EitherRight{TRight}"/> to compare.</param>
         /// <param name="either"><see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <returns>True if <see cref="Either{TLeft, TRight}"/> and <see cref="EitherRight{TRight}"/> are not equal, otherwise false.</returns>
-        public static bool operator !=(in EitherRight<TRight> eitherRight, in Either<TLeft, TRight> either)
+        public static bool operator !=(EitherRight<TRight> eitherRight, Either<TLeft, TRight> either)
         {
             return !(either == eitherRight);
         }
@@ -367,7 +367,7 @@ internal static bool AreEqual(in Either<TLeft, TRight> either1, in Either<TLeft,
         /// <param name="rightValue">Value to compare.</param>
         /// <returns>True if the <see cref="Either{TLeft, TRight}"/> is in <see cref="EitherStates.Right"/> state
         /// and its value is equals to the <paramref name="rightValue"/>, otherwise false.</returns>
-        public static bool operator ==(in Either<TLeft, TRight> either, in TRight rightValue)
+        public static bool operator ==(Either<TLeft, TRight> either, TRight rightValue)
         {
             return either.Equals(rightValue);
         }
@@ -379,7 +379,7 @@ internal static bool AreEqual(in Either<TLeft, TRight> either1, in Either<TLeft,
         /// <param name="rightValue">Value to compare.</param>
         /// <returns>True if the <see cref="Either{TLeft, TRight}"/> is not in <see cref="EitherStates.Right"/> state
         /// with its value equals to the <paramref name="rightValue"/>, otherwise false.</returns>
-        public static bool operator !=(in Either<TLeft, TRight> either, in TRight rightValue)
+        public static bool operator !=(Either<TLeft, TRight> either, TRight rightValue)
         {
             return !(either == rightValue);
         }
@@ -391,7 +391,7 @@ internal static bool AreEqual(in Either<TLeft, TRight> either1, in Either<TLeft,
         /// <param name="either">First <see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <returns>True if the <see cref="Either{TLeft, TRight}"/> is in <see cref="EitherStates.Right"/> state
         /// and its value is equals to the <paramref name="rightValue"/>, otherwise false.</returns>
-        public static bool operator ==(in TRight rightValue, in Either<TLeft, TRight> either)
+        public static bool operator ==(TRight rightValue, Either<TLeft, TRight> either)
         {
             return either == rightValue;
         }
@@ -403,7 +403,7 @@ internal static bool AreEqual(in Either<TLeft, TRight> either1, in Either<TLeft,
         /// <param name="either">First <see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <returns>True if the <see cref="Either{TLeft, TRight}"/> is not in <see cref="EitherStates.Right"/> state
         /// with its value equals to the <paramref name="rightValue"/>, otherwise false.</returns>
-        public static bool operator !=(in TRight rightValue, in Either<TLeft, TRight> either)
+        public static bool operator !=(TRight rightValue, Either<TLeft, TRight> either)
         {
             return !(either == rightValue);
         }
@@ -415,7 +415,7 @@ internal static bool AreEqual(in Either<TLeft, TRight> either1, in Either<TLeft,
         /// <param name="leftValue">Value to compare.</param>
         /// <returns>True if the <see cref="Either{TLeft, TRight}"/> is in <see cref="EitherStates.Left"/> state
         /// and its value is equals to the <paramref name="leftValue"/>, otherwise false.</returns>
-        public static bool operator ==(in Either<TLeft, TRight> either, in TLeft leftValue)
+        public static bool operator ==(Either<TLeft, TRight> either, TLeft leftValue)
         {
             return either.Equals(leftValue);
         }
@@ -427,7 +427,7 @@ internal static bool AreEqual(in Either<TLeft, TRight> either1, in Either<TLeft,
         /// <param name="leftValue">Value to compare.</param>
         /// <returns>True if the <see cref="Either{TLeft, TRight}"/> is not in <see cref="EitherStates.Left"/> state
         /// with its value equals to the <paramref name="leftValue"/>, otherwise false.</returns>
-        public static bool operator !=(in Either<TLeft, TRight> either, in TLeft leftValue)
+        public static bool operator !=(Either<TLeft, TRight> either, TLeft leftValue)
         {
             return !(either == leftValue);
         }
@@ -439,7 +439,7 @@ internal static bool AreEqual(in Either<TLeft, TRight> either1, in Either<TLeft,
         /// <param name="either">First <see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <returns>True if the <see cref="Either{TLeft, TRight}"/> is in <see cref="EitherStates.Left"/> state
         /// and its value is equals to the <paramref name="leftValue"/>, otherwise false.</returns>
-        public static bool operator ==(in TLeft leftValue, in Either<TLeft, TRight> either)
+        public static bool operator ==(TLeft leftValue, Either<TLeft, TRight> either)
         {
             return either == leftValue;
         }
@@ -451,7 +451,7 @@ internal static bool AreEqual(in Either<TLeft, TRight> either1, in Either<TLeft,
         /// <param name="either">First <see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <returns>True if the <see cref="Either{TLeft, TRight}"/> is not in <see cref="EitherStates.Left"/> state
         /// with its value equals to the <paramref name="leftValue"/>, otherwise false.</returns>
-        public static bool operator !=(in TLeft leftValue, in Either<TLeft, TRight> either)
+        public static bool operator !=(TLeft leftValue, Either<TLeft, TRight> either)
         {
             return !(either == leftValue);
         }
@@ -533,7 +533,7 @@ public int CompareTo(Either<TLeft, TRight> other)
         /// <param name="either2">Second <see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <returns>An integer that indicates the relative order of compared objects.</returns>
         [Pure]
-        internal static int Compare(in Either<TLeft, TRight> either1, in Either<TLeft, TRight> either2)
+        internal static int Compare(Either<TLeft, TRight> either1, Either<TLeft, TRight> either2)
         {
             if (either1.IsNone)
                 return either2.IsNone ? 0 : -1;
@@ -559,7 +559,7 @@ internal static int Compare(in Either<TLeft, TRight> either1, in Either<TLeft, T
         /// <param name="either1">The first <see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <param name="either2">The second <see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <(in Either<TLeft, TRight> either1, in Either<TLeft, TRight> either2)
+        public static bool operator <(Either<TLeft, TRight> either1, Either<TLeft, TRight> either2)
         {
             return either1.CompareTo(either2) < 0;
         }
@@ -570,7 +570,7 @@ internal static int Compare(in Either<TLeft, TRight> either1, in Either<TLeft, T
         /// <param name="either1">The first <see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <param name="either2">The second <see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <=(in Either<TLeft, TRight> either1, in Either<TLeft, TRight> either2)
+        public static bool operator <=(Either<TLeft, TRight> either1, Either<TLeft, TRight> either2)
         {
             return either1.CompareTo(either2) <= 0;
         }
@@ -581,7 +581,7 @@ internal static int Compare(in Either<TLeft, TRight> either1, in Either<TLeft, T
         /// <param name="either1">The first <see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <param name="either2">The second <see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >(in Either<TLeft, TRight> either1, in Either<TLeft, TRight> either2)
+        public static bool operator >(Either<TLeft, TRight> either1, Either<TLeft, TRight> either2)
         {
             return either1.CompareTo(either2) > 0;
         }
@@ -592,7 +592,7 @@ internal static int Compare(in Either<TLeft, TRight> either1, in Either<TLeft, T
         /// <param name="either1">The first <see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <param name="either2">The second <see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >=(in Either<TLeft, TRight> either1, in Either<TLeft, TRight> either2)
+        public static bool operator >=(Either<TLeft, TRight> either1, Either<TLeft, TRight> either2)
         {
             return either1.CompareTo(either2) >= 0;
         }
@@ -607,7 +607,7 @@ internal static int Compare(in Either<TLeft, TRight> either1, in Either<TLeft, T
         /// <param name="either"><see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <param name="eitherLeft"><see cref="EitherLeft{TLeft}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <(in Either<TLeft, TRight> either, in EitherLeft<TLeft> eitherLeft)
+        public static bool operator <(Either<TLeft, TRight> either, EitherLeft<TLeft> eitherLeft)
         {
             return Compare(either, eitherLeft) < 0;
         }
@@ -618,7 +618,7 @@ internal static int Compare(in Either<TLeft, TRight> either1, in Either<TLeft, T
         /// <param name="either"><see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <param name="eitherLeft"><see cref="EitherLeft{TLeft}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <=(in Either<TLeft, TRight> either, in EitherLeft<TLeft> eitherLeft)
+        public static bool operator <=(Either<TLeft, TRight> either, EitherLeft<TLeft> eitherLeft)
         {
             return Compare(either, eitherLeft) <= 0;
         }
@@ -629,7 +629,7 @@ internal static int Compare(in Either<TLeft, TRight> either1, in Either<TLeft, T
         /// <param name="either"><see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <param name="eitherLeft"><see cref="EitherLeft{TLeft}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >(in Either<TLeft, TRight> either, in EitherLeft<TLeft> eitherLeft)
+        public static bool operator >(Either<TLeft, TRight> either, EitherLeft<TLeft> eitherLeft)
         {
             return Compare(either, eitherLeft) > 0;
         }
@@ -640,7 +640,7 @@ internal static int Compare(in Either<TLeft, TRight> either1, in Either<TLeft, T
         /// <param name="either"><see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <param name="eitherLeft"><see cref="EitherLeft{TLeft}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >=(in Either<TLeft, TRight> either, in EitherLeft<TLeft> eitherLeft)
+        public static bool operator >=(Either<TLeft, TRight> either, EitherLeft<TLeft> eitherLeft)
         {
             return Compare(either, eitherLeft) >= 0;
         }
@@ -651,7 +651,7 @@ internal static int Compare(in Either<TLeft, TRight> either1, in Either<TLeft, T
         /// <param name="eitherLeft"><see cref="EitherLeft{TLeft}"/> to compare.</param>
         /// <param name="either"><see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <(in EitherLeft<TLeft> eitherLeft, in Either<TLeft, TRight> either)
+        public static bool operator <(EitherLeft<TLeft> eitherLeft, Either<TLeft, TRight> either)
         {
             return Compare(eitherLeft, either) < 0;
         }
@@ -662,7 +662,7 @@ internal static int Compare(in Either<TLeft, TRight> either1, in Either<TLeft, T
         /// <param name="eitherLeft"><see cref="EitherLeft{TLeft}"/> to compare.</param>
         /// <param name="either"><see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <=(in EitherLeft<TLeft> eitherLeft, in Either<TLeft, TRight> either)
+        public static bool operator <=(EitherLeft<TLeft> eitherLeft, Either<TLeft, TRight> either)
         {
             return Compare(eitherLeft, either) <= 0;
         }
@@ -673,7 +673,7 @@ internal static int Compare(in Either<TLeft, TRight> either1, in Either<TLeft, T
         /// <param name="eitherLeft"><see cref="EitherLeft{TLeft}"/> to compare.</param>
         /// <param name="either"><see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >(in EitherLeft<TLeft> eitherLeft, in Either<TLeft, TRight> either)
+        public static bool operator >(EitherLeft<TLeft> eitherLeft, Either<TLeft, TRight> either)
         {
             return Compare(eitherLeft, either) > 0;
         }
@@ -684,7 +684,7 @@ internal static int Compare(in Either<TLeft, TRight> either1, in Either<TLeft, T
         /// <param name="eitherLeft"><see cref="EitherLeft{TLeft}"/> to compare.</param>
         /// <param name="either"><see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >=(in EitherLeft<TLeft> eitherLeft, in Either<TLeft, TRight> either)
+        public static bool operator >=(EitherLeft<TLeft> eitherLeft, Either<TLeft, TRight> either)
         {
             return Compare(eitherLeft, either) >= 0;
         }
@@ -699,7 +699,7 @@ internal static int Compare(in Either<TLeft, TRight> either1, in Either<TLeft, T
         /// <param name="either"><see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <param name="eitherRight"><see cref="EitherRight{TRight}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <(in Either<TLeft, TRight> either, in EitherRight<TRight> eitherRight)
+        public static bool operator <(Either<TLeft, TRight> either, EitherRight<TRight> eitherRight)
         {
             return Compare(either, eitherRight) < 0;
         }
@@ -710,7 +710,7 @@ internal static int Compare(in Either<TLeft, TRight> either1, in Either<TLeft, T
         /// <param name="either"><see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <param name="eitherRight"><see cref="EitherRight{TRight}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <=(in Either<TLeft, TRight> either, in EitherRight<TRight> eitherRight)
+        public static bool operator <=(Either<TLeft, TRight> either, EitherRight<TRight> eitherRight)
         {
             return Compare(either, eitherRight) <= 0;
         }
@@ -721,7 +721,7 @@ internal static int Compare(in Either<TLeft, TRight> either1, in Either<TLeft, T
         /// <param name="either"><see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <param name="eitherRight"><see cref="EitherRight{TRight}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >(in Either<TLeft, TRight> either, in EitherRight<TRight> eitherRight)
+        public static bool operator >(Either<TLeft, TRight> either, EitherRight<TRight> eitherRight)
         {
             return Compare(either, eitherRight) > 0;
         }
@@ -732,7 +732,7 @@ internal static int Compare(in Either<TLeft, TRight> either1, in Either<TLeft, T
         /// <param name="either"><see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <param name="eitherRight"><see cref="EitherRight{TRight}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >=(in Either<TLeft, TRight> either, in EitherRight<TRight> eitherRight)
+        public static bool operator >=(Either<TLeft, TRight> either, EitherRight<TRight> eitherRight)
         {
             return Compare(either, eitherRight) >= 0;
         }
@@ -743,7 +743,7 @@ internal static int Compare(in Either<TLeft, TRight> either1, in Either<TLeft, T
         /// <param name="eitherRight"><see cref="EitherRight{TRight}"/> to compare.</param>
         /// <param name="either"><see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <(in EitherRight<TRight> eitherRight, in Either<TLeft, TRight> either)
+        public static bool operator <(EitherRight<TRight> eitherRight, Either<TLeft, TRight> either)
         {
             return Compare(eitherRight, either) < 0;
         }
@@ -754,7 +754,7 @@ internal static int Compare(in Either<TLeft, TRight> either1, in Either<TLeft, T
         /// <param name="eitherRight"><see cref="EitherRight{TRight}"/> to compare.</param>
         /// <param name="either"><see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <=(in EitherRight<TRight> eitherRight, in Either<TLeft, TRight> either)
+        public static bool operator <=(EitherRight<TRight> eitherRight, Either<TLeft, TRight> either)
         {
             return Compare(eitherRight, either) <= 0;
         }
@@ -765,7 +765,7 @@ internal static int Compare(in Either<TLeft, TRight> either1, in Either<TLeft, T
         /// <param name="eitherRight"><see cref="EitherRight{TRight}"/> to compare.</param>
         /// <param name="either"><see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >(in EitherRight<TRight> eitherRight, in Either<TLeft, TRight> either)
+        public static bool operator >(EitherRight<TRight> eitherRight, Either<TLeft, TRight> either)
         {
             return Compare(eitherRight, either) > 0;
         }
@@ -776,7 +776,7 @@ internal static int Compare(in Either<TLeft, TRight> either1, in Either<TLeft, T
         /// <param name="eitherRight"><see cref="EitherRight{TRight}"/> to compare.</param>
         /// <param name="either"><see cref="Either{TLeft, TRight}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >=(in EitherRight<TRight> eitherRight, in Either<TLeft, TRight> either)
+        public static bool operator >=(EitherRight<TRight> eitherRight, Either<TLeft, TRight> either)
         {
             return Compare(eitherRight, either) >= 0;
         }
diff --git a/src/Here/Either/EitherHelpers.cs b/src/Here/Either/EitherHelpers.cs
index 196fe99..12f6c57 100644
--- a/src/Here/Either/EitherHelpers.cs
+++ b/src/Here/Either/EitherHelpers.cs
@@ -15,7 +15,7 @@ public static class EitherHelpers
         /// <param name="either2">Second <see cref="Either{TLeft,TRight}"/> to compare.</param>
         /// <returns>True if both <see cref="Either{TLeft,TRight}"/> are equal, otherwise false.</returns>
         [PublicAPI, Pure]
-        public static bool AreEqual<TLeft, TRight>(in Either<TLeft, TRight> either1, in Either<TLeft, TRight> either2)
+        public static bool AreEqual<TLeft, TRight>(Either<TLeft, TRight> either1, Either<TLeft, TRight> either2)
         {
             return Either<TLeft, TRight>.AreEqual(either1, either2);
         }
@@ -27,7 +27,7 @@ public static bool AreEqual<TLeft, TRight>(in Either<TLeft, TRight> either1, in
         /// <param name="eitherLeft2">Second <see cref="EitherLeft{TLeft}"/> to compare.</param>
         /// <returns>True if both <see cref="EitherLeft{TLeft}"/> are equal, otherwise false.</returns>
         [PublicAPI, Pure]
-        public static bool AreEqual<TLeft>(in EitherLeft<TLeft> eitherLeft1, in EitherLeft<TLeft> eitherLeft2)
+        public static bool AreEqual<TLeft>(EitherLeft<TLeft> eitherLeft1, EitherLeft<TLeft> eitherLeft2)
         {
             return eitherLeft1.Equals(eitherLeft2);
         }
@@ -39,7 +39,7 @@ public static bool AreEqual<TLeft>(in EitherLeft<TLeft> eitherLeft1, in EitherLe
         /// <param name="eitherRight2">Second <see cref="EitherRight{TRight}"/> to compare.</param>
         /// <returns>True if both <see cref="EitherRight{TRight}"/> are equal, otherwise false.</returns>
         [PublicAPI, Pure]
-        public static bool AreEqual<TRight>(in EitherRight<TRight> eitherRight1, in EitherRight<TRight> eitherRight2)
+        public static bool AreEqual<TRight>(EitherRight<TRight> eitherRight1, EitherRight<TRight> eitherRight2)
         {
             return eitherRight1.Equals(eitherRight2);
         }
@@ -52,7 +52,7 @@ public static bool AreEqual<TRight>(in EitherRight<TRight> eitherRight1, in Eith
         /// <param name="either2">Second <see cref="Either{TLeft,TRight}"/> to compare.</param>
         /// <returns>An integer that indicates the relative order of compared objects.</returns>
         [PublicAPI, Pure]
-        public static int Compare<TLeft, TRight>(in Either<TLeft, TRight> either1, in Either<TLeft, TRight> either2)
+        public static int Compare<TLeft, TRight>(Either<TLeft, TRight> either1, Either<TLeft, TRight> either2)
         {
             return Either<TLeft, TRight>.Compare(either1, either2);
         }
@@ -65,7 +65,7 @@ public static int Compare<TLeft, TRight>(in Either<TLeft, TRight> either1, in Ei
         /// <param name="eitherLeft2">Second <see cref="EitherLeft{TLeft}"/> to compare.</param>
         /// <returns>An integer that indicates the relative order of compared objects.</returns>
         [PublicAPI, Pure]
-        public static int Compare<TLeft>(in EitherLeft<TLeft> eitherLeft1, in EitherLeft<TLeft> eitherLeft2)
+        public static int Compare<TLeft>(EitherLeft<TLeft> eitherLeft1, EitherLeft<TLeft> eitherLeft2)
         {
             return eitherLeft1.CompareTo(eitherLeft2);
         }
@@ -78,7 +78,7 @@ public static int Compare<TLeft>(in EitherLeft<TLeft> eitherLeft1, in EitherLeft
         /// <param name="eitherRight2">Second <see cref="EitherRight{TRight}"/> to compare.</param>
         /// <returns>An integer that indicates the relative order of compared objects.</returns>
         [PublicAPI, Pure]
-        public static int Compare<TRight>(in EitherRight<TRight> eitherRight1, in EitherRight<TRight> eitherRight2)
+        public static int Compare<TRight>(EitherRight<TRight> eitherRight1, EitherRight<TRight> eitherRight2)
         {
             return eitherRight1.CompareTo(eitherRight2);
         }
diff --git a/src/Here/Either/EitherLeft.cs b/src/Here/Either/EitherLeft.cs
index 47c8e95..f826470 100644
--- a/src/Here/Either/EitherLeft.cs
+++ b/src/Here/Either/EitherLeft.cs
@@ -12,7 +12,7 @@ namespace Here
     /// <typeparam name="TLeft">Type of the value embedded as left value in the <see cref="EitherLeft{TLeft}"/>.</typeparam>
     [PublicAPI]
     [DebuggerDisplay("IsLeft, Value = {" + nameof(Left) + "}")]
-    public readonly struct EitherLeft<TLeft> :
+    public struct EitherLeft<TLeft> :
         IEither,
         IEquatable<TLeft>,
         IEquatable<EitherLeft<TLeft>>, 
@@ -72,7 +72,7 @@ public override bool Equals(object obj)
         /// <param name="either1">First <see cref="EitherLeft{TLeft}"/> to compare.</param>
         /// <param name="either2">Second <see cref="EitherLeft{TLeft}"/> to compare.</param>
         /// <returns>True if both <see cref="EitherLeft{TLeft}"/> are equal, otherwise false.</returns>
-        public static bool operator ==(in EitherLeft<TLeft> either1, in EitherLeft<TLeft> either2)
+        public static bool operator ==(EitherLeft<TLeft> either1, EitherLeft<TLeft> either2)
         {
             return either1.Equals(either2);
         }
@@ -83,7 +83,7 @@ public override bool Equals(object obj)
         /// <param name="either1">First <see cref="EitherLeft{TLeft}"/> to compare.</param>
         /// <param name="either2">Second <see cref="EitherLeft{TLeft}"/> to compare.</param>
         /// <returns>True if both <see cref="EitherLeft{TLeft}"/> are not equal, otherwise false.</returns>
-        public static bool operator !=(in EitherLeft<TLeft> either1, in EitherLeft<TLeft> either2)
+        public static bool operator !=(EitherLeft<TLeft> either1, EitherLeft<TLeft> either2)
         {
             return !(either1 == either2);
         }
@@ -127,7 +127,7 @@ public int CompareTo(EitherLeft<TLeft> other)
         /// <param name="left">The first <see cref="EitherLeft{TLeft}"/> to compare.</param>
         /// <param name="right">The second <see cref="EitherLeft{TLeft}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <(in EitherLeft<TLeft> left, in EitherLeft<TLeft> right)
+        public static bool operator <(EitherLeft<TLeft> left, EitherLeft<TLeft> right)
         {
             return left.CompareTo(right) < 0;
         }
@@ -138,7 +138,7 @@ public int CompareTo(EitherLeft<TLeft> other)
         /// <param name="left">The first <see cref="EitherLeft{TLeft}"/> to compare.</param>
         /// <param name="right">The second <see cref="EitherLeft{TLeft}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <=(in EitherLeft<TLeft> left, in EitherLeft<TLeft> right)
+        public static bool operator <=(EitherLeft<TLeft> left, EitherLeft<TLeft> right)
         {
             return left.CompareTo(right) <= 0;
         }
@@ -149,7 +149,7 @@ public int CompareTo(EitherLeft<TLeft> other)
         /// <param name="left">The first <see cref="EitherLeft{TLeft}"/> to compare.</param>
         /// <param name="right">The second <see cref="EitherLeft{TLeft}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >(in EitherLeft<TLeft> left, in EitherLeft<TLeft> right)
+        public static bool operator >(EitherLeft<TLeft> left, EitherLeft<TLeft> right)
         {
             return left.CompareTo(right) > 0;
         }
@@ -160,7 +160,7 @@ public int CompareTo(EitherLeft<TLeft> other)
         /// <param name="left">The first <see cref="EitherLeft{TLeft}"/> to compare.</param>
         /// <param name="right">The second <see cref="EitherLeft{TLeft}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >=(in EitherLeft<TLeft> left, in EitherLeft<TLeft> right)
+        public static bool operator >=(EitherLeft<TLeft> left, EitherLeft<TLeft> right)
         {
             return left.CompareTo(right) >= 0;
         }
diff --git a/src/Here/Either/EitherRight.cs b/src/Here/Either/EitherRight.cs
index 52ba422..2d4e964 100644
--- a/src/Here/Either/EitherRight.cs
+++ b/src/Here/Either/EitherRight.cs
@@ -12,7 +12,7 @@ namespace Here
     /// <typeparam name="TRight">Type of the value embedded as right value in the <see cref="EitherRight{TRight}"/>.</typeparam>
     [PublicAPI]
     [DebuggerDisplay("IsRight, Value = {" + nameof(Value) + "}")]
-    public readonly struct EitherRight<TRight> :
+    public struct EitherRight<TRight> :
         IEither,
         IEquatable<TRight>,
         IEquatable<EitherRight<TRight>>, 
@@ -75,7 +75,7 @@ public override bool Equals(object obj)
         /// <param name="either1">First <see cref="EitherRight{TRight}"/> to compare.</param>
         /// <param name="either2">Second <see cref="EitherRight{TRight}"/> to compare.</param>
         /// <returns>True if both <see cref="EitherRight{TRight}"/> are equal, otherwise false.</returns>
-        public static bool operator ==(in EitherRight<TRight> either1, in EitherRight<TRight> either2)
+        public static bool operator ==(EitherRight<TRight> either1, EitherRight<TRight> either2)
         {
             return either1.Equals(either2);
         }
@@ -86,7 +86,7 @@ public override bool Equals(object obj)
         /// <param name="either1">First <see cref="EitherRight{TRight}"/> to compare.</param>
         /// <param name="either2">Second <see cref="EitherRight{TRight}"/> to compare.</param>
         /// <returns>True if both <see cref="EitherRight{TRight}"/> are not equal, otherwise false.</returns>
-        public static bool operator !=(in EitherRight<TRight> either1, in EitherRight<TRight> either2)
+        public static bool operator !=(EitherRight<TRight> either1, EitherRight<TRight> either2)
         {
             return !(either1 == either2);
         }
@@ -130,7 +130,7 @@ public int CompareTo(EitherRight<TRight> other)
         /// <param name="left">The first <see cref="EitherRight{TRight}"/> to compare.</param>
         /// <param name="right">The second <see cref="EitherRight{TRight}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <(in EitherRight<TRight> left, in EitherRight<TRight> right)
+        public static bool operator <(EitherRight<TRight> left, EitherRight<TRight> right)
         {
             return left.CompareTo(right) < 0;
         }
@@ -141,7 +141,7 @@ public int CompareTo(EitherRight<TRight> other)
         /// <param name="left">The first <see cref="EitherRight{TRight}"/> to compare.</param>
         /// <param name="right">The second <see cref="EitherRight{TRight}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <=(in EitherRight<TRight> left, in EitherRight<TRight> right)
+        public static bool operator <=(EitherRight<TRight> left, EitherRight<TRight> right)
         {
             return left.CompareTo(right) <= 0;
         }
@@ -152,7 +152,7 @@ public int CompareTo(EitherRight<TRight> other)
         /// <param name="left">The first <see cref="EitherRight{TRight}"/> to compare.</param>
         /// <param name="right">The second <see cref="EitherRight{TRight}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >(in EitherRight<TRight> left, in EitherRight<TRight> right)
+        public static bool operator >(EitherRight<TRight> left, EitherRight<TRight> right)
         {
             return left.CompareTo(right) > 0;
         }
@@ -163,7 +163,7 @@ public int CompareTo(EitherRight<TRight> other)
         /// <param name="left">The first <see cref="EitherRight{TRight}"/> to compare.</param>
         /// <param name="right">The second <see cref="EitherRight{TRight}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >=(in EitherRight<TRight> left, in EitherRight<TRight> right)
+        public static bool operator >=(EitherRight<TRight> left, EitherRight<TRight> right)
         {
             return left.CompareTo(right) >= 0;
         }
diff --git a/src/Here/Either/Extensions/EitherLinqExtensions.cs b/src/Here/Either/Extensions/EitherLinqExtensions.cs
index 94473de..0466137 100644
--- a/src/Here/Either/Extensions/EitherLinqExtensions.cs
+++ b/src/Here/Either/Extensions/EitherLinqExtensions.cs
@@ -20,7 +20,7 @@ public static class EitherLinqExtensions
         /// <param name="either"><see cref="Either{TLeft,TRight}"/> on which performing the check.</param>
         /// <returns>True if this <see cref="Either{TLeft,TRight}"/> has a right value, otherwise false.</returns>
         [PublicAPI, Pure]
-        public static bool Any<TLeft, TRight>(in this Either<TLeft, TRight> either)
+        public static bool Any<TLeft, TRight>(this Either<TLeft, TRight> either)
         {
             return either.IsRight;
         }
@@ -35,7 +35,7 @@ public static bool Any<TLeft, TRight>(in this Either<TLeft, TRight> either)
         /// <returns>True if this <see cref="Either{TLeft,TRight}"/> has a right value and matches the predicate, otherwise false.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="predicate"/> is null.</exception>
         [PublicAPI, Pure]
-        public static bool Any<TLeft, TRight>(in this Either<TLeft, TRight> either, [NotNull, InstantHandle] in Predicate<TRight> predicate)
+        public static bool Any<TLeft, TRight>(this Either<TLeft, TRight> either, [NotNull, InstantHandle] Predicate<TRight> predicate)
         {
             Throw.IfArgumentNull(predicate, nameof(predicate));
 
@@ -55,7 +55,7 @@ public static bool Any<TLeft, TRight>(in this Either<TLeft, TRight> either, [Not
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        public static bool All<TLeft, TRight>(in this Either<TLeft, TRight> either, [NotNull, InstantHandle] in Predicate<TRight> predicate)
+        public static bool All<TLeft, TRight>(this Either<TLeft, TRight> either, [NotNull, InstantHandle] Predicate<TRight> predicate)
         {
             return either.Any(predicate);
         }
@@ -69,7 +69,7 @@ public static bool All<TLeft, TRight>(in this Either<TLeft, TRight> either, [Not
         /// <param name="value">Value to check equality with <see cref="Either{TLeft,TRight}"/> right value.</param>
         /// <returns>True if this <see cref="Either{TLeft,TRight}"/> contains the given <paramref name="value"/> as right value, otherwise false.</returns>
         [PublicAPI, Pure]
-        public static bool Contains<TLeft, TRight>(in this Either<TLeft, TRight> either, [CanBeNull] in TRight value)
+        public static bool Contains<TLeft, TRight>(this Either<TLeft, TRight> either, [CanBeNull] TRight value)
         {
             return either.IsRight && EqualityComparer<TRight>.Default.Equals(either._right, value);
         }
@@ -88,7 +88,7 @@ public static bool Contains<TLeft, TRight>(in this Either<TLeft, TRight> either,
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        public static Either<TLeft, TRightOut> Select<TLeft, TRight, TRightOut>(in this Either<TLeft, TRight> either, [NotNull, InstantHandle] in Func<TRight, TRightOut> selector)
+        public static Either<TLeft, TRightOut> Select<TLeft, TRight, TRightOut>(this Either<TLeft, TRight> either, [NotNull, InstantHandle] Func<TRight, TRightOut> selector)
         {
             return either.Map(selector);
         }
@@ -103,7 +103,7 @@ public static Either<TLeft, TRightOut> Select<TLeft, TRight, TRightOut>(in this
         /// <returns>This <see cref="Option{T}"/> if it matches the <paramref name="predicate"/>, otherwise an empty <see cref="Option{T}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="predicate"/> is null.</exception>
         [PublicAPI, Pure]
-        public static Either<TLeft, TRight> Where<TLeft, TRight>(in this Either<TLeft, TRight> either, [NotNull, InstantHandle] in Predicate<TRight> predicate)
+        public static Either<TLeft, TRight> Where<TLeft, TRight>(this Either<TLeft, TRight> either, [NotNull, InstantHandle] Predicate<TRight> predicate)
         {
             if (either.All(predicate))
                 return either;
@@ -123,7 +123,7 @@ public static Either<TLeft, TRight> Where<TLeft, TRight>(in this Either<TLeft, T
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        public static Unit ForEach<TLeft, TRight>(in this Either<TLeft, TRight> either, [NotNull, InstantHandle] in Action<TRight> doAction)
+        public static Unit ForEach<TLeft, TRight>(this Either<TLeft, TRight> either, [NotNull, InstantHandle] Action<TRight> doAction)
         {
             return either.IfRight(doAction);
         }
@@ -146,9 +146,9 @@ public static Unit ForEach<TLeft, TRight>(in this Either<TLeft, TRight> either,
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        public static TAggregate Aggregate<TLeft, TRight, TAggregate>(in this Either<TLeft, TRight> either,
-            [NotNull] in TAggregate initialValue,
-            [NotNull, InstantHandle] in Func<TAggregate, TRight, TAggregate> aggregator)
+        public static TAggregate Aggregate<TLeft, TRight, TAggregate>(this Either<TLeft, TRight> either,
+            [NotNull] TAggregate initialValue,
+            [NotNull, InstantHandle] Func<TAggregate, TRight, TAggregate> aggregator)
         {
             return either.Fold(initialValue, aggregator);
         }
diff --git a/src/Here/Either/Extensions/EitherOperatorsExtensions.cs b/src/Here/Either/Extensions/EitherOperatorsExtensions.cs
index 6d91d2b..b072bd8 100644
--- a/src/Here/Either/Extensions/EitherOperatorsExtensions.cs
+++ b/src/Here/Either/Extensions/EitherOperatorsExtensions.cs
@@ -15,7 +15,7 @@ public static class EitherOperatorsExtensions
         /// </summary>
         /// <param name="either"><see cref="Either{TLeft,TRight}"/> to convert.</param>
         /// <returns>An <see cref="Option{TRight}"/>.</returns>
-        public static Option<TRight> ToOption<TLeft, TRight>(in this Either<TLeft, TRight> either)
+        public static Option<TRight> ToOption<TLeft, TRight>(this Either<TLeft, TRight> either)
         {
             if (either.IsRight)
                 return Option<TRight>.Some(either._right);
@@ -31,7 +31,7 @@ public static Option<TRight> ToOption<TLeft, TRight>(in this Either<TLeft, TRigh
         /// </summary>
         /// <param name="either"><see cref="Either{TLeft,TRight}"/> to convert.</param>
         /// <returns>A <see cref="Result"/>.</returns>
-        public static Result ToResult<TLeft, TRight>(in this Either<TLeft, TRight> either)
+        public static Result ToResult<TLeft, TRight>(this Either<TLeft, TRight> either)
         {
             if (either.IsRight)
                 return Result.Ok();
@@ -43,7 +43,7 @@ public static Result ToResult<TLeft, TRight>(in this Either<TLeft, TRight> eithe
         /// </summary>
         /// <param name="either"><see cref="Either{TLeft,TRight}"/> to convert.</param>
         /// <returns>A <see cref="Result"/>.</returns>
-        public static Result ToResult<TRight>(in this Either<string, TRight> either)
+        public static Result ToResult<TRight>(this Either<string, TRight> either)
         {
             if (either.IsRight)
                 return Result.Ok();
@@ -57,7 +57,7 @@ public static Result ToResult<TRight>(in this Either<string, TRight> either)
         /// </summary>
         /// <param name="either"><see cref="Either{TLeft,TRight}"/> to convert.</param>
         /// <returns>A <see cref="Result{TRight}"/>.</returns>
-        public static Result<TRight> ToValueResult<TLeft, TRight>(in this Either<TLeft, TRight> either)
+        public static Result<TRight> ToValueResult<TLeft, TRight>(this Either<TLeft, TRight> either)
         {
             if (either.IsRight)
                 return Result.Ok(either._right);
@@ -69,7 +69,7 @@ public static Result<TRight> ToValueResult<TLeft, TRight>(in this Either<TLeft,
         /// </summary>
         /// <param name="either"><see cref="Either{TLeft,TRight}"/> to convert.</param>
         /// <returns>A <see cref="Result{TRight}"/>.</returns>
-        public static Result<TRight> ToValueResult<TRight>(in this Either<string, TRight> either)
+        public static Result<TRight> ToValueResult<TRight>(this Either<string, TRight> either)
         {
             if (either.IsRight)
                 return Result.Ok(either._right);
@@ -84,7 +84,7 @@ public static Result<TRight> ToValueResult<TRight>(in this Either<string, TRight
         /// <param name="either"><see cref="Either{TLeft,TRight}"/> to convert.</param>
         /// <returns>A <see cref="CustomResult{TError}"/>.</returns>
         /// <exception cref="InvalidOperationException">If the either is in <see cref="EitherStates.None"/> state.</exception>
-        public static CustomResult<TLeft> ToCustomResult<TLeft, TRight>(in this Either<TLeft, TRight> either)
+        public static CustomResult<TLeft> ToCustomResult<TLeft, TRight>(this Either<TLeft, TRight> either)
         {
             if (either.IsRight)
                 return Result.CustomOk<TLeft>();
@@ -100,7 +100,7 @@ public static CustomResult<TLeft> ToCustomResult<TLeft, TRight>(in this Either<T
         /// <param name="either"><see cref="Either{TLeft,TRight}"/> to convert.</param>
         /// <returns>A <see cref="Result{TRight, TLeft}"/>.</returns>
         /// <exception cref="InvalidOperationException">If the either is in <see cref="EitherStates.None"/> state.</exception>
-        public static Result<TRight, TLeft> ToValueCustomResult<TLeft, TRight>(in this Either<TLeft, TRight> either)
+        public static Result<TRight, TLeft> ToValueCustomResult<TLeft, TRight>(this Either<TLeft, TRight> either)
         {
             if (either.IsRight)
                 return Result.Ok<TRight, TLeft>(either._right);
diff --git a/src/Here/Here.csproj b/src/Here/Here.csproj
index b31d308..b4e5af6 100644
--- a/src/Here/Here.csproj
+++ b/src/Here/Here.csproj
@@ -36,9 +36,9 @@ Supports Source Link</Description>
 
     <IsPackable>true</IsPackable>
     <PackageId>Here</PackageId>
-    <PackageReleaseNotes>➟ Release 0.8.1
+    <PackageReleaseNotes>➟ Release 0.8.0
 - General:
-    - Library use C# 7.2 features.
+    - Library use C# 7.0 features.
     - Change target NetStandard 1.1 to NetStandard 1.0.
     - Adjust some annotations of library methods.
     - Add early throw for parameters that should not be null.
@@ -60,7 +60,7 @@ Supports Source Link</Description>
     - Add an implementation of Unit type.
 
 - Either:
-    - Add a first implementation Either monad (readonly structure).
+    - Add a first implementation Either monad.
         - Operations methods (IfLeft/IfRight/Match/Map, etc.).
         - Linq extensions.
         - Comparison helpers.
@@ -76,7 +76,7 @@ Supports Source Link</Description>
 
   <!-- C# configuration -->
   <PropertyGroup>
-    <LangVersion>7.2</LangVersion>
+    <LangVersion>7.0</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/src/Here/Option/Extensions/OptionDictionaryExtensions.cs b/src/Here/Option/Extensions/OptionDictionaryExtensions.cs
index c354e7d..07e2e9e 100644
--- a/src/Here/Option/Extensions/OptionDictionaryExtensions.cs
+++ b/src/Here/Option/Extensions/OptionDictionaryExtensions.cs
@@ -11,7 +11,7 @@ public static class OptionDictionaryExtensions
     {
         // Helper method to try get a value
         [Pure]
-        private static Option<TValue> TryGetValue<TKey, TValue>([NotNull] in OptionTryGetExtensions.TryGet<TKey, TValue> tryGetFunc, [CanBeNull] in TKey key)
+        private static Option<TValue> TryGetValue<TKey, TValue>([NotNull] OptionTryGetExtensions.TryGet<TKey, TValue> tryGetFunc, [CanBeNull] TKey key)
         {
             if (key == null)
                 return Option<TValue>.None;
@@ -29,7 +29,7 @@ private static Option<TValue> TryGetValue<TKey, TValue>([NotNull] in OptionTryGe
         /// <returns><see cref="Option{T}"/> that wrap the result of the get.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="dictionary"/> is null.</exception>
         [PublicAPI, Pure]
-        public static Option<TValue> TryGetValue<TKey, TValue>([NotNull] this IDictionary<TKey, TValue> dictionary, [CanBeNull] in TKey key)
+        public static Option<TValue> TryGetValue<TKey, TValue>([NotNull] this IDictionary<TKey, TValue> dictionary, [CanBeNull] TKey key)
         {
             Throw.IfArgumentNull(dictionary, nameof(dictionary));
 
@@ -46,7 +46,7 @@ public static Option<TValue> TryGetValue<TKey, TValue>([NotNull] this IDictionar
         /// <returns><see cref="Option{T}"/> that wrap the result of the get.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="dictionary"/> is null.</exception>
         [PublicAPI, Pure]
-        public static Option<TValue> TryGetValue<TKey, TValue>([NotNull] this IDictionary<TKey, object> dictionary, [CanBeNull] in TKey key)
+        public static Option<TValue> TryGetValue<TKey, TValue>([NotNull] this IDictionary<TKey, object> dictionary, [CanBeNull] TKey key)
         {
             Throw.IfArgumentNull(dictionary, nameof(dictionary));
 
@@ -67,7 +67,7 @@ public static Option<TValue> TryGetValue<TKey, TValue>([NotNull] this IDictionar
         /// <returns><see cref="Option{T}"/> that wrap the result of the get.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="dictionary"/> is null.</exception>
         [PublicAPI, Pure]
-        public static Option<TValue> TryGetReadonlyValue<TKey, TValue>([NotNull] this IReadOnlyDictionary<TKey, TValue> dictionary, [CanBeNull] in TKey key)
+        public static Option<TValue> TryGetReadonlyValue<TKey, TValue>([NotNull] this IReadOnlyDictionary<TKey, TValue> dictionary, [CanBeNull] TKey key)
         {
             Throw.IfArgumentNull(dictionary, nameof(dictionary));
 
@@ -84,7 +84,7 @@ public static Option<TValue> TryGetReadonlyValue<TKey, TValue>([NotNull] this IR
         /// <returns><see cref="Option{T}"/> that wrap the result of the get.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="dictionary"/> is null.</exception>
         [PublicAPI, Pure]
-        public static Option<TValue> TryGetReadonlyValue<TKey, TValue>([NotNull] this IReadOnlyDictionary<TKey, object> dictionary, [CanBeNull] in TKey key)
+        public static Option<TValue> TryGetReadonlyValue<TKey, TValue>([NotNull] this IReadOnlyDictionary<TKey, object> dictionary, [CanBeNull] TKey key)
         {
             Throw.IfArgumentNull(dictionary, nameof(dictionary));
 
diff --git a/src/Here/Option/Extensions/OptionEnumerableExtensions.cs b/src/Here/Option/Extensions/OptionEnumerableExtensions.cs
index 452ebfe..b94a311 100644
--- a/src/Here/Option/Extensions/OptionEnumerableExtensions.cs
+++ b/src/Here/Option/Extensions/OptionEnumerableExtensions.cs
@@ -33,7 +33,7 @@ public static Option<T> FirstOrNone<T>([NotNull] this IEnumerable<T> enumerable)
         /// <exception cref="ArgumentNullException">If the <paramref name="enumerable"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="predicate"/> is null.</exception>
         [PublicAPI, Pure]
-        public static Option<T> FirstOrNone<T>([NotNull] this IEnumerable<T> enumerable, [NotNull, InstantHandle] in Predicate<T> predicate)
+        public static Option<T> FirstOrNone<T>([NotNull] this IEnumerable<T> enumerable, [NotNull, InstantHandle] Predicate<T> predicate)
         {
             Throw.IfArgumentNull(enumerable, nameof(enumerable));
             Throw.IfArgumentNull(predicate, nameof(predicate));
@@ -58,7 +58,7 @@ public static Option<T> FirstOrNone<T>([NotNull] this IEnumerable<T> enumerable,
         /// <exception cref="ArgumentNullException">If the <paramref name="enumerable"/> is null.</exception>
         /// <exception cref="InvalidOperationException">If the <paramref name="enumerable"/> contains more than one element.</exception>
         [PublicAPI, Pure]
-        public static Option<T> SingleOrNone<T>([NotNull] this IEnumerable<T> enumerable, in bool throwInvalidException = true)
+        public static Option<T> SingleOrNone<T>([NotNull] this IEnumerable<T> enumerable, bool throwInvalidException = true)
         {
             Throw.IfArgumentNull(enumerable, nameof(enumerable));
 
@@ -90,7 +90,7 @@ public static Option<T> SingleOrNone<T>([NotNull] this IEnumerable<T> enumerable
         /// <exception cref="ArgumentNullException">If the <paramref name="predicate"/> is null.</exception>
         /// <exception cref="InvalidOperationException">If the <paramref name="enumerable"/> contains more than one element matching the <paramref name="predicate"/>.</exception>
         [PublicAPI, Pure]
-        public static Option<T> SingleOrNone<T>([NotNull] this IEnumerable<T> enumerable, [NotNull, InstantHandle] in Predicate<T> predicate, in bool throwInvalidException = true)
+        public static Option<T> SingleOrNone<T>([NotNull] this IEnumerable<T> enumerable, [NotNull, InstantHandle] Predicate<T> predicate, bool throwInvalidException = true)
         {
             Throw.IfArgumentNull(enumerable, nameof(enumerable));
             Throw.IfArgumentNull(predicate, nameof(predicate));
@@ -143,12 +143,12 @@ public static Option<T> LastOrNone<T>([NotNull] this IEnumerable<T> enumerable)
         /// <exception cref="ArgumentNullException">If the <paramref name="enumerable"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="predicate"/> is null.</exception>
         [PublicAPI, Pure]
-        public static Option<T> LastOrNone<T>([NotNull] this IEnumerable<T> enumerable, [NotNull, InstantHandle] in Predicate<T> predicate)
+        public static Option<T> LastOrNone<T>([NotNull] this IEnumerable<T> enumerable, [NotNull, InstantHandle] Predicate<T> predicate)
         {
             Throw.IfArgumentNull(enumerable, nameof(enumerable));
             Throw.IfArgumentNull(predicate, nameof(predicate));
 
-            T matchedItem = default;
+            T matchedItem = default(T);
             bool match = false;
 
             foreach (var item in enumerable)
@@ -288,7 +288,7 @@ public static List<T> ToList<T>([NotNull] this IEnumerable<Option<T>> enumerable
         /// <exception cref="ArgumentNullException">If the <paramref name="enumerable"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="keySelector"/> is null.</exception>
         [PublicAPI, Pure, NotNull]
-        public static Dictionary<TKey, TValue> ToDictionary<TValue, TKey>([NotNull] this IEnumerable<Option<TValue>> enumerable, [NotNull, InstantHandle] in Func<TValue, TKey> keySelector)
+        public static Dictionary<TKey, TValue> ToDictionary<TValue, TKey>([NotNull] this IEnumerable<Option<TValue>> enumerable, [NotNull, InstantHandle] Func<TValue, TKey> keySelector)
         {
             Throw.IfArgumentNull(enumerable, nameof(enumerable));
             Throw.IfArgumentNull(keySelector, nameof(keySelector));
diff --git a/src/Here/Option/Extensions/OptionExtensions.cs b/src/Here/Option/Extensions/OptionExtensions.cs
index c2bcfd5..35d673f 100644
--- a/src/Here/Option/Extensions/OptionExtensions.cs
+++ b/src/Here/Option/Extensions/OptionExtensions.cs
@@ -29,7 +29,7 @@ public static Option<T> ToOption<T>([CanBeNull] this T value)
         /// <param name="nullable">Nullable to convert.</param>
         /// <returns>An <see cref="Option{T}"/>.</returns>
         [PublicAPI, Pure]
-        public static Option<T> ToOption<T>([CanBeNull] in this T? nullable)
+        public static Option<T> ToOption<T>([CanBeNull] this T? nullable)
             where T : struct
         {
             return nullable?.ToOption() ?? Option<T>.None;
@@ -42,7 +42,7 @@ public static Option<T> ToOption<T>([CanBeNull] in this T? nullable)
         /// <param name="option"><see cref="Option{T}"/> to convert.</param>
         /// <returns>An <see cref="Nullable{T}"/>.</returns>
         [PublicAPI, Pure]
-        public static T? ToNullable<T>(in this Option<T> option)
+        public static T? ToNullable<T>(this Option<T> option)
             where T : struct
         {
             return option.HasValue
@@ -56,7 +56,7 @@ public static Option<T> ToOption<T>([CanBeNull] in this T? nullable)
         /// <param name="embeddedOption">An <see cref="Option{T}"/>.</param>
         /// <returns>Flattened <see cref="Option{T}"/>.</returns>
         [PublicAPI, Pure]
-        public static Option<T> Flatten<T>(in this Option<Option<T>> embeddedOption)
+        public static Option<T> Flatten<T>(this Option<Option<T>> embeddedOption)
         {
             return embeddedOption.HasValue ? embeddedOption.Value : Option<T>.None;
         }
@@ -95,7 +95,7 @@ public static Option<string> NoneIfEmptyOrSpace([CanBeNull] this string str)
         /// <param name="option"><see cref="Option{T}"/> on which applying the treatment.</param>
         /// <returns>An <see cref="Option{T}"/>.</returns>
         [PublicAPI, Pure]
-        public static Option<string> NoneIfEmpty(in this Option<string> option)
+        public static Option<string> NoneIfEmpty(this Option<string> option)
         {
             return option.IfElse(
                 str => string.IsNullOrEmpty(str) ? Option<string>.None : Option<string>.Some(str), 
@@ -109,7 +109,7 @@ public static Option<string> NoneIfEmpty(in this Option<string> option)
         /// <param name="option"><see cref="Option{T}"/> on which applying the treatment.</param>
         /// <returns>An <see cref="Option{T}"/>.</returns>
         [PublicAPI, Pure]
-        public static Option<string> NoneIfEmptyOrSpace(in this Option<string> option)
+        public static Option<string> NoneIfEmptyOrSpace(this Option<string> option)
         {
             return option.IfElse(
                 str => string.IsNullOrWhiteSpace(str) ? Option<string>.None : Option<string>.Some(str),
diff --git a/src/Here/Option/Extensions/OptionLinqEnumerableExtensions.cs b/src/Here/Option/Extensions/OptionLinqEnumerableExtensions.cs
index aa8e5dc..069ed19 100644
--- a/src/Here/Option/Extensions/OptionLinqEnumerableExtensions.cs
+++ b/src/Here/Option/Extensions/OptionLinqEnumerableExtensions.cs
@@ -18,7 +18,7 @@ public static class OptionLinqEnumerableExtensions
         /// <param name="option"><see cref="Option{T}"/> on which performing the check.</param>
         /// <returns>True if this <see cref="Option{T}"/> enumerable value has at least one value, otherwise false.</returns>
         [PublicAPI, Pure]
-        public static bool AnyItem<T>(in this Option<T> option)
+        public static bool AnyItem<T>(this Option<T> option)
             where T : IEnumerable
         {
             if (option.HasValue)
@@ -35,7 +35,7 @@ public static bool AnyItem<T>(in this Option<T> option)
         /// <returns>True if this <see cref="Option{T}"/> enumerable has at least one value that matches, otherwise false.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="predicate"/> is null.</exception>
         [PublicAPI, Pure]
-        public static bool AnyItem<T>(in this Option<T> option, [NotNull, InstantHandle] in Predicate<object> predicate)
+        public static bool AnyItem<T>(this Option<T> option, [NotNull, InstantHandle] Predicate<object> predicate)
             where T : IEnumerable
         {
             Throw.IfArgumentNull(predicate, nameof(predicate));
@@ -62,7 +62,7 @@ public static bool AnyItem<T>(in this Option<T> option, [NotNull, InstantHandle]
         /// <returns>True if this <see cref="Option{T}"/> enumerable has at least one value that match, otherwise false.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="predicate"/> is null.</exception>
         [PublicAPI, Pure]
-        public static bool AnyItem<T, TItem>(in this Option<T> option, [NotNull, InstantHandle] Predicate<TItem> predicate)
+        public static bool AnyItem<T, TItem>(this Option<T> option, [NotNull, InstantHandle] Predicate<TItem> predicate)
             where T : IEnumerable<TItem>
         {
             Throw.IfArgumentNull(predicate, nameof(predicate));
@@ -81,7 +81,7 @@ public static bool AnyItem<T, TItem>(in this Option<T> option, [NotNull, Instant
         /// <returns>True if this <see cref="Option{T}"/> enumerable items all match the <paramref name="predicate"/>, otherwise false.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="predicate"/> is null.</exception>
         [PublicAPI, Pure]
-        public static bool AllItems<T>(in this Option<T> option, [NotNull, InstantHandle] in Predicate<object> predicate)
+        public static bool AllItems<T>(this Option<T> option, [NotNull, InstantHandle] Predicate<object> predicate)
             where T : IEnumerable
         {
             Throw.IfArgumentNull(predicate, nameof(predicate));
@@ -110,7 +110,7 @@ public static bool AllItems<T>(in this Option<T> option, [NotNull, InstantHandle
         /// <returns>True if this <see cref="Option{T}"/> enumerable items all match the <paramref name="predicate"/>, otherwise false.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="predicate"/> is null.</exception>
         [PublicAPI, Pure]
-        public static bool AllItems<T, TItem>(in this Option<T> option, [NotNull, InstantHandle] Predicate<TItem> predicate)
+        public static bool AllItems<T, TItem>(this Option<T> option, [NotNull, InstantHandle] Predicate<TItem> predicate)
             where T : IEnumerable<TItem>
         {
             Throw.IfArgumentNull(predicate, nameof(predicate));
@@ -128,7 +128,7 @@ public static bool AllItems<T, TItem>(in this Option<T> option, [NotNull, Instan
         /// <param name="value">Value to check equality with <see cref="Option{T}"/> value.</param>
         /// <returns>True if this <see cref="Option{T}"/> contains the <paramref name="value"/>, otherwise false.</returns>
         [PublicAPI, Pure]
-        public static bool ContainsItem<T>(in this Option<T> option, [CanBeNull] in object value)
+        public static bool ContainsItem<T>(this Option<T> option, [CanBeNull] object value)
             where T : IEnumerable
         {
             if (option.HasValue)
@@ -153,7 +153,7 @@ public static bool ContainsItem<T>(in this Option<T> option, [CanBeNull] in obje
         /// <returns>True if this <see cref="Option{T}"/> contains the <paramref name="value"/>, otherwise false.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="comparer"/> is null.</exception>
         [PublicAPI, Pure]
-        public static bool ContainsItem<T>(in this Option<T> option, [CanBeNull] in object value, [NotNull] in IEqualityComparer<object> comparer)
+        public static bool ContainsItem<T>(this Option<T> option, [CanBeNull] object value, [NotNull] IEqualityComparer<object> comparer)
             where T : IEnumerable
         {
             Throw.IfArgumentNull(comparer, nameof(comparer));
@@ -179,7 +179,7 @@ public static bool ContainsItem<T>(in this Option<T> option, [CanBeNull] in obje
         /// <param name="value">Value to check equality with <see cref="Option{T}"/> value.</param>
         /// <returns>True if this <see cref="Option{T}"/> contains the <paramref name="value"/>, otherwise false.</returns>
         [PublicAPI, Pure]
-        public static bool ContainsItem<T, TItem>(in this Option<T> option, [CanBeNull] in TItem value)
+        public static bool ContainsItem<T, TItem>(this Option<T> option, [CanBeNull] TItem value)
             where T : IEnumerable<TItem>
         {
             if (option.HasValue)
@@ -198,7 +198,7 @@ public static bool ContainsItem<T, TItem>(in this Option<T> option, [CanBeNull]
         /// <returns>True if this <see cref="Option{T}"/> contains the <paramref name="value"/>, otherwise false.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="comparer"/> is null.</exception>
         [PublicAPI, Pure]
-        public static bool ContainsItem<T, TItem>(in this Option<T> option, [CanBeNull] in TItem value, [NotNull] in IEqualityComparer<TItem> comparer)
+        public static bool ContainsItem<T, TItem>(this Option<T> option, [CanBeNull] TItem value, [NotNull] IEqualityComparer<TItem> comparer)
             where T : IEnumerable<TItem>
         {
             Throw.IfArgumentNull(comparer, nameof(comparer));
@@ -218,7 +218,7 @@ public static bool ContainsItem<T, TItem>(in this Option<T> option, [CanBeNull]
         /// <returns>A <see cref="Option{T}"/> with selected items.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="selector"/> is null.</exception>
         [PublicAPI, Pure]
-        public static Option<IEnumerable<TItemOut>> SelectItems<T, TItemOut>(in this Option<T> option, [NotNull, InstantHandle] in Func<object, TItemOut> selector)
+        public static Option<IEnumerable<TItemOut>> SelectItems<T, TItemOut>(this Option<T> option, [NotNull, InstantHandle] Func<object, TItemOut> selector)
             where T : IEnumerable
         {
             Throw.IfArgumentNull(selector, nameof(selector));
@@ -248,7 +248,7 @@ public static Option<IEnumerable<TItemOut>> SelectItems<T, TItemOut>(in this Opt
         /// <returns>A <see cref="Option{T}"/> with selected items.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="selector"/> is null.</exception>
         [PublicAPI, Pure]
-        public static Option<IEnumerable<TItemOut>> SelectItems<T, TItemIn, TItemOut>(in this Option<T> option, [NotNull, InstantHandle] in Func<TItemIn, TItemOut> selector)
+        public static Option<IEnumerable<TItemOut>> SelectItems<T, TItemIn, TItemOut>(this Option<T> option, [NotNull, InstantHandle] Func<TItemIn, TItemOut> selector)
             where T : IEnumerable<TItemIn>
         {
             Throw.IfArgumentNull(selector, nameof(selector));
@@ -272,7 +272,7 @@ public static Option<IEnumerable<TItemOut>> SelectItems<T, TItemIn, TItemOut>(in
         /// <returns>A <see cref="Option{T}"/> with matched items.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="predicate"/> is null.</exception>
         [PublicAPI, Pure]
-        public static Option<IEnumerable> WhereItems<T>(in this Option<T> option, [NotNull, InstantHandle] in Predicate<object> predicate)
+        public static Option<IEnumerable> WhereItems<T>(this Option<T> option, [NotNull, InstantHandle] Predicate<object> predicate)
             where T : IEnumerable
         {
             Throw.IfArgumentNull(predicate, nameof(predicate));
@@ -304,7 +304,7 @@ public static Option<IEnumerable> WhereItems<T>(in this Option<T> option, [NotNu
         /// <returns>A <see cref="Option{T}"/> with matched items.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="predicate"/> is null.</exception>
         [PublicAPI, Pure]
-        public static Option<IEnumerable<TItem>> WhereItems<T, TItem>(in this Option<T> option, [NotNull, InstantHandle] Predicate<TItem> predicate)
+        public static Option<IEnumerable<TItem>> WhereItems<T, TItem>(this Option<T> option, [NotNull, InstantHandle] Predicate<TItem> predicate)
             where T : IEnumerable<TItem>
         {
             Throw.IfArgumentNull(predicate, nameof(predicate));
@@ -329,7 +329,7 @@ public static Option<IEnumerable<TItem>> WhereItems<T, TItem>(in this Option<T>
         /// <returns>This <see cref="Option{T}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onItem"/> is null.</exception>
         [PublicAPI]
-        public static Option<T> ForEachItems<T>(in this Option<T> option, [NotNull, InstantHandle] in Action<object> onItem)
+        public static Option<T> ForEachItems<T>(this Option<T> option, [NotNull, InstantHandle] Action<object> onItem)
             where T : IEnumerable
         {
             Throw.IfArgumentNull(onItem, nameof(onItem));
@@ -353,7 +353,7 @@ public static Option<T> ForEachItems<T>(in this Option<T> option, [NotNull, Inst
         /// <returns>This <see cref="Option{T}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onItem"/> is null.</exception>
         [PublicAPI]
-        public static Option<T> ForEachItems<T, TItem>(in this Option<T> option, [NotNull, InstantHandle] in Action<TItem> onItem)
+        public static Option<T> ForEachItems<T, TItem>(this Option<T> option, [NotNull, InstantHandle] Action<TItem> onItem)
             where T : IEnumerable<TItem>
         {
             Throw.IfArgumentNull(onItem, nameof(onItem));
@@ -381,9 +381,9 @@ public static Option<T> ForEachItems<T, TItem>(in this Option<T> option, [NotNul
         /// <exception cref="ArgumentNullException">If the <paramref name="initialValue"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="aggregator"/> is null.</exception>
         [PublicAPI, NotNull, Pure]
-        public static TAggregate AggregateItems<T, TAggregate>(in this Option<T> option,
-            [NotNull] in TAggregate initialValue,
-            [NotNull, InstantHandle] in Func<TAggregate, object, TAggregate> aggregator)
+        public static TAggregate AggregateItems<T, TAggregate>(this Option<T> option,
+            [NotNull] TAggregate initialValue,
+            [NotNull, InstantHandle] Func<TAggregate, object, TAggregate> aggregator)
             where T : IEnumerable
         {
             Throw.IfArgumentNull(initialValue, nameof(initialValue));
@@ -416,9 +416,9 @@ public static TAggregate AggregateItems<T, TAggregate>(in this Option<T> option,
         /// <exception cref="ArgumentNullException">If the <paramref name="initialValue"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="aggregator"/> is null.</exception>
         [PublicAPI, NotNull, Pure]
-        public static TAggregate AggregateItems<T, TItem, TAggregate>(in this Option<T> option,
-            [NotNull] in TAggregate initialValue,
-            [NotNull, InstantHandle] in Func<TAggregate, TItem, TAggregate> aggregator)
+        public static TAggregate AggregateItems<T, TItem, TAggregate>(this Option<T> option,
+            [NotNull] TAggregate initialValue,
+            [NotNull, InstantHandle] Func<TAggregate, TItem, TAggregate> aggregator)
             where T : IEnumerable<TItem>
         {
             Throw.IfArgumentNull(initialValue, nameof(initialValue));
diff --git a/src/Here/Option/Extensions/OptionLinqExtensions.cs b/src/Here/Option/Extensions/OptionLinqExtensions.cs
index 77893d1..144a08f 100644
--- a/src/Here/Option/Extensions/OptionLinqExtensions.cs
+++ b/src/Here/Option/Extensions/OptionLinqExtensions.cs
@@ -16,7 +16,7 @@ public static class OptionLinqExtensions
         /// <param name="option"><see cref="Option{T}"/> on which performing the check.</param>
         /// <returns>True if this <see cref="Option{T}"/> has a value, otherwise false.</returns>
         [PublicAPI, Pure]
-        public static bool Any<T>(in this Option<T> option)
+        public static bool Any<T>(this Option<T> option)
         {
             return option.HasValue;
         }
@@ -30,7 +30,7 @@ public static bool Any<T>(in this Option<T> option)
         /// <returns>True if this <see cref="Option{T}"/> matches the predicate, otherwise false.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="predicate"/> is null.</exception>
         [PublicAPI, Pure]
-        public static bool Any<T>(in this Option<T> option, [NotNull, InstantHandle] in Predicate<T> predicate)
+        public static bool Any<T>(this Option<T> option, [NotNull, InstantHandle] Predicate<T> predicate)
         {
             return option.Exists(predicate);
         }
@@ -44,7 +44,7 @@ public static bool Any<T>(in this Option<T> option, [NotNull, InstantHandle] in
         /// <returns>True if this <see cref="Option{T}"/> value matches the predicate, otherwise false.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="predicate"/> is null.</exception>
         [PublicAPI, Pure]
-        public static bool All<T>(in this Option<T> option, [NotNull, InstantHandle] in Predicate<T> predicate)
+        public static bool All<T>(this Option<T> option, [NotNull, InstantHandle] Predicate<T> predicate)
         {
             return option.Exists(predicate);
         }
@@ -57,7 +57,7 @@ public static bool All<T>(in this Option<T> option, [NotNull, InstantHandle] in
         /// <param name="value">Value to check equality with <see cref="Option{T}"/> value.</param>
         /// <returns>True if this <see cref="Option{T}"/> contains the given <paramref name="value"/>, otherwise false.</returns>
         [PublicAPI, Pure]
-        public static bool Contains<T>(in this Option<T> option, [CanBeNull] in T value)
+        public static bool Contains<T>(this Option<T> option, [CanBeNull] T value)
         {
             if (option.HasValue)
                 return EqualityComparer<T>.Default.Equals(option.Value, value);
@@ -74,7 +74,7 @@ public static bool Contains<T>(in this Option<T> option, [CanBeNull] in T value)
         /// <returns>An <see cref="Option{T}"/> wrapping selected value.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="selector"/> is null.</exception>
         [PublicAPI, Pure]
-        public static Option<TOut> Select<TIn, TOut>(in this Option<TIn> option, [NotNull, InstantHandle] in Func<TIn, TOut> selector)
+        public static Option<TOut> Select<TIn, TOut>(this Option<TIn> option, [NotNull, InstantHandle] Func<TIn, TOut> selector)
         {
             Throw.IfArgumentNull(selector, nameof(selector));
 
@@ -92,7 +92,7 @@ public static Option<TOut> Select<TIn, TOut>(in this Option<TIn> option, [NotNul
         /// <returns>This <see cref="Option{T}"/> if it matches the <paramref name="predicate"/>, otherwise an empty <see cref="Option{T}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="predicate"/> is null.</exception>
         [PublicAPI, Pure]
-        public static Option<T> Where<T>(in this Option<T> option, [NotNull, InstantHandle] in Predicate<T> predicate)
+        public static Option<T> Where<T>(this Option<T> option, [NotNull, InstantHandle] Predicate<T> predicate)
         {
             if (option.Exists(predicate))
                 return option;
@@ -108,7 +108,7 @@ public static Option<T> Where<T>(in this Option<T> option, [NotNull, InstantHand
         /// <returns>A <see cref="Unit"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="doAction"/> is null.</exception>
         [PublicAPI]
-        public static Unit ForEach<T>(in this Option<T> option, [NotNull, InstantHandle] in Action<T> doAction)
+        public static Unit ForEach<T>(this Option<T> option, [NotNull, InstantHandle] Action<T> doAction)
         {
             Throw.IfArgumentNull(doAction, nameof(doAction));
 
@@ -131,9 +131,9 @@ public static Unit ForEach<T>(in this Option<T> option, [NotNull, InstantHandle]
         /// <exception cref="ArgumentNullException">If the <paramref name="initialValue"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="aggregator"/> is null.</exception>
         [PublicAPI, NotNull, Pure]
-        public static TAggregate Aggregate<T, TAggregate>(in this Option<T> option, 
-            [NotNull] in TAggregate initialValue, 
-            [NotNull, InstantHandle] in Func<TAggregate, T, TAggregate> aggregator)
+        public static TAggregate Aggregate<T, TAggregate>(this Option<T> option, 
+            [NotNull] TAggregate initialValue, 
+            [NotNull, InstantHandle] Func<TAggregate, T, TAggregate> aggregator)
         {
             Throw.IfArgumentNull(initialValue, nameof(initialValue));
             Throw.IfArgumentNull(aggregator, nameof(aggregator));
diff --git a/src/Here/Option/Extensions/OptionNumericCastsExtensions.cs b/src/Here/Option/Extensions/OptionNumericCastsExtensions.cs
index d1fe1d3..b7a1f77 100644
--- a/src/Here/Option/Extensions/OptionNumericCastsExtensions.cs
+++ b/src/Here/Option/Extensions/OptionNumericCastsExtensions.cs
@@ -14,7 +14,7 @@ public static class OptionNumericCastsExtensions
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        private static Option<TTo> SafeConvert<TFrom, TTo>(in this Option<TFrom> option, [NotNull, InstantHandle] Func<TFrom, TTo> converter)
+        private static Option<TTo> SafeConvert<TFrom, TTo>(this Option<TFrom> option, [NotNull, InstantHandle] Func<TFrom, TTo> converter)
         {
             return option.Cast(
                 input =>
@@ -38,7 +38,7 @@ private static Option<TTo> SafeConvert<TFrom, TTo>(in this Option<TFrom> option,
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<bool> ToBool(in this Option<byte> option)
+        public static Option<bool> ToBool(this Option<byte> option)
         {
             return SafeConvert(option, Convert.ToBoolean);
         }
@@ -49,7 +49,7 @@ public static Option<bool> ToBool(in this Option<byte> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<sbyte> ToSByte(in this Option<byte> option)
+        public static Option<sbyte> ToSByte(this Option<byte> option)
         {
             return SafeConvert(option, Convert.ToSByte);
         }
@@ -60,7 +60,7 @@ public static Option<sbyte> ToSByte(in this Option<byte> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<short> ToShort(in this Option<byte> option)
+        public static Option<short> ToShort(this Option<byte> option)
         {
             return SafeConvert(option, Convert.ToInt16);
         }
@@ -71,7 +71,7 @@ public static Option<short> ToShort(in this Option<byte> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<ushort> ToUShort(in this Option<byte> option)
+        public static Option<ushort> ToUShort(this Option<byte> option)
         {
             return SafeConvert(option, Convert.ToUInt16);
         }
@@ -82,7 +82,7 @@ public static Option<ushort> ToUShort(in this Option<byte> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<int> ToInt(in this Option<byte> option)
+        public static Option<int> ToInt(this Option<byte> option)
         {
             return SafeConvert(option, Convert.ToInt32);
         }
@@ -93,7 +93,7 @@ public static Option<int> ToInt(in this Option<byte> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<uint> ToUInt(in this Option<byte> option)
+        public static Option<uint> ToUInt(this Option<byte> option)
         {
             return SafeConvert(option, Convert.ToUInt32);
         }
@@ -104,7 +104,7 @@ public static Option<uint> ToUInt(in this Option<byte> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<long> ToLong(in this Option<byte> option)
+        public static Option<long> ToLong(this Option<byte> option)
         {
             return SafeConvert(option, Convert.ToInt64);
         }
@@ -115,7 +115,7 @@ public static Option<long> ToLong(in this Option<byte> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<ulong> ToULong(in this Option<byte> option)
+        public static Option<ulong> ToULong(this Option<byte> option)
         {
             return SafeConvert(option, Convert.ToUInt64);
         }
@@ -126,7 +126,7 @@ public static Option<ulong> ToULong(in this Option<byte> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<decimal> ToDecimal(in this Option<byte> option)
+        public static Option<decimal> ToDecimal(this Option<byte> option)
         {
             return SafeConvert(option, Convert.ToDecimal);
         }
@@ -137,7 +137,7 @@ public static Option<decimal> ToDecimal(in this Option<byte> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<float> ToFloat(in this Option<byte> option)
+        public static Option<float> ToFloat(this Option<byte> option)
         {
             return SafeConvert(option, Convert.ToSingle);
         }
@@ -148,7 +148,7 @@ public static Option<float> ToFloat(in this Option<byte> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<double> ToDouble(in this Option<byte> option)
+        public static Option<double> ToDouble(this Option<byte> option)
         {
             return SafeConvert(option, Convert.ToDouble);
         }
@@ -163,7 +163,7 @@ public static Option<double> ToDouble(in this Option<byte> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<bool> ToBool(in this Option<sbyte> option)
+        public static Option<bool> ToBool(this Option<sbyte> option)
         {
             return SafeConvert(option, Convert.ToBoolean);
         }
@@ -174,7 +174,7 @@ public static Option<bool> ToBool(in this Option<sbyte> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<byte> ToByte(in this Option<sbyte> option)
+        public static Option<byte> ToByte(this Option<sbyte> option)
         {
             return SafeConvert(option, Convert.ToByte);
         }
@@ -185,7 +185,7 @@ public static Option<byte> ToByte(in this Option<sbyte> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<short> ToShort(in this Option<sbyte> option)
+        public static Option<short> ToShort(this Option<sbyte> option)
         {
             return SafeConvert(option, Convert.ToInt16);
         }
@@ -196,7 +196,7 @@ public static Option<short> ToShort(in this Option<sbyte> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<ushort> ToUShort(in this Option<sbyte> option)
+        public static Option<ushort> ToUShort(this Option<sbyte> option)
         {
             return SafeConvert(option, Convert.ToUInt16);
         }
@@ -207,7 +207,7 @@ public static Option<ushort> ToUShort(in this Option<sbyte> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<int> ToInt(in this Option<sbyte> option)
+        public static Option<int> ToInt(this Option<sbyte> option)
         {
             return SafeConvert(option, Convert.ToInt32);
         }
@@ -218,7 +218,7 @@ public static Option<int> ToInt(in this Option<sbyte> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<uint> ToUInt(in this Option<sbyte> option)
+        public static Option<uint> ToUInt(this Option<sbyte> option)
         {
             return SafeConvert(option, Convert.ToUInt32);
         }
@@ -229,7 +229,7 @@ public static Option<uint> ToUInt(in this Option<sbyte> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<long> ToLong(in this Option<sbyte> option)
+        public static Option<long> ToLong(this Option<sbyte> option)
         {
             return SafeConvert(option, Convert.ToInt64);
         }
@@ -240,7 +240,7 @@ public static Option<long> ToLong(in this Option<sbyte> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<ulong> ToULong(in this Option<sbyte> option)
+        public static Option<ulong> ToULong(this Option<sbyte> option)
         {
             return SafeConvert(option, Convert.ToUInt64);
         }
@@ -251,7 +251,7 @@ public static Option<ulong> ToULong(in this Option<sbyte> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<decimal> ToDecimal(in this Option<sbyte> option)
+        public static Option<decimal> ToDecimal(this Option<sbyte> option)
         {
             return SafeConvert(option, Convert.ToDecimal);
         }
@@ -262,7 +262,7 @@ public static Option<decimal> ToDecimal(in this Option<sbyte> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<float> ToFloat(in this Option<sbyte> option)
+        public static Option<float> ToFloat(this Option<sbyte> option)
         {
             return SafeConvert(option, Convert.ToSingle);
         }
@@ -273,7 +273,7 @@ public static Option<float> ToFloat(in this Option<sbyte> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<double> ToDouble(in this Option<sbyte> option)
+        public static Option<double> ToDouble(this Option<sbyte> option)
         {
             return SafeConvert(option, Convert.ToDouble);
         }
@@ -288,7 +288,7 @@ public static Option<double> ToDouble(in this Option<sbyte> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<bool> ToBool(in this Option<short> option)
+        public static Option<bool> ToBool(this Option<short> option)
         {
             return SafeConvert(option, Convert.ToBoolean);
         }
@@ -299,7 +299,7 @@ public static Option<bool> ToBool(in this Option<short> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<byte> ToByte(in this Option<short> option)
+        public static Option<byte> ToByte(this Option<short> option)
         {
             return SafeConvert(option, Convert.ToByte);
         }
@@ -310,7 +310,7 @@ public static Option<byte> ToByte(in this Option<short> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<sbyte> ToSByte(in this Option<short> option)
+        public static Option<sbyte> ToSByte(this Option<short> option)
         {
             return SafeConvert(option, Convert.ToSByte);
         }
@@ -321,7 +321,7 @@ public static Option<sbyte> ToSByte(in this Option<short> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<ushort> ToUShort(in this Option<short> option)
+        public static Option<ushort> ToUShort(this Option<short> option)
         {
             return SafeConvert(option, Convert.ToUInt16);
         }
@@ -332,7 +332,7 @@ public static Option<ushort> ToUShort(in this Option<short> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<int> ToInt(in this Option<short> option)
+        public static Option<int> ToInt(this Option<short> option)
         {
             return SafeConvert(option, Convert.ToInt32);
         }
@@ -343,7 +343,7 @@ public static Option<int> ToInt(in this Option<short> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<uint> ToUInt(in this Option<short> option)
+        public static Option<uint> ToUInt(this Option<short> option)
         {
             return SafeConvert(option, Convert.ToUInt32);
         }
@@ -354,7 +354,7 @@ public static Option<uint> ToUInt(in this Option<short> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<long> ToLong(in this Option<short> option)
+        public static Option<long> ToLong(this Option<short> option)
         {
             return SafeConvert(option, Convert.ToInt64);
         }
@@ -365,7 +365,7 @@ public static Option<long> ToLong(in this Option<short> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<ulong> ToULong(in this Option<short> option)
+        public static Option<ulong> ToULong(this Option<short> option)
         {
             return SafeConvert(option, Convert.ToUInt64);
         }
@@ -376,7 +376,7 @@ public static Option<ulong> ToULong(in this Option<short> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<decimal> ToDecimal(in this Option<short> option)
+        public static Option<decimal> ToDecimal(this Option<short> option)
         {
             return SafeConvert(option, Convert.ToDecimal);
         }
@@ -387,7 +387,7 @@ public static Option<decimal> ToDecimal(in this Option<short> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<float> ToFloat(in this Option<short> option)
+        public static Option<float> ToFloat(this Option<short> option)
         {
             return SafeConvert(option, Convert.ToSingle);
         }
@@ -398,7 +398,7 @@ public static Option<float> ToFloat(in this Option<short> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<double> ToDouble(in this Option<short> option)
+        public static Option<double> ToDouble(this Option<short> option)
         {
             return SafeConvert(option, Convert.ToDouble);
         }
@@ -413,7 +413,7 @@ public static Option<double> ToDouble(in this Option<short> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<bool> ToBool(in this Option<ushort> option)
+        public static Option<bool> ToBool(this Option<ushort> option)
         {
             return SafeConvert(option, Convert.ToBoolean);
         }
@@ -424,7 +424,7 @@ public static Option<bool> ToBool(in this Option<ushort> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<byte> ToByte(in this Option<ushort> option)
+        public static Option<byte> ToByte(this Option<ushort> option)
         {
             return SafeConvert(option, Convert.ToByte);
         }
@@ -435,7 +435,7 @@ public static Option<byte> ToByte(in this Option<ushort> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<sbyte> ToSByte(in this Option<ushort> option)
+        public static Option<sbyte> ToSByte(this Option<ushort> option)
         {
             return SafeConvert(option, Convert.ToSByte);
         }
@@ -446,7 +446,7 @@ public static Option<sbyte> ToSByte(in this Option<ushort> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<short> ToShort(in this Option<ushort> option)
+        public static Option<short> ToShort(this Option<ushort> option)
         {
             return SafeConvert(option, Convert.ToInt16);
         }
@@ -457,7 +457,7 @@ public static Option<short> ToShort(in this Option<ushort> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<int> ToInt(in this Option<ushort> option)
+        public static Option<int> ToInt(this Option<ushort> option)
         {
             return SafeConvert(option, Convert.ToInt32);
         }
@@ -468,7 +468,7 @@ public static Option<int> ToInt(in this Option<ushort> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<uint> ToUInt(in this Option<ushort> option)
+        public static Option<uint> ToUInt(this Option<ushort> option)
         {
             return SafeConvert(option, Convert.ToUInt32);
         }
@@ -479,7 +479,7 @@ public static Option<uint> ToUInt(in this Option<ushort> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<long> ToLong(in this Option<ushort> option)
+        public static Option<long> ToLong(this Option<ushort> option)
         {
             return SafeConvert(option, Convert.ToInt64);
         }
@@ -490,7 +490,7 @@ public static Option<long> ToLong(in this Option<ushort> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<ulong> ToULong(in this Option<ushort> option)
+        public static Option<ulong> ToULong(this Option<ushort> option)
         {
             return SafeConvert(option, Convert.ToUInt64);
         }
@@ -501,7 +501,7 @@ public static Option<ulong> ToULong(in this Option<ushort> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<decimal> ToDecimal(in this Option<ushort> option)
+        public static Option<decimal> ToDecimal(this Option<ushort> option)
         {
             return SafeConvert(option, Convert.ToDecimal);
         }
@@ -512,7 +512,7 @@ public static Option<decimal> ToDecimal(in this Option<ushort> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<float> ToFloat(in this Option<ushort> option)
+        public static Option<float> ToFloat(this Option<ushort> option)
         {
             return SafeConvert(option, Convert.ToSingle);
         }
@@ -523,7 +523,7 @@ public static Option<float> ToFloat(in this Option<ushort> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<double> ToDouble(in this Option<ushort> option)
+        public static Option<double> ToDouble(this Option<ushort> option)
         {
             return SafeConvert(option, Convert.ToDouble);
         }
@@ -538,7 +538,7 @@ public static Option<double> ToDouble(in this Option<ushort> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<bool> ToBool(in this Option<int> option)
+        public static Option<bool> ToBool(this Option<int> option)
         {
             return SafeConvert(option, Convert.ToBoolean);
         }
@@ -549,7 +549,7 @@ public static Option<bool> ToBool(in this Option<int> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<byte> ToByte(in this Option<int> option)
+        public static Option<byte> ToByte(this Option<int> option)
         {
             return SafeConvert(option, Convert.ToByte);
         }
@@ -560,7 +560,7 @@ public static Option<byte> ToByte(in this Option<int> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<sbyte> ToSByte(in this Option<int> option)
+        public static Option<sbyte> ToSByte(this Option<int> option)
         {
             return SafeConvert(option, Convert.ToSByte);
         }
@@ -571,7 +571,7 @@ public static Option<sbyte> ToSByte(in this Option<int> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<short> ToShort(in this Option<int> option)
+        public static Option<short> ToShort(this Option<int> option)
         {
             return SafeConvert(option, Convert.ToInt16);
         }
@@ -582,7 +582,7 @@ public static Option<short> ToShort(in this Option<int> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<ushort> ToUShort(in this Option<int> option)
+        public static Option<ushort> ToUShort(this Option<int> option)
         {
             return SafeConvert(option, Convert.ToUInt16);
         }
@@ -593,7 +593,7 @@ public static Option<ushort> ToUShort(in this Option<int> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<uint> ToUInt(in this Option<int> option)
+        public static Option<uint> ToUInt(this Option<int> option)
         {
             return SafeConvert(option, Convert.ToUInt32);
         }
@@ -604,7 +604,7 @@ public static Option<uint> ToUInt(in this Option<int> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<long> ToLong(in this Option<int> option)
+        public static Option<long> ToLong(this Option<int> option)
         {
             return SafeConvert(option, Convert.ToInt64);
         }
@@ -615,7 +615,7 @@ public static Option<long> ToLong(in this Option<int> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<ulong> ToULong(in this Option<int> option)
+        public static Option<ulong> ToULong(this Option<int> option)
         {
             return SafeConvert(option, Convert.ToUInt64);
         }
@@ -626,7 +626,7 @@ public static Option<ulong> ToULong(in this Option<int> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<decimal> ToDecimal(in this Option<int> option)
+        public static Option<decimal> ToDecimal(this Option<int> option)
         {
             return SafeConvert(option, Convert.ToDecimal);
         }
@@ -637,7 +637,7 @@ public static Option<decimal> ToDecimal(in this Option<int> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<float> ToFloat(in this Option<int> option)
+        public static Option<float> ToFloat(this Option<int> option)
         {
             return SafeConvert(option, Convert.ToSingle);
         }
@@ -648,7 +648,7 @@ public static Option<float> ToFloat(in this Option<int> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<double> ToDouble(in this Option<int> option)
+        public static Option<double> ToDouble(this Option<int> option)
         {
             return SafeConvert(option, Convert.ToDouble);
         }
@@ -663,7 +663,7 @@ public static Option<double> ToDouble(in this Option<int> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<bool> ToBool(in this Option<uint> option)
+        public static Option<bool> ToBool(this Option<uint> option)
         {
             return SafeConvert(option, Convert.ToBoolean);
         }
@@ -674,7 +674,7 @@ public static Option<bool> ToBool(in this Option<uint> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<byte> ToByte(in this Option<uint> option)
+        public static Option<byte> ToByte(this Option<uint> option)
         {
             return SafeConvert(option, Convert.ToByte);
         }
@@ -685,7 +685,7 @@ public static Option<byte> ToByte(in this Option<uint> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<sbyte> ToSByte(in this Option<uint> option)
+        public static Option<sbyte> ToSByte(this Option<uint> option)
         {
             return SafeConvert(option, Convert.ToSByte);
         }
@@ -696,7 +696,7 @@ public static Option<sbyte> ToSByte(in this Option<uint> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<short> ToShort(in this Option<uint> option)
+        public static Option<short> ToShort(this Option<uint> option)
         {
             return SafeConvert(option, Convert.ToInt16);
         }
@@ -707,7 +707,7 @@ public static Option<short> ToShort(in this Option<uint> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<ushort> ToUShort(in this Option<uint> option)
+        public static Option<ushort> ToUShort(this Option<uint> option)
         {
             return SafeConvert(option, Convert.ToUInt16);
         }
@@ -718,7 +718,7 @@ public static Option<ushort> ToUShort(in this Option<uint> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<int> ToInt(in this Option<uint> option)
+        public static Option<int> ToInt(this Option<uint> option)
         {
             return SafeConvert(option, Convert.ToInt32);
         }
@@ -729,7 +729,7 @@ public static Option<int> ToInt(in this Option<uint> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<long> ToLong(in this Option<uint> option)
+        public static Option<long> ToLong(this Option<uint> option)
         {
             return SafeConvert(option, Convert.ToInt64);
         }
@@ -740,7 +740,7 @@ public static Option<long> ToLong(in this Option<uint> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<ulong> ToULong(in this Option<uint> option)
+        public static Option<ulong> ToULong(this Option<uint> option)
         {
             return SafeConvert(option, Convert.ToUInt64);
         }
@@ -751,7 +751,7 @@ public static Option<ulong> ToULong(in this Option<uint> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<decimal> ToDecimal(in this Option<uint> option)
+        public static Option<decimal> ToDecimal(this Option<uint> option)
         {
             return SafeConvert(option, Convert.ToDecimal);
         }
@@ -762,7 +762,7 @@ public static Option<decimal> ToDecimal(in this Option<uint> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<float> ToFloat(in this Option<uint> option)
+        public static Option<float> ToFloat(this Option<uint> option)
         {
             return SafeConvert(option, Convert.ToSingle);
         }
@@ -773,7 +773,7 @@ public static Option<float> ToFloat(in this Option<uint> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<double> ToDouble(in this Option<uint> option)
+        public static Option<double> ToDouble(this Option<uint> option)
         {
             return SafeConvert(option, Convert.ToDouble);
         }
@@ -788,7 +788,7 @@ public static Option<double> ToDouble(in this Option<uint> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<bool> ToBool(in this Option<long> option)
+        public static Option<bool> ToBool(this Option<long> option)
         {
             return SafeConvert(option, Convert.ToBoolean);
         }
@@ -799,7 +799,7 @@ public static Option<bool> ToBool(in this Option<long> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<byte> ToByte(in this Option<long> option)
+        public static Option<byte> ToByte(this Option<long> option)
         {
             return SafeConvert(option, Convert.ToByte);
         }
@@ -810,7 +810,7 @@ public static Option<byte> ToByte(in this Option<long> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<sbyte> ToSByte(in this Option<long> option)
+        public static Option<sbyte> ToSByte(this Option<long> option)
         {
             return SafeConvert(option, Convert.ToSByte);
         }
@@ -821,7 +821,7 @@ public static Option<sbyte> ToSByte(in this Option<long> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<short> ToShort(in this Option<long> option)
+        public static Option<short> ToShort(this Option<long> option)
         {
             return SafeConvert(option, Convert.ToInt16);
         }
@@ -832,7 +832,7 @@ public static Option<short> ToShort(in this Option<long> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<ushort> ToUShort(in this Option<long> option)
+        public static Option<ushort> ToUShort(this Option<long> option)
         {
             return SafeConvert(option, Convert.ToUInt16);
         }
@@ -843,7 +843,7 @@ public static Option<ushort> ToUShort(in this Option<long> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<int> ToInt(in this Option<long> option)
+        public static Option<int> ToInt(this Option<long> option)
         {
             return SafeConvert(option, Convert.ToInt32);
         }
@@ -854,7 +854,7 @@ public static Option<int> ToInt(in this Option<long> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<uint> ToUInt(in this Option<long> option)
+        public static Option<uint> ToUInt(this Option<long> option)
         {
             return SafeConvert(option, Convert.ToUInt32);
         }
@@ -865,7 +865,7 @@ public static Option<uint> ToUInt(in this Option<long> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<ulong> ToULong(in this Option<long> option)
+        public static Option<ulong> ToULong(this Option<long> option)
         {
             return SafeConvert(option, Convert.ToUInt64);
         }
@@ -876,7 +876,7 @@ public static Option<ulong> ToULong(in this Option<long> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<decimal> ToDecimal(in this Option<long> option)
+        public static Option<decimal> ToDecimal(this Option<long> option)
         {
             return SafeConvert(option, Convert.ToDecimal);
         }
@@ -887,7 +887,7 @@ public static Option<decimal> ToDecimal(in this Option<long> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<float> ToFloat(in this Option<long> option)
+        public static Option<float> ToFloat(this Option<long> option)
         {
             return SafeConvert(option, Convert.ToSingle);
         }
@@ -898,7 +898,7 @@ public static Option<float> ToFloat(in this Option<long> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<double> ToDouble(in this Option<long> option)
+        public static Option<double> ToDouble(this Option<long> option)
         {
             return SafeConvert(option, Convert.ToDouble);
         }
@@ -913,7 +913,7 @@ public static Option<double> ToDouble(in this Option<long> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<bool> ToBool(in this Option<ulong> option)
+        public static Option<bool> ToBool(this Option<ulong> option)
         {
             return SafeConvert(option, Convert.ToBoolean);
         }
@@ -924,7 +924,7 @@ public static Option<bool> ToBool(in this Option<ulong> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<byte> ToByte(in this Option<ulong> option)
+        public static Option<byte> ToByte(this Option<ulong> option)
         {
             return SafeConvert(option, Convert.ToByte);
         }
@@ -935,7 +935,7 @@ public static Option<byte> ToByte(in this Option<ulong> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<sbyte> ToSByte(in this Option<ulong> option)
+        public static Option<sbyte> ToSByte(this Option<ulong> option)
         {
             return SafeConvert(option, Convert.ToSByte);
         }
@@ -946,7 +946,7 @@ public static Option<sbyte> ToSByte(in this Option<ulong> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<short> ToShort(in this Option<ulong> option)
+        public static Option<short> ToShort(this Option<ulong> option)
         {
             return SafeConvert(option, Convert.ToInt16);
         }
@@ -957,7 +957,7 @@ public static Option<short> ToShort(in this Option<ulong> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<ushort> ToUShort(in this Option<ulong> option)
+        public static Option<ushort> ToUShort(this Option<ulong> option)
         {
             return SafeConvert(option, Convert.ToUInt16);
         }
@@ -968,7 +968,7 @@ public static Option<ushort> ToUShort(in this Option<ulong> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<int> ToInt(in this Option<ulong> option)
+        public static Option<int> ToInt(this Option<ulong> option)
         {
             return SafeConvert(option, Convert.ToInt32);
         }
@@ -979,7 +979,7 @@ public static Option<int> ToInt(in this Option<ulong> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<uint> ToUInt(in this Option<ulong> option)
+        public static Option<uint> ToUInt(this Option<ulong> option)
         {
             return SafeConvert(option, Convert.ToUInt32);
         }
@@ -990,7 +990,7 @@ public static Option<uint> ToUInt(in this Option<ulong> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<long> ToLong(in this Option<ulong> option)
+        public static Option<long> ToLong(this Option<ulong> option)
         {
             return SafeConvert(option, Convert.ToInt64);
         }
@@ -1001,7 +1001,7 @@ public static Option<long> ToLong(in this Option<ulong> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<decimal> ToDecimal(in this Option<ulong> option)
+        public static Option<decimal> ToDecimal(this Option<ulong> option)
         {
             return SafeConvert(option, Convert.ToDecimal);
         }
@@ -1012,7 +1012,7 @@ public static Option<decimal> ToDecimal(in this Option<ulong> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<float> ToFloat(in this Option<ulong> option)
+        public static Option<float> ToFloat(this Option<ulong> option)
         {
             return SafeConvert(option, Convert.ToSingle);
         }
@@ -1023,7 +1023,7 @@ public static Option<float> ToFloat(in this Option<ulong> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<double> ToDouble(in this Option<ulong> option)
+        public static Option<double> ToDouble(this Option<ulong> option)
         {
             return SafeConvert(option, Convert.ToDouble);
         }
@@ -1038,7 +1038,7 @@ public static Option<double> ToDouble(in this Option<ulong> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<bool> ToBool(in this Option<decimal> option)
+        public static Option<bool> ToBool(this Option<decimal> option)
         {
             return SafeConvert(option, Convert.ToBoolean);
         }
@@ -1049,7 +1049,7 @@ public static Option<bool> ToBool(in this Option<decimal> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<byte> ToByte(in this Option<decimal> option)
+        public static Option<byte> ToByte(this Option<decimal> option)
         {
             return SafeConvert(option, Convert.ToByte);
         }
@@ -1060,7 +1060,7 @@ public static Option<byte> ToByte(in this Option<decimal> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<sbyte> ToSByte(in this Option<decimal> option)
+        public static Option<sbyte> ToSByte(this Option<decimal> option)
         {
             return SafeConvert(option, Convert.ToSByte);
         }
@@ -1071,7 +1071,7 @@ public static Option<sbyte> ToSByte(in this Option<decimal> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<short> ToShort(in this Option<decimal> option)
+        public static Option<short> ToShort(this Option<decimal> option)
         {
             return SafeConvert(option, Convert.ToInt16);
         }
@@ -1082,7 +1082,7 @@ public static Option<short> ToShort(in this Option<decimal> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<ushort> ToUShort(in this Option<decimal> option)
+        public static Option<ushort> ToUShort(this Option<decimal> option)
         {
             return SafeConvert(option, Convert.ToUInt16);
         }
@@ -1093,7 +1093,7 @@ public static Option<ushort> ToUShort(in this Option<decimal> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<int> ToInt(in this Option<decimal> option)
+        public static Option<int> ToInt(this Option<decimal> option)
         {
             return SafeConvert(option, Convert.ToInt32);
         }
@@ -1104,7 +1104,7 @@ public static Option<int> ToInt(in this Option<decimal> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<uint> ToUInt(in this Option<decimal> option)
+        public static Option<uint> ToUInt(this Option<decimal> option)
         {
             return SafeConvert(option, Convert.ToUInt32);
         }
@@ -1115,7 +1115,7 @@ public static Option<uint> ToUInt(in this Option<decimal> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<long> ToLong(in this Option<decimal> option)
+        public static Option<long> ToLong(this Option<decimal> option)
         {
             return SafeConvert(option, Convert.ToInt64);
         }
@@ -1126,7 +1126,7 @@ public static Option<long> ToLong(in this Option<decimal> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<ulong> ToULong(in this Option<decimal> option)
+        public static Option<ulong> ToULong(this Option<decimal> option)
         {
             return SafeConvert(option, Convert.ToUInt64);
         }
@@ -1137,7 +1137,7 @@ public static Option<ulong> ToULong(in this Option<decimal> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<float> ToFloat(in this Option<decimal> option)
+        public static Option<float> ToFloat(this Option<decimal> option)
         {
             return SafeConvert(option, Convert.ToSingle);
         }
@@ -1148,7 +1148,7 @@ public static Option<float> ToFloat(in this Option<decimal> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<double> ToDouble(in this Option<decimal> option)
+        public static Option<double> ToDouble(this Option<decimal> option)
         {
             return SafeConvert(option, Convert.ToDouble);
         }
@@ -1163,7 +1163,7 @@ public static Option<double> ToDouble(in this Option<decimal> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<bool> ToBool(in this Option<float> option)
+        public static Option<bool> ToBool(this Option<float> option)
         {
             return SafeConvert(option, Convert.ToBoolean);
         }
@@ -1174,7 +1174,7 @@ public static Option<bool> ToBool(in this Option<float> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<byte> ToByte(in this Option<float> option)
+        public static Option<byte> ToByte(this Option<float> option)
         {
             return SafeConvert(option, Convert.ToByte);
         }
@@ -1185,7 +1185,7 @@ public static Option<byte> ToByte(in this Option<float> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<sbyte> ToSByte(in this Option<float> option)
+        public static Option<sbyte> ToSByte(this Option<float> option)
         {
             return SafeConvert(option, Convert.ToSByte);
         }
@@ -1196,7 +1196,7 @@ public static Option<sbyte> ToSByte(in this Option<float> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<short> ToShort(in this Option<float> option)
+        public static Option<short> ToShort(this Option<float> option)
         {
             return SafeConvert(option, Convert.ToInt16);
         }
@@ -1207,7 +1207,7 @@ public static Option<short> ToShort(in this Option<float> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<ushort> ToUShort(in this Option<float> option)
+        public static Option<ushort> ToUShort(this Option<float> option)
         {
             return SafeConvert(option, Convert.ToUInt16);
         }
@@ -1218,7 +1218,7 @@ public static Option<ushort> ToUShort(in this Option<float> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<int> ToInt(in this Option<float> option)
+        public static Option<int> ToInt(this Option<float> option)
         {
             return SafeConvert(option, Convert.ToInt32);
         }
@@ -1229,7 +1229,7 @@ public static Option<int> ToInt(in this Option<float> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<uint> ToUInt(in this Option<float> option)
+        public static Option<uint> ToUInt(this Option<float> option)
         {
             return SafeConvert(option, Convert.ToUInt32);
         }
@@ -1240,7 +1240,7 @@ public static Option<uint> ToUInt(in this Option<float> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<long> ToLong(in this Option<float> option)
+        public static Option<long> ToLong(this Option<float> option)
         {
             return SafeConvert(option, Convert.ToInt64);
         }
@@ -1251,7 +1251,7 @@ public static Option<long> ToLong(in this Option<float> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<ulong> ToULong(in this Option<float> option)
+        public static Option<ulong> ToULong(this Option<float> option)
         {
             return SafeConvert(option, Convert.ToUInt64);
         }
@@ -1262,7 +1262,7 @@ public static Option<ulong> ToULong(in this Option<float> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<decimal> ToDecimal(in this Option<float> option)
+        public static Option<decimal> ToDecimal(this Option<float> option)
         {
             return SafeConvert(option, Convert.ToDecimal);
         }
@@ -1273,7 +1273,7 @@ public static Option<decimal> ToDecimal(in this Option<float> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<double> ToDouble(in this Option<float> option)
+        public static Option<double> ToDouble(this Option<float> option)
         {
             return SafeConvert(option, Convert.ToDouble);
         }
@@ -1288,7 +1288,7 @@ public static Option<double> ToDouble(in this Option<float> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<bool> ToBool(in this Option<double> option)
+        public static Option<bool> ToBool(this Option<double> option)
         {
             return SafeConvert(option, Convert.ToBoolean);
         }
@@ -1299,7 +1299,7 @@ public static Option<bool> ToBool(in this Option<double> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<byte> ToByte(in this Option<double> option)
+        public static Option<byte> ToByte(this Option<double> option)
         {
             return SafeConvert(option, Convert.ToByte);
         }
@@ -1310,7 +1310,7 @@ public static Option<byte> ToByte(in this Option<double> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<sbyte> ToSByte(in this Option<double> option)
+        public static Option<sbyte> ToSByte(this Option<double> option)
         {
             return SafeConvert(option, Convert.ToSByte);
         }
@@ -1321,7 +1321,7 @@ public static Option<sbyte> ToSByte(in this Option<double> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<short> ToShort(in this Option<double> option)
+        public static Option<short> ToShort(this Option<double> option)
         {
             return SafeConvert(option, Convert.ToInt16);
         }
@@ -1332,7 +1332,7 @@ public static Option<short> ToShort(in this Option<double> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<ushort> ToUShort(in this Option<double> option)
+        public static Option<ushort> ToUShort(this Option<double> option)
         {
             return SafeConvert(option, Convert.ToUInt16);
         }
@@ -1343,7 +1343,7 @@ public static Option<ushort> ToUShort(in this Option<double> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<int> ToInt(in this Option<double> option)
+        public static Option<int> ToInt(this Option<double> option)
         {
             return SafeConvert(option, Convert.ToInt32);
         }
@@ -1354,7 +1354,7 @@ public static Option<int> ToInt(in this Option<double> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<uint> ToUInt(in this Option<double> option)
+        public static Option<uint> ToUInt(this Option<double> option)
         {
             return SafeConvert(option, Convert.ToUInt32);
         }
@@ -1365,7 +1365,7 @@ public static Option<uint> ToUInt(in this Option<double> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<long> ToLong(in this Option<double> option)
+        public static Option<long> ToLong(this Option<double> option)
         {
             return SafeConvert(option, Convert.ToInt64);
         }
@@ -1376,7 +1376,7 @@ public static Option<long> ToLong(in this Option<double> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<ulong> ToULong(in this Option<double> option)
+        public static Option<ulong> ToULong(this Option<double> option)
         {
             return SafeConvert(option, Convert.ToUInt64);
         }
@@ -1387,7 +1387,7 @@ public static Option<ulong> ToULong(in this Option<double> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<decimal> ToDecimal(in this Option<double> option)
+        public static Option<decimal> ToDecimal(this Option<double> option)
         {
             return SafeConvert(option, Convert.ToDecimal);
         }
@@ -1398,7 +1398,7 @@ public static Option<decimal> ToDecimal(in this Option<double> option)
         /// <param name="option">The <see cref="Option{T}"/> to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [PublicAPI, Pure]
-        public static Option<float> ToFloat(in this Option<double> option)
+        public static Option<float> ToFloat(this Option<double> option)
         {
             return SafeConvert(option, Convert.ToSingle);
         }
diff --git a/src/Here/Option/Extensions/OptionOperatorsExtensions.cs b/src/Here/Option/Extensions/OptionOperatorsExtensions.cs
index 328184d..7524827 100644
--- a/src/Here/Option/Extensions/OptionOperatorsExtensions.cs
+++ b/src/Here/Option/Extensions/OptionOperatorsExtensions.cs
@@ -18,7 +18,7 @@ public static class OptionOperatorsExtensions
         /// <param name="failureMessage">Failure message in case this <see cref="Option{T}"/> has no value.</param>
         /// <returns>The corresponding <see cref="Result"/>.</returns>
         [PublicAPI, Pure]
-        public static Result ToResult<T>(in this Option<T> option, [CanBeNull] in string failureMessage = null)
+        public static Result ToResult<T>(this Option<T> option, [CanBeNull] string failureMessage = null)
         {
             if (option.HasValue)
                 return Result.Ok();
@@ -33,7 +33,7 @@ public static Result ToResult<T>(in this Option<T> option, [CanBeNull] in string
         /// <param name="failureMessage">Failure message in case the <see cref="Option{T}"/> has no value.</param>
         /// <returns>The corresponding <see cref="Result{T}"/>.</returns>
         [PublicAPI, Pure]
-        public static Result<T> ToValueResult<T>(in this Option<T> option, [CanBeNull] in string failureMessage = null)
+        public static Result<T> ToValueResult<T>(this Option<T> option, [CanBeNull] string failureMessage = null)
         {
             if (option.HasValue)
                 return Result.Ok(option._value);
@@ -51,9 +51,9 @@ public static Result<T> ToValueResult<T>(in this Option<T> option, [CanBeNull] i
         /// <returns>The corresponding <see cref="CustomResult{TError}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorFactory"/> is null.</exception>
         [PublicAPI, Pure]
-        public static CustomResult<TError> ToCustomResult<T, TError>(in this Option<T> option, 
-            [NotNull, InstantHandle] in Func<TError> errorFactory, 
-            [CanBeNull] in string failureMessage = null)
+        public static CustomResult<TError> ToCustomResult<T, TError>(this Option<T> option, 
+            [NotNull, InstantHandle] Func<TError> errorFactory, 
+            [CanBeNull] string failureMessage = null)
         {
             Throw.IfArgumentNull(errorFactory, nameof(errorFactory));
 
@@ -73,9 +73,9 @@ public static CustomResult<TError> ToCustomResult<T, TError>(in this Option<T> o
         /// <returns>The corresponding <see cref="CustomResult{TError}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorObject"/> is null.</exception>
         [PublicAPI, Pure]
-        public static CustomResult<TError> ToCustomResult<T, TError>(in this Option<T> option, 
-            [NotNull] in TError errorObject, 
-            [CanBeNull] in string failureMessage = null)
+        public static CustomResult<TError> ToCustomResult<T, TError>(this Option<T> option, 
+            [NotNull] TError errorObject, 
+            [CanBeNull] string failureMessage = null)
         {
             Throw.IfArgumentNull(errorObject, nameof(errorObject));
 
@@ -95,9 +95,9 @@ public static CustomResult<TError> ToCustomResult<T, TError>(in this Option<T> o
         /// <returns>The corresponding <see cref="Result{T, TError}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorFactory"/> is null.</exception>
         [PublicAPI, Pure]
-        public static Result<T, TError> ToValueCustomResult<T, TError>(in this Option<T> option, 
-            [NotNull, InstantHandle] in Func<TError> errorFactory, 
-            [CanBeNull] in string failureMessage = null)
+        public static Result<T, TError> ToValueCustomResult<T, TError>(this Option<T> option, 
+            [NotNull, InstantHandle] Func<TError> errorFactory, 
+            [CanBeNull] string failureMessage = null)
         {
             Throw.IfArgumentNull(errorFactory, nameof(errorFactory));
 
@@ -117,9 +117,9 @@ public static Result<T, TError> ToValueCustomResult<T, TError>(in this Option<T>
         /// <returns>The corresponding <see cref="Result{T, TError}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorObject"/> is null.</exception>
         [PublicAPI, Pure]
-        public static Result<T, TError> ToValueCustomResult<T, TError>(in this Option<T> option, 
-            [NotNull] in TError errorObject, 
-            [CanBeNull] in string failureMessage = null)
+        public static Result<T, TError> ToValueCustomResult<T, TError>(this Option<T> option, 
+            [NotNull] TError errorObject, 
+            [CanBeNull] string failureMessage = null)
         {
             Throw.IfArgumentNull(errorObject, nameof(errorObject));
 
@@ -142,7 +142,7 @@ public static Result<T, TError> ToValueCustomResult<T, TError>(in this Option<T>
         /// <param name="defaultLeftValue">Default left value to use if the <see cref="Option{T}"/> has no value.</param>
         /// <returns>The corresponding <see cref="Either{TLeft,T}"/>.</returns>
         [PublicAPI, Pure]
-        public static Either<TLeft, T> ToEither<T, TLeft>(in this Option<T> option, [NotNull] in TLeft defaultLeftValue)
+        public static Either<TLeft, T> ToEither<T, TLeft>(this Option<T> option, [NotNull] TLeft defaultLeftValue)
         {
             Throw.IfArgumentNull(defaultLeftValue, nameof(defaultLeftValue));
 
@@ -162,7 +162,7 @@ public static Either<TLeft, T> ToEither<T, TLeft>(in this Option<T> option, [Not
         /// <see cref="Option{T}"/> has no value.</param>
         /// <returns>The corresponding <see cref="Either{TLeft,T}"/>.</returns>
         [PublicAPI, Pure]
-        public static Either<TLeft, T> ToEither<T, TLeft>(in this Option<T> option, [NotNull, InstantHandle] in Func<TLeft> leftValueFactory)
+        public static Either<TLeft, T> ToEither<T, TLeft>(this Option<T> option, [NotNull, InstantHandle] Func<TLeft> leftValueFactory)
         {
             Throw.IfArgumentNull(leftValueFactory, nameof(leftValueFactory));
 
diff --git a/src/Here/Option/Extensions/OptionTryGetExtensions.cs b/src/Here/Option/Extensions/OptionTryGetExtensions.cs
index b428e86..82574ef 100644
--- a/src/Here/Option/Extensions/OptionTryGetExtensions.cs
+++ b/src/Here/Option/Extensions/OptionTryGetExtensions.cs
@@ -46,7 +46,7 @@ public static class OptionTryGetExtensions
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        public static Option<TValue> Get<TInput, TValue>([CanBeNull] in TInput input, [NotNull, InstantHandle] in TryGet<TInput, TValue> tryGetFunc)
+        public static Option<TValue> Get<TInput, TValue>([CanBeNull] TInput input, [NotNull, InstantHandle] TryGet<TInput, TValue> tryGetFunc)
         {
             return tryGetFunc(input, out TValue result)
                 ? result
@@ -68,7 +68,7 @@ public static Option<TValue> Get<TInput, TValue>([CanBeNull] in TInput input, [N
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        public static Option<TValue> DefaultParse<TValue>([CanBeNull] in string input, [NotNull, InstantHandle] in TryParse<TValue> tryParseFunc)
+        public static Option<TValue> DefaultParse<TValue>([CanBeNull] string input, [NotNull, InstantHandle] TryParse<TValue> tryParseFunc)
         {
             return Parse(input, tryParseFunc, NumberStyles.Any, DefaultParseCultureInfo);
         }
@@ -87,7 +87,7 @@ public static Option<TValue> DefaultParse<TValue>([CanBeNull] in string input, [
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        public static Option<TValue> Parse<TValue>([CanBeNull] in string input, [NotNull, InstantHandle] in TryParse<TValue> tryParseFunc, in NumberStyles style, in IFormatProvider culture)
+        public static Option<TValue> Parse<TValue>([CanBeNull] string input, [NotNull, InstantHandle] TryParse<TValue> tryParseFunc, NumberStyles style, IFormatProvider culture)
         {
             return tryParseFunc(input, style, culture, out TValue result)
                 ? result
@@ -137,7 +137,7 @@ public static Option<byte> TryParseByte([CanBeNull] this string str)
         /// <param name="culture">Format provider (culture) to use.</param>
         /// <returns><see cref="Option{T}"/> that wrap the result of the parse.</returns>
         [PublicAPI, Pure]
-        public static Option<byte> TryParseByte([CanBeNull] this string str, in NumberStyles style, in IFormatProvider culture)
+        public static Option<byte> TryParseByte([CanBeNull] this string str, NumberStyles style, IFormatProvider culture)
         {
             return Parse<byte>(str, byte.TryParse, style, culture);
         }
@@ -161,7 +161,7 @@ public static Option<sbyte> TryParseSByte([CanBeNull] this string str)
         /// <param name="culture">Format provider (culture) to use.</param>
         /// <returns><see cref="Option{T}"/> that wrap the result of the parse.</returns>
         [PublicAPI, Pure]
-        public static Option<sbyte> TryParseSByte([CanBeNull] this string str, in NumberStyles style, in IFormatProvider culture)
+        public static Option<sbyte> TryParseSByte([CanBeNull] this string str, NumberStyles style, IFormatProvider culture)
         {
             return Parse<sbyte>(str, sbyte.TryParse, style, culture);
         }
@@ -185,7 +185,7 @@ public static Option<short> TryParseShort([CanBeNull] this string str)
         /// <param name="culture">Format provider (culture) to use.</param>
         /// <returns><see cref="Option{T}"/> that wrap the result of the parse.</returns>
         [PublicAPI, Pure]
-        public static Option<short> TryParseShort([CanBeNull] this string str, in NumberStyles style, in IFormatProvider culture)
+        public static Option<short> TryParseShort([CanBeNull] this string str, NumberStyles style, IFormatProvider culture)
         {
             return Parse<short>(str, short.TryParse, style, culture);
         }
@@ -209,7 +209,7 @@ public static Option<ushort> TryParseUShort([CanBeNull] this string str)
         /// <param name="culture">Format provider (culture) to use.</param>
         /// <returns><see cref="Option{T}"/> that wrap the result of the parse.</returns>
         [PublicAPI, Pure]
-        public static Option<ushort> TryParseUShort([CanBeNull] this string str, in NumberStyles style, in IFormatProvider culture)
+        public static Option<ushort> TryParseUShort([CanBeNull] this string str, NumberStyles style, IFormatProvider culture)
         {
             return Parse<ushort>(str, ushort.TryParse, style, culture);
         }
@@ -233,7 +233,7 @@ public static Option<int> TryParseInt([CanBeNull] this string str)
         /// <param name="culture">Format provider (culture) to use.</param>
         /// <returns><see cref="Option{T}"/> that wrap the result of the parse.</returns>
         [PublicAPI, Pure]
-        public static Option<int> TryParseInt([CanBeNull] this string str, in NumberStyles style, in IFormatProvider culture)
+        public static Option<int> TryParseInt([CanBeNull] this string str, NumberStyles style, IFormatProvider culture)
         {
             return Parse<int>(str, int.TryParse, style, culture);
         }
@@ -257,7 +257,7 @@ public static Option<uint> TryParseUInt([CanBeNull] this string str)
         /// <param name="culture">Format provider (culture) to use.</param>
         /// <returns><see cref="Option{T}"/> that wrap the result of the parse.</returns>
         [PublicAPI, Pure]
-        public static Option<uint> TryParseUInt([CanBeNull] this string str, in NumberStyles style, in IFormatProvider culture)
+        public static Option<uint> TryParseUInt([CanBeNull] this string str, NumberStyles style, IFormatProvider culture)
         {
             return Parse<uint>(str, uint.TryParse, style, culture);
         }
@@ -281,7 +281,7 @@ public static Option<long> TryParseLong([CanBeNull] this string str)
         /// <param name="culture">Format provider (culture) to use.</param>
         /// <returns><see cref="Option{T}"/> that wrap the result of the parse.</returns>
         [PublicAPI, Pure]
-        public static Option<long> TryParseLong([CanBeNull] this string str, in NumberStyles style, in IFormatProvider culture)
+        public static Option<long> TryParseLong([CanBeNull] this string str, NumberStyles style, IFormatProvider culture)
         {
             return Parse<long>(str, long.TryParse, style, culture);
         }
@@ -305,7 +305,7 @@ public static Option<ulong> TryParseULong([CanBeNull] this string str)
         /// <param name="culture">Format provider (culture) to use.</param>
         /// <returns><see cref="Option{T}"/> that wrap the result of the parse.</returns>
         [PublicAPI, Pure]
-        public static Option<ulong> TryParseULong([CanBeNull] this string str, in NumberStyles style, in IFormatProvider culture)
+        public static Option<ulong> TryParseULong([CanBeNull] this string str, NumberStyles style, IFormatProvider culture)
         {
             return Parse<ulong>(str, ulong.TryParse, style, culture);
         }
@@ -329,7 +329,7 @@ public static Option<decimal> TryParseDecimal([CanBeNull] this string str)
         /// <param name="culture">Format provider (culture) to use.</param>
         /// <returns><see cref="Option{T}"/> that wrap the result of the parse.</returns>
         [PublicAPI, Pure]
-        public static Option<decimal> TryParseDecimal([CanBeNull] this string str, in NumberStyles style, in IFormatProvider culture)
+        public static Option<decimal> TryParseDecimal([CanBeNull] this string str, NumberStyles style, IFormatProvider culture)
         {
             return Parse<decimal>(str, decimal.TryParse, style, culture);
         }
@@ -353,7 +353,7 @@ public static Option<float> TryParseFloat([CanBeNull] this string str)
         /// <param name="culture">Format provider (culture) to use.</param>
         /// <returns><see cref="Option{T}"/> that wrap the result of the parse.</returns>
         [PublicAPI, Pure]
-        public static Option<float> TryParseFloat([CanBeNull] this string str, in NumberStyles style, in IFormatProvider culture)
+        public static Option<float> TryParseFloat([CanBeNull] this string str, NumberStyles style, IFormatProvider culture)
         {
             return Parse<float>(str, float.TryParse, style, culture);
         }
@@ -377,7 +377,7 @@ public static Option<double> TryParseDouble([CanBeNull] this string str)
         /// <param name="culture">Format provider (culture) to use.</param>
         /// <returns><see cref="Option{T}"/> that wrap the result of the parse.</returns>
         [PublicAPI, Pure]
-        public static Option<double> TryParseDouble([CanBeNull] this string str, in NumberStyles style, in IFormatProvider culture)
+        public static Option<double> TryParseDouble([CanBeNull] this string str, NumberStyles style, IFormatProvider culture)
         {
             return Parse<double>(str, double.TryParse, style, culture);
         }
diff --git a/src/Here/Option/Option.Implicit.cs b/src/Here/Option/Option.Implicit.cs
index 4d5c6ef..f14b314 100644
--- a/src/Here/Option/Option.Implicit.cs
+++ b/src/Here/Option/Option.Implicit.cs
@@ -11,7 +11,7 @@ public partial struct Option<T>
         /// </summary>
         /// <returns>A None option.</returns>
         [PublicAPI, Pure]
-        public static implicit operator Option<T>([CanBeNull] in Option.NoneClass none)
+        public static implicit operator Option<T>([CanBeNull] Option.NoneClass none)
         {
             return None;
         }
@@ -22,7 +22,7 @@ public static implicit operator Option<T>([CanBeNull] in Option.NoneClass none)
         /// <param name="value">Value to initialize the <see cref="Option{T}"/>.</param>
         /// <returns>An <see cref="Option{T}"/>.</returns>
         [PublicAPI, Pure]
-        public static implicit operator Option<T>([CanBeNull] in T value)
+        public static implicit operator Option<T>([CanBeNull] T value)
         {
             if (value == null)
                 return None;
@@ -36,7 +36,7 @@ public static implicit operator Option<T>([CanBeNull] in T value)
         /// <param name="embeddedOption">A <see cref="Option{T}"/>.</param>
         /// <returns>An <see cref="Option{T}"/>.</returns>
         [PublicAPI, Pure]
-        public static implicit operator Option<T>(in Option<Option<T>> embeddedOption)
+        public static implicit operator Option<T>(Option<Option<T>> embeddedOption)
         {
             return embeddedOption.Flatten();
         }
@@ -47,7 +47,7 @@ public static implicit operator Option<T>(in Option<Option<T>> embeddedOption)
         /// <param name="option"><see cref="Option{T}"/> to convert.</param>
         /// <returns>A corresponding boolean.</returns>
         [PublicAPI, Pure]
-        public static implicit operator bool(in Option<T> option)
+        public static implicit operator bool(Option<T> option)
         {
             return option.HasValue;
         }
@@ -58,7 +58,7 @@ public static implicit operator bool(in Option<T> option)
         /// <param name="option">An <see cref="Option{T}"/> to convert.</param>
         /// <returns>The corresponding <see cref="Result"/>.</returns>
         [PublicAPI, Pure]
-        public static implicit operator Result(in Option<T> option)
+        public static implicit operator Result(Option<T> option)
         {
             return option.ToResult();
         }
@@ -69,7 +69,7 @@ public static implicit operator Result(in Option<T> option)
         /// <param name="option">An <see cref="Option{T}"/> to convert.</param>
         /// <returns>The corresponding <see cref="Result{T}"/>.</returns>
         [PublicAPI, Pure]
-        public static implicit operator Result<T>(in Option<T> option)
+        public static implicit operator Result<T>(Option<T> option)
         {
             return option.ToValueResult();
         }
diff --git a/src/Here/Option/Option.Operations.cs b/src/Here/Option/Option.Operations.cs
index 193fcc9..0091127 100644
--- a/src/Here/Option/Option.Operations.cs
+++ b/src/Here/Option/Option.Operations.cs
@@ -16,7 +16,7 @@ public partial struct Option<T>
         /// <returns>This <see cref="Option{T}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="then"/> is null.</exception>
         [PublicAPI]
-        public Option<T> If([NotNull, InstantHandle] in Action<T> then)
+        public Option<T> If([NotNull, InstantHandle] Action<T> then)
         {
             Throw.IfArgumentNull(then, nameof(then));
 
@@ -32,7 +32,7 @@ public Option<T> If([NotNull, InstantHandle] in Action<T> then)
         /// <returns>This <see cref="Option{T}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="else"/> is null.</exception>
         [PublicAPI]
-        public Option<T> Else([NotNull, InstantHandle] in Action @else)
+        public Option<T> Else([NotNull, InstantHandle] Action @else)
         {
             Throw.IfArgumentNull(@else, nameof(@else));
 
@@ -50,7 +50,7 @@ public Option<T> Else([NotNull, InstantHandle] in Action @else)
         /// <exception cref="ArgumentNullException">If the <paramref name="then"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="else"/> is null.</exception>
         [PublicAPI]
-        public Option<T> IfElse([NotNull, InstantHandle] in Action<T> then, [NotNull, InstantHandle] in Action @else)
+        public Option<T> IfElse([NotNull, InstantHandle] Action<T> then, [NotNull, InstantHandle] Action @else)
         {
             Throw.IfArgumentNull(then, nameof(then));
             Throw.IfArgumentNull(@else, nameof(@else));
@@ -73,7 +73,7 @@ public Option<T> IfElse([NotNull, InstantHandle] in Action<T> then, [NotNull, In
         /// <exception cref="ArgumentNullException">If the <paramref name="then"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="else"/> is null.</exception>
         [PublicAPI]
-        public TResult IfElse<TResult>([NotNull, InstantHandle] in Func<T, TResult> then, [NotNull, InstantHandle] in Func<TResult> @else)
+        public TResult IfElse<TResult>([NotNull, InstantHandle] Func<T, TResult> then, [NotNull, InstantHandle] Func<TResult> @else)
         {
             Throw.IfArgumentNull(then, nameof(then));
             Throw.IfArgumentNull(@else, nameof(@else));
@@ -93,7 +93,7 @@ public TResult IfElse<TResult>([NotNull, InstantHandle] in Func<T, TResult> then
         /// <exception cref="ArgumentNullException">If the <paramref name="then"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="orValue"/> is null.</exception>
         [PublicAPI]
-        public TResult IfOr<TResult>([NotNull, InstantHandle] in Func<T, TResult> then, [NotNull] in TResult orValue)
+        public TResult IfOr<TResult>([NotNull, InstantHandle] Func<T, TResult> then, [NotNull] TResult orValue)
         {
             Throw.IfArgumentNull(then, nameof(then));
             Throw.IfArgumentNull(orValue, nameof(orValue));
@@ -113,7 +113,7 @@ public TResult IfOr<TResult>([NotNull, InstantHandle] in Func<T, TResult> then,
         /// <exception cref="ArgumentNullException">If the <paramref name="else"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="orValue"/> is null.</exception>
         [PublicAPI]
-        public TResult ElseOr<TResult>([NotNull, InstantHandle] in Func<TResult> @else, [NotNull] in TResult orValue)
+        public TResult ElseOr<TResult>([NotNull, InstantHandle] Func<TResult> @else, [NotNull] TResult orValue)
         {
             Throw.IfArgumentNull(@else, nameof(@else));
             Throw.IfArgumentNull(orValue, nameof(orValue));
@@ -130,7 +130,7 @@ public TResult ElseOr<TResult>([NotNull, InstantHandle] in Func<TResult> @else,
         /// <returns>This <see cref="Option{T}"/> value, otherwise the <paramref name="orValue"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="orValue"/> is null.</exception>
         [PublicAPI, Pure, NotNull]
-        public T Or([NotNull] in T orValue)
+        public T Or([NotNull] T orValue)
         {
             Throw.IfArgumentNull(orValue, nameof(orValue));
 
@@ -148,7 +148,7 @@ public T Or([NotNull] in T orValue)
         /// <exception cref="ArgumentNullException">If the <paramref name="orFunc"/> is null.</exception>
         /// <exception cref="NullResultException">If the <see cref="Option{T}"/> has no value and <paramref name="orFunc"/> returns null.</exception>
         [PublicAPI, Pure, NotNull]
-        public T Or([NotNull, InstantHandle] in Func<T> orFunc)
+        public T Or([NotNull, InstantHandle] Func<T> orFunc)
         {
             Throw.IfArgumentNull(orFunc, nameof(orFunc));
 
@@ -167,7 +167,7 @@ public T Or([NotNull, InstantHandle] in Func<T> orFunc)
         /// <returns>This <see cref="Option{T}"/>, otherwise the result of <paramref name="orFunc"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="orFunc"/> is null.</exception>
         [PublicAPI, Pure]
-        public Option<T> Or([NotNull, InstantHandle] in Func<Option<T>> orFunc)
+        public Option<T> Or([NotNull, InstantHandle] Func<Option<T>> orFunc)
         {
             Throw.IfArgumentNull(orFunc, nameof(orFunc));
 
@@ -197,7 +197,7 @@ public T OrDefault()
         /// <exception cref="ArgumentNullException">If the <paramref name="then"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="exception"/> is null.</exception>
         [PublicAPI]
-        public void IfOrThrows([NotNull, InstantHandle] in Action<T> then, [NotNull] in Exception exception)
+        public void IfOrThrows([NotNull, InstantHandle] Action<T> then, [NotNull] Exception exception)
         {
             Throw.IfArgumentNull(then, nameof(then));
             Throw.IfArgumentNull(exception, nameof(exception));
@@ -216,7 +216,7 @@ public void IfOrThrows([NotNull, InstantHandle] in Action<T> then, [NotNull] in
         /// <exception cref="ArgumentNullException">If the <paramref name="then"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="exceptionFunc"/> is null.</exception>
         [PublicAPI]
-        public void IfOrThrows([NotNull, InstantHandle] in Action<T> then, [NotNull, InstantHandle] in Func<Exception> exceptionFunc)
+        public void IfOrThrows([NotNull, InstantHandle] Action<T> then, [NotNull, InstantHandle] Func<Exception> exceptionFunc)
         {
             Throw.IfArgumentNull(then, nameof(then));
             Throw.IfArgumentNull(exceptionFunc, nameof(exceptionFunc));
@@ -237,7 +237,7 @@ public void IfOrThrows([NotNull, InstantHandle] in Action<T> then, [NotNull, Ins
         /// <exception cref="ArgumentNullException">If the <paramref name="then"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="exception"/> is null.</exception>
         [PublicAPI]
-        public TResult IfOrThrows<TResult>([NotNull, InstantHandle] in Func<T, TResult> then, [NotNull] in Exception exception)
+        public TResult IfOrThrows<TResult>([NotNull, InstantHandle] Func<T, TResult> then, [NotNull] Exception exception)
         {
             Throw.IfArgumentNull(then, nameof(then));
             Throw.IfArgumentNull(exception, nameof(exception));
@@ -257,7 +257,7 @@ public TResult IfOrThrows<TResult>([NotNull, InstantHandle] in Func<T, TResult>
         /// <exception cref="ArgumentNullException">If the <paramref name="then"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="exceptionFunc"/> is null.</exception>
         [PublicAPI]
-        public TResult IfOrThrows<TResult>([NotNull, InstantHandle] in Func<T, TResult> then, [NotNull, InstantHandle] in Func<Exception> exceptionFunc)
+        public TResult IfOrThrows<TResult>([NotNull, InstantHandle] Func<T, TResult> then, [NotNull, InstantHandle] Func<Exception> exceptionFunc)
         {
             Throw.IfArgumentNull(then, nameof(then));
             Throw.IfArgumentNull(exceptionFunc, nameof(exceptionFunc));
@@ -274,7 +274,7 @@ public TResult IfOrThrows<TResult>([NotNull, InstantHandle] in Func<T, TResult>
         /// <returns>This <see cref="Option{T}"/> value.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="exception"/> is null.</exception>
         [PublicAPI, NotNull]
-        public T OrThrows([NotNull] in Exception exception)
+        public T OrThrows([NotNull] Exception exception)
         {
             Throw.IfArgumentNull(exception, nameof(exception));
 
@@ -291,7 +291,7 @@ public T OrThrows([NotNull] in Exception exception)
         /// <returns>This <see cref="Option{T}"/> value.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="exceptionFunc"/> is null.</exception>
         [PublicAPI, NotNull]
-        public T OrThrows([NotNull, InstantHandle] in Func<Exception> exceptionFunc)
+        public T OrThrows([NotNull, InstantHandle] Func<Exception> exceptionFunc)
         {
             Throw.IfArgumentNull(exceptionFunc, nameof(exceptionFunc));
 
@@ -307,7 +307,7 @@ public T OrThrows([NotNull, InstantHandle] in Func<Exception> exceptionFunc)
         /// <param name="defaultValue">Default value to use.</param>
         /// <returns>The unwrapped value, otherwise the default one.</returns>
         [PublicAPI, Pure, CanBeNull]
-        public T Unwrap([CanBeNull] in T defaultValue = default)
+        public T Unwrap([CanBeNull] T defaultValue = default(T))
         {
             if (HasValue)
                 return _value;
@@ -321,7 +321,7 @@ public T Unwrap([CanBeNull] in T defaultValue = default)
         /// <returns>The unwrapped value from this <see cref="Option{T}"/> if it has value, otherwise the result from <paramref name="orFunc"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="orFunc"/> is null.</exception>
         [PublicAPI, Pure, CanBeNull]
-        public T Unwrap([NotNull, InstantHandle] in Func<T> orFunc)
+        public T Unwrap([NotNull, InstantHandle] Func<T> orFunc)
         {
             Throw.IfArgumentNull(orFunc, nameof(orFunc));
 
@@ -342,8 +342,8 @@ public T Unwrap([NotNull, InstantHandle] in Func<T> orFunc)
         /// <exception cref="ArgumentNullException">If the <paramref name="converter"/> is null.</exception>
         [PublicAPI, Pure, CanBeNull]
         public TOut Unwrap<TOut>(
-            [NotNull, InstantHandle] in Func<T, TOut> converter, 
-            [CanBeNull] in TOut defaultValue = default)
+            [NotNull, InstantHandle] Func<T, TOut> converter, 
+            [CanBeNull] TOut defaultValue = default(TOut))
         {
             Throw.IfArgumentNull(converter, nameof(converter));
 
@@ -365,8 +365,8 @@ public TOut Unwrap<TOut>(
         /// <exception cref="ArgumentNullException">If the <paramref name="orFunc"/> is null.</exception>
         [PublicAPI, Pure, CanBeNull]
         public TOut Unwrap<TOut>(
-            [NotNull, InstantHandle] in Func<T, TOut> converter, 
-            [NotNull, InstantHandle] in Func<TOut> orFunc)
+            [NotNull, InstantHandle] Func<T, TOut> converter, 
+            [NotNull, InstantHandle] Func<TOut> orFunc)
         {
             Throw.IfArgumentNull(converter, nameof(converter));
             Throw.IfArgumentNull(orFunc, nameof(orFunc));
@@ -384,7 +384,7 @@ public TOut Unwrap<TOut>(
         /// <returns>Converted <see cref="Option{T}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="converter"/> is null.</exception>
         [PublicAPI, Pure]
-        public Option<TTo> Cast<TTo>([NotNull, InstantHandle] in Func<T, TTo> converter)
+        public Option<TTo> Cast<TTo>([NotNull, InstantHandle] Func<T, TTo> converter)
         {
             Throw.IfArgumentNull(converter, nameof(converter));
 
@@ -400,7 +400,7 @@ public Option<TTo> Cast<TTo>([NotNull, InstantHandle] in Func<T, TTo> converter)
         /// <returns>True if this <see cref="Option{T}"/> matches the <paramref name="predicate"/>, otherwise false.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="predicate"/> is null.</exception>
         [PublicAPI, Pure]
-        public bool Exists([NotNull, InstantHandle] in Predicate<T> predicate)
+        public bool Exists([NotNull, InstantHandle] Predicate<T> predicate)
         {
             Throw.IfArgumentNull(predicate, nameof(predicate));
 
diff --git a/src/Here/Option/Option.Operators.cs b/src/Here/Option/Option.Operators.cs
index ed5b23b..130fc67 100644
--- a/src/Here/Option/Option.Operators.cs
+++ b/src/Here/Option/Option.Operators.cs
@@ -12,7 +12,7 @@ public partial struct Option<T>
         /// <param name="option"><see cref="Option{T}"/> to check.</param>
         /// <returns>True if <see cref="Option{T}"/> <see cref="HasNoValue"/>.</returns>
         [PublicAPI, Pure]
-        public static bool operator !(in Option<T> option) => option.HasNoValue;
+        public static bool operator !(Option<T> option) => option.HasNoValue;
 
         /// <summary>
         /// Converts this <see cref="Option{T}"/> if it has a value to an <see cref="Option{T}"/>.
diff --git a/src/Here/Option/Option.cs b/src/Here/Option/Option.cs
index 4c68abb..222a197 100644
--- a/src/Here/Option/Option.cs
+++ b/src/Here/Option/Option.cs
@@ -11,7 +11,7 @@ namespace Here
     /// <typeparam name="T">Type of the value embedded in the <see cref="Option{T}"/>.</typeparam>
     [PublicAPI]
     [DebuggerDisplay("{" + nameof(HasValue) + " ? \"Value = \" + " + nameof(Value) + " : \"No value\"}")]
-    public readonly partial struct Option<T> : IEquatable<T>, IEquatable<Option<T>>, IComparable, IComparable<Option<T>>
+    public partial struct Option<T> : IEquatable<T>, IEquatable<Option<T>>, IComparable, IComparable<Option<T>>
     {
         /// <summary>
         /// Nothing value.
@@ -59,7 +59,7 @@ public T Value
         /// Constructor.
         /// </summary>
         /// <param name="value">A value.</param>
-        private Option([NotNull] in T value)
+        private Option([NotNull] T value)
         {
             HasValue = true;
             _value = value;
@@ -71,7 +71,7 @@ private Option([NotNull] in T value)
         /// <param name="value">A value.</param>
         /// <exception cref="ArgumentNullException">If the <paramref name="value"/> is null.</exception>
         [PublicAPI]
-        public static Option<T> Some([NotNull] in T value)
+        public static Option<T> Some([NotNull] T value)
         {
             if (value == null)
                 throw new ArgumentNullException(nameof(value), "Cannot initialize an Option with a null value.");
@@ -111,7 +111,7 @@ public override bool Equals(object obj)
         /// <param name="equalityComparer">Equality comparer to use to compare values.</param>
         /// <returns>True if the <see cref="Option{T}"/> value is equals to the given value, otherwise false.</returns>
         [Pure]
-        internal static bool AreEqual(in Option<T> option, [CanBeNull] in T value, [CanBeNull] in IEqualityComparer<T> equalityComparer = null)
+        internal static bool AreEqual(Option<T> option, [CanBeNull] T value, [CanBeNull] IEqualityComparer<T> equalityComparer = null)
         {
             if (option.HasNoValue)
                 return false;
@@ -126,7 +126,7 @@ internal static bool AreEqual(in Option<T> option, [CanBeNull] in T value, [CanB
         /// <param name="equalityComparer">Equality comparer to use to compare values.</param>
         /// <returns>True if both <see cref="Option{T}"/> are equal, otherwise false.</returns>
         [Pure]
-        internal static bool AreEqual(in Option<T> option1, in Option<T> option2, [CanBeNull] in IEqualityComparer<T> equalityComparer = null)
+        internal static bool AreEqual(Option<T> option1, Option<T> option2, [CanBeNull] IEqualityComparer<T> equalityComparer = null)
         {
             if (option1.HasNoValue && option2.HasNoValue)
                 return true;
@@ -149,7 +149,7 @@ public override int GetHashCode()
         /// <param name="option1">First <see cref="Option{T}"/> to compare.</param>
         /// <param name="option2">Second <see cref="Option{T}"/> to compare.</param>
         /// <returns>True if both <see cref="Option{T}"/> are equal, otherwise false.</returns>
-        public static bool operator==(in Option<T> option1, in Option<T> option2)
+        public static bool operator==(Option<T> option1, Option<T> option2)
         {
             return AreEqual(option1, option2);
         }
@@ -160,7 +160,7 @@ public override int GetHashCode()
         /// <param name="option1">First <see cref="Option{T}"/> to compare.</param>
         /// <param name="option2">Second <see cref="Option{T}"/> to compare.</param>
         /// <returns>True if <see cref="Option{T}"/> are not equal, otherwise false.</returns>
-        public static bool operator!=(in Option<T> option1, in Option<T> option2)
+        public static bool operator!=(Option<T> option1, Option<T> option2)
         {
             return !(option1 == option2);
         }
@@ -171,7 +171,7 @@ public override int GetHashCode()
         /// <param name="option"><see cref="Option{T}"/> that may embed a value to compare.</param>
         /// <param name="value">Value to compare.</param>
         /// <returns>True if the <see cref="Option{T}"/> value is equals to the given value, otherwise false.</returns>
-        public static bool operator ==(in Option<T> option, in T value)
+        public static bool operator ==(Option<T> option, T value)
         {
             return AreEqual(option, value);
         }
@@ -182,7 +182,7 @@ public override int GetHashCode()
         /// <param name="option"><see cref="Option{T}"/> that may embed a value to compare.</param>
         /// <param name="value">Value to compare.</param>
         /// <returns>True if the <see cref="Option{T}"/> value is not equals to the given value, otherwise false.</returns>
-        public static bool operator !=(in Option<T> option, in T value)
+        public static bool operator !=(Option<T> option, T value)
         {
             return !(option == value);
         }
@@ -193,7 +193,7 @@ public override int GetHashCode()
         /// <param name="value">Value to compare.</param>
         /// <param name="option"><see cref="Option{T}"/> that may embed a value to compare.</param>
         /// <returns>True if the <see cref="Option{T}"/> value is equals to the given value, otherwise false.</returns>
-        public static bool operator ==(in T value, in Option<T> option)
+        public static bool operator ==(T value, Option<T> option)
         {
             return option == value;
         }
@@ -204,7 +204,7 @@ public override int GetHashCode()
         /// <param name="value">Value to compare.</param>
         /// <param name="option"><see cref="Option{T}"/> that may embed a value to compare.</param>
         /// <returns>True if the <see cref="Option{T}"/> value is not equals to the given value, otherwise false.</returns>
-        public static bool operator !=(in T value, in Option<T> option)
+        public static bool operator !=(T value, Option<T> option)
         {
             return !(option == value);
         }
@@ -245,7 +245,7 @@ public int CompareTo(Option<T> other)
         /// <param name="comparer">Equality comparer to use to compare values.</param>
         /// <returns>An integer that indicates the relative order of compared objects.</returns>
         [Pure]
-        internal static int Compare(in Option<T> option1, in Option<T> option2, [CanBeNull] in IComparer<T> comparer = null)
+        internal static int Compare(Option<T> option1, Option<T> option2, [CanBeNull] IComparer<T> comparer = null)
         {
             if (option1.HasValue && !option2.HasValue)
                 return 1;
@@ -260,7 +260,7 @@ internal static int Compare(in Option<T> option1, in Option<T> option2, [CanBeNu
         /// <param name="left">The first <see cref="Option{T}"/> to compare.</param>
         /// <param name="right">The second <see cref="Option{T}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <(in Option<T> left, in Option<T> right)
+        public static bool operator <(Option<T> left, Option<T> right)
         {
             return Compare(left, right) < 0;
         }
@@ -271,7 +271,7 @@ internal static int Compare(in Option<T> option1, in Option<T> option2, [CanBeNu
         /// <param name="left">The first <see cref="Option{T}"/> to compare.</param>
         /// <param name="right">The second <see cref="Option{T}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <=(in Option<T> left, in Option<T> right)
+        public static bool operator <=(Option<T> left, Option<T> right)
         {
             return Compare(left, right) <= 0;
         }
@@ -282,7 +282,7 @@ internal static int Compare(in Option<T> option1, in Option<T> option2, [CanBeNu
         /// <param name="left">The first <see cref="Option{T}"/> to compare.</param>
         /// <param name="right">The second <see cref="Option{T}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >(in Option<T> left, in Option<T> right)
+        public static bool operator >(Option<T> left, Option<T> right)
         {
             return Compare(left, right) > 0;
         }
@@ -293,7 +293,7 @@ internal static int Compare(in Option<T> option1, in Option<T> option2, [CanBeNu
         /// <param name="left">The first <see cref="Option{T}"/> to compare.</param>
         /// <param name="right">The second <see cref="Option{T}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >=(in Option<T> left, in Option<T> right)
+        public static bool operator >=(Option<T> left, Option<T> right)
         {
             return Compare(left, right) >= 0;
         }
diff --git a/src/Here/Option/OptionHelpers.cs b/src/Here/Option/OptionHelpers.cs
index 66a5143..eb78771 100644
--- a/src/Here/Option/OptionHelpers.cs
+++ b/src/Here/Option/OptionHelpers.cs
@@ -17,7 +17,7 @@ public static class OptionHelpers
         /// <param name="equalityComparer">Equality comparer to use to compare values.</param>
         /// <returns>True if both <see cref="Option{T}"/> are equal, otherwise false.</returns>
         [PublicAPI, Pure]
-        public static bool AreEqual<T>(in Option<T> option1, in Option<T> option2, [CanBeNull] in IEqualityComparer<T> equalityComparer = null)
+        public static bool AreEqual<T>(Option<T> option1, Option<T> option2, [CanBeNull] IEqualityComparer<T> equalityComparer = null)
         {
             return Option<T>.AreEqual(option1, option2, equalityComparer);
         }
@@ -30,7 +30,7 @@ public static bool AreEqual<T>(in Option<T> option1, in Option<T> option2, [CanB
         /// <param name="equalityComparer">Equality comparer to use to compare values.</param>
         /// <returns>True if the <see cref="Option{T}"/> value is equals to the given value, otherwise false.</returns>
         [PublicAPI, Pure]
-        public static bool AreEqual<T>(in Option<T> option, [CanBeNull] in T value, [CanBeNull] in IEqualityComparer<T> equalityComparer = null)
+        public static bool AreEqual<T>(Option<T> option, [CanBeNull] T value, [CanBeNull] IEqualityComparer<T> equalityComparer = null)
         {
             return Option<T>.AreEqual(option, value, equalityComparer);
         }
@@ -45,7 +45,7 @@ public static bool AreEqual<T>(in Option<T> option, [CanBeNull] in T value, [Can
         /// <param name="comparer">Equality comparer to use to compare values.</param>
         /// <returns>An integer that indicates the relative order of compared objects.</returns>
         [PublicAPI, Pure]
-        public static int Compare<T>(in Option<T> option1, in Option<T> option2, [CanBeNull] in IComparer<T> comparer = null)
+        public static int Compare<T>(Option<T> option1, Option<T> option2, [CanBeNull] IComparer<T> comparer = null)
         {
             return Option<T>.Compare(option1, option2, comparer);
         }
diff --git a/src/Here/Result/CustomErrorResult.cs b/src/Here/Result/CustomErrorResult.cs
index 6681f2e..cfe28c5 100644
--- a/src/Here/Result/CustomErrorResult.cs
+++ b/src/Here/Result/CustomErrorResult.cs
@@ -10,7 +10,7 @@ namespace Here
     /// </summary>
     [PublicAPI]
     [DebuggerDisplay("{" + nameof(IsSuccess) + " ? \"IsSuccess\" + (" + nameof(IsWarning) + " ? \" with warning\" : System.String.Empty) : \"IsFailure\"}")]
-    public readonly partial struct CustomResult<TError> : IResultError<TError>, IEquatable<CustomResult<TError>>, IComparable, IComparable<CustomResult<TError>>
+    public partial struct CustomResult<TError> : IResultError<TError>, IEquatable<CustomResult<TError>>, IComparable, IComparable<CustomResult<TError>>
     {
         /// <summary>
         /// A success <see cref="CustomResult{TError}"/>.
@@ -45,7 +45,7 @@ namespace Here
         /// <see cref="CustomResult{TError}"/> constructor.
         /// </summary>
         /// <param name="logic">Result logic.</param>
-        internal CustomResult([NotNull] in ResultLogic<TError> logic)
+        internal CustomResult([NotNull] ResultLogic<TError> logic)
         {
             Logic = logic;
         }
@@ -57,7 +57,7 @@ internal CustomResult([NotNull] in ResultLogic<TError> logic)
         /// <param name="message">Result message.</param>
         /// <param name="error">Result error.</param>
         /// <param name="exception">Result embedded exception.</param>
-        internal CustomResult(in bool isWarning, [NotNull] in string message, [CanBeNull] in TError error, [CanBeNull] in Exception exception)
+        internal CustomResult(bool isWarning, [NotNull] string message, [CanBeNull] TError error, [CanBeNull] Exception exception)
         {
             Logic = new ResultLogic<TError>(isWarning, message, error, exception);
         }
@@ -71,7 +71,7 @@ internal CustomResult(in bool isWarning, [NotNull] in string message, [CanBeNull
         /// <param name="value">Value.</param>
         /// <returns>A <see cref="CustomResult{TError}"/>.</returns>
         [PublicAPI, Pure]
-        public Result<T> Cast<T>([CanBeNull] in T value)
+        public Result<T> Cast<T>([CanBeNull] T value)
         {
             if (IsFailure)
                 return ToFailValueResult<T>();
@@ -86,7 +86,7 @@ public Result<T> Cast<T>([CanBeNull] in T value)
         /// <returns>A <see cref="CustomResult{TError}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="valueFactory"/> is null.</exception>
         [PublicAPI, Pure]
-        public Result<T> Cast<T>([NotNull, InstantHandle] in Func<T> valueFactory)
+        public Result<T> Cast<T>([NotNull, InstantHandle] Func<T> valueFactory)
         {
             Throw.IfArgumentNull(valueFactory, nameof(valueFactory));
 
@@ -102,7 +102,7 @@ public Result<T> Cast<T>([NotNull, InstantHandle] in Func<T> valueFactory)
         /// <param name="value">Value.</param>
         /// <returns>A <see cref="Result{T, TError}"/>.</returns>
         [PublicAPI, Pure]
-        public Result<T, TError> CustomCast<T>([CanBeNull] in T value)
+        public Result<T, TError> CustomCast<T>([CanBeNull] T value)
         {
             if (IsFailure)
                 return ToFailValueCustomResult<T>();
@@ -119,7 +119,7 @@ public Result<T, TError> CustomCast<T>([CanBeNull] in T value)
         /// <returns>A <see cref="Result{T, TError}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="valueFactory"/> is null.</exception>
         [PublicAPI, Pure]
-        public Result<T, TError> CustomCast<T>([NotNull, InstantHandle] in Func<T> valueFactory)
+        public Result<T, TError> CustomCast<T>([NotNull, InstantHandle] Func<T> valueFactory)
         {
             Throw.IfArgumentNull(valueFactory, nameof(valueFactory));
 
@@ -165,7 +165,7 @@ internal Result<T> ToFailValueResult<T>()
         /// <param name="errorObject">Custom error object to use.</param>
         /// <returns>A failed <see cref="CustomResult{TError}"/>.</returns>
         [Pure]
-        internal CustomResult<TError> ToFailCustomResult([NotNull] in TError errorObject)
+        internal CustomResult<TError> ToFailCustomResult([NotNull] TError errorObject)
         {
             Debug.Assert(ResultLogic.IsConvertibleToFailure(Logic), "Cannot convert a success CustomResult<TError> to a CustomResult<TError> failure.");
             return Result.CustomFail(Logic.Message, errorObject, Logic.Exception);
@@ -179,7 +179,7 @@ internal CustomResult<TError> ToFailCustomResult([NotNull] in TError errorObject
         /// <param name="exception">Exception to set in the failure <see cref="CustomResult{TError}"/>.</param>
         /// <returns>A failed <see cref="CustomResult{TError}"/>.</returns>
         [Pure]
-        internal CustomResult<TError> ToFailCustomResult([NotNull] in string additionalMessage, [CanBeNull] in Exception exception = null)
+        internal CustomResult<TError> ToFailCustomResult([NotNull] string additionalMessage, [CanBeNull] Exception exception = null)
         {
             Debug.Assert(ResultLogic.IsConvertibleToFailure(Logic), "Cannot convert a success Result<T, TError> to a CustomResult<TError> failure.");
             return Result.CustomFail(Logic.Message + additionalMessage, Logic.Error, exception);
@@ -204,7 +204,7 @@ internal Result<T, TError> ToFailValueCustomResult<T>()
         /// <param name="errorObject">Custom error object to use.</param>
         /// <returns>A failed <see cref="Result{T, TError}"/>.</returns>
         [Pure]
-        internal Result<T, TError> ToFailValueCustomResult<T>([NotNull] in TError errorObject)
+        internal Result<T, TError> ToFailValueCustomResult<T>([NotNull] TError errorObject)
         {
             Debug.Assert(ResultLogic.IsConvertibleToFailure(Logic), "Cannot convert a success CustomResult<TError> to a Result<T, TError> failure.");
             return Result.Fail<T, TError>(Logic.Message, errorObject, Logic.Exception);
@@ -218,7 +218,7 @@ internal Result<T, TError> ToFailValueCustomResult<T>([NotNull] in TError errorO
         /// <param name="exception">Exception to set in the warning <see cref="CustomResult{TError}"/>.</param>
         /// <returns>A warning <see cref="CustomResult{TError}"/>.</returns>
         [Pure]
-        internal CustomResult<TError> ToWarnValueCustomResult([NotNull] in string message, [CanBeNull] in Exception exception = null)
+        internal CustomResult<TError> ToWarnValueCustomResult([NotNull] string message, [CanBeNull] Exception exception = null)
         {
             Debug.Assert(ResultLogic.IsConvertibleToWarning(Logic), "Cannot convert a warning CustomResult<TError> to a CustomResult<TError> warning.");
             return Result.CustomWarn<TError>(message, exception);
@@ -234,7 +234,7 @@ internal CustomResult<TError> ToWarnValueCustomResult([NotNull] in string messag
         /// <param name="other"><see cref="CustomResult{TError}"/> to compare.</param>
         /// <returns>True if both <see cref="CustomResult{TError}"/> are equal and successful, otherwise false.</returns>
         [PublicAPI, Pure]
-        public bool SuccessEquals(in CustomResult<TError> other)
+        public bool SuccessEquals(CustomResult<TError> other)
         {
             if (IsSuccess && other.IsSuccess)
                 return Equals(other);
@@ -261,7 +261,7 @@ public override bool Equals(object obj)
         /// <param name="result1">First <see cref="CustomResult{TError}"/> to compare.</param>
         /// <param name="result2">Second <see cref="CustomResult{TError}"/> to compare.</param>
         /// <returns>True if both <see cref="CustomResult{TError}"/> are equal, otherwise false.</returns>
-        public static bool operator ==(in CustomResult<TError> result1, in CustomResult<TError> result2)
+        public static bool operator ==(CustomResult<TError> result1, CustomResult<TError> result2)
         {
             return result1.Equals(result2);
         }
@@ -272,7 +272,7 @@ public override bool Equals(object obj)
         /// <param name="result1">First <see cref="CustomResult{TError}"/> to compare.</param>
         /// <param name="result2">Second <see cref="CustomResult{TError}"/> to compare.</param>
         /// <returns>True if both <see cref="CustomResult{TError}"/> are not equal, otherwise false.</returns>
-        public static bool operator !=(in CustomResult<TError> result1, in CustomResult<TError> result2)
+        public static bool operator !=(CustomResult<TError> result1, CustomResult<TError> result2)
         {
             return !(result1 == result2);
         }
@@ -314,7 +314,7 @@ public int CompareTo(CustomResult<TError> other)
         /// <param name="left">The first <see cref="CustomResult{TError}"/> to compare.</param>
         /// <param name="right">The second <see cref="CustomResult{TError}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <(in CustomResult<TError> left, in CustomResult<TError> right)
+        public static bool operator <(CustomResult<TError> left, CustomResult<TError> right)
         {
             return left.CompareTo(right) < 0;
         }
@@ -325,7 +325,7 @@ public int CompareTo(CustomResult<TError> other)
         /// <param name="left">The first <see cref="CustomResult{TError}"/> to compare.</param>
         /// <param name="right">The second <see cref="CustomResult{TError}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <=(in CustomResult<TError> left, in CustomResult<TError> right)
+        public static bool operator <=(CustomResult<TError> left, CustomResult<TError> right)
         {
             return left.CompareTo(right) <= 0;
         }
@@ -336,7 +336,7 @@ public int CompareTo(CustomResult<TError> other)
         /// <param name="left">The first <see cref="CustomResult{TError}"/> to compare.</param>
         /// <param name="right">The second <see cref="CustomResult{TError}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >(in CustomResult<TError> left, in CustomResult<TError> right)
+        public static bool operator >(CustomResult<TError> left, CustomResult<TError> right)
         {
             return left.CompareTo(right) > 0;
         }
@@ -347,7 +347,7 @@ public int CompareTo(CustomResult<TError> other)
         /// <param name="left">The first <see cref="CustomResult{TError}"/> to compare.</param>
         /// <param name="right">The second <see cref="CustomResult{TError}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >=(in CustomResult<TError> left, in CustomResult<TError> right)
+        public static bool operator >=(CustomResult<TError> left, CustomResult<TError> right)
         {
             return left.CompareTo(right) >= 0;
         }
diff --git a/src/Here/Result/Extensions/ResultExtensions.cs b/src/Here/Result/Extensions/ResultExtensions.cs
index fa8b2af..6d5c085 100644
--- a/src/Here/Result/Extensions/ResultExtensions.cs
+++ b/src/Here/Result/Extensions/ResultExtensions.cs
@@ -34,7 +34,7 @@ public static bool IsOnlySuccess([NotNull] this IResult result)
         /// <param name="defaultValue">Default value to use.</param>
         /// <returns>The unwrapped value from this <see cref="IResult{T}"/> if it has a value, otherwise the default value.</returns>
         [PublicAPI, Pure]
-        public static T Unwrap<T>([NotNull]this IResult<T> result, [CanBeNull] in T defaultValue = default)
+        public static T Unwrap<T>([NotNull]this IResult<T> result, [CanBeNull] T defaultValue = default(T))
         {
             if (result.IsSuccess)
                 return result.Value;
@@ -51,7 +51,7 @@ public static T Unwrap<T>([NotNull]this IResult<T> result, [CanBeNull] in T defa
         /// <returns>The unwrapped value from this <see cref="IResult{T}"/> if it has a value, otherwise the default value.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="orFunc"/> is null.</exception>
         [PublicAPI, Pure]
-        public static T Unwrap<T>([NotNull] this IResult<T> result, [NotNull, InstantHandle] in Func<T> orFunc)
+        public static T Unwrap<T>([NotNull] this IResult<T> result, [NotNull, InstantHandle] Func<T> orFunc)
         {
             Throw.IfArgumentNull(orFunc, nameof(orFunc));
 
@@ -74,8 +74,8 @@ public static T Unwrap<T>([NotNull] this IResult<T> result, [NotNull, InstantHan
         /// <exception cref="ArgumentNullException">If the <paramref name="converter"/> is null.</exception>
         [PublicAPI, Pure]
         public static TOut Unwrap<T, TOut>([NotNull] this IResult<T> result,
-            [NotNull, InstantHandle] in Func<T, TOut> converter,
-            [CanBeNull] in TOut defaultValue = default)
+            [NotNull, InstantHandle] Func<T, TOut> converter,
+            [CanBeNull] TOut defaultValue = default(TOut))
         {
             Throw.IfArgumentNull(converter, nameof(converter));
 
@@ -99,8 +99,8 @@ public static TOut Unwrap<T, TOut>([NotNull] this IResult<T> result,
         /// <exception cref="ArgumentNullException">If the <paramref name="orFunc"/> is null.</exception>
         [PublicAPI, Pure]
         public static TOut Unwrap<T, TOut>([NotNull] this IResult<T> result,
-            [NotNull, InstantHandle] in Func<T, TOut> converter,
-            [NotNull, InstantHandle] in Func<TOut> orFunc)
+            [NotNull, InstantHandle] Func<T, TOut> converter,
+            [NotNull, InstantHandle] Func<TOut> orFunc)
         {
             Throw.IfArgumentNull(converter, nameof(converter));
             Throw.IfArgumentNull(orFunc, nameof(orFunc));
@@ -124,7 +124,7 @@ public static TOut Unwrap<T, TOut>([NotNull] this IResult<T> result,
         /// <exception cref="ArgumentNullException">If the <paramref name="predicate"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorMessage"/> is null or empty.</exception>
         [PublicAPI, Pure]
-        public static Result Ensure(in this Result result, [NotNull, InstantHandle] in Func<bool> predicate, [NotNull] in string errorMessage)
+        public static Result Ensure(this Result result, [NotNull, InstantHandle] Func<bool> predicate, [NotNull] string errorMessage)
         {
             Throw.IfArgumentNull(predicate, nameof(predicate));
             Throw.IfArgumentNull(errorMessage, nameof(errorMessage));
@@ -153,7 +153,7 @@ public static Result Ensure(in this Result result, [NotNull, InstantHandle] in F
         /// <exception cref="ArgumentNullException">If the <paramref name="predicate"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorMessage"/> is null or empty.</exception>
         [PublicAPI, Pure]
-        public static Result<T> Ensure<T>(in this Result<T> result, [NotNull, InstantHandle] in Predicate<T> predicate, [NotNull] in string errorMessage)
+        public static Result<T> Ensure<T>(this Result<T> result, [NotNull, InstantHandle] Predicate<T> predicate, [NotNull] string errorMessage)
         {
             Throw.IfArgumentNull(predicate, nameof(predicate));
             Throw.IfArgumentNull(errorMessage, nameof(errorMessage));
@@ -173,7 +173,7 @@ public static Result<T> Ensure<T>(in this Result<T> result, [NotNull, InstantHan
         /// <param name="embeddedResult">A <see cref="Result{Result}"/>.</param>
         /// <returns>Flattened <see cref="Result"/>.</returns>
         [PublicAPI, Pure]
-        public static Result Flatten(in this Result<Result> embeddedResult)
+        public static Result Flatten(this Result<Result> embeddedResult)
         {
             if (embeddedResult.IsFailure)
             {
@@ -210,7 +210,7 @@ public static Result Flatten(in this Result<Result> embeddedResult)
         /// <param name="embeddedResult">A <see cref="Result{Result}"/>.</param>
         /// <returns>Flattened <see cref="Result{T}"/>.</returns>
         [PublicAPI, Pure]
-        public static Result<T> Flatten<T>(in this Result<Result<T>> embeddedResult)
+        public static Result<T> Flatten<T>(this Result<Result<T>> embeddedResult)
         {
             if (embeddedResult.IsFailure)
             {
@@ -258,10 +258,10 @@ public static Result<T> Flatten<T>(in this Result<Result<T>> embeddedResult)
         /// <exception cref="ArgumentNullException">If the <paramref name="errorMessage"/> is null or empty.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorObject"/> is null or empty.</exception>
         [PublicAPI, Pure]
-        public static CustomResult<TError> Ensure<TError>(in this CustomResult<TError> result, 
-            [NotNull, InstantHandle] in Func<bool> predicate, 
-            [NotNull] in string errorMessage, 
-            [NotNull] in TError errorObject)
+        public static CustomResult<TError> Ensure<TError>(this CustomResult<TError> result, 
+            [NotNull, InstantHandle] Func<bool> predicate, 
+            [NotNull] string errorMessage, 
+            [NotNull] TError errorObject)
         {
             Throw.IfArgumentNull(predicate, nameof(predicate));
             Throw.IfArgumentNull(errorMessage, nameof(errorMessage));
@@ -289,10 +289,10 @@ public static CustomResult<TError> Ensure<TError>(in this CustomResult<TError> r
         /// <exception cref="ArgumentNullException">If the <paramref name="errorMessage"/> is null or empty.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorFactory"/> is null or empty.</exception>
         [PublicAPI, Pure]
-        public static CustomResult<TError> Ensure<TError>(in this CustomResult<TError> result,
-            [NotNull, InstantHandle] in Func<bool> predicate,
-            [NotNull] in string errorMessage,
-            [NotNull, InstantHandle] in Func<TError> errorFactory)
+        public static CustomResult<TError> Ensure<TError>(this CustomResult<TError> result,
+            [NotNull, InstantHandle] Func<bool> predicate,
+            [NotNull] string errorMessage,
+            [NotNull, InstantHandle] Func<TError> errorFactory)
         {
             Throw.IfArgumentNull(predicate, nameof(predicate));
             Throw.IfArgumentNull(errorMessage, nameof(errorMessage));
@@ -325,10 +325,10 @@ public static CustomResult<TError> Ensure<TError>(in this CustomResult<TError> r
         /// <exception cref="ArgumentNullException">If the <paramref name="errorMessage"/> is null or empty.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorObject"/> is null or empty.</exception>
         [PublicAPI, Pure]
-        public static Result<T, TError> Ensure<T, TError>(in this Result<T, TError> result,
-            [NotNull, InstantHandle] in Predicate<T> predicate,
-            [NotNull] in string errorMessage,
-            [NotNull] in TError errorObject)
+        public static Result<T, TError> Ensure<T, TError>(this Result<T, TError> result,
+            [NotNull, InstantHandle] Predicate<T> predicate,
+            [NotNull] string errorMessage,
+            [NotNull] TError errorObject)
         {
             Throw.IfArgumentNull(predicate, nameof(predicate));
             Throw.IfArgumentNull(errorMessage, nameof(errorMessage));
@@ -357,10 +357,10 @@ public static Result<T, TError> Ensure<T, TError>(in this Result<T, TError> resu
         /// <exception cref="ArgumentNullException">If the <paramref name="errorMessage"/> is null or empty.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorFactory"/> is null or empty.</exception>
         [PublicAPI, Pure]
-        public static Result<T, TError> Ensure<T, TError>(in this Result<T, TError> result,
-            [NotNull, InstantHandle] in Predicate<T> predicate,
-            [NotNull] in string errorMessage,
-            [NotNull, InstantHandle] in Func<TError> errorFactory)
+        public static Result<T, TError> Ensure<T, TError>(this Result<T, TError> result,
+            [NotNull, InstantHandle] Predicate<T> predicate,
+            [NotNull] string errorMessage,
+            [NotNull, InstantHandle] Func<TError> errorFactory)
         {
             Throw.IfArgumentNull(predicate, nameof(predicate));
             Throw.IfArgumentNull(errorMessage, nameof(errorMessage));
@@ -381,7 +381,7 @@ public static Result<T, TError> Ensure<T, TError>(in this Result<T, TError> resu
         /// <param name="embeddedResult">A <see cref="Result{Result, TError}"/>.</param>
         /// <returns>Flattened <see cref="Result"/>.</returns>
         [PublicAPI, Pure]
-        public static Result Flatten<TError>(in this Result<Result, TError> embeddedResult)
+        public static Result Flatten<TError>(this Result<Result, TError> embeddedResult)
         {
             Result<Result> tmpResult = embeddedResult;
             return tmpResult.Flatten();
@@ -393,7 +393,7 @@ public static Result Flatten<TError>(in this Result<Result, TError> embeddedResu
         /// <param name="embeddedResult">A <see cref="Result{Result, TError}"/>.</param>
         /// <returns>Flattened <see cref="Result{T}"/>.</returns>
         [PublicAPI, Pure]
-        public static Result<T> Flatten<T, TError>(in this Result<Result<T>, TError> embeddedResult)
+        public static Result<T> Flatten<T, TError>(this Result<Result<T>, TError> embeddedResult)
         {
             Result<Result<T>> tmpResult = embeddedResult;
             return tmpResult.Flatten();
@@ -405,7 +405,7 @@ public static Result<T> Flatten<T, TError>(in this Result<Result<T>, TError> emb
         /// <param name="embeddedResult">A <see cref="Result{Result, TError}"/>.</param>
         /// <returns>Flattened <see cref="CustomResult{TError}"/>.</returns>
         [PublicAPI, Pure]
-        public static CustomResult<TError> Flatten<TError>(in this Result<CustomResult<TError>, TError> embeddedResult)
+        public static CustomResult<TError> Flatten<TError>(this Result<CustomResult<TError>, TError> embeddedResult)
         {
             if (embeddedResult.IsFailure)
             {
@@ -442,7 +442,7 @@ public static CustomResult<TError> Flatten<TError>(in this Result<CustomResult<T
         /// <param name="embeddedResult">A <see cref="Result{Result, TError}"/>.</param>
         /// <returns>Flattened <see cref="Result{T, TError}"/>.</returns>
         [PublicAPI, Pure]
-        public static Result<T, TError> Flatten<T, TError>(in this Result<Result<T, TError>, TError> embeddedResult)
+        public static Result<T, TError> Flatten<T, TError>(this Result<Result<T, TError>, TError> embeddedResult)
         {
             if (embeddedResult.IsFailure)
             {
diff --git a/src/Here/Result/Extensions/ResultExtensions_OnAny.cs b/src/Here/Result/Extensions/ResultExtensions_OnAny.cs
index 05e62e1..a0e8320 100644
--- a/src/Here/Result/Extensions/ResultExtensions_OnAny.cs
+++ b/src/Here/Result/Extensions/ResultExtensions_OnAny.cs
@@ -24,7 +24,7 @@ public static partial class ResultExtensions
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        public static Result OnAny(in this Result result, [NotNull, InstantHandle] in Action onAny)
+        public static Result OnAny(this Result result, [NotNull, InstantHandle] Action onAny)
         {
             Throw.IfArgumentNull(onAny, nameof(onAny));
 
@@ -43,7 +43,7 @@ public static Result OnAny(in this Result result, [NotNull, InstantHandle] in Ac
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        public static Result OnAny(in this Result result, [NotNull, InstantHandle] in Action<Result> onAny)
+        public static Result OnAny(this Result result, [NotNull, InstantHandle] Action<Result> onAny)
         {
             Throw.IfArgumentNull(onAny, nameof(onAny));
 
@@ -63,7 +63,7 @@ public static Result OnAny(in this Result result, [NotNull, InstantHandle] in Ac
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        public static TOut OnAny<TOut>(in this Result result, [NotNull, InstantHandle] in Func<TOut> onAny)
+        public static TOut OnAny<TOut>(this Result result, [NotNull, InstantHandle] Func<TOut> onAny)
         {
             Throw.IfArgumentNull(onAny, nameof(onAny));
 
@@ -82,7 +82,7 @@ public static TOut OnAny<TOut>(in this Result result, [NotNull, InstantHandle] i
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        public static TOut OnAny<TOut>(in this Result result, [NotNull, InstantHandle] in Func<Result, TOut> onAny)
+        public static TOut OnAny<TOut>(this Result result, [NotNull, InstantHandle] Func<Result, TOut> onAny)
         {
             Throw.IfArgumentNull(onAny, nameof(onAny));
 
@@ -105,7 +105,7 @@ public static TOut OnAny<TOut>(in this Result result, [NotNull, InstantHandle] i
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        public static Result<T> OnAny<T>(in this Result<T> result, [NotNull, InstantHandle] in Action onAny)
+        public static Result<T> OnAny<T>(this Result<T> result, [NotNull, InstantHandle] Action onAny)
         {
             Throw.IfArgumentNull(onAny, nameof(onAny));
 
@@ -125,7 +125,7 @@ public static Result<T> OnAny<T>(in this Result<T> result, [NotNull, InstantHand
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        public static Result<T> OnAny<T>(in this Result<T> result, [NotNull, InstantHandle] in Action<Result<T>> onAny)
+        public static Result<T> OnAny<T>(this Result<T> result, [NotNull, InstantHandle] Action<Result<T>> onAny)
         {
             Throw.IfArgumentNull(onAny, nameof(onAny));
 
@@ -146,7 +146,7 @@ public static Result<T> OnAny<T>(in this Result<T> result, [NotNull, InstantHand
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        public static TOut OnAny<TIn, TOut>(in this Result<TIn> result, [NotNull, InstantHandle] in Func<TOut> onAny)
+        public static TOut OnAny<TIn, TOut>(this Result<TIn> result, [NotNull, InstantHandle] Func<TOut> onAny)
         {
             Throw.IfArgumentNull(onAny, nameof(onAny));
 
@@ -166,7 +166,7 @@ public static TOut OnAny<TIn, TOut>(in this Result<TIn> result, [NotNull, Instan
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        public static TOut OnAny<TIn, TOut>(in this Result<TIn> result, [NotNull, InstantHandle] in Func<Result<TIn>, TOut> onAny)
+        public static TOut OnAny<TIn, TOut>(this Result<TIn> result, [NotNull, InstantHandle] Func<Result<TIn>, TOut> onAny)
         {
             Throw.IfArgumentNull(onAny, nameof(onAny));
 
@@ -189,7 +189,7 @@ public static TOut OnAny<TIn, TOut>(in this Result<TIn> result, [NotNull, Instan
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        public static CustomResult<TError> OnAny<TError>(in this CustomResult<TError> result, [NotNull, InstantHandle] in Action onAny)
+        public static CustomResult<TError> OnAny<TError>(this CustomResult<TError> result, [NotNull, InstantHandle] Action onAny)
         {
             Throw.IfArgumentNull(onAny, nameof(onAny));
 
@@ -209,7 +209,7 @@ public static CustomResult<TError> OnAny<TError>(in this CustomResult<TError> re
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        public static CustomResult<TError> OnAny<TError>(in this CustomResult<TError> result, [NotNull, InstantHandle] in Action<CustomResult<TError>> onAny)
+        public static CustomResult<TError> OnAny<TError>(this CustomResult<TError> result, [NotNull, InstantHandle] Action<CustomResult<TError>> onAny)
         {
             Throw.IfArgumentNull(onAny, nameof(onAny));
 
@@ -230,7 +230,7 @@ public static CustomResult<TError> OnAny<TError>(in this CustomResult<TError> re
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        public static TOut OnAny<TOut, TError>(in this CustomResult<TError> result, [NotNull, InstantHandle] in Func<TOut> onAny)
+        public static TOut OnAny<TOut, TError>(this CustomResult<TError> result, [NotNull, InstantHandle] Func<TOut> onAny)
         {
             Throw.IfArgumentNull(onAny, nameof(onAny));
 
@@ -250,7 +250,7 @@ public static TOut OnAny<TOut, TError>(in this CustomResult<TError> result, [Not
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        public static TOut OnAny<TOut, TError>(in this CustomResult<TError> result, [NotNull, InstantHandle] in Func<CustomResult<TError>, TOut> onAny)
+        public static TOut OnAny<TOut, TError>(this CustomResult<TError> result, [NotNull, InstantHandle] Func<CustomResult<TError>, TOut> onAny)
         {
             Throw.IfArgumentNull(onAny, nameof(onAny));
 
@@ -274,7 +274,7 @@ public static TOut OnAny<TOut, TError>(in this CustomResult<TError> result, [Not
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        public static Result<T, TError> OnAny<T, TError>(in this Result<T, TError> result, [NotNull, InstantHandle] in Action onAny)
+        public static Result<T, TError> OnAny<T, TError>(this Result<T, TError> result, [NotNull, InstantHandle] Action onAny)
         {
             Throw.IfArgumentNull(onAny, nameof(onAny));
 
@@ -295,7 +295,7 @@ public static Result<T, TError> OnAny<T, TError>(in this Result<T, TError> resul
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        public static Result<T, TError> OnAny<T, TError>(in this Result<T, TError> result, [NotNull, InstantHandle] in Action<Result<T, TError>> onAny)
+        public static Result<T, TError> OnAny<T, TError>(this Result<T, TError> result, [NotNull, InstantHandle] Action<Result<T, TError>> onAny)
         {
             Throw.IfArgumentNull(onAny, nameof(onAny));
 
@@ -317,7 +317,7 @@ public static Result<T, TError> OnAny<T, TError>(in this Result<T, TError> resul
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        public static TOut OnAny<TIn, TOut, TError>(in this Result<TIn, TError> result, [NotNull, InstantHandle] in Func<TOut> onAny)
+        public static TOut OnAny<TIn, TOut, TError>(this Result<TIn, TError> result, [NotNull, InstantHandle] Func<TOut> onAny)
         {
             Throw.IfArgumentNull(onAny, nameof(onAny));
 
@@ -338,7 +338,7 @@ public static TOut OnAny<TIn, TOut, TError>(in this Result<TIn, TError> result,
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        public static TOut OnAny<TIn, TOut, TError>(in this Result<TIn, TError> result, [NotNull, InstantHandle] in Func<Result<TIn, TError>, TOut> onAny)
+        public static TOut OnAny<TIn, TOut, TError>(this Result<TIn, TError> result, [NotNull, InstantHandle] Func<Result<TIn, TError>, TOut> onAny)
         {
             Throw.IfArgumentNull(onAny, nameof(onAny));
 
diff --git a/src/Here/Result/Extensions/ResultExtensions_OnFailure.cs b/src/Here/Result/Extensions/ResultExtensions_OnFailure.cs
index 0ac738e..d02da48 100644
--- a/src/Here/Result/Extensions/ResultExtensions_OnFailure.cs
+++ b/src/Here/Result/Extensions/ResultExtensions_OnFailure.cs
@@ -19,7 +19,7 @@ public static partial class ResultExtensions
         /// <returns>This <see cref="Result"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         [PublicAPI]
-        public static Result OnFailure(in this Result result, [NotNull, InstantHandle] in Action onFailure, in bool treatWarningAsError = false)
+        public static Result OnFailure(this Result result, [NotNull, InstantHandle] Action onFailure, bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
 
@@ -38,7 +38,7 @@ public static Result OnFailure(in this Result result, [NotNull, InstantHandle] i
         /// <returns>This <see cref="Result"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         [PublicAPI]
-        public static Result OnFailure(in this Result result, [NotNull, InstantHandle] in Action<Result> onFailure, in bool treatWarningAsError = false)
+        public static Result OnFailure(this Result result, [NotNull, InstantHandle] Action<Result> onFailure, bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
 
@@ -59,10 +59,10 @@ public static Result OnFailure(in this Result result, [NotNull, InstantHandle] i
         /// <returns>An output value.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         [PublicAPI]
-        public static TOut OnFailure<TOut>(in this Result result, 
-            [NotNull, InstantHandle] in Func<Result, TOut> onFailure, 
-            [CanBeNull] in TOut defaultValue,
-            in bool treatWarningAsError = false)
+        public static TOut OnFailure<TOut>(this Result result, 
+            [NotNull, InstantHandle] Func<Result, TOut> onFailure, 
+            [CanBeNull] TOut defaultValue,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
 
@@ -84,10 +84,10 @@ public static TOut OnFailure<TOut>(in this Result result,
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="valueFactory"/> is null.</exception>
         [PublicAPI]
-        public static TOut OnFailure<TOut>(in this Result result,
-            [NotNull, InstantHandle] in Func<Result, TOut> onFailure,
-            [NotNull, InstantHandle] in Func<TOut> valueFactory,
-            in bool treatWarningAsError = false)
+        public static TOut OnFailure<TOut>(this Result result,
+            [NotNull, InstantHandle] Func<Result, TOut> onFailure,
+            [NotNull, InstantHandle] Func<TOut> valueFactory,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
             Throw.IfArgumentNull(valueFactory, nameof(valueFactory));
@@ -111,7 +111,7 @@ public static TOut OnFailure<TOut>(in this Result result,
         /// <returns>This <see cref="Result{T}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         [PublicAPI]
-        public static Result<T> OnFailure<T>(in this Result<T> result, [NotNull, InstantHandle] in Action onFailure, in bool treatWarningAsError = false)
+        public static Result<T> OnFailure<T>(this Result<T> result, [NotNull, InstantHandle] Action onFailure, bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
 
@@ -131,7 +131,7 @@ public static Result<T> OnFailure<T>(in this Result<T> result, [NotNull, Instant
         /// <returns>This <see cref="Result{T}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         [PublicAPI]
-        public static Result<T> OnFailure<T>(in this Result<T> result, [NotNull, InstantHandle] in Action<Result<T>> onFailure, in bool treatWarningAsError = false)
+        public static Result<T> OnFailure<T>(this Result<T> result, [NotNull, InstantHandle] Action<Result<T>> onFailure, bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
 
@@ -153,10 +153,10 @@ public static Result<T> OnFailure<T>(in this Result<T> result, [NotNull, Instant
         /// <returns>An output value.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         [PublicAPI]
-        public static TOut OnFailure<TIn, TOut>(in this Result<TIn> result,
-            [NotNull, InstantHandle] in Func<Result<TIn>, TOut> onFailure,
-            [CanBeNull] in TOut defaultValue,
-            in bool treatWarningAsError = false)
+        public static TOut OnFailure<TIn, TOut>(this Result<TIn> result,
+            [NotNull, InstantHandle] Func<Result<TIn>, TOut> onFailure,
+            [CanBeNull] TOut defaultValue,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
 
@@ -179,10 +179,10 @@ public static TOut OnFailure<TIn, TOut>(in this Result<TIn> result,
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="valueFactory"/> is null.</exception>
         [PublicAPI]
-        public static TOut OnFailure<TIn, TOut>(in this Result<TIn> result,
-            [NotNull, InstantHandle] in Func<Result<TIn>, TOut> onFailure,
-            [NotNull, InstantHandle] in Func<TIn, TOut> valueFactory,
-            in bool treatWarningAsError = false)
+        public static TOut OnFailure<TIn, TOut>(this Result<TIn> result,
+            [NotNull, InstantHandle] Func<Result<TIn>, TOut> onFailure,
+            [NotNull, InstantHandle] Func<TIn, TOut> valueFactory,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
             Throw.IfArgumentNull(valueFactory, nameof(valueFactory));
@@ -206,9 +206,9 @@ public static TOut OnFailure<TIn, TOut>(in this Result<TIn> result,
         /// <returns>This <see cref="CustomResult{TError}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         [PublicAPI]
-        public static CustomResult<TError> OnFailure<TError>(in this CustomResult<TError> result, 
-            [NotNull, InstantHandle] in Action onFailure,
-            in bool treatWarningAsError = false)
+        public static CustomResult<TError> OnFailure<TError>(this CustomResult<TError> result, 
+            [NotNull, InstantHandle] Action onFailure,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
 
@@ -228,9 +228,9 @@ public static CustomResult<TError> OnFailure<TError>(in this CustomResult<TError
         /// <returns>This <see cref="CustomResult{TError}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         [PublicAPI]
-        public static CustomResult<TError> OnFailure<TError>(in this CustomResult<TError> result, 
-            [NotNull, InstantHandle] in Action<CustomResult<TError>> onFailure,
-            in bool treatWarningAsError = false)
+        public static CustomResult<TError> OnFailure<TError>(this CustomResult<TError> result, 
+            [NotNull, InstantHandle] Action<CustomResult<TError>> onFailure,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
 
@@ -252,10 +252,10 @@ public static CustomResult<TError> OnFailure<TError>(in this CustomResult<TError
         /// <returns>An output value.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         [PublicAPI]
-        public static TOut OnFailure<TOut, TError>(in this CustomResult<TError> result,
-            [NotNull, InstantHandle] in Func<CustomResult<TError>, TOut> onFailure,
-            [CanBeNull] in TOut defaultValue,
-            in bool treatWarningAsError = false)
+        public static TOut OnFailure<TOut, TError>(this CustomResult<TError> result,
+            [NotNull, InstantHandle] Func<CustomResult<TError>, TOut> onFailure,
+            [CanBeNull] TOut defaultValue,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
 
@@ -278,10 +278,10 @@ public static TOut OnFailure<TOut, TError>(in this CustomResult<TError> result,
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="valueFactory"/> is null.</exception>
         [PublicAPI]
-        public static TOut OnFailure<TOut, TError>(in this CustomResult<TError> result,
-            [NotNull, InstantHandle] in Func<CustomResult<TError>, TOut> onFailure,
-            [NotNull, InstantHandle] in Func<TOut> valueFactory,
-            in bool treatWarningAsError = false)
+        public static TOut OnFailure<TOut, TError>(this CustomResult<TError> result,
+            [NotNull, InstantHandle] Func<CustomResult<TError>, TOut> onFailure,
+            [NotNull, InstantHandle] Func<TOut> valueFactory,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
             Throw.IfArgumentNull(valueFactory, nameof(valueFactory));
@@ -306,9 +306,9 @@ public static TOut OnFailure<TOut, TError>(in this CustomResult<TError> result,
         /// <returns>This <see cref="Result{T, TError}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         [PublicAPI]
-        public static Result<T, TError> OnFailure<T, TError>(in this Result<T, TError> result,
-            [NotNull, InstantHandle] in Action onFailure,
-            in bool treatWarningAsError = false)
+        public static Result<T, TError> OnFailure<T, TError>(this Result<T, TError> result,
+            [NotNull, InstantHandle] Action onFailure,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
 
@@ -329,9 +329,9 @@ public static Result<T, TError> OnFailure<T, TError>(in this Result<T, TError> r
         /// <returns>This <see cref="Result{T, TError}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         [PublicAPI]
-        public static Result<T, TError> OnFailure<T, TError>(in this Result<T, TError> result,
-            [NotNull, InstantHandle] in Action<Result<T, TError>> onFailure,
-            in bool treatWarningAsError = false)
+        public static Result<T, TError> OnFailure<T, TError>(this Result<T, TError> result,
+            [NotNull, InstantHandle] Action<Result<T, TError>> onFailure,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
 
@@ -354,10 +354,10 @@ public static Result<T, TError> OnFailure<T, TError>(in this Result<T, TError> r
         /// <returns>An output value.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         [PublicAPI]
-        public static TOut OnFailure<TIn, TOut, TError>(in this Result<TIn, TError> result,
-            [NotNull, InstantHandle] in Func<Result<TIn, TError>, TOut> onFailure,
-            [CanBeNull] in TOut defaultValue,
-            in bool treatWarningAsError = false)
+        public static TOut OnFailure<TIn, TOut, TError>(this Result<TIn, TError> result,
+            [NotNull, InstantHandle] Func<Result<TIn, TError>, TOut> onFailure,
+            [CanBeNull] TOut defaultValue,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
 
@@ -381,10 +381,10 @@ public static TOut OnFailure<TIn, TOut, TError>(in this Result<TIn, TError> resu
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="valueFactory"/> is null.</exception>
         [PublicAPI]
-        public static TOut OnFailure<TIn, TOut, TError>(in this Result<TIn, TError> result,
-            [NotNull, InstantHandle] in Func<Result<TIn, TError>, TOut> onFailure,
-            [NotNull, InstantHandle] in Func<TIn, TOut> valueFactory,
-            in bool treatWarningAsError = false)
+        public static TOut OnFailure<TIn, TOut, TError>(this Result<TIn, TError> result,
+            [NotNull, InstantHandle] Func<Result<TIn, TError>, TOut> onFailure,
+            [NotNull, InstantHandle] Func<TIn, TOut> valueFactory,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
             Throw.IfArgumentNull(valueFactory, nameof(valueFactory));
diff --git a/src/Here/Result/Extensions/ResultExtensions_OnSuccess.cs b/src/Here/Result/Extensions/ResultExtensions_OnSuccess.cs
index 47d2971..fa6a60e 100644
--- a/src/Here/Result/Extensions/ResultExtensions_OnSuccess.cs
+++ b/src/Here/Result/Extensions/ResultExtensions_OnSuccess.cs
@@ -20,7 +20,7 @@ public static partial class ResultExtensions
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        private static bool IsConsideredFailure([NotNull] in IResult result, in bool treatWarningAsError)
+        private static bool IsConsideredFailure([NotNull] IResult result, bool treatWarningAsError)
         {
             return result.IsFailure || (treatWarningAsError && result.IsWarning);
         }
@@ -34,7 +34,7 @@ private static bool IsConsideredFailure([NotNull] in IResult result, in bool tre
 #if SUPPORTS_AGGRESSIVE_INLINING
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #endif
-        private static bool IsConsideredSuccess([NotNull] in IResult result, in bool treatWarningAsError)
+        private static bool IsConsideredSuccess([NotNull] IResult result, bool treatWarningAsError)
         {
             return !IsConsideredFailure(result, treatWarningAsError);
         }
@@ -50,7 +50,7 @@ private static bool IsConsideredSuccess([NotNull] in IResult result, in bool tre
         /// <returns>This <see cref="Result"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         [PublicAPI]
-        public static Result OnSuccess(in this Result result, [NotNull, InstantHandle] in Action onSuccess, in bool treatWarningAsError = false)
+        public static Result OnSuccess(this Result result, [NotNull, InstantHandle] Action onSuccess, bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
 
@@ -69,7 +69,7 @@ public static Result OnSuccess(in this Result result, [NotNull, InstantHandle] i
         /// <returns>This <see cref="Result"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         [PublicAPI]
-        public static Result OnSuccess(in this Result result, [NotNull, InstantHandle] in Action<Result> onSuccess, in bool treatWarningAsError = false)
+        public static Result OnSuccess(this Result result, [NotNull, InstantHandle] Action<Result> onSuccess, bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
 
@@ -88,7 +88,7 @@ public static Result OnSuccess(in this Result result, [NotNull, InstantHandle] i
         /// <returns>A <see cref="Result"/> resulting of <paramref name="onSuccess"/>, otherwise a failure.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         [PublicAPI]
-        public static Result OnSuccess(in this Result result, [NotNull, InstantHandle] in Func<Result, Result> onSuccess, in bool treatWarningAsError = false)
+        public static Result OnSuccess(this Result result, [NotNull, InstantHandle] Func<Result, Result> onSuccess, bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
 
@@ -110,7 +110,7 @@ public static Result OnSuccess(in this Result result, [NotNull, InstantHandle] i
         /// <returns>A <see cref="Result{T}"/> resulting of <paramref name="onSuccess"/>, otherwise a failure.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         [PublicAPI]
-        public static Result<T> OnSuccess<T>(in this Result result, [NotNull, InstantHandle] in Func<Result, T> onSuccess, in bool treatWarningAsError = false)
+        public static Result<T> OnSuccess<T>(this Result result, [NotNull, InstantHandle] Func<Result, T> onSuccess, bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
 
@@ -130,7 +130,7 @@ public static Result<T> OnSuccess<T>(in this Result result, [NotNull, InstantHan
         /// <returns>A <see cref="Result{T}"/> resulting of <paramref name="onSuccess"/>, otherwise a failure.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         [PublicAPI]
-        public static Result<T> OnSuccess<T>(in this Result result, [NotNull, InstantHandle] in Func<Result, Result<T>> onSuccess, in bool treatWarningAsError = false)
+        public static Result<T> OnSuccess<T>(this Result result, [NotNull, InstantHandle] Func<Result, Result<T>> onSuccess, bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
 
@@ -154,10 +154,10 @@ public static Result<T> OnSuccess<T>(in this Result result, [NotNull, InstantHan
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorObject"/> is null.</exception>
         [PublicAPI]
-        public static CustomResult<TError> OnSuccess<TError>(in this Result result,
-            [NotNull, InstantHandle] in Func<Result, CustomResult<TError>> onSuccess,
-            [NotNull] in TError errorObject,
-            in bool treatWarningAsError = false)
+        public static CustomResult<TError> OnSuccess<TError>(this Result result,
+            [NotNull, InstantHandle] Func<Result, CustomResult<TError>> onSuccess,
+            [NotNull] TError errorObject,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(errorObject, nameof(errorObject));
@@ -182,10 +182,10 @@ public static CustomResult<TError> OnSuccess<TError>(in this Result result,
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorFactory"/> is null.</exception>
         [PublicAPI]
-        public static CustomResult<TError> OnSuccess<TError>(in this Result result,
-            [NotNull, InstantHandle] in Func<Result, CustomResult<TError>> onSuccess,
-            [NotNull, InstantHandle] in Func<Result, TError> errorFactory,
-            in bool treatWarningAsError = false)
+        public static CustomResult<TError> OnSuccess<TError>(this Result result,
+            [NotNull, InstantHandle] Func<Result, CustomResult<TError>> onSuccess,
+            [NotNull, InstantHandle] Func<Result, TError> errorFactory,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(errorFactory, nameof(errorFactory));
@@ -211,10 +211,10 @@ public static CustomResult<TError> OnSuccess<TError>(in this Result result,
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorObject"/> is null.</exception>
         [PublicAPI]
-        public static Result<T, TError> OnSuccess<T, TError>(in this Result result,
-            [NotNull, InstantHandle] in Func<Result, Result<T, TError>> onSuccess,
-            [NotNull] in TError errorObject,
-            in bool treatWarningAsError = false)
+        public static Result<T, TError> OnSuccess<T, TError>(this Result result,
+            [NotNull, InstantHandle] Func<Result, Result<T, TError>> onSuccess,
+            [NotNull] TError errorObject,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(errorObject, nameof(errorObject));
@@ -240,10 +240,10 @@ public static Result<T, TError> OnSuccess<T, TError>(in this Result result,
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorFactory"/> is null.</exception>
         [PublicAPI]
-        public static Result<T, TError> OnSuccess<T, TError>(in this Result result, 
-            [NotNull, InstantHandle] in Func<Result, Result<T, TError>> onSuccess, 
-            [NotNull, InstantHandle] in Func<Result, TError> errorFactory,
-            in bool treatWarningAsError = false)
+        public static Result<T, TError> OnSuccess<T, TError>(this Result result, 
+            [NotNull, InstantHandle] Func<Result, Result<T, TError>> onSuccess, 
+            [NotNull, InstantHandle] Func<Result, TError> errorFactory,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(errorFactory, nameof(errorFactory));
@@ -265,10 +265,10 @@ public static Result<T, TError> OnSuccess<T, TError>(in this Result result,
         /// <returns>An output value.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         [PublicAPI]
-        public static TOut OnSuccess<TOut>(in this Result result,
-            [NotNull, InstantHandle] in Func<Result, TOut> onSuccess,
-            [CanBeNull] in TOut defaultValue,
-            in bool treatWarningAsError = false)
+        public static TOut OnSuccess<TOut>(this Result result,
+            [NotNull, InstantHandle] Func<Result, TOut> onSuccess,
+            [CanBeNull] TOut defaultValue,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
 
@@ -290,10 +290,10 @@ public static TOut OnSuccess<TOut>(in this Result result,
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="valueFactory"/> is null.</exception>
         [PublicAPI]
-        public static TOut OnSuccess<TOut>(in this Result result,
-            [NotNull, InstantHandle] in Func<Result, TOut> onSuccess,
-            [NotNull, InstantHandle] in Func<Result, TOut> valueFactory,
-            in bool treatWarningAsError = false)
+        public static TOut OnSuccess<TOut>(this Result result,
+            [NotNull, InstantHandle] Func<Result, TOut> onSuccess,
+            [NotNull, InstantHandle] Func<Result, TOut> valueFactory,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(valueFactory, nameof(valueFactory));
@@ -317,9 +317,9 @@ public static TOut OnSuccess<TOut>(in this Result result,
         /// <returns>This <see cref="Result{T}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         [PublicAPI]
-        public static Result<T> OnSuccess<T>(in this Result<T> result,
-            [NotNull, InstantHandle] in Action<T> onSuccess,
-            in bool treatWarningAsError = false)
+        public static Result<T> OnSuccess<T>(this Result<T> result,
+            [NotNull, InstantHandle] Action<T> onSuccess,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
 
@@ -340,9 +340,9 @@ public static Result<T> OnSuccess<T>(in this Result<T> result,
         /// <returns>A <see cref="Result{TOut}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="converter"/> is null.</exception>
         [PublicAPI]
-        public static Result<TOut> OnSuccess<TIn, TOut>(in this Result<TIn> result,
-            [NotNull, InstantHandle] in Func<TIn, TOut> converter,
-            in bool treatWarningAsError = false)
+        public static Result<TOut> OnSuccess<TIn, TOut>(this Result<TIn> result,
+            [NotNull, InstantHandle] Func<TIn, TOut> converter,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(converter, nameof(converter));
 
@@ -362,9 +362,9 @@ public static Result<TOut> OnSuccess<TIn, TOut>(in this Result<TIn> result,
         /// <returns>A <see cref="Result"/> resulting of <paramref name="onSuccess"/>, otherwise a failure.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         [PublicAPI]
-        public static Result OnSuccess<T>(in this Result<T> result,
-            [NotNull, InstantHandle] in Func<T, Result> onSuccess,
-            in bool treatWarningAsError = false)
+        public static Result OnSuccess<T>(this Result<T> result,
+            [NotNull, InstantHandle] Func<T, Result> onSuccess,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
 
@@ -388,9 +388,9 @@ public static Result OnSuccess<T>(in this Result<T> result,
         /// <returns>A <see cref="Result{TOut}"/> resulting of <paramref name="onSuccess"/>, otherwise a failure.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         [PublicAPI]
-        public static Result<TOut> OnSuccess<TIn, TOut>(in this Result<TIn> result,
-            [NotNull, InstantHandle] in Func<TIn, Result<TOut>> onSuccess,
-            in bool treatWarningAsError = false)
+        public static Result<TOut> OnSuccess<TIn, TOut>(this Result<TIn> result,
+            [NotNull, InstantHandle] Func<TIn, Result<TOut>> onSuccess,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
 
@@ -415,10 +415,10 @@ public static Result<TOut> OnSuccess<TIn, TOut>(in this Result<TIn> result,
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorObject"/> is null.</exception>
         [PublicAPI]
-        public static CustomResult<TError> OnSuccess<T, TError>(in this Result<T> result,
-            [NotNull, InstantHandle] in Func<T, CustomResult<TError>> onSuccess,
-            [NotNull] in TError errorObject,
-            in bool treatWarningAsError = false)
+        public static CustomResult<TError> OnSuccess<T, TError>(this Result<T> result,
+            [NotNull, InstantHandle] Func<T, CustomResult<TError>> onSuccess,
+            [NotNull] TError errorObject,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(errorObject, nameof(errorObject));
@@ -444,10 +444,10 @@ public static CustomResult<TError> OnSuccess<T, TError>(in this Result<T> result
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorFactory"/> is null.</exception>
         [PublicAPI]
-        public static CustomResult<TError> OnSuccess<T, TError>(in this Result<T> result,
-            [NotNull, InstantHandle] in Func<T, CustomResult<TError>> onSuccess,
-            [NotNull, InstantHandle] in Func<Result<T>, TError> errorFactory,
-            in bool treatWarningAsError = false)
+        public static CustomResult<TError> OnSuccess<T, TError>(this Result<T> result,
+            [NotNull, InstantHandle] Func<T, CustomResult<TError>> onSuccess,
+            [NotNull, InstantHandle] Func<Result<T>, TError> errorFactory,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(errorFactory, nameof(errorFactory));
@@ -474,10 +474,10 @@ public static CustomResult<TError> OnSuccess<T, TError>(in this Result<T> result
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorObject"/> is null.</exception>
         [PublicAPI]
-        public static Result<TOut, TError> OnSuccess<TIn, TOut, TError>(in this Result<TIn> result,
-            [NotNull, InstantHandle] in Func<TIn, Result<TOut, TError>> onSuccess,
-            [NotNull] in TError errorObject,
-            in bool treatWarningAsError = false)
+        public static Result<TOut, TError> OnSuccess<TIn, TOut, TError>(this Result<TIn> result,
+            [NotNull, InstantHandle] Func<TIn, Result<TOut, TError>> onSuccess,
+            [NotNull] TError errorObject,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(errorObject, nameof(errorObject));
@@ -504,10 +504,10 @@ public static Result<TOut, TError> OnSuccess<TIn, TOut, TError>(in this Result<T
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorFactory"/> is null.</exception>
         [PublicAPI]
-        public static Result<TOut, TError> OnSuccess<TIn, TOut, TError>(in this Result<TIn> result,
-            [NotNull, InstantHandle] in Func<TIn, Result<TOut, TError>> onSuccess,
-            [NotNull, InstantHandle] in Func<Result<TIn>, TError> errorFactory,
-            in bool treatWarningAsError = false)
+        public static Result<TOut, TError> OnSuccess<TIn, TOut, TError>(this Result<TIn> result,
+            [NotNull, InstantHandle] Func<TIn, Result<TOut, TError>> onSuccess,
+            [NotNull, InstantHandle] Func<Result<TIn>, TError> errorFactory,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(errorFactory, nameof(errorFactory));
@@ -530,10 +530,10 @@ public static Result<TOut, TError> OnSuccess<TIn, TOut, TError>(in this Result<T
         /// <returns>An output value.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         [PublicAPI]
-        public static TOut OnSuccess<TIn, TOut>(in this Result<TIn> result,
-            [NotNull, InstantHandle] in Func<Result<TIn>, TOut> onSuccess,
-            [CanBeNull] in TOut defaultValue,
-            in bool treatWarningAsError = false)
+        public static TOut OnSuccess<TIn, TOut>(this Result<TIn> result,
+            [NotNull, InstantHandle] Func<Result<TIn>, TOut> onSuccess,
+            [CanBeNull] TOut defaultValue,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
 
@@ -556,10 +556,10 @@ public static TOut OnSuccess<TIn, TOut>(in this Result<TIn> result,
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="valueFactory"/> is null.</exception>
         [PublicAPI]
-        public static TOut OnSuccess<TIn, TOut>(in this Result<TIn> result,
-            [NotNull, InstantHandle] in Func<Result<TIn>, TOut> onSuccess,
-            [NotNull, InstantHandle] in Func<Result<TIn>, TOut> valueFactory,
-            in bool treatWarningAsError = false)
+        public static TOut OnSuccess<TIn, TOut>(this Result<TIn> result,
+            [NotNull, InstantHandle] Func<Result<TIn>, TOut> onSuccess,
+            [NotNull, InstantHandle] Func<Result<TIn>, TOut> valueFactory,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(valueFactory, nameof(valueFactory));
@@ -583,9 +583,9 @@ public static TOut OnSuccess<TIn, TOut>(in this Result<TIn> result,
         /// <returns>This <see cref="CustomResult{TError}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         [PublicAPI]
-        public static CustomResult<TError> OnSuccess<TError>(in this CustomResult<TError> result,
-            [NotNull, InstantHandle] in Action onSuccess,
-            in bool treatWarningAsError = false)
+        public static CustomResult<TError> OnSuccess<TError>(this CustomResult<TError> result,
+            [NotNull, InstantHandle] Action onSuccess,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
 
@@ -605,9 +605,9 @@ public static CustomResult<TError> OnSuccess<TError>(in this CustomResult<TError
         /// <returns>This <see cref="CustomResult{TError}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         [PublicAPI]
-        public static CustomResult<TError> OnSuccess<TError>(in this CustomResult<TError> result,
-            [NotNull, InstantHandle] in Action<CustomResult<TError>> onSuccess,
-            in bool treatWarningAsError = false)
+        public static CustomResult<TError> OnSuccess<TError>(this CustomResult<TError> result,
+            [NotNull, InstantHandle] Action<CustomResult<TError>> onSuccess,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
 
@@ -630,10 +630,10 @@ public static CustomResult<TError> OnSuccess<TError>(in this CustomResult<TError
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorObject"/> is null.</exception>
         [PublicAPI]
-        public static Result<T, TError> OnSuccess<T, TError>(in this CustomResult<TError> result,
-            [NotNull, InstantHandle] in Func<CustomResult<TError>, T> onSuccess,
-            [NotNull] in TError errorObject,
-            in bool treatWarningAsError = false)
+        public static Result<T, TError> OnSuccess<T, TError>(this CustomResult<TError> result,
+            [NotNull, InstantHandle] Func<CustomResult<TError>, T> onSuccess,
+            [NotNull] TError errorObject,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(errorObject, nameof(errorObject));
@@ -662,10 +662,10 @@ public static Result<T, TError> OnSuccess<T, TError>(in this CustomResult<TError
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorFactory"/> is null.</exception>
         [PublicAPI]
-        public static Result<T, TError> OnSuccess<T, TError>(in this CustomResult<TError> result,
-            [NotNull, InstantHandle] in Func<CustomResult<TError>, T> onSuccess,
-            [NotNull, InstantHandle] in Func<CustomResult<TError>, TError> errorFactory,
-            in bool treatWarningAsError = false)
+        public static Result<T, TError> OnSuccess<T, TError>(this CustomResult<TError> result,
+            [NotNull, InstantHandle] Func<CustomResult<TError>, T> onSuccess,
+            [NotNull, InstantHandle] Func<CustomResult<TError>, TError> errorFactory,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(errorFactory, nameof(errorFactory));
@@ -691,9 +691,9 @@ public static Result<T, TError> OnSuccess<T, TError>(in this CustomResult<TError
         /// <returns>A <see cref="Result"/> resulting of <paramref name="onSuccess"/>, otherwise a failure.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         [PublicAPI]
-        public static Result OnSuccess<TError>(in this CustomResult<TError> result,
-            [NotNull, InstantHandle] in Func<CustomResult<TError>, Result> onSuccess,
-            in bool treatWarningAsError = false)
+        public static Result OnSuccess<TError>(this CustomResult<TError> result,
+            [NotNull, InstantHandle] Func<CustomResult<TError>, Result> onSuccess,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
 
@@ -717,9 +717,9 @@ public static Result OnSuccess<TError>(in this CustomResult<TError> result,
         /// <returns>A <see cref="Result{T}"/> resulting of <paramref name="onSuccess"/>, otherwise a failure.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         [PublicAPI]
-        public static Result<T> OnSuccess<T, TError>(in this CustomResult<TError> result,
-            [NotNull, InstantHandle] in Func<CustomResult<TError>, Result<T>> onSuccess,
-            in bool treatWarningAsError = false)
+        public static Result<T> OnSuccess<T, TError>(this CustomResult<TError> result,
+            [NotNull, InstantHandle] Func<CustomResult<TError>, Result<T>> onSuccess,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
 
@@ -741,10 +741,10 @@ public static Result<T> OnSuccess<T, TError>(in this CustomResult<TError> result
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorObject"/> is null.</exception>
         [PublicAPI]
-        public static CustomResult<TError> OnSuccess<TError>(in this CustomResult<TError> result,
-            [NotNull, InstantHandle] in Func<CustomResult<TError>, CustomResult<TError>> onSuccess,
-            [NotNull] in TError errorObject,
-            in bool treatWarningAsError = false)
+        public static CustomResult<TError> OnSuccess<TError>(this CustomResult<TError> result,
+            [NotNull, InstantHandle] Func<CustomResult<TError>, CustomResult<TError>> onSuccess,
+            [NotNull] TError errorObject,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(errorObject, nameof(errorObject));
@@ -770,10 +770,10 @@ public static CustomResult<TError> OnSuccess<TError>(in this CustomResult<TError
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorFactory"/> is null.</exception>
         [PublicAPI]
-        public static CustomResult<TError> OnSuccess<TError>(in this CustomResult<TError> result,
-            [NotNull, InstantHandle] in Func<CustomResult<TError>, CustomResult<TError>> onSuccess,
-            [NotNull, InstantHandle] in Func<CustomResult<TError>, TError> errorFactory,
-            in bool treatWarningAsError = false)
+        public static CustomResult<TError> OnSuccess<TError>(this CustomResult<TError> result,
+            [NotNull, InstantHandle] Func<CustomResult<TError>, CustomResult<TError>> onSuccess,
+            [NotNull, InstantHandle] Func<CustomResult<TError>, TError> errorFactory,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(errorFactory, nameof(errorFactory));
@@ -800,10 +800,10 @@ public static CustomResult<TError> OnSuccess<TError>(in this CustomResult<TError
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorObject"/> is null.</exception>
         [PublicAPI]
-        public static Result<T, TError> OnSuccess<T, TError>(in this CustomResult<TError> result,
-            [NotNull, InstantHandle] in Func<CustomResult<TError>, Result<T, TError>> onSuccess,
-            [NotNull] in TError errorObject,
-            in bool treatWarningAsError = false)
+        public static Result<T, TError> OnSuccess<T, TError>(this CustomResult<TError> result,
+            [NotNull, InstantHandle] Func<CustomResult<TError>, Result<T, TError>> onSuccess,
+            [NotNull] TError errorObject,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(errorObject, nameof(errorObject));
@@ -832,10 +832,10 @@ public static Result<T, TError> OnSuccess<T, TError>(in this CustomResult<TError
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorFactory"/> is null.</exception>
         [PublicAPI]
-        public static Result<T, TError> OnSuccess<T, TError>(in this CustomResult<TError> result,
-            [NotNull, InstantHandle] in Func<CustomResult<TError>, Result<T, TError>> onSuccess,
-            [NotNull, InstantHandle] in Func<CustomResult<TError>, TError> errorFactory,
-            in bool treatWarningAsError = false)
+        public static Result<T, TError> OnSuccess<T, TError>(this CustomResult<TError> result,
+            [NotNull, InstantHandle] Func<CustomResult<TError>, Result<T, TError>> onSuccess,
+            [NotNull, InstantHandle] Func<CustomResult<TError>, TError> errorFactory,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(errorFactory, nameof(errorFactory));
@@ -863,10 +863,10 @@ public static Result<T, TError> OnSuccess<T, TError>(in this CustomResult<TError
         /// <returns>An output value.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         [PublicAPI]
-        public static TOut OnSuccess<TOut, TError>(in this CustomResult<TError> result,
-            [NotNull, InstantHandle] in Func<CustomResult<TError>, TOut> onSuccess,
-            [CanBeNull] in TOut defaultValue,
-            in bool treatWarningAsError = false)
+        public static TOut OnSuccess<TOut, TError>(this CustomResult<TError> result,
+            [NotNull, InstantHandle] Func<CustomResult<TError>, TOut> onSuccess,
+            [CanBeNull] TOut defaultValue,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
 
@@ -889,10 +889,10 @@ public static TOut OnSuccess<TOut, TError>(in this CustomResult<TError> result,
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="valueFactory"/> is null.</exception>
         [PublicAPI]
-        public static TOut OnSuccess<TOut, TError>(in this CustomResult<TError> result,
-            [NotNull, InstantHandle] in Func<CustomResult<TError>, TOut> onSuccess,
-            [NotNull, InstantHandle] in Func<CustomResult<TError>, TOut> valueFactory,
-            in bool treatWarningAsError = false)
+        public static TOut OnSuccess<TOut, TError>(this CustomResult<TError> result,
+            [NotNull, InstantHandle] Func<CustomResult<TError>, TOut> onSuccess,
+            [NotNull, InstantHandle] Func<CustomResult<TError>, TOut> valueFactory,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(valueFactory, nameof(valueFactory));
@@ -917,9 +917,9 @@ public static TOut OnSuccess<TOut, TError>(in this CustomResult<TError> result,
         /// <returns>This <see cref="Result{T, TError}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         [PublicAPI]
-        public static Result<T, TError> OnSuccess<T, TError>(in this Result<T, TError> result,
-            [NotNull, InstantHandle] in Action<T> onSuccess,
-            in bool treatWarningAsError = false)
+        public static Result<T, TError> OnSuccess<T, TError>(this Result<T, TError> result,
+            [NotNull, InstantHandle] Action<T> onSuccess,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
 
@@ -943,10 +943,10 @@ public static Result<T, TError> OnSuccess<T, TError>(in this Result<T, TError> r
         /// <exception cref="ArgumentNullException">If the <paramref name="converter"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorObject"/> is null.</exception>
         [PublicAPI]
-        public static Result<TOut, TError> OnSuccess<TIn, TOut, TError>(in this Result<TIn, TError> result,
-            [NotNull, InstantHandle] in Func<TIn, TOut> converter, 
-            [NotNull] in TError errorObject,
-            in bool treatWarningAsError = false)
+        public static Result<TOut, TError> OnSuccess<TIn, TOut, TError>(this Result<TIn, TError> result,
+            [NotNull, InstantHandle] Func<TIn, TOut> converter, 
+            [NotNull] TError errorObject,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(converter, nameof(converter));
             Throw.IfArgumentNull(errorObject, nameof(errorObject));
@@ -975,10 +975,10 @@ public static Result<TOut, TError> OnSuccess<TIn, TOut, TError>(in this Result<T
         /// <exception cref="ArgumentNullException">If the <paramref name="converter"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorFactory"/> is null.</exception>
         [PublicAPI]
-        public static Result<TOut, TError> OnSuccess<TIn, TOut, TError>(in this Result<TIn, TError> result,
-            [NotNull, InstantHandle] in Func<TIn, TOut> converter,
-            [NotNull, InstantHandle] in Func<Result<TIn, TError>, TError> errorFactory,
-            in bool treatWarningAsError = false)
+        public static Result<TOut, TError> OnSuccess<TIn, TOut, TError>(this Result<TIn, TError> result,
+            [NotNull, InstantHandle] Func<TIn, TOut> converter,
+            [NotNull, InstantHandle] Func<Result<TIn, TError>, TError> errorFactory,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(converter, nameof(converter));
             Throw.IfArgumentNull(errorFactory, nameof(errorFactory));
@@ -1004,9 +1004,9 @@ public static Result<TOut, TError> OnSuccess<TIn, TOut, TError>(in this Result<T
         /// <returns>A <see cref="Result"/> resulting of <paramref name="onSuccess"/>, otherwise a failure.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         [PublicAPI]
-        public static Result OnSuccess<T, TError>(in this Result<T, TError> result,
-            [NotNull, InstantHandle] in Func<T, Result> onSuccess,
-            in bool treatWarningAsError = false)
+        public static Result OnSuccess<T, TError>(this Result<T, TError> result,
+            [NotNull, InstantHandle] Func<T, Result> onSuccess,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
 
@@ -1031,9 +1031,9 @@ public static Result OnSuccess<T, TError>(in this Result<T, TError> result,
         /// <returns>A <see cref="Result{TOut}"/> resulting of <paramref name="onSuccess"/>, otherwise a failure.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         [PublicAPI]
-        public static Result<TOut> OnSuccess<TIn, TOut, TError>(in this Result<TIn, TError> result,
-            [NotNull, InstantHandle] in Func<TIn, Result<TOut>> onSuccess,
-            in bool treatWarningAsError = false)
+        public static Result<TOut> OnSuccess<TIn, TOut, TError>(this Result<TIn, TError> result,
+            [NotNull, InstantHandle] Func<TIn, Result<TOut>> onSuccess,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
 
@@ -1056,10 +1056,10 @@ public static Result<TOut> OnSuccess<TIn, TOut, TError>(in this Result<TIn, TErr
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorObject"/> is null.</exception>
         [PublicAPI]
-        public static CustomResult<TError> OnSuccess<T, TError>(in this Result<T, TError> result,
-            [NotNull, InstantHandle] in Func<T, CustomResult<TError>> onSuccess,
-            [NotNull] in TError errorObject,
-            in bool treatWarningAsError = false)
+        public static CustomResult<TError> OnSuccess<T, TError>(this Result<T, TError> result,
+            [NotNull, InstantHandle] Func<T, CustomResult<TError>> onSuccess,
+            [NotNull] TError errorObject,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(errorObject, nameof(errorObject));
@@ -1086,10 +1086,10 @@ public static CustomResult<TError> OnSuccess<T, TError>(in this Result<T, TError
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorFactory"/> is null.</exception>
         [PublicAPI]
-        public static CustomResult<TError> OnSuccess<T, TError>(in this Result<T, TError> result,
-            [NotNull, InstantHandle] in Func<T, CustomResult<TError>> onSuccess,
-            [NotNull, InstantHandle] in Func<Result<T, TError>, TError> errorFactory,
-            in bool treatWarningAsError = false)
+        public static CustomResult<TError> OnSuccess<T, TError>(this Result<T, TError> result,
+            [NotNull, InstantHandle] Func<T, CustomResult<TError>> onSuccess,
+            [NotNull, InstantHandle] Func<Result<T, TError>, TError> errorFactory,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(errorFactory, nameof(errorFactory));
@@ -1117,10 +1117,10 @@ public static CustomResult<TError> OnSuccess<T, TError>(in this Result<T, TError
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorObject"/> is null.</exception>
         [PublicAPI]
-        public static Result<TOut, TError> OnSuccess<TIn, TOut, TError>(in this Result<TIn, TError> result,
-            [NotNull, InstantHandle] in Func<TIn, Result<TOut, TError>> onSuccess,
-            [NotNull] in TError errorObject,
-            in bool treatWarningAsError = false)
+        public static Result<TOut, TError> OnSuccess<TIn, TOut, TError>(this Result<TIn, TError> result,
+            [NotNull, InstantHandle] Func<TIn, Result<TOut, TError>> onSuccess,
+            [NotNull] TError errorObject,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(errorObject, nameof(errorObject));
@@ -1150,10 +1150,10 @@ public static Result<TOut, TError> OnSuccess<TIn, TOut, TError>(in this Result<T
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorFactory"/> is null.</exception>
         [PublicAPI]
-        public static Result<TOut, TError> OnSuccess<TIn, TOut, TError>(in this Result<TIn, TError> result,
-            [NotNull, InstantHandle] in Func<TIn, Result<TOut, TError>> onSuccess,
-            [NotNull, InstantHandle] in Func<Result<TIn, TError>, TError> errorFactory,
-            in bool treatWarningAsError = false)
+        public static Result<TOut, TError> OnSuccess<TIn, TOut, TError>(this Result<TIn, TError> result,
+            [NotNull, InstantHandle] Func<TIn, Result<TOut, TError>> onSuccess,
+            [NotNull, InstantHandle] Func<Result<TIn, TError>, TError> errorFactory,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(errorFactory, nameof(errorFactory));
@@ -1182,10 +1182,10 @@ public static Result<TOut, TError> OnSuccess<TIn, TOut, TError>(in this Result<T
         /// <returns>An output value.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         [PublicAPI]
-        public static TOut OnSuccess<TIn, TOut, TError>(in this Result<TIn, TError> result,
-            [NotNull, InstantHandle] in Func<Result<TIn, TError>, TOut> onSuccess,
-            [CanBeNull] in TOut defaultValue,
-            in bool treatWarningAsError = false)
+        public static TOut OnSuccess<TIn, TOut, TError>(this Result<TIn, TError> result,
+            [NotNull, InstantHandle] Func<Result<TIn, TError>, TOut> onSuccess,
+            [CanBeNull] TOut defaultValue,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
 
@@ -1209,10 +1209,10 @@ public static TOut OnSuccess<TIn, TOut, TError>(in this Result<TIn, TError> resu
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="valueFactory"/> is null.</exception>
         [PublicAPI]
-        public static TOut OnSuccess<TIn, TOut, TError>(in this Result<TIn, TError> result,
-            [NotNull, InstantHandle] in Func<Result<TIn, TError>, TOut> onSuccess,
-            [NotNull, InstantHandle] in Func<Result<TIn, TError>, TOut> valueFactory,
-            in bool treatWarningAsError = false)
+        public static TOut OnSuccess<TIn, TOut, TError>(this Result<TIn, TError> result,
+            [NotNull, InstantHandle] Func<Result<TIn, TError>, TOut> onSuccess,
+            [NotNull, InstantHandle] Func<Result<TIn, TError>, TOut> valueFactory,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(valueFactory, nameof(valueFactory));
diff --git a/src/Here/Result/Extensions/ResultExtensions_OnSuccessOrFailure.cs b/src/Here/Result/Extensions/ResultExtensions_OnSuccessOrFailure.cs
index d434fb4..b4f93c7 100644
--- a/src/Here/Result/Extensions/ResultExtensions_OnSuccessOrFailure.cs
+++ b/src/Here/Result/Extensions/ResultExtensions_OnSuccessOrFailure.cs
@@ -22,10 +22,10 @@ public static partial class ResultExtensions
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         [PublicAPI]
-        public static Result OnSuccessOrFailure(in this Result result,
-            [NotNull, InstantHandle] in Action onSuccess,
-            [NotNull, InstantHandle] in Action onFailure,
-            in bool treatWarningAsError = false)
+        public static Result OnSuccessOrFailure(this Result result,
+            [NotNull, InstantHandle] Action onSuccess,
+            [NotNull, InstantHandle] Action onFailure,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
@@ -49,10 +49,10 @@ public static Result OnSuccessOrFailure(in this Result result,
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         [PublicAPI]
-        public static Result OnSuccessOrFailure(in this Result result,
-            [NotNull, InstantHandle] in Action onSuccess,
-            [NotNull, InstantHandle] in Action<Result> onFailure,
-            in bool treatWarningAsError = false)
+        public static Result OnSuccessOrFailure(this Result result,
+            [NotNull, InstantHandle] Action onSuccess,
+            [NotNull, InstantHandle] Action<Result> onFailure,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
@@ -76,10 +76,10 @@ public static Result OnSuccessOrFailure(in this Result result,
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         [PublicAPI]
-        public static Result OnSuccessOrFailure(in this Result result,
-            [NotNull, InstantHandle] in Action<Result> onSuccess,
-            [NotNull, InstantHandle] in Action<Result> onFailure,
-            in bool treatWarningAsError = false)
+        public static Result OnSuccessOrFailure(this Result result,
+            [NotNull, InstantHandle] Action<Result> onSuccess,
+            [NotNull, InstantHandle] Action<Result> onFailure,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
@@ -104,10 +104,10 @@ public static Result OnSuccessOrFailure(in this Result result,
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         [PublicAPI]
-        public static TOut OnSuccessOrFailure<TOut>(in this Result result,
-            [NotNull, InstantHandle] in Func<Result, TOut> onSuccess,
-            [NotNull, InstantHandle] in Func<Result, TOut> onFailure,
-            in bool treatWarningAsError = false)
+        public static TOut OnSuccessOrFailure<TOut>(this Result result,
+            [NotNull, InstantHandle] Func<Result, TOut> onSuccess,
+            [NotNull, InstantHandle] Func<Result, TOut> onFailure,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
@@ -134,10 +134,10 @@ public static TOut OnSuccessOrFailure<TOut>(in this Result result,
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         [PublicAPI]
-        public static Result<T> OnSuccessOrFailure<T>(in this Result<T> result,
-            [NotNull, InstantHandle] in Action onSuccess,
-            [NotNull, InstantHandle] in Action onFailure,
-            in bool treatWarningAsError = false)
+        public static Result<T> OnSuccessOrFailure<T>(this Result<T> result,
+            [NotNull, InstantHandle] Action onSuccess,
+            [NotNull, InstantHandle] Action onFailure,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
@@ -162,10 +162,10 @@ public static Result<T> OnSuccessOrFailure<T>(in this Result<T> result,
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         [PublicAPI]
-        public static Result<T> OnSuccessOrFailure<T>(in this Result<T> result,
-            [NotNull, InstantHandle] in Action<Result<T>> onSuccess,
-            [NotNull, InstantHandle] in Action<Result<T>> onFailure,
-            in bool treatWarningAsError = false)
+        public static Result<T> OnSuccessOrFailure<T>(this Result<T> result,
+            [NotNull, InstantHandle] Action<Result<T>> onSuccess,
+            [NotNull, InstantHandle] Action<Result<T>> onFailure,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
@@ -191,10 +191,10 @@ public static Result<T> OnSuccessOrFailure<T>(in this Result<T> result,
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         [PublicAPI]
-        public static TOut OnSuccessOrFailure<TIn, TOut>(in this Result<TIn> result,
-            [NotNull, InstantHandle] in Func<Result<TIn>, TOut> onSuccess,
-            [NotNull, InstantHandle] in Func<Result<TIn>, TOut> onFailure,
-            in bool treatWarningAsError = false)
+        public static TOut OnSuccessOrFailure<TIn, TOut>(this Result<TIn> result,
+            [NotNull, InstantHandle] Func<Result<TIn>, TOut> onSuccess,
+            [NotNull, InstantHandle] Func<Result<TIn>, TOut> onFailure,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
@@ -221,10 +221,10 @@ public static TOut OnSuccessOrFailure<TIn, TOut>(in this Result<TIn> result,
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         [PublicAPI]
-        public static CustomResult<TError> OnSuccessOrFailure<TError>(in this CustomResult<TError> result,
-            [NotNull, InstantHandle] in Action onSuccess,
-            [NotNull, InstantHandle] in Action onFailure,
-            in bool treatWarningAsError = false)
+        public static CustomResult<TError> OnSuccessOrFailure<TError>(this CustomResult<TError> result,
+            [NotNull, InstantHandle] Action onSuccess,
+            [NotNull, InstantHandle] Action onFailure,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
@@ -249,10 +249,10 @@ public static CustomResult<TError> OnSuccessOrFailure<TError>(in this CustomResu
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         [PublicAPI]
-        public static CustomResult<TError> OnSuccessOrFailure<TError>(in this CustomResult<TError> result,
-            [NotNull, InstantHandle] in Action onSuccess,
-            [NotNull, InstantHandle] in Action<CustomResult<TError>> onFailure,
-            in bool treatWarningAsError = false)
+        public static CustomResult<TError> OnSuccessOrFailure<TError>(this CustomResult<TError> result,
+            [NotNull, InstantHandle] Action onSuccess,
+            [NotNull, InstantHandle] Action<CustomResult<TError>> onFailure,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
@@ -277,10 +277,10 @@ public static CustomResult<TError> OnSuccessOrFailure<TError>(in this CustomResu
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         [PublicAPI]
-        public static CustomResult<TError> OnSuccessOrFailure<TError>(in this CustomResult<TError> result,
-            [NotNull, InstantHandle] in Action<CustomResult<TError>> onSuccess,
-            [NotNull, InstantHandle] in Action<CustomResult<TError>> onFailure,
-            in bool treatWarningAsError = false)
+        public static CustomResult<TError> OnSuccessOrFailure<TError>(this CustomResult<TError> result,
+            [NotNull, InstantHandle] Action<CustomResult<TError>> onSuccess,
+            [NotNull, InstantHandle] Action<CustomResult<TError>> onFailure,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
@@ -306,10 +306,10 @@ public static CustomResult<TError> OnSuccessOrFailure<TError>(in this CustomResu
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         [PublicAPI]
-        public static TOut OnSuccessOrFailure<TOut, TError>(in this CustomResult<TError> result,
-            [NotNull, InstantHandle] in Func<CustomResult<TError>, TOut> onSuccess,
-            [NotNull, InstantHandle] in Func<CustomResult<TError>, TOut> onFailure,
-            in bool treatWarningAsError = false)
+        public static TOut OnSuccessOrFailure<TOut, TError>(this CustomResult<TError> result,
+            [NotNull, InstantHandle] Func<CustomResult<TError>, TOut> onSuccess,
+            [NotNull, InstantHandle] Func<CustomResult<TError>, TOut> onFailure,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
@@ -337,10 +337,10 @@ public static TOut OnSuccessOrFailure<TOut, TError>(in this CustomResult<TError>
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         [PublicAPI]
-        public static Result<T, TError> OnSuccessOrFailure<T, TError>(in this Result<T, TError> result,
-            [NotNull, InstantHandle] in Action onSuccess,
-            [NotNull, InstantHandle] in Action onFailure,
-            in bool treatWarningAsError = false)
+        public static Result<T, TError> OnSuccessOrFailure<T, TError>(this Result<T, TError> result,
+            [NotNull, InstantHandle] Action onSuccess,
+            [NotNull, InstantHandle] Action onFailure,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
@@ -366,10 +366,10 @@ public static Result<T, TError> OnSuccessOrFailure<T, TError>(in this Result<T,
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         [PublicAPI]
-        public static Result<T, TError> OnSuccessOrFailure<T, TError>(in this Result<T, TError> result,
-            [NotNull, InstantHandle] in Action<Result<T, TError>> onSuccess,
-            [NotNull, InstantHandle] in Action<Result<T, TError>> onFailure,
-            in bool treatWarningAsError = false)
+        public static Result<T, TError> OnSuccessOrFailure<T, TError>(this Result<T, TError> result,
+            [NotNull, InstantHandle] Action<Result<T, TError>> onSuccess,
+            [NotNull, InstantHandle] Action<Result<T, TError>> onFailure,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
@@ -396,10 +396,10 @@ public static Result<T, TError> OnSuccessOrFailure<T, TError>(in this Result<T,
         /// <exception cref="ArgumentNullException">If the <paramref name="onSuccess"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="onFailure"/> is null.</exception>
         [PublicAPI]
-        public static TOut OnSuccessOrFailure<TIn, TOut, TError>(in this Result<TIn, TError> result,
-            [NotNull, InstantHandle] in Func<Result<TIn, TError>, TOut> onSuccess,
-            [NotNull, InstantHandle] in Func<Result<TIn, TError>, TOut> onFailure,
-            in bool treatWarningAsError = false)
+        public static TOut OnSuccessOrFailure<TIn, TOut, TError>(this Result<TIn, TError> result,
+            [NotNull, InstantHandle] Func<Result<TIn, TError>, TOut> onSuccess,
+            [NotNull, InstantHandle] Func<Result<TIn, TError>, TOut> onFailure,
+            bool treatWarningAsError = false)
         {
             Throw.IfArgumentNull(onSuccess, nameof(onSuccess));
             Throw.IfArgumentNull(onFailure, nameof(onFailure));
diff --git a/src/Here/Result/Extensions/ResultOperatorsExtensions.cs b/src/Here/Result/Extensions/ResultOperatorsExtensions.cs
index 3626621..5e55f6f 100644
--- a/src/Here/Result/Extensions/ResultOperatorsExtensions.cs
+++ b/src/Here/Result/Extensions/ResultOperatorsExtensions.cs
@@ -15,7 +15,7 @@ public static class ResultOperatorsExtensions
         /// </summary>
         /// <param name="result"><see cref="Result"/> to convert.</param>
         /// <returns>An <see cref="Option{Boolean}"/>.</returns>
-        public static Option<bool> ToOption(in this Result result)
+        public static Option<bool> ToOption(this Result result)
         {
             return Option<bool>.Some(result.Logic.IsSuccess);
         }
@@ -26,7 +26,7 @@ public static Option<bool> ToOption(in this Result result)
         /// <typeparam name="T">Type of the result value.</typeparam>
         /// <param name="result"><see cref="Result{T}"/> to convert.</param>
         /// <returns>An <see cref="Option{T}"/>.</returns>
-        public static Option<T> ToOption<T>(in this Result<T> result)
+        public static Option<T> ToOption<T>(this Result<T> result)
         {
             if (result.Logic.IsSuccess)
                 return result._value;
@@ -39,7 +39,7 @@ public static Option<T> ToOption<T>(in this Result<T> result)
         /// <typeparam name="TError">Error type of the result.</typeparam>
         /// <param name="result"><see cref="CustomResult{TError}"/> to convert.</param>
         /// <returns>An <see cref="Option{Boolean}"/>.</returns>
-        public static Option<bool> ToOption<TError>(in this CustomResult<TError> result)
+        public static Option<bool> ToOption<TError>(this CustomResult<TError> result)
         {
             return Option<bool>.Some(result.Logic.IsSuccess);
         }
@@ -51,7 +51,7 @@ public static Option<bool> ToOption<TError>(in this CustomResult<TError> result)
         /// <typeparam name="TError">Error type of the result.</typeparam>
         /// <param name="result"><see cref="Result{T, TError}"/> to convert.</param>
         /// <returns>An <see cref="Option{T}"/>.</returns>
-        public static Option<T> ToOption<T, TError>(in this Result<T, TError> result)
+        public static Option<T> ToOption<T, TError>(this Result<T, TError> result)
         {
             if (result.Logic.IsSuccess)
                 return result._value;
@@ -68,7 +68,7 @@ public static Option<T> ToOption<T, TError>(in this Result<T, TError> result)
         /// <typeparam name="T">Type of the result value.</typeparam>
         /// <param name="result"><see cref="Result{T}"/> to convert.</param>
         /// <returns>An <see cref="Either{String, T}"/>.</returns>
-        public static Either<string, T> ToEither<T>(in this Result<T> result)
+        public static Either<string, T> ToEither<T>(this Result<T> result)
         {
             if (result.IsSuccess)
             {
@@ -87,7 +87,7 @@ public static Either<string, T> ToEither<T>(in this Result<T> result)
         /// <typeparam name="TError">Error type of the result.</typeparam>
         /// <param name="result"><see cref="Result{T, TError}"/> to convert.</param>
         /// <returns>An <see cref="Either{String,T}"/>.</returns>
-        public static Either<string, T> ToMessageEither<T, TError>(in this Result<T, TError> result)
+        public static Either<string, T> ToMessageEither<T, TError>(this Result<T, TError> result)
         {
             if (result.IsSuccess)
             {
@@ -106,7 +106,7 @@ public static Either<string, T> ToMessageEither<T, TError>(in this Result<T, TEr
         /// <typeparam name="TError">Error type of the result.</typeparam>
         /// <param name="result"><see cref="Result{T, TError}"/> to convert.</param>
         /// <returns>An <see cref="Either{TError,T}"/>.</returns>
-        public static Either<TError, T> ToEither<T, TError>(in this Result<T, TError> result)
+        public static Either<TError, T> ToEither<T, TError>(this Result<T, TError> result)
         {
             if (result.IsSuccess)
             {
diff --git a/src/Here/Result/Result.Implicit.cs b/src/Here/Result/Result.Implicit.cs
index 9e904f2..9c68ee1 100644
--- a/src/Here/Result/Result.Implicit.cs
+++ b/src/Here/Result/Result.Implicit.cs
@@ -12,7 +12,7 @@ public partial struct Result
         /// <param name="result"><see cref="Result"/> to convert.</param>
         /// <returns>An <see cref="Option{T}"/>.</returns>
         [PublicAPI, Pure]
-        public static implicit operator Option<bool>(in Result result)
+        public static implicit operator Option<bool>(Result result)
         {
             return result.ToOption();
         }
@@ -26,7 +26,7 @@ public partial struct Result<T>
         /// <param name="result"><see cref="Result{T}"/> to convert.</param>
         /// <returns>A <see cref="Result"/>.</returns>
         [PublicAPI, Pure]
-        public static implicit operator Result(in Result<T> result)
+        public static implicit operator Result(Result<T> result)
         {
             return new Result(result.Logic);
         }
@@ -37,7 +37,7 @@ public static implicit operator Result(in Result<T> result)
         /// <param name="result"><see cref="Result{T}"/> to convert.</param>
         /// <returns>An <see cref="Option{T}"/>.</returns>
         [PublicAPI, Pure]
-        public static implicit operator Option<T>(in Result<T> result)
+        public static implicit operator Option<T>(Result<T> result)
         {
             return result.ToOption();
         }
@@ -51,7 +51,7 @@ public partial struct CustomResult<TError>
         /// <param name="result"><see cref="CustomResult{TError}"/> to convert.</param>
         /// <returns>A <see cref="Result"/>.</returns>
         [PublicAPI, Pure]
-        public static implicit operator Result(in CustomResult<TError> result)
+        public static implicit operator Result(CustomResult<TError> result)
         {
             return new Result(ResultLogic.ToResultLogic(result.Logic));
         }
@@ -62,7 +62,7 @@ public static implicit operator Result(in CustomResult<TError> result)
         /// <param name="result"><see cref="CustomResult{TError}"/> to convert.</param>
         /// <returns>An <see cref="Option{T}"/>.</returns>
         [PublicAPI, Pure]
-        public static implicit operator Option<bool>(in CustomResult<TError> result)
+        public static implicit operator Option<bool>(CustomResult<TError> result)
         {
             return result.ToOption();
         }
@@ -76,7 +76,7 @@ public partial struct Result<T, TError>
         /// <param name="result"><see cref="Result{T, TError}"/> to convert.</param>
         /// <returns>A <see cref="Result"/>.</returns>
         [PublicAPI, Pure]
-        public static implicit operator Result(in Result<T, TError> result)
+        public static implicit operator Result(Result<T, TError> result)
         {
             return new Result(ResultLogic.ToResultLogic(result.Logic));
         }
@@ -87,7 +87,7 @@ public static implicit operator Result(in Result<T, TError> result)
         /// <param name="result"><see cref="Result{T, TError}"/> to convert.</param>
         /// <returns>A <see cref="CustomResult{TError}"/>.</returns>
         [PublicAPI, Pure]
-        public static implicit operator CustomResult<TError>(in Result<T, TError> result)
+        public static implicit operator CustomResult<TError>(Result<T, TError> result)
         {
             return new CustomResult<TError>(result.Logic);
         }
@@ -98,10 +98,10 @@ public static implicit operator CustomResult<TError>(in Result<T, TError> result
         /// <param name="result"><see cref="Result{T, TError}"/> to convert.</param>
         /// <returns>A <see cref="Result{T}"/>.</returns>
         [PublicAPI, Pure]
-        public static implicit operator Result<T>(in Result<T, TError> result)
+        public static implicit operator Result<T>(Result<T, TError> result)
         {
             return new Result<T>(
-                result.IsSuccess ? result.Value : default,
+                result.IsSuccess ? result.Value : default(T),
                 ResultLogic.ToResultLogic(result.Logic));
         }
 
@@ -111,7 +111,7 @@ public static implicit operator Result<T>(in Result<T, TError> result)
         /// <param name="result"><see cref="Result{T}"/> to convert.</param>
         /// <returns>An <see cref="Option{T}"/>.</returns>
         [PublicAPI, Pure]
-        public static implicit operator Option<T>(in Result<T, TError> result)
+        public static implicit operator Option<T>(Result<T, TError> result)
         {
             return result.ToOption();
         }
diff --git a/src/Here/Result/Result.cs b/src/Here/Result/Result.cs
index 35caf40..0d7eb1d 100644
--- a/src/Here/Result/Result.cs
+++ b/src/Here/Result/Result.cs
@@ -9,7 +9,7 @@ namespace Here
     /// </summary>
     [PublicAPI]
     [DebuggerDisplay("{" + nameof(IsSuccess) + " ? \"IsSuccess\" + (" + nameof(IsWarning) + " ? \" with warning\" : System.String.Empty) : \"IsFailure\"}")]
-    public readonly partial struct Result : IResult, IEquatable<Result>, IComparable, IComparable<Result>
+    public partial struct Result : IResult, IEquatable<Result>, IComparable, IComparable<Result>
     {
         /// <summary>
         /// A success <see cref="Result"/>.
@@ -40,7 +40,7 @@ namespace Here
         /// <see cref="Result"/> constructor.
         /// </summary>
         /// <param name="logic">Result logic.</param>
-        internal Result([NotNull] in ResultLogic logic)
+        internal Result([NotNull] ResultLogic logic)
         {
             Logic = logic;
         }
@@ -51,7 +51,7 @@ internal Result([NotNull] in ResultLogic logic)
         /// <param name="isWarning">Result warning flag.</param>
         /// <param name="message">Result message.</param>
         /// <param name="exception">Result embedded exception.</param>
-        private Result(in bool isWarning, [NotNull] in string message, [CanBeNull] in Exception exception)
+        private Result(bool isWarning, [NotNull] string message, [CanBeNull] Exception exception)
         {
             Logic = new ResultLogic(isWarning, message, exception);
         }
@@ -65,7 +65,7 @@ private Result(in bool isWarning, [NotNull] in string message, [CanBeNull] in Ex
         /// <param name="value">Value.</param>
         /// <returns>A <see cref="Result{T}"/>.</returns>
         [PublicAPI, Pure]
-        public Result<T> Cast<T>([CanBeNull] in T value)
+        public Result<T> Cast<T>([CanBeNull] T value)
         {
             if (IsFailure)
                 return ToFailValueResult<T>();
@@ -80,7 +80,7 @@ public Result<T> Cast<T>([CanBeNull] in T value)
         /// <returns>A <see cref="Result{T}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="valueFactory"/> is null.</exception>
         [PublicAPI, Pure]
-        public Result<T> Cast<T>([NotNull, InstantHandle] in Func<T> valueFactory)
+        public Result<T> Cast<T>([NotNull, InstantHandle] Func<T> valueFactory)
         {
             Throw.IfArgumentNull(valueFactory, nameof(valueFactory));
 
@@ -97,7 +97,7 @@ public Result<T> Cast<T>([NotNull, InstantHandle] in Func<T> valueFactory)
         /// <returns>A <see cref="CustomResult{TError}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorObject"/> is null.</exception>
         [PublicAPI, Pure]
-        public CustomResult<TError> CustomCast<TError>([NotNull] in TError errorObject)
+        public CustomResult<TError> CustomCast<TError>([NotNull] TError errorObject)
         {
             Throw.IfArgumentNull(errorObject, nameof(errorObject));
 
@@ -116,7 +116,7 @@ public CustomResult<TError> CustomCast<TError>([NotNull] in TError errorObject)
         /// <returns>A <see cref="CustomResult{TError}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorFactory"/> is null.</exception>
         [PublicAPI, Pure]
-        public CustomResult<TError> CustomCast<TError>([NotNull, InstantHandle] in Func<TError> errorFactory)
+        public CustomResult<TError> CustomCast<TError>([NotNull, InstantHandle] Func<TError> errorFactory)
         {
             Throw.IfArgumentNull(errorFactory, nameof(errorFactory));
 
@@ -137,7 +137,7 @@ public CustomResult<TError> CustomCast<TError>([NotNull, InstantHandle] in Func<
         /// <returns>A <see cref="Result{T, TError}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorObject"/> is null.</exception>
         [PublicAPI, Pure]
-        public Result<T, TError> Cast<T, TError>([CanBeNull] in T value, [NotNull] in TError errorObject)
+        public Result<T, TError> Cast<T, TError>([CanBeNull] T value, [NotNull] TError errorObject)
         {
             Throw.IfArgumentNull(errorObject, nameof(errorObject));
 
@@ -158,7 +158,7 @@ public Result<T, TError> Cast<T, TError>([CanBeNull] in T value, [NotNull] in TE
         /// <returns>A <see cref="Result{T, TError}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorFactory"/> is null.</exception>
         [PublicAPI, Pure]
-        public Result<T, TError> Cast<T, TError>([CanBeNull] in T value, [NotNull, InstantHandle] in Func<TError> errorFactory)
+        public Result<T, TError> Cast<T, TError>([CanBeNull] T value, [NotNull, InstantHandle] Func<TError> errorFactory)
         {
             Throw.IfArgumentNull(errorFactory, nameof(errorFactory));
 
@@ -180,7 +180,7 @@ public Result<T, TError> Cast<T, TError>([CanBeNull] in T value, [NotNull, Insta
         /// <exception cref="ArgumentNullException">If the <paramref name="valueFactory"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorObject"/> is null.</exception>
         [PublicAPI, Pure]
-        public Result<T, TError> Cast<T, TError>([NotNull, InstantHandle] in Func<T> valueFactory, [NotNull] in TError errorObject)
+        public Result<T, TError> Cast<T, TError>([NotNull, InstantHandle] Func<T> valueFactory, [NotNull] TError errorObject)
         {
             Throw.IfArgumentNull(valueFactory, nameof(valueFactory));
             Throw.IfArgumentNull(errorObject, nameof(errorObject));
@@ -203,7 +203,7 @@ public Result<T, TError> Cast<T, TError>([NotNull, InstantHandle] in Func<T> val
         /// <exception cref="ArgumentNullException">If the <paramref name="valueFactory"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorFactory"/> is null.</exception>
         [PublicAPI, Pure]
-        public Result<T, TError> Cast<T, TError>([NotNull, InstantHandle] in Func<T> valueFactory, [NotNull, InstantHandle] in Func<TError> errorFactory)
+        public Result<T, TError> Cast<T, TError>([NotNull, InstantHandle] Func<T> valueFactory, [NotNull, InstantHandle] Func<TError> errorFactory)
         {
             Throw.IfArgumentNull(valueFactory, nameof(valueFactory));
             Throw.IfArgumentNull(errorFactory, nameof(errorFactory));
@@ -245,7 +245,7 @@ internal Result ToFailResult()
         /// <param name="exception">Exception to set in the failure <see cref="Result"/>.</param>
         /// <returns>A failed <see cref="Result"/>.</returns>
         [Pure]
-        internal Result ToFailResult([NotNull] in string additionalMessage, [CanBeNull] in Exception exception = null)
+        internal Result ToFailResult([NotNull] string additionalMessage, [CanBeNull] Exception exception = null)
         {
             Debug.Assert(ResultLogic.IsConvertibleToFailure(Logic), "Cannot convert a success Result to a Result failure.");
             return Fail(Logic.Message + additionalMessage, exception);
@@ -270,7 +270,7 @@ internal Result<T> ToFailValueResult<T>()
         /// <param name="errorObject">Error object to use.</param>
         /// <returns>A failed <see cref="CustomResult{TError}"/>.</returns>
         [Pure]
-        internal CustomResult<TError> ToFailCustomResult<TError>([NotNull] in TError errorObject)
+        internal CustomResult<TError> ToFailCustomResult<TError>([NotNull] TError errorObject)
         {
             Debug.Assert(ResultLogic.IsConvertibleToFailure(Logic), "Cannot convert a success Result to a CustomResult<TError> failure.");
             return CustomFail(Logic.Message, errorObject, Logic.Exception);
@@ -283,7 +283,7 @@ internal CustomResult<TError> ToFailCustomResult<TError>([NotNull] in TError err
         /// <param name="errorObject">Error object to use.</param>
         /// <returns>A failed <see cref="Result{T, TError}"/>.</returns>
         [Pure]
-        internal Result<T, TError> ToFailValueCustomResult<T, TError>([NotNull] in TError errorObject)
+        internal Result<T, TError> ToFailValueCustomResult<T, TError>([NotNull] TError errorObject)
         {
             Debug.Assert(ResultLogic.IsConvertibleToFailure(Logic), "Cannot convert a success Result to a Result<T, TError> failure.");
             return Fail<T, TError>(Logic.Message, errorObject, Logic.Exception);
@@ -297,7 +297,7 @@ internal Result<T, TError> ToFailValueCustomResult<T, TError>([NotNull] in TErro
         /// <param name="exception">Exception to set in the warning <see cref="Result"/>.</param>
         /// <returns>A warning <see cref="Result"/>.</returns>
         [Pure]
-        internal Result ToWarnResult([NotNull] in string message, [CanBeNull] in Exception exception = null)
+        internal Result ToWarnResult([NotNull] string message, [CanBeNull] Exception exception = null)
         {
             Debug.Assert(ResultLogic.IsConvertibleToWarning(Logic), "Cannot convert a warning Result<T> to a Result<T> warning.");
             return Warn(message, exception);
@@ -313,7 +313,7 @@ internal Result ToWarnResult([NotNull] in string message, [CanBeNull] in Excepti
         /// <param name="other"><see cref="Result"/> to compare.</param>
         /// <returns>True if both <see cref="Result"/> are equal and successful, otherwise false.</returns>
         [PublicAPI, Pure]
-        public bool SuccessEquals(in Result other)
+        public bool SuccessEquals(Result other)
         {
             if (IsSuccess && other.IsSuccess)
                 return Equals(other);
@@ -340,7 +340,7 @@ public override bool Equals(object obj)
         /// <param name="result1">First <see cref="Result"/> to compare.</param>
         /// <param name="result2">Second <see cref="Result"/> to compare.</param>
         /// <returns>True if both <see cref="Result"/> are equal, otherwise false.</returns>
-        public static bool operator ==(in Result result1, in Result result2)
+        public static bool operator ==(Result result1, Result result2)
         {
             return result1.Equals(result2);
         }
@@ -351,7 +351,7 @@ public override bool Equals(object obj)
         /// <param name="result1">First <see cref="Result"/> to compare.</param>
         /// <param name="result2">Second <see cref="Result"/> to compare.</param>
         /// <returns>True if both <see cref="Result"/> are not equal, otherwise false.</returns>
-        public static bool operator !=(in Result result1, in Result result2)
+        public static bool operator !=(Result result1, Result result2)
         {
             return !(result1 == result2);
         }
@@ -393,7 +393,7 @@ public int CompareTo(Result other)
         /// <param name="left">The first <see cref="Result"/> to compare.</param>
         /// <param name="right">The second <see cref="Result"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <(in Result left, in Result right)
+        public static bool operator <(Result left, Result right)
         {
             return left.CompareTo(right) < 0;
         }
@@ -404,7 +404,7 @@ public int CompareTo(Result other)
         /// <param name="left">The first <see cref="Result"/> to compare.</param>
         /// <param name="right">The second <see cref="Result"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <=(in Result left, in Result right)
+        public static bool operator <=(Result left, Result right)
         {
             return left.CompareTo(right) <= 0;
         }
@@ -415,7 +415,7 @@ public int CompareTo(Result other)
         /// <param name="left">The first <see cref="Result"/> to compare.</param>
         /// <param name="right">The second <see cref="Result"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >(in Result left, in Result right)
+        public static bool operator >(Result left, Result right)
         {
             return left.CompareTo(right) > 0;
         }
@@ -426,7 +426,7 @@ public int CompareTo(Result other)
         /// <param name="left">The first <see cref="Result"/> to compare.</param>
         /// <param name="right">The second <see cref="Result"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >=(in Result left, in Result right)
+        public static bool operator >=(Result left, Result right)
         {
             return left.CompareTo(right) >= 0;
         }
@@ -458,7 +458,7 @@ public static Result Ok()
         /// <exception cref="ArgumentNullException">If the <paramref name="message"/> is null or empty.</exception>
         [PublicAPI, Pure]
         [ContractAnnotation("message:null => halt")]
-        public static Result Warn([NotNull] in string message, [CanBeNull] in Exception exception = null)
+        public static Result Warn([NotNull] string message, [CanBeNull] Exception exception = null)
         {
             return new Result(true, message, exception);
         }
@@ -472,7 +472,7 @@ public static Result Warn([NotNull] in string message, [CanBeNull] in Exception
         /// <exception cref="ArgumentNullException">If the <paramref name="error"/> is null or empty.</exception>
         [PublicAPI, Pure]
         [ContractAnnotation("error:null => halt")]
-        public static Result Fail([NotNull] in string error, [CanBeNull] in Exception exception = null)
+        public static Result Fail([NotNull] string error, [CanBeNull] Exception exception = null)
         {
             return new Result(false, error, exception);
         }
@@ -485,7 +485,7 @@ public static Result Fail([NotNull] in string error, [CanBeNull] in Exception ex
         /// <exception cref="ArgumentNullException">If the <paramref name="exception"/> is null.</exception>
         [PublicAPI, Pure]
         [ContractAnnotation("exception:null => halt")]
-        public static Result Fail([NotNull] in Exception exception)
+        public static Result Fail([NotNull] Exception exception)
         {
             Throw.IfArgumentNull(exception, nameof(exception));
 
@@ -502,7 +502,7 @@ public static Result Fail([NotNull] in Exception exception)
         /// <param name="value">Result value.</param>
         /// <returns>A <see cref="Result{T}"/>.</returns>
         [PublicAPI, Pure]
-        public static Result<T> Ok<T>([CanBeNull] in T value)
+        public static Result<T> Ok<T>([CanBeNull] T value)
         {
             return new Result<T>(value);
         }
@@ -517,7 +517,7 @@ public static Result<T> Ok<T>([CanBeNull] in T value)
         /// <exception cref="ArgumentNullException">If the <paramref name="message"/> is null or empty.</exception>
         [PublicAPI, Pure]
         [ContractAnnotation("message:null => halt")]
-        public static Result<T> Warn<T>([CanBeNull] in T value, [NotNull] in string message, [CanBeNull] in Exception exception = null)
+        public static Result<T> Warn<T>([CanBeNull] T value, [NotNull] string message, [CanBeNull] Exception exception = null)
         {
             return new Result<T>(true, value, message, exception);
         }
@@ -531,9 +531,9 @@ public static Result<T> Warn<T>([CanBeNull] in T value, [NotNull] in string mess
         /// <exception cref="ArgumentNullException">If the <paramref name="error"/> is null or empty.</exception>
         [PublicAPI, Pure]
         [ContractAnnotation("error:null => halt")]
-        public static Result<T> Fail<T>([NotNull] in string error, [CanBeNull] in Exception exception = null)
+        public static Result<T> Fail<T>([NotNull] string error, [CanBeNull] Exception exception = null)
         {
-            return new Result<T>(false, default, error, exception);
+            return new Result<T>(false, default(T), error, exception);
         }
 
         /// <summary>
@@ -544,11 +544,11 @@ public static Result<T> Fail<T>([NotNull] in string error, [CanBeNull] in Except
         /// <exception cref="ArgumentNullException">If the <paramref name="exception"/> is null.</exception>
         [PublicAPI, Pure]
         [ContractAnnotation("exception:null => halt")]
-        public static Result<T> Fail<T>([NotNull] in Exception exception)
+        public static Result<T> Fail<T>([NotNull] Exception exception)
         {
             Throw.IfArgumentNull(exception, nameof(exception));
 
-            return new Result<T>(false, default, exception.Message, exception);
+            return new Result<T>(false, default(T), exception.Message, exception);
         }
 
         #endregion
@@ -574,9 +574,9 @@ public static CustomResult<TError> CustomOk<TError>()
         /// <exception cref="ArgumentNullException">If the <paramref name="message"/> is null or empty.</exception>
         [PublicAPI, Pure]
         [ContractAnnotation("message:null => halt")]
-        public static CustomResult<TError> CustomWarn<TError>([NotNull] in string message, [CanBeNull] in Exception exception = null)
+        public static CustomResult<TError> CustomWarn<TError>([NotNull] string message, [CanBeNull] Exception exception = null)
         {
-            return new CustomResult<TError>(true, message, default, exception);
+            return new CustomResult<TError>(true, message, default(TError), exception);
         }
 
         /// <summary>
@@ -590,7 +590,7 @@ public static CustomResult<TError> CustomWarn<TError>([NotNull] in string messag
         /// <exception cref="ArgumentNullException">If the <paramref name="error"/> is null.</exception>
         [PublicAPI, Pure]
         [ContractAnnotation("message:null => halt; error:null => halt")]
-        public static CustomResult<TError> CustomFail<TError>([NotNull] in string message, [NotNull] in TError error, [CanBeNull] in Exception exception = null)
+        public static CustomResult<TError> CustomFail<TError>([NotNull] string message, [NotNull] TError error, [CanBeNull] Exception exception = null)
         {
             return new CustomResult<TError>(false, message, error, exception);
         }
@@ -605,7 +605,7 @@ public static CustomResult<TError> CustomFail<TError>([NotNull] in string messag
         /// <exception cref="ArgumentNullException">If the <paramref name="exception"/> is null.</exception>
         [PublicAPI, Pure]
         [ContractAnnotation("error:null => halt; exception:null => halt")]
-        public static CustomResult<TError> CustomFail<TError>([NotNull] in TError error, [NotNull] in Exception exception)
+        public static CustomResult<TError> CustomFail<TError>([NotNull] TError error, [NotNull] Exception exception)
         {
             Throw.IfArgumentNull(exception, nameof(exception));
 
@@ -622,7 +622,7 @@ public static CustomResult<TError> CustomFail<TError>([NotNull] in TError error,
         /// <param name="value">Result value.</param>
         /// <returns>A <see cref="Result{T, TError}"/>.</returns>
         [PublicAPI, Pure]
-        public static Result<T, TError> Ok<T, TError>([CanBeNull] in T value)
+        public static Result<T, TError> Ok<T, TError>([CanBeNull] T value)
         {
             return new Result<T, TError>(value);
         }
@@ -637,7 +637,7 @@ public static Result<T, TError> Ok<T, TError>([CanBeNull] in T value)
         /// <exception cref="ArgumentNullException">If the <paramref name="message"/> is null or empty.</exception>
         [PublicAPI, Pure]
         [ContractAnnotation("message:null => halt")]
-        public static Result<T, TError> Warn<T, TError>([CanBeNull] in T value, [NotNull] in string message, [CanBeNull] in Exception exception = null)
+        public static Result<T, TError> Warn<T, TError>([CanBeNull] T value, [NotNull] string message, [CanBeNull] Exception exception = null)
         {
             return new Result<T, TError>(value, message, exception);
         }
@@ -653,7 +653,7 @@ public static Result<T, TError> Warn<T, TError>([CanBeNull] in T value, [NotNull
         /// <exception cref="ArgumentNullException">If the <paramref name="error"/> is null.</exception>
         [PublicAPI, Pure]
         [ContractAnnotation("message:null => halt; error:null => halt")]
-        public static Result<T, TError> Fail<T, TError>([NotNull] in string message, [NotNull] in TError error, [CanBeNull] in Exception exception = null)
+        public static Result<T, TError> Fail<T, TError>([NotNull] string message, [NotNull] TError error, [CanBeNull] Exception exception = null)
         {
             return new Result<T, TError>(message, error, exception);
         }
@@ -668,7 +668,7 @@ public static Result<T, TError> Fail<T, TError>([NotNull] in string message, [No
         /// <exception cref="ArgumentNullException">If the <paramref name="exception"/> is null.</exception>
         [PublicAPI, Pure]
         [ContractAnnotation("error:null => halt; exception:null => halt")]
-        public static Result<T, TError> Fail<T, TError>([NotNull] in TError error, [NotNull] in Exception exception)
+        public static Result<T, TError> Fail<T, TError>([NotNull] TError error, [NotNull] Exception exception)
         {
             Throw.IfArgumentNull(exception, nameof(exception));
 
diff --git a/src/Here/Result/ResultHelpers.cs b/src/Here/Result/ResultHelpers.cs
index 571f567..057d467 100644
--- a/src/Here/Result/ResultHelpers.cs
+++ b/src/Here/Result/ResultHelpers.cs
@@ -18,7 +18,7 @@ public static class ResultHelpers
         /// <param name="result2">Second <see cref="Result"/> to compare.</param>
         /// <returns>True if both <see cref="Result"/> are equal, otherwise false.</returns>
         [PublicAPI, Pure]
-        public static bool AreEqual(in Result result1, in Result result2)
+        public static bool AreEqual(Result result1, Result result2)
         {
             return result1.Equals(result2);
         }
@@ -32,7 +32,7 @@ public static bool AreEqual(in Result result1, in Result result2)
         /// <param name="equalityComparer">Equality comparer to use to compare values.</param>
         /// <returns>True if both <see cref="Result{T}"/> are equal, otherwise false.</returns>
         [PublicAPI, Pure]
-        public static bool AreEqual<T>(in Result<T> result1, in Result<T> result2, [CanBeNull] in IEqualityComparer<T> equalityComparer = null)
+        public static bool AreEqual<T>(Result<T> result1, Result<T> result2, [CanBeNull] IEqualityComparer<T> equalityComparer = null)
         {
             return Result<T>.AreEqual(result1, result2, equalityComparer);
         }
@@ -46,7 +46,7 @@ public static bool AreEqual<T>(in Result<T> result1, in Result<T> result2, [CanB
         /// <param name="equalityComparer">Equality comparer to use to compare values.</param>
         /// <returns>True if the <see cref="Result{T}"/> value is equals to the given value, otherwise false.</returns>
         [PublicAPI, Pure]
-        public static bool AreEqual<T>(in Result<T> result, [CanBeNull] in T value, [CanBeNull] in IEqualityComparer<T> equalityComparer = null)
+        public static bool AreEqual<T>(Result<T> result, [CanBeNull] T value, [CanBeNull] IEqualityComparer<T> equalityComparer = null)
         {
             return Result<T>.AreEqual(result, value, equalityComparer);
         }
@@ -59,7 +59,7 @@ public static bool AreEqual<T>(in Result<T> result, [CanBeNull] in T value, [Can
         /// <param name="result2">Second <see cref="CustomResult{TError}"/> to compare.</param>
         /// <returns>True if both <see cref="CustomResult{TError}"/> are equal, otherwise false.</returns>
         [PublicAPI, Pure]
-        public static bool AreEqual<TError>(in CustomResult<TError> result1, in CustomResult<TError> result2)
+        public static bool AreEqual<TError>(CustomResult<TError> result1, CustomResult<TError> result2)
         {
             return result1.Equals(result2);
         }
@@ -74,7 +74,7 @@ public static bool AreEqual<TError>(in CustomResult<TError> result1, in CustomRe
         /// <param name="equalityComparer">Equality comparer to use to compare values.</param>
         /// <returns>True if both <see cref="Result{T, TError}"/> are equal, otherwise false.</returns>
         [PublicAPI, Pure]
-        public static bool AreEqual<T, TError>(in Result<T, TError> result1, in Result<T, TError> result2, [CanBeNull] in IEqualityComparer<T> equalityComparer = null)
+        public static bool AreEqual<T, TError>(Result<T, TError> result1, Result<T, TError> result2, [CanBeNull] IEqualityComparer<T> equalityComparer = null)
         {
             return Result<T, TError>.AreEqual(result1, result2);
         }
@@ -89,7 +89,7 @@ public static bool AreEqual<T, TError>(in Result<T, TError> result1, in Result<T
         /// <param name="equalityComparer">Equality comparer to use to compare values.</param>
         /// <returns>True if the <see cref="Result{T, TError}"/> value is equals to the given value, otherwise false.</returns>
         [PublicAPI, Pure]
-        public static bool AreEqual<T, TError>(in Result<T, TError> result, [CanBeNull] in T value, [CanBeNull] in IEqualityComparer<T> equalityComparer = null)
+        public static bool AreEqual<T, TError>(Result<T, TError> result, [CanBeNull] T value, [CanBeNull] IEqualityComparer<T> equalityComparer = null)
         {
             return Result<T, TError>.AreEqual(result, value, equalityComparer);
         }
@@ -105,7 +105,7 @@ public static bool AreEqual<T, TError>(in Result<T, TError> result, [CanBeNull]
         /// <param name="result2">Second <see cref="Result"/> to compare.</param>
         /// <returns>True if both <see cref="Result"/> are equal and successful, otherwise false.</returns>
         [PublicAPI, Pure]
-        public static bool SuccessEqual(in Result result1, in Result result2)
+        public static bool SuccessEqual(Result result1, Result result2)
         {
             return result1.SuccessEquals(result2);
         }
@@ -119,7 +119,7 @@ public static bool SuccessEqual(in Result result1, in Result result2)
         /// <param name="equalityComparer">Equality comparer to use to compare values.</param>
         /// <returns>True if both <see cref="Result{T}"/> are equal and successful, otherwise false.</returns>
         [PublicAPI, Pure]
-        public static bool SuccessEqual<T>(in Result<T> result1, in Result<T> result2, [CanBeNull] in IEqualityComparer<T> equalityComparer = null)
+        public static bool SuccessEqual<T>(Result<T> result1, Result<T> result2, [CanBeNull] IEqualityComparer<T> equalityComparer = null)
         {
             return Result<T>.AreSuccessEqual(result1, result2, equalityComparer);
         }
@@ -132,7 +132,7 @@ public static bool SuccessEqual<T>(in Result<T> result1, in Result<T> result2, [
         /// <param name="result2">Second <see cref="CustomResult{TError}"/> to compare.</param>
         /// <returns>True if both <see cref="CustomResult{TError}"/> are equal and successful, otherwise false.</returns>
         [PublicAPI, Pure]
-        public static bool SuccessEqual<TError>(in CustomResult<TError> result1, in CustomResult<TError> result2)
+        public static bool SuccessEqual<TError>(CustomResult<TError> result1, CustomResult<TError> result2)
         {
             return result1.SuccessEquals(result2);
         }
@@ -147,7 +147,7 @@ public static bool SuccessEqual<TError>(in CustomResult<TError> result1, in Cust
         /// <param name="equalityComparer">Equality comparer to use to compare values.</param>
         /// <returns>True if both <see cref="Result{T, TError}"/> are equal and successful, otherwise false.</returns>
         [PublicAPI, Pure]
-        public static bool SuccessEqual<T, TError>(in Result<T, TError> result1, in Result<T, TError> result2, [CanBeNull] in IEqualityComparer<T> equalityComparer = null)
+        public static bool SuccessEqual<T, TError>(Result<T, TError> result1, Result<T, TError> result2, [CanBeNull] IEqualityComparer<T> equalityComparer = null)
         {
             return Result<T, TError>.AreSuccessEqual(result1, result2, equalityComparer);
         }
@@ -164,7 +164,7 @@ public static bool SuccessEqual<T, TError>(in Result<T, TError> result1, in Resu
         /// <param name="result2">Second <see cref="Result"/> to compare.</param>
         /// <returns>An integer that indicates the relative order of compared objects.</returns>
         [PublicAPI, Pure]
-        public static int Compare(in Result result1, in Result result2)
+        public static int Compare(Result result1, Result result2)
         {
             return result1.CompareTo(result2);
         }
@@ -178,7 +178,7 @@ public static int Compare(in Result result1, in Result result2)
         /// <param name="result2">Second <see cref="Result{T}"/> to compare.</param>
         /// <returns>An integer that indicates the relative order of compared objects.</returns>
         [PublicAPI, Pure]
-        public static int Compare<T>(in Result<T> result1, in Result<T> result2)
+        public static int Compare<T>(Result<T> result1, Result<T> result2)
         {
             return result1.CompareTo(result2);
         }
@@ -192,7 +192,7 @@ public static int Compare<T>(in Result<T> result1, in Result<T> result2)
         /// <param name="result2">Second <see cref="CustomResult{TError}"/> to compare.</param>
         /// <returns>An integer that indicates the relative order of compared objects.</returns>
         [PublicAPI, Pure]
-        public static int Compare<TError>(in CustomResult<TError> result1, in CustomResult<TError> result2)
+        public static int Compare<TError>(CustomResult<TError> result1, CustomResult<TError> result2)
         {
             return result1.CompareTo(result2);
         }
@@ -207,7 +207,7 @@ public static int Compare<TError>(in CustomResult<TError> result1, in CustomResu
         /// <param name="result2">Second <see cref="Result{T,TError}"/> to compare.</param>
         /// <returns>An integer that indicates the relative order of compared objects.</returns>
         [PublicAPI, Pure]
-        public static int Compare<T, TError>(in Result<T, TError> result1, in Result<T, TError> result2)
+        public static int Compare<T, TError>(Result<T, TError> result1, Result<T, TError> result2)
         {
             return result1.CompareTo(result2);
         }
diff --git a/src/Here/Result/ResultLogics.cs b/src/Here/Result/ResultLogics.cs
index 88bb4bb..bdc41f1 100644
--- a/src/Here/Result/ResultLogics.cs
+++ b/src/Here/Result/ResultLogics.cs
@@ -60,7 +60,7 @@ public ResultLogic()
             IsWarning = false;
             IsFailure = false;
             Message = null;
-            _error = default;
+            _error = default(TError);
             Exception = null;
         }
 
@@ -71,7 +71,7 @@ public ResultLogic()
         /// <param name="message">Message.</param>
         /// <param name="error">Error object.</param>
         /// <param name="exception">Result embedded exception.</param>
-        public ResultLogic(in bool isWarning, [NotNull] in string message, [CanBeNull] in TError error, [CanBeNull] in Exception exception)
+        public ResultLogic(bool isWarning, [NotNull] string message, [CanBeNull] TError error, [CanBeNull] Exception exception)
         {
             // Warning & Failure must have a message
             if (string.IsNullOrEmpty(message))
@@ -125,7 +125,7 @@ public override int GetHashCode()
         /// <param name="result1">First <see cref="ResultLogic{TError}"/> to compare.</param>
         /// <param name="result2">Second <see cref="ResultLogic{TError}"/> to compare.</param>
         /// <returns>True if both <see cref="ResultLogic{TError}"/> are equal, otherwise false.</returns>
-        public static bool operator ==(in ResultLogic<TError> result1, in ResultLogic<TError> result2)
+        public static bool operator ==(ResultLogic<TError> result1, ResultLogic<TError> result2)
         {
             if (ReferenceEquals(result1, result2))
                 return true;
@@ -138,7 +138,7 @@ public override int GetHashCode()
         /// <param name="result1">First <see cref="ResultLogic{TError}"/> to compare.</param>
         /// <param name="result2">Second <see cref="ResultLogic{TError}"/> to compare.</param>
         /// <returns>True if both <see cref="ResultLogic{TError}"/> are not equal, otherwise false.</returns>
-        public static bool operator !=(in ResultLogic<TError> result1, in ResultLogic<TError> result2)
+        public static bool operator !=(ResultLogic<TError> result1, ResultLogic<TError> result2)
         {
             return !(result1 == result2);
         }
@@ -179,7 +179,7 @@ public int CompareTo(ResultLogic<TError> other)
         /// <param name="left">The first <see cref="ResultLogic{TError}"/> to compare.</param>
         /// <param name="right">The second <see cref="ResultLogic{TError}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <(in ResultLogic<TError> left, in ResultLogic<TError> right)
+        public static bool operator <(ResultLogic<TError> left, ResultLogic<TError> right)
         {
             return left.CompareTo(right) < 0;
         }
@@ -190,7 +190,7 @@ public int CompareTo(ResultLogic<TError> other)
         /// <param name="left">The first <see cref="ResultLogic{TError}"/> to compare.</param>
         /// <param name="right">The second <see cref="ResultLogic{TError}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <=(in ResultLogic<TError> left, in ResultLogic<TError> right)
+        public static bool operator <=(ResultLogic<TError> left, ResultLogic<TError> right)
         {
             return left.CompareTo(right) <= 0;
         }
@@ -201,7 +201,7 @@ public int CompareTo(ResultLogic<TError> other)
         /// <param name="left">The first <see cref="ResultLogic{TError}"/> to compare.</param>
         /// <param name="right">The second <see cref="ResultLogic{TError}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >(in ResultLogic<TError> left, in ResultLogic<TError> right)
+        public static bool operator >(ResultLogic<TError> left, ResultLogic<TError> right)
         {
             return left.CompareTo(right) > 0;
         }
@@ -212,7 +212,7 @@ public int CompareTo(ResultLogic<TError> other)
         /// <param name="left">The first <see cref="ResultLogic{TError}"/> to compare.</param>
         /// <param name="right">The second <see cref="ResultLogic{TError}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >=(in ResultLogic<TError> left, in ResultLogic<TError> right)
+        public static bool operator >=(ResultLogic<TError> left, ResultLogic<TError> right)
         {
             return left.CompareTo(right) >= 0;
         }
@@ -248,7 +248,7 @@ public ResultLogic()
         /// <param name="isWarning">Warning flag.</param>
         /// <param name="message">Result message.</param>
         /// <param name="exception">Result embedded exception.</param>
-        public ResultLogic(in bool isWarning, [NotNull] in string message, [CanBeNull] in Exception exception)
+        public ResultLogic(bool isWarning, [NotNull] string message, [CanBeNull] Exception exception)
             : base(isWarning, message, isWarning ? null : message, exception)
         {
         }
@@ -261,7 +261,7 @@ public ResultLogic(in bool isWarning, [NotNull] in string message, [CanBeNull] i
         /// <param name="logic"><see cref="ResultLogic{TError}"/> to check.</param>
         /// <returns>True if the <see cref="ResultLogic{TError}"/> is convertible, otherwise false.</returns>
         [Pure]
-        internal static bool IsConvertibleToFailure<TError>(in ResultLogic<TError> logic)
+        internal static bool IsConvertibleToFailure<TError>(ResultLogic<TError> logic)
         {
             return !logic.IsSuccess || logic.IsWarning;
         }
@@ -271,7 +271,7 @@ internal static bool IsConvertibleToFailure<TError>(in ResultLogic<TError> logic
         /// </summary>
         /// <param name="logic"><see cref="ResultLogic{TError}"/> to check.</param>
         /// <returns>True if the <see cref="ResultLogic{TError}"/> is convertible, otherwise false.</returns>
-        internal static bool IsConvertibleToWarning<TError>(in ResultLogic<TError> logic)
+        internal static bool IsConvertibleToWarning<TError>(ResultLogic<TError> logic)
         {
             return !logic.IsFailure;
         }
@@ -283,7 +283,7 @@ internal static bool IsConvertibleToWarning<TError>(in ResultLogic<TError> logic
         /// <param name="logic"><see cref="ResultLogic{TError}"/> to convert.</param>
         /// <returns>A <see cref="ResultLogic"/>.</returns>
         [Pure]
-        internal static ResultLogic ToResultLogic<TError>(in ResultLogic<TError> logic)
+        internal static ResultLogic ToResultLogic<TError>(ResultLogic<TError> logic)
         {
             if (logic.IsSuccess && !logic.IsWarning)
                 return new ResultLogic();
@@ -330,7 +330,7 @@ public override int GetHashCode()
         /// <param name="result1">First <see cref="ResultLogic"/> to compare.</param>
         /// <param name="result2">Second <see cref="ResultLogic"/> to compare.</param>
         /// <returns>True if both <see cref="ResultLogic"/> are equal, otherwise false.</returns>
-        public static bool operator ==(in ResultLogic result1, in ResultLogic result2)
+        public static bool operator ==(ResultLogic result1, ResultLogic result2)
         {
             if (ReferenceEquals(result1, result2))
                 return true;
@@ -343,7 +343,7 @@ public override int GetHashCode()
         /// <param name="result1">First <see cref="ResultLogic"/> to compare.</param>
         /// <param name="result2">Second <see cref="ResultLogic"/> to compare.</param>
         /// <returns>True if both <see cref="ResultLogic"/> are not equal, otherwise false.</returns>
-        public static bool operator !=(in ResultLogic result1, in ResultLogic result2)
+        public static bool operator !=(ResultLogic result1, ResultLogic result2)
         {
             return !(result1 == result2);
         }
@@ -368,7 +368,7 @@ public int CompareTo(ResultLogic other)
         /// <param name="left">The first <see cref="ResultLogic"/> to compare.</param>
         /// <param name="right">The second <see cref="ResultLogic"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <(in ResultLogic left, in ResultLogic right)
+        public static bool operator <(ResultLogic left, ResultLogic right)
         {
             return left.CompareTo(right) < 0;
         }
@@ -379,7 +379,7 @@ public int CompareTo(ResultLogic other)
         /// <param name="left">The first <see cref="ResultLogic"/> to compare.</param>
         /// <param name="right">The second <see cref="ResultLogic"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <=(in ResultLogic left, in ResultLogic right)
+        public static bool operator <=(ResultLogic left, ResultLogic right)
         {
             return left.CompareTo(right) <= 0;
         }
@@ -390,7 +390,7 @@ public int CompareTo(ResultLogic other)
         /// <param name="left">The first <see cref="ResultLogic"/> to compare.</param>
         /// <param name="right">The second <see cref="ResultLogic"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >(in ResultLogic left, in ResultLogic right)
+        public static bool operator >(ResultLogic left, ResultLogic right)
         {
             return left.CompareTo(right) > 0;
         }
@@ -401,7 +401,7 @@ public int CompareTo(ResultLogic other)
         /// <param name="left">The first <see cref="ResultLogic"/> to compare.</param>
         /// <param name="right">The second <see cref="ResultLogic"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >=(in ResultLogic left, in ResultLogic right)
+        public static bool operator >=(ResultLogic left, ResultLogic right)
         {
             return left.CompareTo(right) >= 0;
         }
diff --git a/src/Here/Result/ResultScopes.cs b/src/Here/Result/ResultScopes.cs
index 60538b0..2c903f7 100644
--- a/src/Here/Result/ResultScopes.cs
+++ b/src/Here/Result/ResultScopes.cs
@@ -16,7 +16,7 @@ public static class ResultScope
         /// <returns>A <see cref="Result"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="action"/> is null.</exception>
         [PublicAPI]
-        public static Result SafeResult([NotNull, InstantHandle] in Action action)
+        public static Result SafeResult([NotNull, InstantHandle] Action action)
         {
             Throw.IfArgumentNull(action, nameof(action));
 
@@ -38,7 +38,7 @@ public static Result SafeResult([NotNull, InstantHandle] in Action action)
         /// <returns>A <see cref="Result"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="action"/> is null.</exception>
         [PublicAPI]
-        public static Result SafeResult([NotNull, InstantHandle] in Func<Result> action)
+        public static Result SafeResult([NotNull, InstantHandle] Func<Result> action)
         {
             Throw.IfArgumentNull(action, nameof(action));
 
@@ -59,7 +59,7 @@ public static Result SafeResult([NotNull, InstantHandle] in Func<Result> action)
         /// <returns>A <see cref="Result{T}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="action"/> is null.</exception>
         [PublicAPI]
-        public static Result<T> SafeValueResult<T>([NotNull, InstantHandle] in Func<Result<T>> action)
+        public static Result<T> SafeValueResult<T>([NotNull, InstantHandle] Func<Result<T>> action)
         {
             Throw.IfArgumentNull(action, nameof(action));
 
@@ -82,7 +82,7 @@ public static Result<T> SafeValueResult<T>([NotNull, InstantHandle] in Func<Resu
         /// <exception cref="ArgumentNullException">If the <paramref name="action"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorObject"/> is null.</exception>
         [PublicAPI]
-        public static CustomResult<TError> SafeCustomResult<TError>([NotNull, InstantHandle] in Func<CustomResult<TError>> action, [NotNull] in TError errorObject)
+        public static CustomResult<TError> SafeCustomResult<TError>([NotNull, InstantHandle] Func<CustomResult<TError>> action, [NotNull] TError errorObject)
         {
             Throw.IfArgumentNull(action, nameof(action));
             Throw.IfArgumentNull(errorObject, nameof(errorObject));
@@ -106,7 +106,7 @@ public static CustomResult<TError> SafeCustomResult<TError>([NotNull, InstantHan
         /// <exception cref="ArgumentNullException">If the <paramref name="action"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorFactory"/> is null.</exception>
         [PublicAPI]
-        public static CustomResult<TError> SafeCustomResult<TError>([NotNull, InstantHandle] in Func<CustomResult<TError>> action, [NotNull] in Func<TError> errorFactory)
+        public static CustomResult<TError> SafeCustomResult<TError>([NotNull, InstantHandle] Func<CustomResult<TError>> action, [NotNull] Func<TError> errorFactory)
         {
             Throw.IfArgumentNull(action, nameof(action));
             Throw.IfArgumentNull(errorFactory, nameof(errorFactory));
@@ -130,7 +130,7 @@ public static CustomResult<TError> SafeCustomResult<TError>([NotNull, InstantHan
         /// <exception cref="ArgumentNullException">If the <paramref name="action"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorObject"/> is null.</exception>
         [PublicAPI]
-        public static Result<T, TError> SafeValueCustomResult<T, TError>([NotNull, InstantHandle] in Func<Result<T, TError>> action, [NotNull] in TError errorObject)
+        public static Result<T, TError> SafeValueCustomResult<T, TError>([NotNull, InstantHandle] Func<Result<T, TError>> action, [NotNull] TError errorObject)
         {
             Throw.IfArgumentNull(action, nameof(action));
             Throw.IfArgumentNull(errorObject, nameof(errorObject));
@@ -154,7 +154,7 @@ public static Result<T, TError> SafeValueCustomResult<T, TError>([NotNull, Insta
         /// <exception cref="ArgumentNullException">If the <paramref name="action"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorFactory"/> is null.</exception>
         [PublicAPI]
-        public static Result<T, TError> SafeValueCustomResult<T, TError>([NotNull, InstantHandle] in Func<Result<T, TError>> action, [NotNull] in Func<TError> errorFactory)
+        public static Result<T, TError> SafeValueCustomResult<T, TError>([NotNull, InstantHandle] Func<Result<T, TError>> action, [NotNull] Func<TError> errorFactory)
         {
             Throw.IfArgumentNull(action, nameof(action));
             Throw.IfArgumentNull(errorFactory, nameof(errorFactory));
diff --git a/src/Here/Result/ValueCustomErrorResult.cs b/src/Here/Result/ValueCustomErrorResult.cs
index 9d86637..98160ac 100644
--- a/src/Here/Result/ValueCustomErrorResult.cs
+++ b/src/Here/Result/ValueCustomErrorResult.cs
@@ -12,7 +12,7 @@ namespace Here
     /// </summary>
     [PublicAPI]
     [DebuggerDisplay("{" + nameof(IsSuccess) + " ? \"IsSuccess\" + (" + nameof(IsWarning) + " ? \" with warning\" : System.String.Empty) + \", Value = \" + " + nameof(_value) + " : \"IsFailure\"}")]
-    public readonly partial struct Result<T, TError> : IResult<T>, IResultError<TError>, IEquatable<T>, IEquatable<Result<T, TError>>, IComparable, IComparable<Result<T, TError>>
+    public partial struct Result<T, TError> : IResult<T>, IResultError<TError>, IEquatable<T>, IEquatable<Result<T, TError>>, IComparable, IComparable<Result<T, TError>>
     {
         /// <inheritdoc />
         public bool IsSuccess => Logic.IsSuccess;
@@ -59,7 +59,7 @@ public T Value
         /// <see cref="Result{T, TError}"/> "Ok" constructor.
         /// </summary>
         /// <param name="value">Result value.</param>
-        internal Result([CanBeNull] in T value)
+        internal Result([CanBeNull] T value)
         {
             Logic = new ResultLogic<TError>();
             _value = value;
@@ -71,9 +71,9 @@ internal Result([CanBeNull] in T value)
         /// <param name="value">Embedded value.</param>
         /// <param name="message">Result message.</param>
         /// <param name="exception">Result embedded exception.</param>
-        internal Result([CanBeNull] in T value, [NotNull] in string message, [CanBeNull] in Exception exception)
+        internal Result([CanBeNull] T value, [NotNull] string message, [CanBeNull] Exception exception)
         {
-            Logic = new ResultLogic<TError>(true, message, default, exception);
+            Logic = new ResultLogic<TError>(true, message, default(TError), exception);
             _value = value;
         }
 
@@ -83,10 +83,10 @@ internal Result([CanBeNull] in T value, [NotNull] in string message, [CanBeNull]
         /// <param name="message">Result message.</param>
         /// <param name="error">Result error object.</param>
         /// <param name="exception">Result embedded exception.</param>
-        internal Result([NotNull] in string message, [NotNull] in TError error, [CanBeNull] in Exception exception)
+        internal Result([NotNull] string message, [NotNull] TError error, [CanBeNull] Exception exception)
         {
             Logic = new ResultLogic<TError>(false, message, error, exception);
-            _value = default;
+            _value = default(T);
         }
 
         /// <summary>
@@ -94,7 +94,7 @@ internal Result([NotNull] in string message, [NotNull] in TError error, [CanBeNu
         /// </summary>
         /// <param name="value">Result value.</param>
         /// <param name="logic">Result logic.</param>
-        internal Result([CanBeNull] in T value, [NotNull] in ResultLogic<TError> logic)
+        internal Result([CanBeNull] T value, [NotNull] ResultLogic<TError> logic)
         {
             Logic = logic;
             _value = value;
@@ -126,7 +126,7 @@ public Result<TOut, TError> Cast<TOut>()
         /// <returns>A <see cref="Result{TOut, TError}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="converter"/> is null.</exception>
         [PublicAPI, Pure]
-        public Result<TOut, TError> Cast<TOut>([NotNull, InstantHandle] in Func<T, TOut> converter)
+        public Result<TOut, TError> Cast<TOut>([NotNull, InstantHandle] Func<T, TOut> converter)
         {
             Throw.IfArgumentNull(converter, nameof(converter));
 
@@ -184,7 +184,7 @@ internal CustomResult<TError> ToFailCustomResult()
         /// <param name="errorObject">Custom error object to use.</param>
         /// <returns>A failed <see cref="CustomResult{TError}"/>.</returns>
         [Pure]
-        internal CustomResult<TError> ToFailCustomResult([NotNull] in TError errorObject)
+        internal CustomResult<TError> ToFailCustomResult([NotNull] TError errorObject)
         {
             Debug.Assert(ResultLogic.IsConvertibleToFailure(Logic), "Cannot convert a success Result<T, TError> to a CustomResult<TError> failure.");
             return Result.CustomFail(Logic.Message, errorObject, Logic.Exception);
@@ -209,7 +209,7 @@ internal Result<TOut, TError> ToFailValueCustomResult<TOut>()
         /// <param name="errorObject">Custom error object to use.</param>
         /// <returns>A failed <see cref="Result{TOut, TError}"/>.</returns>
         [Pure]
-        internal Result<TOut, TError> ToFailValueCustomResult<TOut>([NotNull] in TError errorObject)
+        internal Result<TOut, TError> ToFailValueCustomResult<TOut>([NotNull] TError errorObject)
         {
             Debug.Assert(ResultLogic.IsConvertibleToFailure(Logic), "Cannot convert a success Result<TIn, TError> to a Result<TOut, TError> failure.");
             return Result.Fail<TOut, TError>(Logic.Message, errorObject, Logic.Exception);
@@ -223,7 +223,7 @@ internal Result<TOut, TError> ToFailValueCustomResult<TOut>([NotNull] in TError
         /// <param name="exception">Exception to set in the failure <see cref="Result{TOut, TError}"/>.</param>
         /// <returns>A failed <see cref="Result{TOut, TError}"/>.</returns>
         [Pure]
-        internal Result<TOut, TError> ToFailValueCustomResult<TOut>([NotNull] in string additionalMessage, [CanBeNull] in Exception exception = null)
+        internal Result<TOut, TError> ToFailValueCustomResult<TOut>([NotNull] string additionalMessage, [CanBeNull] Exception exception = null)
         {
             Debug.Assert(Logic.IsFailure, "Cannot convert a success Result<TIn, TError> to a Result<TOut, TError> failure.");
             return Result.Fail<TOut, TError>(Logic.Message + additionalMessage, Logic.Error, exception);
@@ -237,7 +237,7 @@ internal Result<TOut, TError> ToFailValueCustomResult<TOut>([NotNull] in string
         /// <param name="exception">Exception to set in the warning <see cref="Result{T, TError}"/>.</param>
         /// <returns>A warning <see cref="Result{T, TError}"/>.</returns>
         [Pure]
-        internal Result<T, TError> ToWarnValueCustomResult([NotNull] in string message, [CanBeNull] in Exception exception = null)
+        internal Result<T, TError> ToWarnValueCustomResult([NotNull] string message, [CanBeNull] Exception exception = null)
         {
             Debug.Assert(ResultLogic.IsConvertibleToWarning(Logic), "Cannot convert a warning Result<T, TError> to a Result<T, TError> warning.");
             return Result.Warn<T, TError>(_value, message, exception);
@@ -253,7 +253,7 @@ internal Result<T, TError> ToWarnValueCustomResult([NotNull] in string message,
         /// <param name="other"><see cref="Result{T, TError}"/> to compare.</param>
         /// <returns>True if both <see cref="Result{T, TError}"/> are equal and successful, otherwise false.</returns>
         [PublicAPI, Pure]
-        public bool SuccessEquals(in Result<T, TError> other)
+        public bool SuccessEquals(Result<T, TError> other)
         {
             return AreSuccessEqual(this, other);
         }
@@ -288,7 +288,7 @@ public override bool Equals(object obj)
         /// <param name="equalityComparer">Equality comparer to use to compare values.</param>
         /// <returns>True if the <see cref="Result{T, TError}"/> value is equals to the given value, otherwise false.</returns>
         [PublicAPI, Pure]
-        internal static bool AreEqual(in Result<T, TError> result, [CanBeNull] in T value, [CanBeNull] in IEqualityComparer<T> equalityComparer = null)
+        internal static bool AreEqual(Result<T, TError> result, [CanBeNull] T value, [CanBeNull] IEqualityComparer<T> equalityComparer = null)
         {
             if (result.IsSuccess)
                 return (equalityComparer ?? EqualityComparer<T>.Default).Equals(result._value, value);
@@ -303,7 +303,7 @@ internal static bool AreEqual(in Result<T, TError> result, [CanBeNull] in T valu
         /// <param name="equalityComparer">Equality comparer to use to compare values.</param>
         /// <returns>True if both <see cref="Result{T, TError}"/> are equal, otherwise false.</returns>
         [Pure]
-        internal static bool AreEqual(in Result<T, TError> result1, in Result<T, TError> result2, [CanBeNull] in IEqualityComparer<T> equalityComparer = null)
+        internal static bool AreEqual(Result<T, TError> result1, Result<T, TError> result2, [CanBeNull] IEqualityComparer<T> equalityComparer = null)
         {
             return result1.Logic.Equals(result2.Logic)
                    && (equalityComparer ?? EqualityComparer<T>.Default).Equals(result1._value, result2._value);
@@ -317,7 +317,7 @@ internal static bool AreEqual(in Result<T, TError> result1, in Result<T, TError>
         /// <param name="equalityComparer">Equality comparer to use to compare values.</param>
         /// <returns>True if both <see cref="Result{T, TError}"/> are equal, otherwise false.</returns>
         [Pure]
-        internal static bool AreSuccessEqual(in Result<T, TError> result1, in Result<T, TError> result2, [CanBeNull] in IEqualityComparer<T> equalityComparer = null)
+        internal static bool AreSuccessEqual(Result<T, TError> result1, Result<T, TError> result2, [CanBeNull] IEqualityComparer<T> equalityComparer = null)
         {
             if (result1.IsSuccess && result2.IsSuccess)
                 return AreEqual(result1, result2);
@@ -330,7 +330,7 @@ internal static bool AreSuccessEqual(in Result<T, TError> result1, in Result<T,
         /// <param name="result1">First <see cref="Result{T, TError}"/> to compare.</param>
         /// <param name="result2">Second <see cref="Result{T, TError}"/> to compare.</param>
         /// <returns>True if both <see cref="Result{T, TError}"/> are equal, otherwise false.</returns>
-        public static bool operator ==(in Result<T, TError> result1, in Result<T, TError> result2)
+        public static bool operator ==(Result<T, TError> result1, Result<T, TError> result2)
         {
             return AreEqual(result1, result2);
         }
@@ -341,7 +341,7 @@ internal static bool AreSuccessEqual(in Result<T, TError> result1, in Result<T,
         /// <param name="result1">First <see cref="Result{T, TError}"/> to compare.</param>
         /// <param name="result2">Second <see cref="Result{T, TError}"/> to compare.</param>
         /// <returns>True if both <see cref="Result{T, TError}"/> are not equal, otherwise false.</returns>
-        public static bool operator !=(in Result<T, TError> result1, in Result<T, TError> result2)
+        public static bool operator !=(Result<T, TError> result1, Result<T, TError> result2)
         {
             return !(result1 == result2);
         }
@@ -358,7 +358,7 @@ public override int GetHashCode()
         /// <param name="result"><see cref="Result{T, TError}"/> that may embed a value to compare.</param>
         /// <param name="value">Value to compare.</param>
         /// <returns>True if the <see cref="Result{T, TError}"/> value is equals to the given value, otherwise false.</returns>
-        public static bool operator ==(in Result<T, TError> result, in T value)
+        public static bool operator ==(Result<T, TError> result, T value)
         {
             return AreEqual(result, value);
         }
@@ -369,7 +369,7 @@ public override int GetHashCode()
         /// <param name="result"><see cref="Result{T, TError}"/> that may embed a value to compare.</param>
         /// <param name="value">Value to compare.</param>
         /// <returns>True if the <see cref="Result{T, TError}"/> value is not equals to the given value, otherwise false.</returns>
-        public static bool operator !=(in Result<T, TError> result, in T value)
+        public static bool operator !=(Result<T, TError> result, T value)
         {
             return !(result == value);
         }
@@ -380,7 +380,7 @@ public override int GetHashCode()
         /// <param name="value">Value to compare.</param>
         /// <param name="result"><see cref="Result{T, TError}"/> that may embed a value to compare.</param>
         /// <returns>True if the <see cref="Result{T, TError}"/> value is equals to the given value, otherwise false.</returns>
-        public static bool operator ==(in T value, in Result<T, TError> result)
+        public static bool operator ==(T value, Result<T, TError> result)
         {
             return result == value;
         }
@@ -391,7 +391,7 @@ public override int GetHashCode()
         /// <param name="value">Value to compare.</param>
         /// <param name="result"><see cref="Result{T, TError}"/> that may embed a value to compare.</param>
         /// <returns>True if the <see cref="Result{T, TError}"/> value is not equals to the given value, otherwise false.</returns>
-        public static bool operator !=(in T value, in Result<T, TError> result)
+        public static bool operator !=(T value, Result<T, TError> result)
         {
             return !(result == value);
         }
@@ -436,7 +436,7 @@ public int CompareTo(Result<T, TError> other)
         /// <param name="left">The first <see cref="Result{T, TError}"/> to compare.</param>
         /// <param name="right">The second <see cref="Result{T, TError}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <(in Result<T, TError> left, in Result<T, TError> right)
+        public static bool operator <(Result<T, TError> left, Result<T, TError> right)
         {
             return left.CompareTo(right) < 0;
         }
@@ -447,7 +447,7 @@ public int CompareTo(Result<T, TError> other)
         /// <param name="left">The first <see cref="Result{T, TError}"/> to compare.</param>
         /// <param name="right">The second <see cref="Result{T, TError}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <=(in Result<T, TError> left, in Result<T, TError> right)
+        public static bool operator <=(Result<T, TError> left, Result<T, TError> right)
         {
             return left.CompareTo(right) <= 0;
         }
@@ -458,7 +458,7 @@ public int CompareTo(Result<T, TError> other)
         /// <param name="left">The first <see cref="Result{T, TError}"/> to compare.</param>
         /// <param name="right">The second <see cref="Result{T, TError}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >(in Result<T, TError> left, in Result<T, TError> right)
+        public static bool operator >(Result<T, TError> left, Result<T, TError> right)
         {
             return left.CompareTo(right) > 0;
         }
@@ -469,7 +469,7 @@ public int CompareTo(Result<T, TError> other)
         /// <param name="left">The first <see cref="Result{T, TError}"/> to compare.</param>
         /// <param name="right">The second <see cref="Result{T, TError}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >=(in Result<T, TError> left, in Result<T, TError> right)
+        public static bool operator >=(Result<T, TError> left, Result<T, TError> right)
         {
             return left.CompareTo(right) >= 0;
         }
diff --git a/src/Here/Result/ValueResult.cs b/src/Here/Result/ValueResult.cs
index 4bd0551..5dda366 100644
--- a/src/Here/Result/ValueResult.cs
+++ b/src/Here/Result/ValueResult.cs
@@ -11,7 +11,7 @@ namespace Here
     /// </summary>
     [PublicAPI]
     [DebuggerDisplay("{" + nameof(IsSuccess) + " ? \"IsSuccess\" + (" + nameof(IsWarning) + " ? \" with warning\" : System.String.Empty) + \", Value = \" + " + nameof(_value) + " : \"IsFailure\"}")]
-    public readonly partial struct Result<T> : IResult<T>, IEquatable<T>, IEquatable<Result<T>>, IComparable, IComparable<Result<T>>
+    public partial struct Result<T> : IResult<T>, IEquatable<T>, IEquatable<Result<T>>, IComparable, IComparable<Result<T>>
     {
         /// <inheritdoc />
         public bool IsSuccess => Logic.IsSuccess;
@@ -54,7 +54,7 @@ public T Value
         /// <see cref="Result{T}"/> "Ok" constructor.
         /// </summary>
         /// <param name="value">Result value.</param>
-        internal Result([CanBeNull] in T value)
+        internal Result([CanBeNull] T value)
         {
             Logic = new ResultLogic();
             _value = value;
@@ -67,7 +67,7 @@ internal Result([CanBeNull] in T value)
         /// <param name="value">Embedded value.</param>
         /// <param name="message">Result message.</param>
         /// <param name="exception">Result embedded exception.</param>
-        internal Result(bool isWarning, [CanBeNull] in T value, [NotNull] in string message, [CanBeNull] in Exception exception)
+        internal Result(bool isWarning, [CanBeNull] T value, [NotNull] string message, [CanBeNull] Exception exception)
         {
             Logic = new ResultLogic(isWarning, message, exception);
             _value = value;
@@ -78,7 +78,7 @@ internal Result(bool isWarning, [CanBeNull] in T value, [NotNull] in string mess
         /// </summary>
         /// <param name="value">Result value.</param>
         /// <param name="logic">Result logic.</param>
-        internal Result([CanBeNull] in T value, [NotNull] in ResultLogic logic)
+        internal Result([CanBeNull] T value, [NotNull] ResultLogic logic)
         {
             Logic = logic;
             _value = value;
@@ -108,7 +108,7 @@ public Result<TOut> Cast<TOut>()
         /// <returns>A <see cref="Result{TOut}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="converter"/> is null.</exception>
         [PublicAPI, Pure]
-        public Result<TOut> Cast<TOut>([NotNull, InstantHandle] in Func<T, TOut> converter)
+        public Result<TOut> Cast<TOut>([NotNull, InstantHandle] Func<T, TOut> converter)
         {
             Throw.IfArgumentNull(converter, nameof(converter));
 
@@ -125,7 +125,7 @@ public Result<TOut> Cast<TOut>([NotNull, InstantHandle] in Func<T, TOut> convert
         /// <returns>A <see cref="CustomResult{TError}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorObject"/> is null.</exception>
         [PublicAPI, Pure]
-        public CustomResult<TError> CustomCast<TError>([NotNull] in TError errorObject)
+        public CustomResult<TError> CustomCast<TError>([NotNull] TError errorObject)
         {
             Throw.IfArgumentNull(errorObject, nameof(errorObject));
 
@@ -144,7 +144,7 @@ public CustomResult<TError> CustomCast<TError>([NotNull] in TError errorObject)
         /// <returns>A <see cref="CustomResult{TError}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorFactory"/> is null.</exception>
         [PublicAPI, Pure]
-        public CustomResult<TError> CustomCast<TError>([NotNull, InstantHandle] in Func<TError> errorFactory)
+        public CustomResult<TError> CustomCast<TError>([NotNull, InstantHandle] Func<TError> errorFactory)
         {
             Throw.IfArgumentNull(errorFactory, nameof(errorFactory));
 
@@ -164,7 +164,7 @@ public CustomResult<TError> CustomCast<TError>([NotNull, InstantHandle] in Func<
         /// <returns>A <see cref="Result{TOut, TError}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorObject"/> is null.</exception>
         [PublicAPI, Pure]
-        public Result<TOut, TError> Cast<TOut, TError>([NotNull] in TError errorObject)
+        public Result<TOut, TError> Cast<TOut, TError>([NotNull] TError errorObject)
             where TOut : class
         {
             Throw.IfArgumentNull(errorObject, nameof(errorObject));
@@ -185,7 +185,7 @@ public Result<TOut, TError> Cast<TOut, TError>([NotNull] in TError errorObject)
         /// <returns>A <see cref="Result{TOut, TError}"/>.</returns>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorFactory"/> is null.</exception>
         [PublicAPI, Pure]
-        public Result<TOut, TError> Cast<TOut, TError>([NotNull, InstantHandle] in Func<TError> errorFactory)
+        public Result<TOut, TError> Cast<TOut, TError>([NotNull, InstantHandle] Func<TError> errorFactory)
             where TOut : class
         {
             Throw.IfArgumentNull(errorFactory, nameof(errorFactory));
@@ -208,7 +208,7 @@ public Result<TOut, TError> Cast<TOut, TError>([NotNull, InstantHandle] in Func<
         /// <exception cref="ArgumentNullException">If the <paramref name="converter"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorObject"/> is null.</exception>
         [PublicAPI, Pure]
-        public Result<TOut, TError> Cast<TOut, TError>([NotNull, InstantHandle] in Func<T, TOut> converter, [NotNull] in TError errorObject)
+        public Result<TOut, TError> Cast<TOut, TError>([NotNull, InstantHandle] Func<T, TOut> converter, [NotNull] TError errorObject)
         {
             Throw.IfArgumentNull(converter, nameof(converter));
             Throw.IfArgumentNull(errorObject, nameof(errorObject));
@@ -231,7 +231,7 @@ public Result<TOut, TError> Cast<TOut, TError>([NotNull, InstantHandle] in Func<
         /// <exception cref="ArgumentNullException">If the <paramref name="converter"/> is null.</exception>
         /// <exception cref="ArgumentNullException">If the <paramref name="errorFactory"/> is null.</exception>
         [PublicAPI, Pure]
-        public Result<TOut, TError> Cast<TOut, TError>([NotNull, InstantHandle] in Func<T, TOut> converter, [NotNull, InstantHandle] in Func<TError> errorFactory)
+        public Result<TOut, TError> Cast<TOut, TError>([NotNull, InstantHandle] Func<T, TOut> converter, [NotNull, InstantHandle] Func<TError> errorFactory)
         {
             Throw.IfArgumentNull(converter, nameof(converter));
             Throw.IfArgumentNull(errorFactory, nameof(errorFactory));
@@ -279,7 +279,7 @@ internal Result<TOut> ToFailValueResult<TOut>()
         /// <param name="exception">Exception to set in the failure <see cref="Result{T}"/>.</param>
         /// <returns>A failed <see cref="Result{TOut}"/>.</returns>
         [Pure]
-        internal Result<TOut> ToFailValueResult<TOut>([NotNull] in string additionalMessage, [CanBeNull] in Exception exception = null)
+        internal Result<TOut> ToFailValueResult<TOut>([NotNull] string additionalMessage, [CanBeNull] Exception exception = null)
         {
             Debug.Assert(ResultLogic.IsConvertibleToFailure(Logic), "Cannot convert a success Result<T> to a Result<T> failure.");
             return Result.Fail<TOut>(Logic.Message + additionalMessage, exception);
@@ -291,7 +291,7 @@ internal Result<TOut> ToFailValueResult<TOut>([NotNull] in string additionalMess
         /// </summary>
         /// <returns>A failed <see cref="CustomResult{TError}"/>.</returns>
         [Pure]
-        internal CustomResult<TError> ToFailCustomResult<TError>([NotNull] in TError errorObject)
+        internal CustomResult<TError> ToFailCustomResult<TError>([NotNull] TError errorObject)
         {
             Debug.Assert(ResultLogic.IsConvertibleToFailure(Logic), "Cannot convert a success Result<T> to a CustomResult<TError> failure.");
             return Result.CustomFail(Logic.Message, errorObject, Logic.Exception);
@@ -303,7 +303,7 @@ internal CustomResult<TError> ToFailCustomResult<TError>([NotNull] in TError err
         /// </summary>
         /// <returns>A failed <see cref="Result{TOut, TError}"/>.</returns>
         [Pure]
-        internal Result<TOut, TError> ToFailValueCustomResult<TOut, TError>([NotNull] in TError errorObject)
+        internal Result<TOut, TError> ToFailValueCustomResult<TOut, TError>([NotNull] TError errorObject)
         {
             Debug.Assert(ResultLogic.IsConvertibleToFailure(Logic), "Cannot convert a success Result<T> to a Result<T, TError> failure.");
             return Result.Fail<TOut, TError>(Logic.Message, errorObject, Logic.Exception);
@@ -317,7 +317,7 @@ internal Result<TOut, TError> ToFailValueCustomResult<TOut, TError>([NotNull] in
         /// <param name="exception">Exception to set in the warning <see cref="Result{T}"/>.</param>
         /// <returns>A warning <see cref="Result{T}"/>.</returns>
         [Pure]
-        internal Result<T> ToWarnValueResult([NotNull] in string message, [CanBeNull] in Exception exception = null)
+        internal Result<T> ToWarnValueResult([NotNull] string message, [CanBeNull] Exception exception = null)
         {
             Debug.Assert(ResultLogic.IsConvertibleToWarning(Logic), "Cannot convert a warning Result<T> to a Result<T> warning.");
             return Result.Warn(_value, message, exception);
@@ -333,7 +333,7 @@ internal Result<T> ToWarnValueResult([NotNull] in string message, [CanBeNull] in
         /// <param name="other"><see cref="Result{T}"/> to compare.</param>
         /// <returns>True if both <see cref="Result{T}"/> are equal and successful, otherwise false.</returns>
         [PublicAPI, Pure]
-        public bool SuccessEquals(in Result<T> other)
+        public bool SuccessEquals(Result<T> other)
         {
             return AreSuccessEqual(this, other);
         }
@@ -368,7 +368,7 @@ public override bool Equals(object obj)
         /// <param name="equalityComparer">Equality comparer to use to compare values.</param>
         /// <returns>True if the <see cref="Result{T}"/> value is equals to the given value, otherwise false.</returns>
         [PublicAPI, Pure]
-        internal static bool AreEqual(in Result<T> result, [CanBeNull] in T value, [CanBeNull] in IEqualityComparer<T> equalityComparer = null)
+        internal static bool AreEqual(Result<T> result, [CanBeNull] T value, [CanBeNull] IEqualityComparer<T> equalityComparer = null)
         {
             if (result.IsSuccess)
                 return (equalityComparer ?? EqualityComparer<T>.Default).Equals(result._value, value);
@@ -383,7 +383,7 @@ internal static bool AreEqual(in Result<T> result, [CanBeNull] in T value, [CanB
         /// <param name="equalityComparer">Equality comparer to use to compare values.</param>
         /// <returns>True if both <see cref="Result{T}"/> are equal, otherwise false.</returns>
         [Pure]
-        internal static bool AreEqual(in Result<T> result1, in Result<T> result2, [CanBeNull] in IEqualityComparer<T> equalityComparer = null)
+        internal static bool AreEqual(Result<T> result1, Result<T> result2, [CanBeNull] IEqualityComparer<T> equalityComparer = null)
         {
             return result1.Logic.Equals(result2.Logic)
                 && (equalityComparer ?? EqualityComparer<T>.Default).Equals(result1._value, result2._value);
@@ -397,7 +397,7 @@ internal static bool AreEqual(in Result<T> result1, in Result<T> result2, [CanBe
         /// <param name="equalityComparer">Equality comparer to use to compare values.</param>
         /// <returns>True if both <see cref="Result{T}"/> are equal, otherwise false.</returns>
         [Pure]
-        internal static bool AreSuccessEqual(in Result<T> result1, in Result<T> result2, [CanBeNull] in IEqualityComparer<T> equalityComparer = null)
+        internal static bool AreSuccessEqual(Result<T> result1, Result<T> result2, [CanBeNull] IEqualityComparer<T> equalityComparer = null)
         {
             if (result1.IsSuccess && result2.IsSuccess)
                 return AreEqual(result1, result2);
@@ -410,7 +410,7 @@ internal static bool AreSuccessEqual(in Result<T> result1, in Result<T> result2,
         /// <param name="result1">First <see cref="Result{T}"/> to compare.</param>
         /// <param name="result2">Second <see cref="Result{T}"/> to compare.</param>
         /// <returns>True if both <see cref="Result{T}"/> are equal, otherwise false.</returns>
-        public static bool operator ==(in Result<T> result1, in Result<T> result2)
+        public static bool operator ==(Result<T> result1, Result<T> result2)
         {
             return AreEqual(result1, result2);
         }
@@ -421,7 +421,7 @@ internal static bool AreSuccessEqual(in Result<T> result1, in Result<T> result2,
         /// <param name="result1">First <see cref="Result{T}"/> to compare.</param>
         /// <param name="result2">Second <see cref="Result{T}"/> to compare.</param>
         /// <returns>True if both <see cref="Result{T}"/> are not equal, otherwise false.</returns>
-        public static bool operator !=(in Result<T> result1, in Result<T> result2)
+        public static bool operator !=(Result<T> result1, Result<T> result2)
         {
             return !(result1 == result2);
         }
@@ -438,7 +438,7 @@ public override int GetHashCode()
         /// <param name="result"><see cref="Result{T}"/> that may embed a value to compare.</param>
         /// <param name="value">Value to compare.</param>
         /// <returns>True if the <see cref="Result{T}"/> value is equals to the given value, otherwise false.</returns>
-        public static bool operator ==(in Result<T> result, in T value)
+        public static bool operator ==(Result<T> result, T value)
         {
             return AreEqual(result, value);
         }
@@ -449,7 +449,7 @@ public override int GetHashCode()
         /// <param name="result"><see cref="Result{T}"/> that may embed a value to compare.</param>
         /// <param name="value">Value to compare.</param>
         /// <returns>True if the <see cref="Result{T}"/> value is not equals to the given value, otherwise false.</returns>
-        public static bool operator !=(in Result<T> result, in T value)
+        public static bool operator !=(Result<T> result, T value)
         {
             return !(result == value);
         }
@@ -460,7 +460,7 @@ public override int GetHashCode()
         /// <param name="value">Value to compare.</param>
         /// <param name="result"><see cref="Result{T}"/> that may embed a value to compare.</param>
         /// <returns>True if the <see cref="Result{T}"/> value is equals to the given value, otherwise false.</returns>
-        public static bool operator ==(in T value, in Result<T> result)
+        public static bool operator ==(T value, Result<T> result)
         {
             return result == value;
         }
@@ -471,7 +471,7 @@ public override int GetHashCode()
         /// <param name="value">Value to compare.</param>
         /// <param name="result"><see cref="Result{T}"/> that may embed a value to compare.</param>
         /// <returns>True if the <see cref="Result{T}"/> value is not equals to the given value, otherwise false.</returns>
-        public static bool operator !=(in T value, in Result<T> result)
+        public static bool operator !=(T value, Result<T> result)
         {
             return !(result == value);
         }
@@ -516,7 +516,7 @@ public int CompareTo(Result<T> other)
         /// <param name="left">The first <see cref="Result{T}"/> to compare.</param>
         /// <param name="right">The second <see cref="Result{T}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <(in Result<T> left, in Result<T> right)
+        public static bool operator <(Result<T> left, Result<T> right)
         {
             return left.CompareTo(right) < 0;
         }
@@ -527,7 +527,7 @@ public int CompareTo(Result<T> other)
         /// <param name="left">The first <see cref="Result{T}"/> to compare.</param>
         /// <param name="right">The second <see cref="Result{T}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator <=(in Result<T> left, in Result<T> right)
+        public static bool operator <=(Result<T> left, Result<T> right)
         {
             return left.CompareTo(right) <= 0;
         }
@@ -538,7 +538,7 @@ public int CompareTo(Result<T> other)
         /// <param name="left">The first <see cref="Result{T}"/> to compare.</param>
         /// <param name="right">The second <see cref="Result{T}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >(in Result<T> left, in Result<T> right)
+        public static bool operator >(Result<T> left, Result<T> right)
         {
             return left.CompareTo(right) > 0;
         }
@@ -549,7 +549,7 @@ public int CompareTo(Result<T> other)
         /// <param name="left">The first <see cref="Result{T}"/> to compare.</param>
         /// <param name="right">The second <see cref="Result{T}"/> to compare.</param>
         /// <returns>The comparison result.</returns>
-        public static bool operator >=(in Result<T> left, in Result<T> right)
+        public static bool operator >=(Result<T> left, Result<T> right)
         {
             return left.CompareTo(right) >= 0;
         }
diff --git a/src/Here/Unit/Unit.cs b/src/Here/Unit/Unit.cs
index fb4604a..8d80510 100644
--- a/src/Here/Unit/Unit.cs
+++ b/src/Here/Unit/Unit.cs
@@ -7,7 +7,7 @@ namespace Here
     /// Type that only have a unique value.
     /// </summary>
     [PublicAPI]
-    public readonly struct Unit : IEquatable<Unit>, IComparable, IComparable<Unit>
+    public struct Unit : IEquatable<Unit>, IComparable, IComparable<Unit>
     {
         /// <summary>
         /// Unique <see cref="Unit"/> value.
diff --git a/src/Here/ValueObject/ValueObject.cs b/src/Here/ValueObject/ValueObject.cs
index 8d01b1c..cac1a29 100644
--- a/src/Here/ValueObject/ValueObject.cs
+++ b/src/Here/ValueObject/ValueObject.cs
@@ -25,7 +25,7 @@ public abstract class ValueObject
         /// <param name="object1">First <see cref="ValueObject"/> to compare.</param>
         /// <param name="object2">Second <see cref="ValueObject"/> to compare.</param>
         /// <returns>True if both <see cref="ValueObject"/> are equal, otherwise false.</returns>
-        protected static bool EqualOperator(in ValueObject object1, in ValueObject object2)
+        protected static bool EqualOperator(ValueObject object1, ValueObject object2)
         {
             if (object1 is null)
                 return object2 is null;
@@ -40,7 +40,7 @@ protected static bool EqualOperator(in ValueObject object1, in ValueObject objec
         /// <param name="object1">First <see cref="ValueObject"/> to compare.</param>
         /// <param name="object2">Second <see cref="ValueObject"/> to compare.</param>
         /// <returns>True if both <see cref="ValueObject"/> are not equal, otherwise false.</returns>
-        protected static bool NotEqualOperator(in ValueObject object1, in ValueObject object2)
+        protected static bool NotEqualOperator(ValueObject object1, ValueObject object2)
         {
             return !EqualOperator(object1, object2);
         }