Add unsafe functions for converting between Set and Map

[josephcsible]

In #814, @treeowl asked for functions like these:

unsafeToSet :: (k -> a -> b) -> Map k a -> Set b
unsafeToMap :: (b -> (k, a)) -> Set b -> Map k a

And also ones that live in an Applicative, which I assume means ones like these:

unsafeToSetA :: Applicative t => (k -> a -> t b) -> Map k a -> t (Set b)
unsafeToMapA :: Applicative t => (b -> t (k, a)) -> Set b -> t (Map k a)

Note the lack of Ord constraints: these functions are unsafe in that it's the user's responsibility to make sure the k and b values agree on their ordering, just as it is for mapMonotonic. I think those are reasonable functions to add, but a little bit out of scope of that issue, hence this one.

[alexfmpe]

Maybe we could instead have 'smaller' building blocks?

toSet :: Map k a -> Set (Arg k a)
toMap :: Set (Arg k a) -> Map k a

that can then be composed with other ones to generate all the variants?

unsafeToSet :: (k -> a -> b) -> Map k a -> Set b
unsafeToSet f = Set.mapMonotonic (\(Arg k a) -> f k a) . toSet
unsafeToMap :: (b -> (k, a)) -> Set b -> Map k a
unsafeToMap f = toMap . Set.mapMonotonic (uncurry Arg . f)

This isomorphism might also be useful elsewhere actually

[josephcsible]

@alexfmpe Hah, see #817 and #814 (comment)

[alexfmpe]

Oh nevermind, you already stated all that in #814 (comment) .

I thought containers avoided functions that were easily derivable from already exposed ones (unless a specialized version was more efficient) to keep the API small?

[meooow25]

Is there a use for these functions? I'm wary of adding new unsafe functions unless there is good reason for it.

[josephcsible]

I'll defer that to @treeowl since these were his idea to add.

[meooow25]

@treeowl do you think these would be useful?