[Haskell-cafe] A small oversight

[Andrew Coppin]

I just discovered the highly useful function Data.Function.on. I vaguely 
recall a few people muttering a couple of years back that this would be 
a useful thing to have, but I had no idea it was in the standard 
libraries now.

Anyway, while using it, I discovered a small omission from the Haskell 
libraries: We have min, max, minimum and maximum. We also have minimumBy 
and maximumBy. But there's no sign of minBy or maxBy. You can do, for 
example,

  (min `on` postcode) customer1 customer2

but that gives you the lowest postcode, not the customer to which this 
postcode belongs. By contrast,

  minimumBy (compare `on` postcode) [customer1, customer2]

gives you the corresponding customer. But it seems silly to have to 
actually construct a list just for this. So... is there any danger of 
getting minBy and maxBy added? (I don't actually know off the top of my 
head where min and max are defined - the Prelude?)



Also, constructions like

  sortBy (compare `on` foo)

must surely be very common. Perhaps it would be an idea to define a 
family of functions like

  sortOn :: (Ord y) => (x -> y) -> [x] -> [x]
  sortOn foo = sortBy (compare `on` foo)

Just an idea.



Finally, take a look at this:

  newtype SwapOrd x = SwapOrd (unswap_ord :: x) deriving Eq

  instance Ord x => Ord (SwapOrd x) where
    compare x y = swap_ord $ compare x y

  swap_ord :: Ordering -> Ordering
  swap_ord o = case o of
    EQ -> EQ
    GT -> LT
    LT -> GT

Just in case you wanted to sort things in reverse order. I think having 
swap_ord would be nice if nothing else...