(Difference between revisions)
(Why we did this.)
(Clean up to make more like a how-to, move context to talk page)
Latest revision as of 18:36, 16 February 2007
 1 The problem / code
Consider the function:
apply :: (Ord k) => k -> v -> (v -> v) -> [(k,v)] -> [(k,v)] apply k v f ds = let (p1,px) = span ( (k >) . fst) ds (p2,p3) = case px of  -> ((k,v),) (x:xs) -> if fst x == k then ((k, f $ snd x), xs) else ((k, v), x:xs) in p1 ++ (p2 : p3)
This takes a list of key/value pairs and processes it as follows:
- The function is given a key to look for.
- If the key is found, a function is applied to the associated value.
- If the key is not found, it is inserted (at the correct place) with a specified 'default value'.
several times and you will end up with a sorted list.
uses the fact that the list is sorted to cut the search short in the 'I can't find it' case - hence the
However, Haskell already provides this and much more functionality.
 2 The solution: Data.Map
When you are making excessive use of (key,value) pairs it is usually time to switch to
function is almost the same as
, only that function has the type:
insertWith :: Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Here the update function receives the new value as well.