# Key-value apply

### From HaskellWiki

(Difference between revisions)

(Another day, another random function...) |
(Data.Map can be used) |
||

Line 22: | Line 22: | ||

Does a function like this already exist somewhere? (Hoogle seems to indicate not.) Is this a special case of something more general? Is there a better implementation? (The code isn't very readable at it is.) Can you think of a better name than just '<hask>apply</hask>'? Have you ever had call to use such a function yourself? |
Does a function like this already exist somewhere? (Hoogle seems to indicate not.) Is this a special case of something more general? Is there a better implementation? (The code isn't very readable at it is.) Can you think of a better name than just '<hask>apply</hask>'? Have you ever had call to use such a function yourself? |
||

+ | |||

+ | == Data.Map == |
||

+ | |||

+ | When you are making excessive use of (key,value) pairs it is usually time to switch to Data.Map. <hask>apply</hask> 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. |
||

+ | --[[User:Twanvl|Twanvl]] |
||

[[Category:Code]] |
[[Category:Code]] |

## Revision as of 18:25, 15 February 2007

I just wrote this 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)

As you can see (?!), 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'.

apply

apply

Ord

apply

## Data.Map

When you are making excessive use of (key,value) pairs it is usually time to switch to Data.Map.apply

Data.Map.insertWith

insertWith :: Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a

Here the update function receives the new value as well. --Twanvl