Add a way to combine comparison functions

[mlms13]

Relude_Ord defines a type for comparison functions type compare('a) = ('a, 'a) => ordering

In that module we already define a by function (and alias it as cmap) which is the essence of being a contravariant functor. What we don't have is an append (or combine) function, which is the essence of being a Semigroup.

But we could, and it would make defining complex compare functions much simpler.

For example, imagine you have a user record that defines first and last name fields, and you want to order these user records by last name, then if last names are equal, by first name.

type t = {
  firstName: string,
  lastName: string,
};

let compare = (a, b) => {
  let byLastName = Ord.by(user => user.lastName, String.compare);
  let byFirstName = Ord.by(user => user.firstName, String.compare);
  Ord.combine(byLastName, byFirstName, a, b);
};

Or, more tersely:

let compare =
  Ord.combine(
    Ord.by(user => user.lastName, String.compare),
    Ord.by(user => user.firstName, String.compare)
  );

[andywhite37]

That's a good idea! It kind of sparked a memory where I recalled doing something like that, so I just went looking. There is indeed no semigroup defined for Ord or OrdExtensions. I found a test where I used the Ord.by function to return a tuple of values and then used a Tuple compare function to simulate what you are saying. The Semigroup would be more straightforward than this.

https://github.com/reazen/relude/blob/main/__tests__/extensions/Relude_Extensions_Ord_test.re#L59-L82

I think sometime after all this, I ran across an article or example talking about Semigroup for Ord (same as what you are saying), and I thought it was neat at the time, but I guess I never went back and added that.

[mlms13]

Oh nice, cool to see you made an example that was heading in that direction!

For other prior art...

• I remember fp-ts has a getMonoid function for Ord, which is where I think I first encountered this idea
• If you believe ChatGPT, in Haskell, Ordering implements Semigroup and comparing is the by or contramap equivalent, so you can do this:

import Data.Ord (comparing)
import Data.Semigroup ((<>))

data User = User
  { firstName :: String
  , lastName  :: String
  } deriving (Show)

compareUser :: User -> User -> Ordering
compareUser = comparing lastName <> comparing firstName

Obviously we won't end up with something quite that elegant in Reason, but the idea seems solid and established.

[andywhite37]

Oh yeah, it was fp-ts where I saw the Semigroup for Ord concept.