dear applicative geniuses --
thanks for all the help. some comments :
1) the fromList / unzip versions are nice but as others have pointed
out, construction is more expensive than traversal (or traversal w/
copying, like Data.Map.map.) hopefully the maintainers of Data.Map et
al will consider adding one-traversal unzip functions.
2) i too would love John Meacham's unionWithJoin function. i might
call that "outerJoin" myself. there was discussion about this at some
point in time on the libraries list, i'm not sure what happened to it.
3) wren, thanks for the (applicative) pointer. when i tried to
interrogate hoogle it pointed me there too -- though i had to boil
down my question several times. i think it went something like this
Map a (b -> c) -> Map a b -> Map a c
--> no answer
m a (b -> c) -> m a b -> m a c
--> no answer
m (b -> c) -> m b -> m c
--> <*> and a million other hits
at which point i'd practically answered the question myself. this is
not a knock on hoogle -- i often have this experience, it seems to
lead me in the right direction Socratically.
4) ross, i had to ask ghci to even believe your code type-checks! i
didn't realize currying worked that way -- i've never thought to pass
in functions of different arities. as an experiment, i tried
Prelude Data.Map> :t intersectionWith 1
intersectionWith 1
:: (Num (a -> b -> c), Ord k) => Map k a -> Map k b -> Map k c
Prelude Data.Map> :t intersectionWith (const 1)
intersectionWith (const 1)
:: (Num (b -> c), Ord k) => Map k a -> Map k b -> Map k c
Prelude Data.Map> :t intersectionWith id
intersectionWith id
:: (Ord k) => Map k (b -> c) -> Map k b -> Map k c
Prelude Data.Map> :t intersectionWith (\a b c -> c)
intersectionWith (\a b c -> c)
:: (Ord k) => Map k a -> Map k b -> Map k (t -> t)
all of which make sense to me now, but still honestly blow my mind!
best regards, b
ps actually the first two don't make much sense to me, when i think
about it.....
On Fri, Jul 30, 2010 at 8:13 PM, Ben
dear traversable geniuses --
i am looking for "better" implementations of
unzipMap :: M.Map a (b, c) -> (M.Map a b, M.Map a c) unzipMap m = (M.map fst m, M.map snd m)
unliftMap :: (Ord a) => M.Map a (b -> c) -> M.Map a b -> M.Map a c unliftMap mf ma = M.mapWithKey (\k v -> mf M.! k $ v) ma
the first is obviously inefficient as it traverses the map twice. the second just seems like it is some kind of fmap.
any ideas?
ben