Question

I am trying to build a smallish haskell app that will translate a few key phrases from english to french.

First, i have a list of ordered pairs of strings that represent and english word/phrase followed by the french translations:

icards = [("the", "le"),("savage", "violent"),("work", "travail"),
("wild", "sauvage"),("chance", "occasion"),("than a", "qu'un")...]

next i have a new data:

data Entry = Entry {wrd, def :: String, len :: Int, phr :: Bool}
deriving Show

then i use the icards to populate a list of Entrys:

entries :: [Entry]
entries = map (\(x, y) -> Entry x y (length x) (' ' `elem` x)) icards

for simplicity, i create a new type that will be [Entry] called Run.

Now, i want to create a hash table based on the number of characters in the english word. This will be used later to speed up searchings. So i want to create a function called runs:

runs :: [Run]
runs = --This will run through the entries and return a new [Entry] that has all of the
         words of the same length grouped together.

I also have:

maxl = maximum [len e | e <- entries]

Answer 1

groupBy and sortBy are both in Data.List.

import Data.List
import Data.Function -- for `on`
runs :: [Run]
runs = f 0 $ groupBy ((==) `on` len) $ sortBy (compare `on` len) entries
  where f _                              []           =      []
        f i (r @ (Entry {len = l} : _) : rs) | i == l = r  : f (i + 1) rs
        f i                              rs           = [] : f (i + 1) rs

Personally, I would use a Map instead

import qualified Data.Map as M
runs :: M.Map String Entry
runs = M.fromList $ map (\entry -> (wrd entry, entry)) entries

and lookup directly by English word instead of a two step length-of-English-word and then English-word process.