feat: replace comparator with external library

README.md

···
       // provided and no with() calls are done then the resulting class
       // will only include the default string which might not be favorable
       defaults: [Variant(Primary)],
-      // Create a comparator to see when two top level keys are matching
-      comparator: fn(a: Key, b: Key) {
-        case a, b {
-          Size(_), Size(_) -> True
-          Variant(_), Variant(_) -> True
-          _, _ -> False
-        }
-      },
     )
 
   let class =

gleam.toml

···
 
 [dependencies]
 gleam_stdlib = ">= 0.44.0 and < 2.0.0"
+comparator = ">= 1.0.0 and < 2.0.0"
 
 [dev-dependencies]
 gleeunit = ">= 1.0.0 and < 2.0.0"

manifest.toml

···
 # You typically do not need to edit this file
 
 packages = [
+  { name = "comparator", version = "1.0.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "comparator", source = "hex", outer_checksum = "62A817E00FF301CE780F03D0FEE0943D5881138B3852F1DEE2FB72381604F949" },
   { name = "glailwind_merge", version = "1.1.0", build_tools = ["gleam"], requirements = ["tails"], otp_app = "glailwind_merge", source = "hex", outer_checksum = "3A9B557E63D174A430950B9748180DF386C96DEAD1FD0E6891A98D3A76175C59" },
   { name = "gleam_stdlib", version = "0.63.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "5E216C7D5E8BE22359C9D7DAA2CFBD66039BC12565542F34CD033C5BB57071ED" },
   { name = "gleeunit", version = "1.6.1", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "FDC68A8C492B1E9B429249062CD9BAC9B5538C6FBF584817205D0998C42E1DAC" },
···
 ]
 
 [requirements]
+comparator = { version = ">= 1.0.0 and < 2.0.0" }
 glailwind_merge = { version = ">= 1.1.0 and < 2.0.0" }
 gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" }
 gleeunit = { version = ">= 1.0.0 and < 2.0.0" }

src/gva.gleam

···
+import comparator
 import gleam/list
 import gleam/string
 
···
     default: String,
     resolver: fn(a) -> String,
     defaults: List(a),
-    comparator: fn(a, a) -> Bool,
     using: List(a),
   )
 }
···
   case defaults {
     [default, ..defaults] -> {
       let is_applied =
-        list.filter(using, fn(a) { class.comparator(a, default) })
+        list.filter(using, fn(a) { comparator.is_same_kind(a, default) })
         |> list.length
         > 0
       case is_applied {
···
 /// 
 /// The resolver handles which types should go to which classes
 /// 
-/// The comparator checks when two top level keys are matching
-/// 
 /// 
 /// ## Examples
 /// 
···
 ///       // provided and no with() calls are done then the resulting class
 ///       // will only include the default string which might not be favorable
 ///       defaults: [Variant(Primary)],
-///       // Create a comparator to see when two top level keys are matching
-///       comparator: fn(a: Key, b: Key) {
-///         case a, b {
-///           Size(_), Size(_) -> True
-///           Variant(_), Variant(_) -> True
-///           _, _ -> False
-///         }
-///       },
 ///     )
 /// 
 ///   let class =
···
 pub fn gva(
   default default: String,
   resolver resolver: fn(a) -> String,
-  comparator comparator: fn(a, a) -> Bool,
   defaults defaults: List(a),
 ) {
-  Class(default, resolver, defaults, comparator, [])
+  Class(default, resolver, defaults, [])
 }

test/gva_test.gleam

···
         }
       },
       defaults: [],
-      comparator: fn(a: BasicKey, b: BasicKey) {
-        case a, b {
-          BasicSize(_), BasicSize(_) -> True
-          BasicVariant(_), BasicVariant(_) -> True
-          _, _ -> False
-        }
-      },
     )
 
   let class =
···
       AdvancedVariant(AdvancedDefaultVariant),
       AdvancedSize(AdvancedDefaultSize),
     ],
-    comparator: fn(a: AdvancedKey, b: AdvancedKey) {
-      case a, b {
-        AdvancedSize(_), AdvancedSize(_) -> True
-        AdvancedVariant(_), AdvancedVariant(_) -> True
-        _, _ -> False
-      }
-    },
   )
 }