Experimental idea: IsBetween with explicit Inclusive and Exlusive boundaries

Funcky.Test/Extensions/NumberExtensionsTest.cs

@@ -0,0 +1,12 @@
+namespace Funcky.Test.Extensions;
+
+public class NumberExtensionsTest
+{
+    [Fact]
+    public void Example()
+    {
+        var position = 12;
+
+        Assert.True(position.IsBetween<Including, Excluding>(20, 0));
+    }
+}

Funcky/Extensions/Excluding.cs

@@ -0,0 +1,13 @@
+namespace Funcky.Extensions;
+
+public class Excluding : IIntervalBoundary
+{
+    private Excluding(int number)
+    {
+        Value = number;
+    }
+
+    public int Value { get; }
+
+    public static implicit operator Excluding(int number) => new(number);
+}

Funcky/Extensions/IIntervalBoundary.cs

@@ -0,0 +1,6 @@
+namespace Funcky.Extensions;
+
+public interface IIntervalBoundary
+{
+    int Value { get; }
+}

Funcky/Extensions/Including.cs

@@ -0,0 +1,13 @@
+namespace Funcky.Extensions;
+
+public class Including : IIntervalBoundary
+{
+    private Including(int number)
+    {
+        Value = number;
+    }
+
+    public int Value { get; }
+
+    public static implicit operator Including(int number) => new(number);
+}

Funcky/Extensions/NumberExtensions.cs

@@ -0,0 +1,35 @@
+namespace Funcky.Extensions;
+
+public static class NumberExtensions
+{
+    public static bool IsBetween<TFrom, TTo>(this int number, TFrom from, TTo to)
+        where TFrom : IIntervalBoundary
+        where TTo : IIntervalBoundary
+        => from.Value < to.Value
+            ? IsBetweenForward(number, from, to)
+            : IsBetweenBackward(number, from, to);
+
+    private static bool IsBetweenForward<TFrom, TTo>(int number, TFrom from, TTo to)
+        where TFrom : IIntervalBoundary
+        where TTo : IIntervalBoundary
+        => (from, to) switch
+        {
+            (Including, Including) => from.Value <= number && number <= to.Value,
+            (Including, Excluding) => from.Value <= number && number < to.Value,
+            (Excluding, Including) => from.Value < number && number <= to.Value,
+            (Excluding, Excluding) => from.Value < number && number < to.Value,
+            _ => false,
+        };
+
+    private static bool IsBetweenBackward<TFrom, TTo>(int number, TFrom from, TTo to)
+        where TFrom : IIntervalBoundary
+        where TTo : IIntervalBoundary
+        => (from, to) switch
+        {
+            (Including, Including) => from.Value >= number && number >= to.Value,
+            (Including, Excluding) => from.Value >= number && number > to.Value,
+            (Excluding, Including) => from.Value > number && number >= to.Value,
+            (Excluding, Excluding) => from.Value > number && number > to.Value,
+            _ => false,
+        };
+}