I want to use Data.List.groupBy to group a list of tuples based on the equality of the snd
element.
I could do this:
groupBy (\l r -> snd l == snd r) listOfTuples
But it strikes me as too much boilerplate in the comparison function -- especially because it could get a lot more messy if I were doing a more complicated comparison. I would like to do something like:
groupBy (comparing snd) listOfTuples
but the type signature of comparing is comparing :: (Ord a) => (b -> a) -> b -> b -> Ordering
, so it doesn't compile in this example.
I could also do:
groupBy (\l r -> (comparing snd l r) == EQ) listOfTuples
But this is no better than the first try. Is there a standard-library solution to this problem, before I roll-my-own?
rio 's tag line is "a standard library for Haskell." The idea is that the actual standard library for Haskell—the base package—leaves much to be desired. Very few real world applications use only base . There is a common set of functionality that is used by a large majority of applications.
Immutability and purity. Most programming languages out there default to mutability: a variable or field in a data structure can be changed at any time. Haskell is different in two ways: Values are immutable by default, and mutability must be explicitly indicated with a variable type.
groupBy ((==) `on` snd) listOfTuples
I think there used to be equating = on (==)
in the standard libraries, though I can't seem to find it now.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With