fromListWithDefault

[maxigit]

I often use Map to group list by a key. The result is of type Map k [a]. There is at the moment no easy way to build such Map even though this use case seems frequent. I have to use fromwith (++) but this means I have to wrap the value in a list instead of being able to just cons them (using :).

Given a list of tuple key-value, the code I'm using is Map.fromLift (++) [(k, [x]) | <- kxs ] but I think it
will better to be able to do something like Map.newFunction ([]) (:) kxs or equivalent. I know such a function is really to write using the existing functions. However, all solution involve having to wrap the value unnecessarily in a list.
The different options I can envisage would be

Ord k => b -> (a -> b -> b) -> [(k, a)] -> Map k b
Ord k => b -> (b -> a -> b) > [(k, a)] -> Map k b
Ord k => (a -> b) -> (b -> a -> b) -> [(k, a)] -> Map k b

Or alternatively, just regroup each value in a list and let user to fold them .

Ord k => [(k, a)] -> Map k [a]
Ord k => (a -> k) -> [a] -> Map k [a]

I hope the signature is enough to describe what each function does.
I'm happy to send PR if people things is a good idea and function names are welcome !

[treeowl]

Ah, now I understand the (a -> b) function. You're using that because you surely have at least one element if you're folding. I'm leaning toward foldl'Duplicates :: (b -> a -> b) -> (a -> b) -> [(k, a)] -> Map k b foldrDuplicates :: (a -> b -> b) -> (a -> b) -> [(k, a)] -> Map k b but these are also a bit ugly. Another option is foldMapDuplicatesLeftStrict:: Semigroup s => (a -> s) -> [(k, a)] -> Map k s foldMapDuplicatesRightStrict :: Semigroup s => (a -> s) -> [(k, a)] -> Map k s but I can't seem to find good names for those.

…

On Mon, Jan 30, 2017 at 5:20 PM, Max ***@***.***> wrote: I often use Map to group list by a key. The result is of type Map k [a]. There is at the moment no easy way to build such Map even though this use case seems frequent. I have to use fromwith (++) but this means I have to wrap the value in a list instead of being able to just cons them (using : ). Given a list of tuple key-value, the code I'm using is Map.fromLift (++) [(k, [x]) | <- kxs ] but I think it will better to be able to do something like Map.newFunction ([]) (:) kxs or equivalent. I know such a function is really to write using the existing functions. However, all solution involve having to wrap the value unnecessarily in a list. The different options I can envisage would be Ord k => b -> (a -> b -> b) -> [(k, a)] -> Map k b Ord k => b -> (b -> a -> b) > [(k, a)] -> Map k b Ord k => (a -> b) -> (b -> a -> b) -> [(k, a)] -> Map k b Or alternatively, just regroup each value in a list and let user to fold them . Ord k => [(k, a)] -> Map k [a] Ord k => (a -> k) -> [a] -> Map k [a] I hope the signature is enough to describe what each function does. I'm happy to send PR if people things is a good idea and function names are welcome ! — You are receiving this because you are subscribed to this thread. Reply to this email directly, view it on GitHub <#386>, or mute the thread <https://github.com/notifications/unsubscribe-auth/ABzi_e3ufBOVyNDQxRNhkbDaGIf0iLJyks5rXmIsgaJpZM4Lx_ig> .

[maxigit]

About, the name, as it constructing a Map from a list, I think it should belongs to the fromList* family.
I thought initially of fromListWithDefault because we are just adding a default value to fromListWith.
In fact, we are mapping at the same time, so maybe fromListWithMap or something ...

[sjakobi]

Related: #333, haskell-unordered-containers/unordered-containers#264

[meooow25]

I agree that the fromwith (++) situation is not ideal.

fromListWith :: Ord k => (a -> a -> a) -> [(k, a)] -> Map k a

fromListWith only lets us perform foldl1 on the values that share a key.

Ord k => (a -> b) -> (b -> a -> b) -> [(k, a)] -> Map k b

This proposed type is more useful, it performs a foldlMap1. This is also equivalent to performing an upsert (#809) for each key-value, and (a -> b) -> (b -> a -> b) -> ... is equivalent to (a -> Maybe b -> b) -> .... It seems reasonable to have this function, with a decent name. fromListWithUpsert doesn't seem terrible...

fromListWithUpsert :: Ord k => (a -> Maybe b -> b) -> [(k, a)] -> Map k b

group :: Ord k => [(k, a)] -> Map k [a]
group = fromListWithUpsert (\x -> maybe [x] (x:))

foldl'Duplicates :: (b -> a -> b) -> (a -> b) -> [(k, a)] -> Map k b

Since we have upsert now, it feels more consistent to stick to that name and style rather than the Foldable1 name and style.

We can go further too. With an alter version, (a -> Maybe b -> Maybe b), we can even delete an entry. Though I'm not sure if this is useful in practice.

[maxigit]

8 years later, I'm still using Haskell , still encountering the same problem and haven't found a nice solution, mainly because it is easy to shoot yourself in the foot when trying to do so (The Semigroup instance of Map just discard things without warning).

For example, a failed attempt using foldMap in ghci

 > let xs = [("A", 1) , ("A", 5), ("B", 2), ("A", 2)]
> foldMap (fmap (:[]) . uncurry Data.Map.singleton ) xs
fromList [("A",[1]),("B",[2])]

It compiles (but fail to group).

I think using a -> Maybe b -> b (ala upsert) is great.
I didn't find the name obvious initially but it make sense when you think about it, so I am all for fromListWithUpsert.

I don't see any obvious use case for an alter version, things can easily be deleted later if necessary. The more important things is to be able to group things without shouting oneself in the foot (as per my example above).

[meooow25]

Yes the Semigroup behavior is also a known issue, #539.

fromListWithUpsert doesn't seem terrible...

I realized a bit later that we need a with-key version too, and fromListWithUpsertWithKey is terrible. Maybe fromListUpsert and fromListUpsertWithKey? Or fromListUpserting and fromListUpsertingWithKey? Wish I could think of something better.

[maxigit]

fromlistWithUpsert is good enough.
I'm not sure the withKey version is necessary. When you build from a list you already have the list (with the keys) so it is easy to process the list beforehand (or the map afterward.