Am Sonntag 23 August 2009 20:12:16 schrieb I. J. Kennedy:

Given a sort function that works on numbers, you can sort in reverse order by first negating the list, then sorting, then negating again:

Prelude Data.List> let revsort = (map negate) . sort . (map negate)

The function sort takes any list of Ord; negate works on any Num.

Prelude Data.List> :t negate negate :: (Num a) => a -> a Prelude Data.List> :t sort sort :: (Ord a) => [a] -> [a]

I'd therefore expect my revsort function to work on any type that is both an Ord and a Num. However:

Prelude Data.List> :t revsort revsort :: [Integer] -> [Integer]

I was expecting something like revsort :: (Ord a, Num a) => [a] -> [a] instead.

Question: Why did the GHCI's type inference mechanism jump to the conclusion that revsort should only work with Integer lists?

Because you defined it without an argument or type signature. By the monomorphism restriction ( http://www.haskell.org/haskellwiki/Monomorphism_Restriction ), such values must have a monomorphic type and by the defaulting rules, that is chosen as Integer. You can a) specify a type signature (good in source files) b) define it as a function binding let revsort xs = map negate . sort . map negate $ xs c) turn off the monomorphism restriction in ghci: Prelude> :set -XNoMonomorphismRestriction Prelude> :m +Data.List Prelude Data.List> let revsort = map negate . sort . map negate Prelude Data.List> :t revsort revsort :: (Num a, Ord a) => [a] -> [a] (might put :set -XNoMonomorphismRestriction in your .ghci file) btw, another way to revsort is let revsort = sortBy (flip compare)