diff --git a/src/core-taggeds-failure/Failure/Failure.T/T.Equality.GetHashCode.cs b/src/core-taggeds-failure/Failure/Failure.T/T.Equality.GetHashCode.cs
index 4ece2ac2..96c747b0 100644
--- a/src/core-taggeds-failure/Failure/Failure.T/T.Equality.GetHashCode.cs
+++ b/src/core-taggeds-failure/Failure/Failure.T/T.Equality.GetHashCode.cs
@@ -5,11 +5,13 @@ namespace System;
 
 partial struct Failure<TFailureCode>
 {
-    public override int GetHashCode() => HashCode.Combine(
-        EqualityContractHashCode(),
-        FailureCodeComparer.GetHashCode(FailureCode),
-        FailureMessageComparer.GetHashCode(FailureMessage),
-        SourceException is null ? default : SourceExceptionComparer.GetHashCode(SourceException));
+    public override int GetHashCode()
+        =>
+        HashCode.Combine(
+            EqualityContractHashCode(),
+            FailureCodeComparer.GetHashCode(FailureCode),
+            FailureMessageComparer.GetHashCode(FailureMessage),
+            SourceException is null ? default : SourceExceptionComparer.GetHashCode(SourceException));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int EqualityContractHashCode()
diff --git a/src/core-taggeds-optional/Optional/Optional.T/Optional.T.Equality.GetHashCode.cs b/src/core-taggeds-optional/Optional/Optional.T/Optional.T.Equality.GetHashCode.cs
index c7c6f11f..4450db1b 100644
--- a/src/core-taggeds-optional/Optional/Optional.T/Optional.T.Equality.GetHashCode.cs
+++ b/src/core-taggeds-optional/Optional/Optional.T/Optional.T.Equality.GetHashCode.cs
@@ -6,20 +6,16 @@ namespace System;
 partial struct Optional<T>
 {
     public override int GetHashCode()
-        =>
-        hasValue ? PresentHashCode() : AbsentHashCode();
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private int PresentHashCode()
-        =>
-        value is not null
-        ? HashCode.Combine(EqualityContractHashCode(), true, EqualityComparer<T>.Default.GetHashCode(value))
-        : HashCode.Combine(EqualityContractHashCode(), true);
+    {
+        if (hasValue)
+        {
+            return value is not null
+                ? HashCode.Combine(EqualityContractHashCode(), true, EqualityComparer<T>.Default.GetHashCode(value))
+                : HashCode.Combine(EqualityContractHashCode(), true);
+        }
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static int AbsentHashCode()
-        =>
-        HashCode.Combine(EqualityContractHashCode());
+        return HashCode.Combine(EqualityContractHashCode());
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int EqualityContractHashCode()
diff --git a/src/core-taggeds-result/Result/Result.T.EqualityComparer/Result.T.EqualityComparer.Equality.cs b/src/core-taggeds-result/Result/Result.T.EqualityComparer/Result.T.EqualityComparer.Equality.cs
index 73f1ceec..b743f4f5 100644
--- a/src/core-taggeds-result/Result/Result.T.EqualityComparer/Result.T.EqualityComparer.Equality.cs
+++ b/src/core-taggeds-result/Result/Result.T.EqualityComparer/Result.T.EqualityComparer.Equality.cs
@@ -1,6 +1,4 @@
-using System.Runtime.CompilerServices;
-
-namespace System;
+namespace System;
 
 partial struct Result<TSuccess, TFailure>
 {
@@ -13,25 +11,24 @@ public bool Equals(Result<TSuccess, TFailure> x, Result<TSuccess, TFailure> y)
                 return false;
             }
 
-            return x.isSuccess
-                ? successComparer.Equals(x.success, y.success)
-                : failureComparer.Equals(x.failure, y.failure);
+            if (x.isSuccess)
+            {
+                return successComparer.Equals(x.success, y.success);
+            }
+
+            return failureComparer.Equals(x.failure, y.failure);
         }
 
         public int GetHashCode(Result<TSuccess, TFailure> obj)
-            =>
-            obj.isSuccess ? SuccessHashCode(obj.success) : FailureHashCode(obj.failure);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private int SuccessHashCode(TSuccess success)
-            =>
-            success is not null
-            ? HashCode.Combine(true, successComparer.GetHashCode(success))
-            : HashCode.Combine(true);
+        {
+            if (obj.isSuccess)
+            {
+                return obj.success is not null
+                    ? HashCode.Combine(true, successComparer.GetHashCode(obj.success))
+                    : HashCode.Combine(true);
+            }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private int FailureHashCode(TFailure failure)
-            =>
-            HashCode.Combine(false, failureComparer.GetHashCode(failure));
+            return HashCode.Combine(false, failureComparer.GetHashCode(obj.failure));
+        }
     }
 }
diff --git a/src/core-taggeds-result/Result/Result.T/Result.T.Equality.Equals.cs b/src/core-taggeds-result/Result/Result.T/Result.T.Equality.Equals.cs
index afc0247d..6ec88252 100644
--- a/src/core-taggeds-result/Result/Result.T/Result.T.Equality.Equals.cs
+++ b/src/core-taggeds-result/Result/Result.T/Result.T.Equality.Equals.cs
@@ -11,8 +11,11 @@ public bool Equals(Result<TSuccess, TFailure> other)
             return false;
         }
 
-        return isSuccess
-            ? EqualityComparer<TSuccess>.Default.Equals(success, other.success)
-            : EqualityComparer<TFailure>.Default.Equals(failure, other.failure);
+        if (isSuccess)
+        {
+            return EqualityComparer<TSuccess>.Default.Equals(success, other.success);
+        }
+
+        return EqualityComparer<TFailure>.Default.Equals(failure, other.failure);
     }
 }
diff --git a/src/core-taggeds-result/Result/Result.T/Result.T.Equality.GetHashCode.cs b/src/core-taggeds-result/Result/Result.T/Result.T.Equality.GetHashCode.cs
index b952412c..be6ba735 100644
--- a/src/core-taggeds-result/Result/Result.T/Result.T.Equality.GetHashCode.cs
+++ b/src/core-taggeds-result/Result/Result.T/Result.T.Equality.GetHashCode.cs
@@ -6,20 +6,16 @@ namespace System;
 partial struct Result<TSuccess, TFailure>
 {
     public override int GetHashCode()
-        =>
-        isSuccess ? SuccessHashCode() : FailureHashCode();
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private int SuccessHashCode()
-        =>
-        success is not null
-        ? HashCode.Combine(EqualityContractHashCode(), true, EqualityComparer<TSuccess>.Default.GetHashCode(success))
-        : HashCode.Combine(EqualityContractHashCode(), true);
+    {
+        if (isSuccess)
+        {
+            return success is not null
+                ? HashCode.Combine(EqualityContractHashCode(), true, EqualityComparer<TSuccess>.Default.GetHashCode(success))
+                : HashCode.Combine(EqualityContractHashCode(), true);
+        }
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private int FailureHashCode()
-        =>
-        HashCode.Combine(EqualityContractHashCode(), false, EqualityComparer<TFailure>.Default.GetHashCode(failure));
+        return HashCode.Combine(EqualityContractHashCode(), false, EqualityComparer<TFailure>.Default.GetHashCode(failure));
+    }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static int EqualityContractHashCode()