From 4c642bec61bd1ed4084123ad0f1b889f8fa4459e Mon Sep 17 00:00:00 2001
From: bmazzarol <bmazzarol@gmail.com>
Date: Wed, 3 Apr 2024 23:07:06 +0800
Subject: [PATCH] feat: ensure refinements are typed

---
 Tuxedo.Tests/BooleanRefinementTests.cs        |  8 +--
 Tuxedo.Tests/IntRefinementTests.cs            | 24 +++----
 Tuxedo.Tests/StringRefinementTests.cs         | 55 ++++++++------
 Tuxedo/IRefinement.cs                         | 12 ++--
 Tuxedo/Refined.cs                             | 18 ++---
 Tuxedo/Refinements/AbsoluteUri.cs             | 28 --------
 Tuxedo/Refinements/And.cs                     | 13 ++--
 Tuxedo/Refinements/AnyUri.cs                  | 28 --------
 Tuxedo/Refinements/Empty.cs                   | 34 ---------
 Tuxedo/Refinements/Empty/Empty.Collection.cs  | 27 +++++++
 Tuxedo/Refinements/Empty/Empty.Object.cs      | 25 +++++++
 .../{Even.cs => Even/Even.Decimal.cs}         |  9 ++-
 Tuxedo/Refinements/Even/Even.Double.cs        | 13 ++++
 Tuxedo/Refinements/Even/Even.Float.cs         | 13 ++++
 Tuxedo/Refinements/Even/Even.Int.cs           | 12 ++++
 Tuxedo/Refinements/Even/Even.Long.cs          | 12 ++++
 Tuxedo/Refinements/Even/Even.Short.cs         | 12 ++++
 Tuxedo/Refinements/False.cs                   |  6 +-
 Tuxedo/Refinements/MatchesRegex.cs            | 18 ++---
 Tuxedo/Refinements/NonEmpty.cs                | 34 ---------
 .../NonEmpty/NonEmpty.Collection.cs           | 27 +++++++
 .../Refinements/NonEmpty/NonEmpty.Object.cs   | 35 +++++++++
 Tuxedo/Refinements/Not.cs                     |  9 +--
 Tuxedo/Refinements/Positive.cs                | 33 ---------
 .../Refinements/Positive/Positive.Decimal.cs  | 12 ++++
 .../Refinements/Positive/Positive.Double.cs   | 12 ++++
 Tuxedo/Refinements/Positive/Positive.Float.cs | 12 ++++
 Tuxedo/Refinements/Positive/Positive.Int.cs   | 12 ++++
 Tuxedo/Refinements/Positive/Positive.Long.cs  | 12 ++++
 Tuxedo/Refinements/Positive/Positive.Short.cs | 12 ++++
 Tuxedo/Refinements/RelativeUri.cs             | 28 --------
 Tuxedo/Refinements/Size.cs                    | 18 ++---
 Tuxedo/Refinements/StartsWith.cs              |  8 +--
 Tuxedo/Refinements/Trimmed.cs                 | 38 +++++-----
 Tuxedo/Refinements/True.cs                    |  6 +-
 Tuxedo/Refinements/Uri.cs                     | 72 +++++++++++++++++++
 Tuxedo/Refinements/Uuid.cs                    | 10 +--
 37 files changed, 452 insertions(+), 305 deletions(-)
 delete mode 100644 Tuxedo/Refinements/AbsoluteUri.cs
 delete mode 100644 Tuxedo/Refinements/AnyUri.cs
 delete mode 100644 Tuxedo/Refinements/Empty.cs
 create mode 100644 Tuxedo/Refinements/Empty/Empty.Collection.cs
 create mode 100644 Tuxedo/Refinements/Empty/Empty.Object.cs
 rename Tuxedo/Refinements/{Even.cs => Even/Even.Decimal.cs} (82%)
 create mode 100644 Tuxedo/Refinements/Even/Even.Double.cs
 create mode 100644 Tuxedo/Refinements/Even/Even.Float.cs
 create mode 100644 Tuxedo/Refinements/Even/Even.Int.cs
 create mode 100644 Tuxedo/Refinements/Even/Even.Long.cs
 create mode 100644 Tuxedo/Refinements/Even/Even.Short.cs
 delete mode 100644 Tuxedo/Refinements/NonEmpty.cs
 create mode 100644 Tuxedo/Refinements/NonEmpty/NonEmpty.Collection.cs
 create mode 100644 Tuxedo/Refinements/NonEmpty/NonEmpty.Object.cs
 delete mode 100644 Tuxedo/Refinements/Positive.cs
 create mode 100644 Tuxedo/Refinements/Positive/Positive.Decimal.cs
 create mode 100644 Tuxedo/Refinements/Positive/Positive.Double.cs
 create mode 100644 Tuxedo/Refinements/Positive/Positive.Float.cs
 create mode 100644 Tuxedo/Refinements/Positive/Positive.Int.cs
 create mode 100644 Tuxedo/Refinements/Positive/Positive.Long.cs
 create mode 100644 Tuxedo/Refinements/Positive/Positive.Short.cs
 delete mode 100644 Tuxedo/Refinements/RelativeUri.cs
 create mode 100644 Tuxedo/Refinements/Uri.cs

diff --git a/Tuxedo.Tests/BooleanRefinementTests.cs b/Tuxedo.Tests/BooleanRefinementTests.cs
index 5963dbd..a18443b 100644
--- a/Tuxedo.Tests/BooleanRefinementTests.cs
+++ b/Tuxedo.Tests/BooleanRefinementTests.cs
@@ -67,21 +67,21 @@ public static void Case6()
     [Fact(DisplayName = "A refinement can be inverted")]
     public static void Case7()
     {
-        Refined<bool, Not<True>> refined = false;
+        Refined<bool, Not<bool, True>> refined = false;
         (refined is { Value: false }).Should().BeTrue();
-        Refined.TryRefine<bool, Not<True>>(false, out _).Should().BeTrue();
+        Refined.TryRefine<bool, Not<bool, True>>(false, out _).Should().BeTrue();
     }
 
     [Fact(DisplayName = "An inverted refinement fail")]
     public static void Case8()
     {
-        Refined.TryRefine<bool, Not<True>>(true, out _).Should().BeFalse();
+        Refined.TryRefine<bool, Not<bool, True>>(true, out _).Should().BeFalse();
     }
 
     [Fact(DisplayName = "An inverted refinement fail and throws")]
     public static void Case9()
     {
-        var act = () => (Refined<bool, Not<True>>)true;
+        var act = () => (Refined<bool, Not<bool, True>>)true;
         act.Should()
             .Throw<RefinementFailureException>()
             .WithMessage("Not: Value must be true")
diff --git a/Tuxedo.Tests/IntRefinementTests.cs b/Tuxedo.Tests/IntRefinementTests.cs
index b035090..170fa62 100644
--- a/Tuxedo.Tests/IntRefinementTests.cs
+++ b/Tuxedo.Tests/IntRefinementTests.cs
@@ -78,21 +78,21 @@ public static void Case8()
     [Fact(DisplayName = "Using Not odd integers can be refined with even")]
     public static void Case9()
     {
-        Refined<int, Not<Even>> refined = 1;
+        Refined<int, Not<int, Even>> refined = 1;
         refined.Value.Should().Be(1);
-        Refined.TryRefine<int, Not<Even>>(1, out _).Should().BeTrue();
+        Refined.TryRefine<int, Not<int, Even>>(1, out _).Should().BeTrue();
     }
 
     [Fact(DisplayName = "Using Not even integers cannot be refined with even")]
     public static void Case10()
     {
-        Refined.TryRefine<int, Not<Even>>(2, out _).Should().BeFalse();
+        Refined.TryRefine<int, Not<int, Even>>(2, out _).Should().BeFalse();
     }
 
     [Fact(DisplayName = "Using Not even integers cannot be refined with even and throws")]
     public static void Case11()
     {
-        var act = () => Refined.Refine<int, Not<Even>>(2);
+        var act = () => Refined.Refine<int, Not<int, Even>>(2);
         act.Should()
             .Throw<RefinementFailureException>()
             .WithMessage("Not: Value must be an even number, but found 2")
@@ -103,28 +103,22 @@ public static void Case11()
     [Fact(DisplayName = "A non default integer can be refined")]
     public static void Case12()
     {
-        Refined<int, NonEmpty> refined = 1;
+        Refined<int, NonEmpty<int>> refined = 1;
         refined.Value.Should().Be(1);
-        Refined.TryRefine<int, NonEmpty>(1, out _).Should().BeTrue();
+        Refined.TryRefine<int, NonEmpty<int>>(1, out _).Should().BeTrue();
     }
 
     [Fact(DisplayName = "A default integer cannot be refined")]
     public static void Case13()
     {
-        Refined.TryRefine<int, NonEmpty>(default, out _).Should().BeFalse();
+        Refined.TryRefine<int, NonEmpty<int>>(default, out _).Should().BeFalse();
     }
 
     [Fact(DisplayName = "A default integer can be refined with empty")]
     public static void Case14()
     {
-        Refined<int, Empty> refined = default;
+        Refined<int, Empty<int>> refined = default(int);
         refined.Value.Should().Be(default);
-        Refined.TryRefine<int, Empty>(default, out _).Should().BeTrue();
-    }
-
-    [Fact(DisplayName = "A int cannot be refined by size")]
-    public static void Case15()
-    {
-        Refined.TryRefine<int, Size<Even>>(1, out _).Should().BeFalse();
+        Refined.TryRefine<int, Empty<int>>(default, out _).Should().BeTrue();
     }
 }
diff --git a/Tuxedo.Tests/StringRefinementTests.cs b/Tuxedo.Tests/StringRefinementTests.cs
index d8cd1e2..c55e08a 100644
--- a/Tuxedo.Tests/StringRefinementTests.cs
+++ b/Tuxedo.Tests/StringRefinementTests.cs
@@ -39,9 +39,9 @@ public static void Case4()
     [Fact(DisplayName = "A non-empty string refinement can be inverted")]
     public static void Case5()
     {
-        Refined<string, Not<NonEmpty>> refined = string.Empty;
+        Refined<string, Not<string, NonEmpty>> refined = string.Empty;
         refined.Value.Should().BeEmpty();
-        Refined.TryRefine<string, Not<NonEmpty>>(string.Empty, out _).Should().BeTrue();
+        Refined.TryRefine<string, Not<string, NonEmpty>>(string.Empty, out _).Should().BeTrue();
     }
 
     [Fact(DisplayName = "A trimmed string can be refined")]
@@ -77,7 +77,7 @@ public static void Case9()
         var act = () => (Refined<string, Trimmed>)" Hello, World! ";
         act.Should()
             .Throw<RefinementFailureException>()
-            .WithMessage("Value must have no leading or trailing whitespace")
+            .WithMessage("Value must be trimmed, but found ' Hello, World! '")
             .And.Value.Should()
             .Be(" Hello, World! ");
     }
@@ -85,19 +85,22 @@ public static void Case9()
     [Fact(DisplayName = "A refinement can be combined with logical AND")]
     public static void Case10()
     {
-        Refined<string, And<NonEmpty, Trimmed>> refined = "Hello, World!";
+        Refined<string, And<string, NonEmpty, Trimmed>> refined = "Hello, World!";
         ((string)refined).Should().Be("Hello, World!");
-        Refined.TryRefine<string, And<NonEmpty, Trimmed>>("Hello, World!", out _).Should().BeTrue();
+        Refined
+            .TryRefine<string, And<string, NonEmpty, Trimmed>>("Hello, World!", out _)
+            .Should()
+            .BeTrue();
     }
 
     [Fact(DisplayName = "A refinement can be combined with logical AND and throws")]
     public static void Case11()
     {
-        var act = () => (Refined<string, And<NonEmpty, Trimmed>>)" Hello, World! ";
+        var act = () => (Refined<string, And<string, NonEmpty, Trimmed>>)" Hello, World! ";
         act.Should()
             .Throw<RefinementFailureException>()
             .WithMessage(
-                "Value cannot be empty and Value must have no leading or trailing whitespace"
+                "Value cannot be empty and Value must be trimmed, but found ' Hello, World! '"
             )
             .And.Value.Should()
             .Be(" Hello, World! ");
@@ -130,18 +133,23 @@ public static void Case13()
     [Fact(DisplayName = "A absolute uri can be refined")]
     public static void Case14()
     {
-        Refined<string, AbsoluteUri> refined = "https://www.bmazzarol.com.au";
+        Refined<string, Uri<UriKindAbsolute>> refined = "https://www.bmazzarol.com.au";
         ((string)refined).Should().Be("https://www.bmazzarol.com.au");
         Refined
-            .TryRefine<string, AbsoluteUri>("https://www.bmazzarol.com.au", out _)
+            .TryRefine<string, Uri<UriKindAbsolute>>("https://www.bmazzarol.com.au", out _)
             .Should()
             .BeTrue();
 
-        Refined<string, Uri, AbsoluteUri> refined2 = "http://www.bmazzarol.com.au";
+        Refined<string, System.Uri, Uri<UriKindAbsolute>> refined2 = "http://www.bmazzarol.com.au";
         ((string)refined2).Should().Be("http://www.bmazzarol.com.au");
-        ((Uri)refined2).Should().Be(new Uri("http://www.bmazzarol.com.au", UriKind.Absolute));
+        ((System.Uri)refined2)
+            .Should()
+            .Be(new System.Uri("http://www.bmazzarol.com.au", UriKind.Absolute));
         Refined
-            .TryRefine<string, Uri, AbsoluteUri>("http://www.bmazzarol.com.au", out _)
+            .TryRefine<string, System.Uri, Uri<UriKindAbsolute>>(
+                "http://www.bmazzarol.com.au",
+                out _
+            )
             .Should()
             .BeTrue();
     }
@@ -149,30 +157,33 @@ public static void Case14()
     [Fact(DisplayName = "A absolute uri cannot be refined and throws")]
     public static void Case15()
     {
-        var act = () => (Refined<string, AbsoluteUri>)"/some/path";
+        var act = () => (Refined<string, Uri<UriKindAbsolute>>)"/some/path";
         act.Should()
             .Throw<RefinementFailureException>()
-            .WithMessage("Value must be a valid absolute URI")
+            .WithMessage("Value must be a valid URI")
             .And.Value.Should()
             .Be("/some/path");
-        Refined.TryRefine<string, Uri, AbsoluteUri>("/some/path", out _).Should().BeFalse();
+        Refined
+            .TryRefine<string, System.Uri, Uri<UriKindAbsolute>>("/some/path", out _)
+            .Should()
+            .BeFalse();
     }
 
     [Fact(DisplayName = "A relative uri can be refined")]
     public static void Case16()
     {
-        Refined<string, RelativeUri> refined = "/some/path";
+        Refined<string, Uri<UriKindRelative>> refined = "/some/path";
         ((string)refined).Should().Be("/some/path");
-        Refined.TryRefine<string, RelativeUri>("/some/path", out _).Should().BeTrue();
+        Refined.TryRefine<string, Uri<UriKindRelative>>("/some/path", out _).Should().BeTrue();
     }
 
     [Fact(DisplayName = "A relative uri cannot be refined and throws")]
     public static void Case17()
     {
-        var act = () => (Refined<string, RelativeUri>)"https://www.bmazzarol.com.au";
+        var act = () => (Refined<string, Uri<UriKindRelative>>)"https://www.bmazzarol.com.au";
         act.Should()
             .Throw<RefinementFailureException>()
-            .WithMessage("Value must be a valid relative URI")
+            .WithMessage("Value must be a valid URI")
             .And.Value.Should()
             .Be("https://www.bmazzarol.com.au");
     }
@@ -182,16 +193,16 @@ public static void Case17()
     [InlineData("https://www.bmazzarol.com.au")]
     public static void Case18(string uri)
     {
-        Refined<string, AnyUri> refined = uri;
+        Refined<string, Uri> refined = uri;
         ((string)refined).Should().Be(uri);
-        Refined.TryRefine<string, AnyUri>(uri, out _).Should().BeTrue();
+        Refined.TryRefine<string, Uri>(uri, out _).Should().BeTrue();
     }
 
     [Fact(DisplayName = "A non uri cannot be refined and throws")]
     public static void Case19()
     {
         // invalid uri characters
-        var act = () => (Refined<string, AnyUri>)null!;
+        var act = () => (Refined<string, Uri>)null!;
         act.Should()
             .Throw<RefinementFailureException>()
             .WithMessage("Value must be a valid URI")
diff --git a/Tuxedo/IRefinement.cs b/Tuxedo/IRefinement.cs
index 7c45a42..8d0a6b8 100644
--- a/Tuxedo/IRefinement.cs
+++ b/Tuxedo/IRefinement.cs
@@ -9,7 +9,8 @@ namespace Tuxedo;
 /// A refined type is a type that is a subset of another type, limited by some predicate.
 /// </summary>
 /// <typeparam name="TThis">the refinement instance; must be a struct type to enable lookup</typeparam>
-public interface IRefinement<TThis>
+/// <typeparam name="T">type to refine</typeparam>
+public interface IRefinement<TThis, in T>
     where TThis : struct
 {
     /// <summary>
@@ -17,22 +18,23 @@ public interface IRefinement<TThis>
     /// </summary>
     /// <param name="value">value to test for refinement</param>
     /// <returns>true if the value can be refined; otherwise, false</returns>
-    bool CanBeRefined<T>(T value);
+    bool CanBeRefined(T value);
 
     /// <summary>
     /// Builds a failure message for the given value when it cannot be refined.
     /// </summary>
     /// <param name="value">value that cannot be refined</param>
     /// <returns>failure message</returns>
-    string BuildFailureMessage<T>(T value);
+    string BuildFailureMessage(T value);
 }
 
 /// <summary>
 /// Defines that a contract can be used to refine some type T, with a refined result.
 /// </summary>
 /// <typeparam name="TThis">the refinement instance; must be a struct type to enable lookup</typeparam>
+/// <typeparam name="TIn">input type to refine</typeparam>
 /// <typeparam name="TOut">result of the refinement</typeparam>
-public interface IRefinementResult<TThis, TOut> : IRefinement<TThis>
+public interface IRefinement<TThis, in TIn, TOut> : IRefinement<TThis, TIn>
     where TThis : struct
 {
     /// <summary>
@@ -41,5 +43,5 @@ public interface IRefinementResult<TThis, TOut> : IRefinement<TThis>
     /// <param name="value">value to test for refinement</param>
     /// <param name="refinedValue">refined value</param>
     /// <returns>true if the value can be refined; otherwise, false</returns>
-    bool TryRefine<TIn>(TIn value, [NotNullWhen(true)] out TOut? refinedValue);
+    bool TryRefine(TIn value, [NotNullWhen(true)] out TOut? refinedValue);
 }
diff --git a/Tuxedo/Refined.cs b/Tuxedo/Refined.cs
index c219428..147c515 100644
--- a/Tuxedo/Refined.cs
+++ b/Tuxedo/Refined.cs
@@ -4,12 +4,12 @@
 namespace Tuxedo;
 
 /// <summary>
-/// Represents a refined type, the refinement is enforced by the TRefinement type which is an implementation of <see cref="IRefinement{TThis}"/>
+/// Represents a refined type, the refinement is enforced by the TRefinement type which is an implementation of <see cref="IRefinement{TThis,T}"/>
 /// </summary>
 /// <typeparam name="T">refined type</typeparam>
 /// <typeparam name="TRefinement">refinement on the type</typeparam>
 public readonly record struct Refined<T, TRefinement>
-    where TRefinement : struct, IRefinement<TRefinement>
+    where TRefinement : struct, IRefinement<TRefinement, T>
 {
     /// <summary>
     /// The underlying value of the refined type
@@ -48,14 +48,14 @@ public void Deconstruct(out T value)
 }
 
 /// <summary>
-/// Represents a refined type, the refinement is enforced by the TRefinement type which is an implementation of <see cref="IRefinement{TThis}"/>
+/// Represents a refined type, the refinement is enforced by the TRefinement type which is an implementation of <see cref="IRefinement{TThis,T}"/>
 /// </summary>
 /// <typeparam name="TRaw">raw refined type</typeparam>
 /// <typeparam name="TRefined">refined type</typeparam>
 /// <typeparam name="TRefinement">refinement on the type</typeparam>
 [StructLayout(LayoutKind.Auto)]
 public readonly record struct Refined<TRaw, TRefined, TRefinement>
-    where TRefinement : struct, IRefinementResult<TRefinement, TRefined>
+    where TRefinement : struct, IRefinement<TRefinement, TRaw, TRefined>
 {
     /// <summary>
     /// The underlying value of the refined type
@@ -124,7 +124,7 @@ public static class Refined
     /// <typeparam name="TRefinement">refinement applied to the type</typeparam>
     /// <returns>true if the value was refined; otherwise, false</returns>
     public static bool TryRefine<T, TRefinement>(T value, out Refined<T, TRefinement> refined)
-        where TRefinement : struct, IRefinement<TRefinement>
+        where TRefinement : struct, IRefinement<TRefinement, T>
     {
         var refinement = default(TRefinement);
         if (!refinement.CanBeRefined(value))
@@ -150,7 +150,7 @@ public static bool TryRefine<TRaw, TRefined, TRefinement>(
         TRaw value,
         out Refined<TRaw, TRefined, TRefinement> refined
     )
-        where TRefinement : struct, IRefinementResult<TRefinement, TRefined>
+        where TRefinement : struct, IRefinement<TRefinement, TRaw, TRefined>
     {
         var refinement = default(TRefinement);
         if (!refinement.TryRefine(value, out var refinedValue))
@@ -167,7 +167,7 @@ out Refined<TRaw, TRefined, TRefinement> refined
     [SuppressMessage("Design", "MA0026:Fix TODO comment")]
     [SuppressMessage("Info Code Smell", "S1135:Track uses of \"TODO\" tags")]
     private static void Throw<T, TRefinement>(T value, TRefinement refinement)
-        where TRefinement : struct, IRefinement<TRefinement>
+        where TRefinement : struct, IRefinement<TRefinement, T>
     {
         // TODO: find a way to rewind the stack trace to the caller
         throw new RefinementFailureException(value, refinement.BuildFailureMessage(value));
@@ -182,7 +182,7 @@ private static void Throw<T, TRefinement>(T value, TRefinement refinement)
     /// <returns>refined value</returns>
     /// <exception cref="RefinementFailureException">thrown if the value cannot be refined</exception>
     public static Refined<T, TRefinement> Refine<T, TRefinement>(T value)
-        where TRefinement : struct, IRefinement<TRefinement>
+        where TRefinement : struct, IRefinement<TRefinement, T>
     {
         var refinement = default(TRefinement);
         if (refinement.CanBeRefined(value))
@@ -206,7 +206,7 @@ public static Refined<T, TRefinement> Refine<T, TRefinement>(T value)
     public static Refined<TRaw, TRefined, TRefinement> Refine<TRaw, TRefined, TRefinement>(
         TRaw value
     )
-        where TRefinement : struct, IRefinementResult<TRefinement, TRefined>
+        where TRefinement : struct, IRefinement<TRefinement, TRaw, TRefined>
     {
         var refinement = default(TRefinement);
         if (refinement.TryRefine(value, out var refinedValue))
diff --git a/Tuxedo/Refinements/AbsoluteUri.cs b/Tuxedo/Refinements/AbsoluteUri.cs
deleted file mode 100644
index 6954197..0000000
--- a/Tuxedo/Refinements/AbsoluteUri.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-using System.Diagnostics.CodeAnalysis;
-
-namespace Tuxedo;
-
-/// <summary>
-/// Enforces that a string value is a valid absolute <see cref="Uri"/>
-/// </summary>
-public readonly struct AbsoluteUri : IRefinementResult<AbsoluteUri, Uri>
-{
-    /// <inheritdoc />
-    public bool CanBeRefined<T>(T value) => TryRefine(value, out _);
-
-    /// <inheritdoc />
-    public bool TryRefine<TIn>(TIn value, [NotNullWhen(true)] out Uri? refinedValue)
-    {
-        if (value is string s && Uri.TryCreate(s, UriKind.Absolute, out var uri))
-        {
-            refinedValue = uri;
-            return true;
-        }
-
-        refinedValue = null;
-        return false;
-    }
-
-    /// <inheritdoc />
-    public string BuildFailureMessage<T>(T value) => "Value must be a valid absolute URI";
-}
diff --git a/Tuxedo/Refinements/And.cs b/Tuxedo/Refinements/And.cs
index efb9120..6507298 100644
--- a/Tuxedo/Refinements/And.cs
+++ b/Tuxedo/Refinements/And.cs
@@ -5,13 +5,14 @@
 /// </summary>
 /// <typeparam name="TFirstRefinement">first refinement</typeparam>
 /// <typeparam name="TSecondRefinement">second refinement</typeparam>
-public readonly struct And<TFirstRefinement, TSecondRefinement>
-    : IRefinement<And<TFirstRefinement, TSecondRefinement>>
-    where TFirstRefinement : struct, IRefinement<TFirstRefinement>
-    where TSecondRefinement : struct, IRefinement<TSecondRefinement>
+/// <typeparam name="T">type of value</typeparam>
+public readonly struct And<T, TFirstRefinement, TSecondRefinement>
+    : IRefinement<And<T, TFirstRefinement, TSecondRefinement>, T>
+    where TFirstRefinement : struct, IRefinement<TFirstRefinement, T>
+    where TSecondRefinement : struct, IRefinement<TSecondRefinement, T>
 {
     /// <inheritdoc />
-    public bool CanBeRefined<T>(T value)
+    public bool CanBeRefined(T value)
     {
         var firstRefinement = default(TFirstRefinement);
         var secondRefinement = default(TSecondRefinement);
@@ -19,7 +20,7 @@ public bool CanBeRefined<T>(T value)
     }
 
     /// <inheritdoc />
-    public string BuildFailureMessage<T>(T value)
+    public string BuildFailureMessage(T value)
     {
         var firstRefinement = default(TFirstRefinement);
         var secondRefinement = default(TSecondRefinement);
diff --git a/Tuxedo/Refinements/AnyUri.cs b/Tuxedo/Refinements/AnyUri.cs
deleted file mode 100644
index 8287ac7..0000000
--- a/Tuxedo/Refinements/AnyUri.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-using System.Diagnostics.CodeAnalysis;
-
-namespace Tuxedo;
-
-/// <summary>
-/// Enforces that a string value is a valid <see cref="Uri"/>
-/// </summary>
-public readonly struct AnyUri : IRefinementResult<AnyUri, Uri>
-{
-    /// <inheritdoc />
-    public bool CanBeRefined<T>(T value) => TryRefine(value, out _);
-
-    /// <inheritdoc />
-    public bool TryRefine<T>(T value, [NotNullWhen(true)] out Uri? refinedValue)
-    {
-        if (value is string s && Uri.TryCreate(s, UriKind.RelativeOrAbsolute, out var uri))
-        {
-            refinedValue = uri;
-            return true;
-        }
-
-        refinedValue = null;
-        return false;
-    }
-
-    /// <inheritdoc />
-    public string BuildFailureMessage<T>(T value) => "Value must be a valid URI";
-}
diff --git a/Tuxedo/Refinements/Empty.cs b/Tuxedo/Refinements/Empty.cs
deleted file mode 100644
index aaa4042..0000000
--- a/Tuxedo/Refinements/Empty.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-using System.Collections;
-
-namespace Tuxedo;
-
-/// <summary>
-/// Enforces that a value is empty
-/// </summary>
-public readonly struct Empty : IRefinement<Empty>
-{
-    /// <inheritdoc />
-    public bool CanBeRefined<T>(T value)
-    {
-        switch (value)
-        {
-            case null:
-                return true;
-            case string text:
-                return string.IsNullOrEmpty(text);
-            case ICollection collection:
-                return collection.Count == 0;
-            case IEnumerable enumerable:
-            {
-                var enumerator = enumerable.GetEnumerator();
-                using var disposable = enumerator as IDisposable;
-                return !enumerator.MoveNext();
-            }
-            default:
-                return EqualityComparer<T>.Default.Equals(value, default!);
-        }
-    }
-
-    /// <inheritdoc />
-    public string BuildFailureMessage<T>(T value) => "Value must be empty";
-}
diff --git a/Tuxedo/Refinements/Empty/Empty.Collection.cs b/Tuxedo/Refinements/Empty/Empty.Collection.cs
new file mode 100644
index 0000000..5a9ff0d
--- /dev/null
+++ b/Tuxedo/Refinements/Empty/Empty.Collection.cs
@@ -0,0 +1,27 @@
+using System.Collections;
+
+namespace Tuxedo;
+
+/// <summary>
+/// Enforces that a value is empty
+/// </summary>
+public readonly struct Empty : IRefinement<Empty, IEnumerable>
+{
+    bool IRefinement<Empty, IEnumerable>.CanBeRefined(IEnumerable? value)
+    {
+        switch (value)
+        {
+            case null:
+                return true;
+            case ICollection collection:
+                return collection.Count == 0;
+        }
+
+        var enumerator = value.GetEnumerator();
+        using var disposable = enumerator as IDisposable;
+        return !enumerator.MoveNext();
+    }
+
+    string IRefinement<Empty, IEnumerable>.BuildFailureMessage(IEnumerable value) =>
+        "Value must be empty";
+}
diff --git a/Tuxedo/Refinements/Empty/Empty.Object.cs b/Tuxedo/Refinements/Empty/Empty.Object.cs
new file mode 100644
index 0000000..f7cb5db
--- /dev/null
+++ b/Tuxedo/Refinements/Empty/Empty.Object.cs
@@ -0,0 +1,25 @@
+namespace Tuxedo;
+
+/// <summary>
+/// Enforces that a value is empty
+/// </summary>
+public readonly struct Empty<T, TComparer> : IRefinement<Empty<T, TComparer>, T>
+    where TComparer : struct, IConstant<TComparer, IEqualityComparer<T?>>
+{
+    bool IRefinement<Empty<T, TComparer>, T>.CanBeRefined(T value) =>
+        default(TComparer).Value.Equals(value, default);
+
+    string IRefinement<Empty<T, TComparer>, T>.BuildFailureMessage(T value) =>
+        "Value must be empty";
+}
+
+/// <summary>
+/// Enforces that a value is empty
+/// </summary>
+public readonly struct Empty<T> : IRefinement<Empty<T>, T>
+{
+    bool IRefinement<Empty<T>, T>.CanBeRefined(T value) =>
+        default(DefaultComparer<T?>).Value!.Equals(value, default);
+
+    string IRefinement<Empty<T>, T>.BuildFailureMessage(T value) => "Value must be empty";
+}
diff --git a/Tuxedo/Refinements/Even.cs b/Tuxedo/Refinements/Even/Even.Decimal.cs
similarity index 82%
rename from Tuxedo/Refinements/Even.cs
rename to Tuxedo/Refinements/Even/Even.Decimal.cs
index 2eda9a2..2f53755 100644
--- a/Tuxedo/Refinements/Even.cs
+++ b/Tuxedo/Refinements/Even/Even.Decimal.cs
@@ -3,9 +3,9 @@
 namespace Tuxedo;
 
 /// <summary>
-/// Enforces that an integer value is even
+/// Enforces that an numeric value is even
 /// </summary>
-public readonly struct Even : IRefinement<Even>
+public readonly partial struct Even : IRefinement<Even, decimal>
 {
     /// <inheritdoc />
     public bool CanBeRefined<T>(T value) =>
@@ -40,4 +40,9 @@ IEnumerable enumerable
                 => $"Value must have an even count, but found {enumerable.Cast<object?>().Count()}",
             _ => "Value must be even"
         };
+
+    bool IRefinement<Even, decimal>.CanBeRefined(decimal value) => value % 2 == 0;
+
+    string IRefinement<Even, decimal>.BuildFailureMessage(decimal value) =>
+        $"Value must be an even number, but found {value}";
 }
diff --git a/Tuxedo/Refinements/Even/Even.Double.cs b/Tuxedo/Refinements/Even/Even.Double.cs
new file mode 100644
index 0000000..faeecc2
--- /dev/null
+++ b/Tuxedo/Refinements/Even/Even.Double.cs
@@ -0,0 +1,13 @@
+namespace Tuxedo;
+
+/// <summary>
+/// Enforces that an numeric value is even
+/// </summary>
+public readonly partial struct Even : IRefinement<Even, double>
+{
+    bool IRefinement<Even, double>.CanBeRefined(double value) =>
+        Math.Abs(value % 2) - 0 < double.Epsilon;
+
+    string IRefinement<Even, double>.BuildFailureMessage(double value) =>
+        $"Value must be an even number, but found {value}";
+}
diff --git a/Tuxedo/Refinements/Even/Even.Float.cs b/Tuxedo/Refinements/Even/Even.Float.cs
new file mode 100644
index 0000000..d775d9d
--- /dev/null
+++ b/Tuxedo/Refinements/Even/Even.Float.cs
@@ -0,0 +1,13 @@
+namespace Tuxedo;
+
+/// <summary>
+/// Enforces that an numeric value is even
+/// </summary>
+public readonly partial struct Even : IRefinement<Even, float>
+{
+    bool IRefinement<Even, float>.CanBeRefined(float value) =>
+        Math.Abs(value % 2) - 0 < float.Epsilon;
+
+    string IRefinement<Even, float>.BuildFailureMessage(float value) =>
+        $"Value must be an even number, but found {value}";
+}
diff --git a/Tuxedo/Refinements/Even/Even.Int.cs b/Tuxedo/Refinements/Even/Even.Int.cs
new file mode 100644
index 0000000..db2b7a9
--- /dev/null
+++ b/Tuxedo/Refinements/Even/Even.Int.cs
@@ -0,0 +1,12 @@
+namespace Tuxedo;
+
+/// <summary>
+/// Enforces that an numeric value is even
+/// </summary>
+public readonly partial struct Even : IRefinement<Even, int>
+{
+    bool IRefinement<Even, int>.CanBeRefined(int value) => value % 2 == 0;
+
+    string IRefinement<Even, int>.BuildFailureMessage(int value) =>
+        $"Value must be an even number, but found {value}";
+}
diff --git a/Tuxedo/Refinements/Even/Even.Long.cs b/Tuxedo/Refinements/Even/Even.Long.cs
new file mode 100644
index 0000000..2d50446
--- /dev/null
+++ b/Tuxedo/Refinements/Even/Even.Long.cs
@@ -0,0 +1,12 @@
+namespace Tuxedo;
+
+/// <summary>
+/// Enforces that an numeric value is even
+/// </summary>
+public readonly partial struct Even : IRefinement<Even, long>
+{
+    bool IRefinement<Even, long>.CanBeRefined(long value) => value % 2 == 0;
+
+    string IRefinement<Even, long>.BuildFailureMessage(long value) =>
+        $"Value must be an even number, but found {value}";
+}
diff --git a/Tuxedo/Refinements/Even/Even.Short.cs b/Tuxedo/Refinements/Even/Even.Short.cs
new file mode 100644
index 0000000..4eb02ff
--- /dev/null
+++ b/Tuxedo/Refinements/Even/Even.Short.cs
@@ -0,0 +1,12 @@
+namespace Tuxedo;
+
+/// <summary>
+/// Enforces that an numeric value is even
+/// </summary>
+public readonly partial struct Even : IRefinement<Even, short>
+{
+    bool IRefinement<Even, short>.CanBeRefined(short value) => value % 2 == 0;
+
+    string IRefinement<Even, short>.BuildFailureMessage(short value) =>
+        $"Value must be an even number, but found {value}";
+}
diff --git a/Tuxedo/Refinements/False.cs b/Tuxedo/Refinements/False.cs
index 574d044..50d1c37 100644
--- a/Tuxedo/Refinements/False.cs
+++ b/Tuxedo/Refinements/False.cs
@@ -3,11 +3,11 @@
 /// <summary>
 /// Enforces that a boolean value is false
 /// </summary>
-public readonly struct False : IRefinement<False>
+public readonly struct False : IRefinement<False, bool>
 {
     /// <inheritdoc />
-    public bool CanBeRefined<T>(T value) => value is false;
+    public bool CanBeRefined(bool value) => !value;
 
     /// <inheritdoc />
-    public string BuildFailureMessage<T>(T value) => "Value must be false";
+    public string BuildFailureMessage(bool value) => "Value must be false";
 }
diff --git a/Tuxedo/Refinements/MatchesRegex.cs b/Tuxedo/Refinements/MatchesRegex.cs
index 4b2e630..121e942 100644
--- a/Tuxedo/Refinements/MatchesRegex.cs
+++ b/Tuxedo/Refinements/MatchesRegex.cs
@@ -7,23 +7,17 @@ namespace Tuxedo;
 /// </summary>
 /// <typeparam name="TRegex">the regular expression to match</typeparam>
 public readonly struct MatchesRegex<TRegex>
-    : IRefinementResult<MatchesRegex<TRegex>, MatchCollection>
+    : IRefinement<MatchesRegex<TRegex>, string, MatchCollection>
     where TRegex : struct, IConstant<TRegex, string>
 {
     /// <inheritdoc />
-    public bool CanBeRefined<T>(T value) => value is string s && TryRefine(s, out _);
+    public bool CanBeRefined(string value) => TryRefine(value, out _);
 
     /// <inheritdoc />
-    public bool TryRefine<T>(T value, out MatchCollection refinedValue)
+    public bool TryRefine(string value, out MatchCollection refinedValue)
     {
-        if (value is not string s)
-        {
-            refinedValue = default!;
-            return false;
-        }
-
         refinedValue = Regex.Matches(
-            s,
+            value,
             default(TRegex).Value,
             RegexOptions.None,
             TimeSpan.FromSeconds(30)
@@ -31,7 +25,7 @@ public bool TryRefine<T>(T value, out MatchCollection refinedValue)
         return refinedValue.Count > 0;
     }
 
-    /// <inheritdoc cref="IRefinement{TThis}.BuildFailureMessage{T}" />
-    public string BuildFailureMessage<T>(T value) =>
+    /// <inheritdoc />
+    public string BuildFailureMessage(string value) =>
         $"Value must match the regular expression '{default(TRegex).Value}'";
 }
diff --git a/Tuxedo/Refinements/NonEmpty.cs b/Tuxedo/Refinements/NonEmpty.cs
deleted file mode 100644
index 0e4de00..0000000
--- a/Tuxedo/Refinements/NonEmpty.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-using System.Collections;
-
-namespace Tuxedo;
-
-/// <summary>
-/// Enforces that a value is not empty
-/// </summary>
-public readonly struct NonEmpty : IRefinement<NonEmpty>
-{
-    /// <inheritdoc />
-    public bool CanBeRefined<T>(T value)
-    {
-        switch (value)
-        {
-            case null:
-                return false;
-            case string text:
-                return text.Length > 0;
-            case ICollection collection:
-                return collection.Count > 0;
-            case IEnumerable enumerable:
-            {
-                var enumerator = enumerable.GetEnumerator();
-                using var disposable = enumerator as IDisposable;
-                return enumerator.MoveNext();
-            }
-            default:
-                return !EqualityComparer<T>.Default.Equals(value, default!);
-        }
-    }
-
-    /// <inheritdoc />
-    public string BuildFailureMessage<T>(T value) => "Value cannot be empty";
-}
diff --git a/Tuxedo/Refinements/NonEmpty/NonEmpty.Collection.cs b/Tuxedo/Refinements/NonEmpty/NonEmpty.Collection.cs
new file mode 100644
index 0000000..6acd2da
--- /dev/null
+++ b/Tuxedo/Refinements/NonEmpty/NonEmpty.Collection.cs
@@ -0,0 +1,27 @@
+using System.Collections;
+
+namespace Tuxedo;
+
+/// <summary>
+/// Enforces that a value is not empty
+/// </summary>
+public readonly struct NonEmpty : IRefinement<NonEmpty, IEnumerable>
+{
+    bool IRefinement<NonEmpty, IEnumerable>.CanBeRefined(IEnumerable value)
+    {
+        switch (value)
+        {
+            case null:
+                return false;
+            case ICollection collection:
+                return collection.Count > 0;
+        }
+
+        var enumerator = value.GetEnumerator();
+        using var disposable = enumerator as IDisposable;
+        return enumerator.MoveNext();
+    }
+
+    string IRefinement<NonEmpty, IEnumerable>.BuildFailureMessage(IEnumerable value) =>
+        "Value cannot be empty";
+}
diff --git a/Tuxedo/Refinements/NonEmpty/NonEmpty.Object.cs b/Tuxedo/Refinements/NonEmpty/NonEmpty.Object.cs
new file mode 100644
index 0000000..1500008
--- /dev/null
+++ b/Tuxedo/Refinements/NonEmpty/NonEmpty.Object.cs
@@ -0,0 +1,35 @@
+namespace Tuxedo;
+
+/// <summary>
+/// Enforces that a value is not empty
+/// </summary>
+public readonly struct NonEmpty<T, TComparer> : IRefinement<NonEmpty<T, TComparer>, T>
+    where TComparer : struct, IConstant<TComparer, IEqualityComparer<T?>>
+{
+    bool IRefinement<NonEmpty<T, TComparer>, T>.CanBeRefined(T value) =>
+        !default(TComparer).Value.Equals(value, default);
+
+    string IRefinement<NonEmpty<T, TComparer>, T>.BuildFailureMessage(T value) =>
+        "Value cannot be empty";
+}
+
+/// <summary>
+/// Enforces that a value is not empty
+/// </summary>
+public readonly struct NonEmpty<T> : IRefinement<NonEmpty<T>, T>
+{
+    bool IRefinement<NonEmpty<T>, T>.CanBeRefined(T value) =>
+        !default(DefaultComparer<T?>).Value!.Equals(value, default);
+
+    string IRefinement<NonEmpty<T>, T>.BuildFailureMessage(T value) => "Value cannot be empty";
+}
+
+/// <summary>
+/// Default comparer for a type
+/// </summary>
+/// <typeparam name="T">type</typeparam>
+public readonly struct DefaultComparer<T> : IConstant<DefaultComparer<T>, IEqualityComparer<T?>>
+{
+    /// <inheritdoc />
+    public IEqualityComparer<T?> Value => EqualityComparer<T?>.Default;
+}
diff --git a/Tuxedo/Refinements/Not.cs b/Tuxedo/Refinements/Not.cs
index 0a83373..ec57ead 100644
--- a/Tuxedo/Refinements/Not.cs
+++ b/Tuxedo/Refinements/Not.cs
@@ -4,13 +4,14 @@
 /// Inverts a refinement
 /// </summary>
 /// <typeparam name="TRefinement">refinement to invert</typeparam>
-public readonly struct Not<TRefinement> : IRefinement<Not<TRefinement>>
-    where TRefinement : struct, IRefinement<TRefinement>
+/// <typeparam name="T">type of value</typeparam>
+public readonly struct Not<T, TRefinement> : IRefinement<Not<T, TRefinement>, T>
+    where TRefinement : struct, IRefinement<TRefinement, T>
 {
     /// <inheritdoc />
-    public bool CanBeRefined<T>(T value) => !default(TRefinement).CanBeRefined(value);
+    public bool CanBeRefined(T value) => !default(TRefinement).CanBeRefined(value);
 
     /// <inheritdoc />
-    public string BuildFailureMessage<T>(T value) =>
+    public string BuildFailureMessage(T value) =>
         $"Not: {default(TRefinement).BuildFailureMessage(value)}";
 }
diff --git a/Tuxedo/Refinements/Positive.cs b/Tuxedo/Refinements/Positive.cs
deleted file mode 100644
index 3296379..0000000
--- a/Tuxedo/Refinements/Positive.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-namespace Tuxedo;
-
-/// <summary>
-/// Ensures that an integer value is positive
-/// </summary>
-public readonly struct Positive : IRefinement<Positive>
-{
-    /// <inheritdoc />
-    public bool CanBeRefined<T>(T value) =>
-        value switch
-        {
-            short s => s > 0,
-            int i => i > 0,
-            long l => l > 0,
-            float f => f > 0,
-            double d => d > 0,
-            decimal d => d > 0,
-            _ => false
-        };
-
-    /// <inheritdoc />
-    public string BuildFailureMessage<T>(T value) =>
-        value switch
-        {
-            short s => $"Value must be positive, but found {s}",
-            int i => $"Value must be positive, but found {i}",
-            long l => $"Value must be positive, but found {l}",
-            float f => $"Value must be positive, but found {f}",
-            double d => $"Value must be positive, but found {d}",
-            decimal d => $"Value must be positive, but found {d}",
-            _ => "Value must be positive"
-        };
-}
diff --git a/Tuxedo/Refinements/Positive/Positive.Decimal.cs b/Tuxedo/Refinements/Positive/Positive.Decimal.cs
new file mode 100644
index 0000000..9fa99fc
--- /dev/null
+++ b/Tuxedo/Refinements/Positive/Positive.Decimal.cs
@@ -0,0 +1,12 @@
+namespace Tuxedo;
+
+/// <summary>
+/// Ensures that an numeric value is positive
+/// </summary>
+public readonly partial struct Positive : IRefinement<Positive, decimal>
+{
+    bool IRefinement<Positive, decimal>.CanBeRefined(decimal value) => value > 0;
+
+    string IRefinement<Positive, decimal>.BuildFailureMessage(decimal value) =>
+        $"Value must be positive, but found {value}";
+}
diff --git a/Tuxedo/Refinements/Positive/Positive.Double.cs b/Tuxedo/Refinements/Positive/Positive.Double.cs
new file mode 100644
index 0000000..605fdad
--- /dev/null
+++ b/Tuxedo/Refinements/Positive/Positive.Double.cs
@@ -0,0 +1,12 @@
+namespace Tuxedo;
+
+/// <summary>
+/// Ensures that an numeric value is positive
+/// </summary>
+public readonly partial struct Positive : IRefinement<Positive, double>
+{
+    bool IRefinement<Positive, double>.CanBeRefined(double value) => value > 0;
+
+    string IRefinement<Positive, double>.BuildFailureMessage(double value) =>
+        $"Value must be positive, but found {value}";
+}
diff --git a/Tuxedo/Refinements/Positive/Positive.Float.cs b/Tuxedo/Refinements/Positive/Positive.Float.cs
new file mode 100644
index 0000000..e6dc05e
--- /dev/null
+++ b/Tuxedo/Refinements/Positive/Positive.Float.cs
@@ -0,0 +1,12 @@
+namespace Tuxedo;
+
+/// <summary>
+/// Ensures that an numeric value is positive
+/// </summary>
+public readonly partial struct Positive : IRefinement<Positive, float>
+{
+    bool IRefinement<Positive, float>.CanBeRefined(float value) => value > 0;
+
+    string IRefinement<Positive, float>.BuildFailureMessage(float value) =>
+        $"Value must be positive, but found {value}";
+}
diff --git a/Tuxedo/Refinements/Positive/Positive.Int.cs b/Tuxedo/Refinements/Positive/Positive.Int.cs
new file mode 100644
index 0000000..1136d7b
--- /dev/null
+++ b/Tuxedo/Refinements/Positive/Positive.Int.cs
@@ -0,0 +1,12 @@
+namespace Tuxedo;
+
+/// <summary>
+/// Ensures that an numeric value is positive
+/// </summary>
+public readonly partial struct Positive : IRefinement<Positive, int>
+{
+    bool IRefinement<Positive, int>.CanBeRefined(int value) => value > 0;
+
+    string IRefinement<Positive, int>.BuildFailureMessage(int value) =>
+        $"Value must be positive, but found {value}";
+}
diff --git a/Tuxedo/Refinements/Positive/Positive.Long.cs b/Tuxedo/Refinements/Positive/Positive.Long.cs
new file mode 100644
index 0000000..6de619f
--- /dev/null
+++ b/Tuxedo/Refinements/Positive/Positive.Long.cs
@@ -0,0 +1,12 @@
+namespace Tuxedo;
+
+/// <summary>
+/// Ensures that an numeric value is positive
+/// </summary>
+public readonly partial struct Positive : IRefinement<Positive, long>
+{
+    bool IRefinement<Positive, long>.CanBeRefined(long value) => value > 0;
+
+    string IRefinement<Positive, long>.BuildFailureMessage(long value) =>
+        $"Value must be positive, but found {value}";
+}
diff --git a/Tuxedo/Refinements/Positive/Positive.Short.cs b/Tuxedo/Refinements/Positive/Positive.Short.cs
new file mode 100644
index 0000000..22de534
--- /dev/null
+++ b/Tuxedo/Refinements/Positive/Positive.Short.cs
@@ -0,0 +1,12 @@
+namespace Tuxedo;
+
+/// <summary>
+/// Ensures that an numeric value is positive
+/// </summary>
+public readonly partial struct Positive : IRefinement<Positive, short>
+{
+    bool IRefinement<Positive, short>.CanBeRefined(short value) => value > 0;
+
+    string IRefinement<Positive, short>.BuildFailureMessage(short value) =>
+        $"Value must be positive, but found {value}";
+}
diff --git a/Tuxedo/Refinements/RelativeUri.cs b/Tuxedo/Refinements/RelativeUri.cs
deleted file mode 100644
index dee977a..0000000
--- a/Tuxedo/Refinements/RelativeUri.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-using System.Diagnostics.CodeAnalysis;
-
-namespace Tuxedo;
-
-/// <summary>
-/// Enforces that a string value is a valid relative <see cref="Uri"/>
-/// </summary>
-public readonly struct RelativeUri : IRefinementResult<RelativeUri, Uri>
-{
-    /// <inheritdoc />
-    public bool CanBeRefined<T>(T value) => TryRefine(value, out _);
-
-    /// <inheritdoc />
-    public bool TryRefine<TIn>(TIn value, [NotNullWhen(true)] out Uri? refinedValue)
-    {
-        if (value is string s && Uri.TryCreate(s, UriKind.Relative, out var uri))
-        {
-            refinedValue = uri;
-            return true;
-        }
-
-        refinedValue = null;
-        return false;
-    }
-
-    /// <inheritdoc />
-    public string BuildFailureMessage<T>(T value) => "Value must be a valid relative URI";
-}
diff --git a/Tuxedo/Refinements/Size.cs b/Tuxedo/Refinements/Size.cs
index 5ddd35a..43d661c 100644
--- a/Tuxedo/Refinements/Size.cs
+++ b/Tuxedo/Refinements/Size.cs
@@ -6,27 +6,27 @@ namespace Tuxedo;
 /// Enforces that a value has a specific size
 /// </summary>
 /// <typeparam name="TSize">size refinement</typeparam>
-public readonly struct Size<TSize> : IRefinement<Size<TSize>>
-    where TSize : struct, IRefinement<TSize>
+public readonly struct Size<TSize> : IRefinement<Size<TSize>, IEnumerable>
+    where TSize : struct, IRefinement<TSize, int>
 {
     /// <inheritdoc />
-    public bool CanBeRefined<T>(T value)
+    public bool CanBeRefined(IEnumerable value)
     {
         switch (value)
         {
             case ICollection collection:
                 return default(TSize).CanBeRefined(collection.Count);
-            case IEnumerable enumerable:
+            default:
             {
-                var count = enumerable.Cast<object?>().Count();
+                var count = 0;
+                foreach (var _ in value)
+                    count++;
                 return default(TSize).CanBeRefined(count);
             }
-            default:
-                return false;
         }
     }
 
     /// <inheritdoc />
-    public string BuildFailureMessage<T>(T value) =>
-        $"The values size failed refinement: {default(TSize).BuildFailureMessage(default(int))}";
+    public string BuildFailureMessage(IEnumerable value) =>
+        $"The values size failed refinement: {default(TSize).BuildFailureMessage(default)}";
 }
diff --git a/Tuxedo/Refinements/StartsWith.cs b/Tuxedo/Refinements/StartsWith.cs
index 3a4eb88..fb986c6 100644
--- a/Tuxedo/Refinements/StartsWith.cs
+++ b/Tuxedo/Refinements/StartsWith.cs
@@ -4,14 +4,14 @@
 /// Enforces that a string value starts with a specific prefix
 /// </summary>
 /// <typeparam name="TPrefix">prefix type</typeparam>
-public readonly struct StartsWith<TPrefix> : IRefinement<StartsWith<TPrefix>>
+public readonly struct StartsWith<TPrefix> : IRefinement<StartsWith<TPrefix>, string>
     where TPrefix : struct, IConstant<TPrefix, string>
 {
     /// <inheritdoc />
-    public bool CanBeRefined<T>(T value) =>
-        value is string s && s.StartsWith(default(TPrefix).Value, StringComparison.Ordinal);
+    public bool CanBeRefined(string value) =>
+        value.StartsWith(default(TPrefix).Value, StringComparison.Ordinal);
 
     /// <inheritdoc />
-    public string BuildFailureMessage<T>(T value) =>
+    public string BuildFailureMessage(string value) =>
         $"Value must start with '{default(TPrefix).Value}'";
 }
diff --git a/Tuxedo/Refinements/Trimmed.cs b/Tuxedo/Refinements/Trimmed.cs
index f909ee3..4884821 100644
--- a/Tuxedo/Refinements/Trimmed.cs
+++ b/Tuxedo/Refinements/Trimmed.cs
@@ -5,26 +5,30 @@ namespace Tuxedo;
 /// <summary>
 /// Ensures that a string value has no leading or trailing whitespace
 /// </summary>
-public readonly struct Trimmed : IRefinementResult<Trimmed, string>
+public readonly struct Trimmed : IRefinement<Trimmed, string, string>
 {
-    /// <inheritdoc />
-    public bool CanBeRefined<T>(T value) =>
-        value is string s && s.Equals(s.Trim(), StringComparison.Ordinal);
-
-    /// <inheritdoc />
-    public bool TryRefine<TIn>(TIn value, [NotNullWhen(true)] out string? refinedValue)
+    /// <summary>
+    /// Determines if the value is trimmed
+    /// </summary>
+    /// <param name="value">The value to check</param>
+    /// <returns>True if the value is trimmed, otherwise false</returns>
+    public bool CanBeRefined(string value)
     {
-        if (value is string s)
-        {
-            refinedValue = s.Trim();
-            return true;
-        }
-
-        refinedValue = null;
-        return false;
+        return string.Equals(value.Trim(), value, StringComparison.Ordinal);
     }
 
+    /// <summary>
+    /// Builds a failure message
+    /// </summary>
+    /// <param name="value">The value that failed the refinement</param>
+    /// <returns>A message describing the failure</returns>
+    public string BuildFailureMessage(string value) =>
+        $"Value must be trimmed, but found '{value}'";
+
     /// <inheritdoc />
-    public string BuildFailureMessage<T>(T value) =>
-        "Value must have no leading or trailing whitespace";
+    public bool TryRefine(string value, [NotNullWhen(true)] out string? refinedValue)
+    {
+        refinedValue = value.Trim();
+        return true;
+    }
 }
diff --git a/Tuxedo/Refinements/True.cs b/Tuxedo/Refinements/True.cs
index de6fc57..90d30fa 100644
--- a/Tuxedo/Refinements/True.cs
+++ b/Tuxedo/Refinements/True.cs
@@ -3,11 +3,11 @@
 /// <summary>
 /// Enforces that a boolean value is true
 /// </summary>
-public readonly struct True : IRefinement<True>
+public readonly struct True : IRefinement<True, bool>
 {
     /// <inheritdoc />
-    public bool CanBeRefined<T>(T value) => value is true;
+    public bool CanBeRefined(bool value) => value;
 
     /// <inheritdoc />
-    public string BuildFailureMessage<T>(T value) => "Value must be true";
+    public string BuildFailureMessage(bool value) => "Value must be true";
 }
diff --git a/Tuxedo/Refinements/Uri.cs b/Tuxedo/Refinements/Uri.cs
new file mode 100644
index 0000000..3e8fd5f
--- /dev/null
+++ b/Tuxedo/Refinements/Uri.cs
@@ -0,0 +1,72 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace Tuxedo;
+
+/// <summary>
+/// Enforces that a string value is a valid <see cref="System.Uri"/> matching a specific <see cref="UriKind"/>
+/// </summary>
+public readonly struct Uri<TKind> : IRefinement<Uri<TKind>, string, System.Uri>
+    where TKind : struct, IConstant<TKind, UriKind>
+{
+    /// <inheritdoc />
+    public bool CanBeRefined(string value) => TryRefine(value, out _);
+
+    /// <inheritdoc />
+    public bool TryRefine(string value, [NotNullWhen(true)] out System.Uri? refinedValue)
+    {
+        if (System.Uri.TryCreate(value, default(TKind).Value, out var uri))
+        {
+            refinedValue = uri;
+            return true;
+        }
+
+        refinedValue = null;
+        return false;
+    }
+
+    /// <inheritdoc />
+    public string BuildFailureMessage(string value) => "Value must be a valid URI";
+}
+
+/// <summary>
+/// Enforces that a string value is a valid <see cref="System.Uri"/>
+/// </summary>
+public readonly struct Uri : IRefinement<Uri, string, System.Uri>
+{
+    /// <inheritdoc />
+    public bool CanBeRefined(string value) => TryRefine(value, out _);
+
+    /// <inheritdoc />
+    public bool TryRefine(string value, [NotNullWhen(true)] out System.Uri? refinedValue)
+    {
+        if (System.Uri.TryCreate(value, UriKind.RelativeOrAbsolute, out var uri))
+        {
+            refinedValue = uri;
+            return true;
+        }
+
+        refinedValue = null;
+        return false;
+    }
+
+    /// <inheritdoc />
+    public string BuildFailureMessage(string value) => "Value must be a valid URI";
+}
+
+/// <summary>
+/// Represents a <see cref="UriKind.Absolute"/> at the type level
+/// </summary>
+public readonly struct UriKindAbsolute : IConstant<UriKindAbsolute, UriKind>
+{
+    /// <inheritdoc />
+    public UriKind Value => UriKind.Absolute;
+}
+
+/// <summary>
+/// Represents a <see cref="UriKind.Relative"/> at the type level
+/// </summary>
+public readonly struct UriKindRelative : IConstant<UriKindRelative, UriKind>
+{
+    /// <inheritdoc />
+    public UriKind Value => UriKind.Relative;
+}
diff --git a/Tuxedo/Refinements/Uuid.cs b/Tuxedo/Refinements/Uuid.cs
index 599f250..f106462 100644
--- a/Tuxedo/Refinements/Uuid.cs
+++ b/Tuxedo/Refinements/Uuid.cs
@@ -3,15 +3,15 @@
 /// <summary>
 /// Enforces that a string value is a valid <see cref="Guid"/>
 /// </summary>
-public readonly struct Uuid : IRefinementResult<Uuid, Guid>
+public readonly struct Uuid : IRefinement<Uuid, string, Guid>
 {
     /// <inheritdoc />
-    public bool CanBeRefined<T>(T value) => TryRefine(value, out _);
+    public bool CanBeRefined(string value) => TryRefine(value, out _);
 
     /// <inheritdoc />
-    public bool TryRefine<T>(T value, out Guid refinedValue) =>
-        value is string s && Guid.TryParse(s, out refinedValue);
+    public bool TryRefine(string value, out Guid refinedValue) =>
+        Guid.TryParse(value, out refinedValue);
 
     /// <inheritdoc />
-    public string BuildFailureMessage<T>(T value) => "Value must be a valid GUID";
+    public string BuildFailureMessage(string value) => "Value must be a valid GUID";
 }