Bump version to 1.0.1; add changelog & tests

Update project for release 1.0.1: bump package version in gleam.toml and CI Gleam version (1.13.0 -> 1.14.0). Add a CHANGELOG.md documenting 1.0.1 and 1.0.0 entries. Improve docs for cmp.reverse and expand tests: make by_normalized_string_test use proper lowercase normalization and assert normalization changes results, add reverse_test to verify Lt/Gt inversion and Eq stability, and add chain_empty_test to assert chain([]) returns Eq.

Author: lupodevelop

.github/workflows/test.yml

@@ -15,7 +15,7 @@ jobs:
       - uses: erlef/setup-beam@v1
         with:
           otp-version: "28"
-          gleam-version: "1.13.0"
+          gleam-version: "1.14.0"
           rebar3-version: "3"
           # elixir-version: "1"
       - run: gleam deps download

CHANGELOG.md

@@ -0,0 +1,35 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.1] - 2026-03-20
+
+### Fixed
+
+- Improved `by_normalized_string` test: now uses a real normalizer (`string.lowercase`)
+  and verifies that normalization actually changes the comparison result
+
+### Added
+
+- Test for `reverse/1`: covers `Lt↔Gt` inversion and `Eq` stability
+- Test for `chain/1` with empty list: verifies it always returns `Eq`
+- Expanded doc comment for `reverse/1` with example and explicit description of behaviour
+
+## [1.0.0] - 2026-03-18
+
+### Added
+
+- `Comparator(a)` type alias (`fn(a, a) -> order.Order`)
+- Basic comparators: `natural_int/2`, `natural_string/2`, `natural_float/2`
+- Contramap helpers: `by/2`, `by_int/1`, `by_string/1`, `by_float/1`,
+  `by_string_with/2`, `by_normalized_string/3`
+- Composition: `then/2`, `chain/1`, `lazy_then/2`, `reverse/1`
+- Container comparators: `option/2`, `pair/2`, `triple/3`, `list_compare/1`
+- Full test suite with gleeunit
+- README with design philosophy, usage examples, and Unicode normalization guide
+
+[1.0.1]: https://github.com/lupodevelop/cmp/compare/v1.0.0...v1.0.1
+[1.0.0]: https://github.com/lupodevelop/cmp/releases/tag/v1.0.0

gleam.toml

@@ -1,5 +1,5 @@
 name = "cmp_gleam"
-version = "1.0.0"
+version = "1.0.1"
 
 # Fill out these fields if you intend to generate HTML documentation or publish
 # your project to the Hex package manager.

src/cmp.gleam

@@ -15,7 +15,15 @@ pub fn natural_int(a: Int, b: Int) -> order.Order {
 }
 
 /// Reverse the ordering produced by `comp`.
-/// Delegates to `order.reverse` for correctness.
+/// `Lt` becomes `Gt`, `Gt` becomes `Lt`, `Eq` stays `Eq`.
+/// Delegates to `order.reverse` from stdlib.
+///
+/// Example:
+///
+/// ```gleam
+/// let desc = cmp.reverse(cmp.by_int(fn(u) { u.age }))
+/// list.sort(users, by: desc)
+/// ```
 pub fn reverse(comp: Comparator(a)) -> Comparator(a) {
   order.reverse(comp)
 }

test/cmp_gleam_test.gleam

@@ -88,15 +88,24 @@ pub fn by_string_with_test() {
 pub fn by_normalized_string_test() {
   let u1 = #("A", 1)
   let u2 = #("a", 2)
+  let u3 = #("B", 3)
   let key = fn(u) {
     case u {
       #(name, _) -> name
     }
   }
-  // Normalizer that maps any string to the same value -> equal
-  let normalize = fn(_s) { "x" }
-  let c = cmp.by_normalized_string(key, normalize, string.compare)
+  // Normalizer that folds to lowercase: "A" == "a" -> Eq
+  let to_lower = string.lowercase
+  let c = cmp.by_normalized_string(key, to_lower, string.compare)
   assert c(u1, u2) == order.Eq
+
+  // Without normalization "A" < "a" (uppercase < lowercase in unicode),
+  // but after lowercasing "a" == "a" -> Eq; confirms normalization changes result
+  assert string.compare("A", "a") != order.Eq
+
+  // Normalization still orders different values correctly: "a" < "b"
+  assert c(u1, u3) == order.Lt
+  assert c(u3, u1) == order.Gt
 }
 
 pub fn chain_test() {
@@ -205,6 +214,33 @@ pub fn triple_test() {
   assert t_cmp(a, c) == order.Gt
 }
 
+pub fn reverse_test() {
+  let asc = cmp.by_int(fn(u) {
+    case u {
+      #(_, age) -> age
+    }
+  })
+  let desc = cmp.reverse(asc)
+
+  let u1 = #("Alice", 30)
+  let u2 = #("Bob", 25)
+
+  // ascending: 30 > 25
+  assert asc(u1, u2) == order.Gt
+  // reversed: 30 < 25
+  assert desc(u1, u2) == order.Lt
+  assert desc(u2, u1) == order.Gt
+
+  // equal values stay Eq after reverse
+  assert desc(u1, u1) == order.Eq
+}
+
+pub fn chain_empty_test() {
+  let c = cmp.chain([])
+  assert c(1, 2) == order.Eq
+  assert c(42, 42) == order.Eq
+}
+
 pub fn natural_float_test() {
   assert cmp.natural_float(1.2, 2.3) == order.Lt
   assert cmp.natural_float(2.3, 1.2) == order.Gt