order.reverse (#476)

Author: aslilac

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.
 

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) }
+}

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])
+}