Key-value apply
Revision as of 18:36, 16 February 2007 by BrettGiles (talk | contribs) (Clean up to make more like a how-to, move context to talk page)
The printable version is no longer supported and may have rendering errors. Please update your browser bookmarks and please use the default browser print function instead.
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'.
Notice that if you start with a completely empty list, you can call apply
several times and you will end up with a sorted list. apply
uses the fact that the list is sorted to cut the search short in the 'I can't find it' case - hence the Ord
context.
However, Haskell already provides this and much more functionality.
The solution: Data.Map
Data.Map
When you are making excessive use of (key,value) pairs it is usually time to switch to Data.Map
. The apply
function is almost the same as Data.Map.insertWith
, 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.