View source for Key-value apply

==The problem / code ==
Consider the function:

<haskell>
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)
</haskell>

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 <hask>apply</hask> several times and you will end up with a sorted list.  <hask>apply</hask> uses the fact that the list is sorted to cut the search short in the 'I can't find it' case - hence the <hask>Ord</hask> context.

However, Haskell already provides this and much more functionality.

== The solution: <hask>Data.Map</hask> ==

When you are making excessive use of (key,value) pairs it is usually time to switch to <hask>Data.Map</hask>. The <hask>apply</hask> function is almost the same as <hask>Data.Map.insertWith</hask>, only that function has the type:
<haskell>
insertWith :: Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
</haskell>
Here the update function receives the new value as well.



[[Category:How to]] 
[[Category:Code]]