`order.reverse` (#476)

3 files changed, 32 insertions, 8 deletions

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6213b65..306be71 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,6 +3,8 @@
 ## Unreleased
 
 - The `list` module gains the `list.map2` function.
+- `reverse` has been renamed to `negate` in the `order` module.
+- A new `reverse` function is added to the `order` module, which reverses an ordering function.
 - `flatten` has been renamed to `concat` in the `list` module. The old name is
   still available as an alias and is deprecated.
 
diff --git a/src/gleam/order.gleam b/src/gleam/order.gleam
index 77ad033..12ce011 100644
--- a/src/gleam/order.gleam
+++ b/src/gleam/order.gleam
@@ -18,21 +18,21 @@ pub type Order {
 /// ## Examples
 ///
 /// ```gleam
-/// > reverse(Lt)
+/// > negate(Lt)
 /// Gt
 /// ```
 ///
 /// ```gleam
-/// > reverse(Eq)
+/// > negate(Eq)
 /// Eq
 /// ```
 ///
 /// ```gleam
-/// > reverse(Lt)
+/// > negate(Lt)
 /// Gt
 /// ```
 ///
-pub fn reverse(order: Order) -> Order {
+pub fn negate(order: Order) -> Order {
   case order {
     Lt -> Gt
     Eq -> Eq
@@ -117,3 +117,17 @@ pub fn min(a: Order, b: Order) -> Order {
     _, _ -> b
   }
 }
+
+/// Inverts an ordering function, so less-than becomes greater-than and greater-than
+/// becomes less-than.
+///
+/// ## Examples
+///
+/// ```gleam
+/// > list.sort([1, 5, 4], by: reverse(int.compare))
+/// [5, 4, 1]
+/// ```
+///
+pub fn reverse(orderer: fn(a, a) -> Order) -> fn(a, a) -> Order {
+  fn(a, b) { orderer(b, a) }
+}
diff --git a/test/gleam/order_test.gleam b/test/gleam/order_test.gleam
index 44a1e22..e9929d3 100644
--- a/test/gleam/order_test.gleam
+++ b/test/gleam/order_test.gleam
@@ -1,14 +1,16 @@
+import gleam/int
+import gleam/list
 import gleam/order.{Eq, Gt, Lt}
 import gleam/should
 
-pub fn reverse_test() {
-  order.reverse(Lt)
+pub fn negate_test() {
+  order.negate(Lt)
   |> should.equal(Gt)
 
-  order.reverse(Eq)
+  order.negate(Eq)
   |> should.equal(Eq)
 
-  order.reverse(Gt)
+  order.negate(Gt)
   |> should.equal(Lt)
 }
 
@@ -109,3 +111,9 @@ pub fn min_test() {
   order.min(Gt, Gt)
   |> should.equal(Gt)
 }
+
+pub fn reverse_test() {
+  [4, 5, 1]
+  |> list.sort(by: order.reverse(int.compare))
+  |> should.equal([5, 4, 1])
+}