Question

Suppose I have an enum like

data T = A | B | C deriving (Enum)

and a list of enum values as input:

[B, C, C, A, C, A, C]

What I’m looking for is a function that, given this input, returns how often each element occurs in the input. A simple form for the output would be a list of the frequencies ([2, 1, 4] in this case), but this is not a requirement. My current approach looks like this:

countEnum :: Enum a => [a] -> [a] -> [Word]

countEnum elems =
  let f x = map (fromIntegral . fromEnum . (fromEnum x ==)) [0 .. length elems - 1]
  in foldr (zipWith (+)) (replicate (length elems) 0) . map f

This works, but I see at least two issues:

1. It uses the length function.
2. It requires that the caller specifies all possible values in the first argument.

Is there a way to improve this?

Answer 1

Usually a bit faster than sorting a list is using a Map,

enumFreq :: Enum a => [a] -> Map Int Word
enumFreq = foldl' (\mp e -> Map.insertWith' (+) (fromEnum e) 1 mp) Map.empty

and you can get

• the frequencies only per Map.elems $ enumFreq list
• the pairs (value,frequency) per [(toEnum i, f) | (i,f) <- Map.assocs $ enumFreq list]

If your type is itself in Ord, you can skip the fromEnum and toEnum.

If you have Ix and Bounded instances and the type doesn’t have too many elements,

import Data.Array.Unboxed

enumFreq :: (Ix a, Bounded a) => [a] -> UArray a Word
enumFreq = accumArray (+) 0 (minBound,maxBound) . (`zip` repeat 1)

has better asymptotic behaviour, uses less memory and is faster already for fairly short lists. (But that depends on a high proportion of the type’s elements being present in the list.)