# Key-value apply

## 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.

## The solution: `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