Get rid of Option [T] when get values from Map[T, T] - scala

Question

I am writing my own Semigroup for Map [T, T]. The logic of the function is as follows:
in case of the same key the values should be combined in the result map.
in case of different keys the values should be added to the result map.
I wrote this function, but I ran into a problem: the get(key) method returns not just T, but Option[T].
What are the ways to solve this problem?
trait Semigroup[T]:
extension (left: T) def combine(right: T): T
given Semigroup[Int] with
extension (left: Int) def combine(right: Int): Int = ???
given Semigroup[String] with
extension (left: String) def combine(right: String): String = ???
given [T]: Semigroup[List[T]] with
extension (left: List[T]) def combine(right: List[T]): List[T] = ???
given [T: Semigroup]: Semigroup[Map[String, T]] with
extension (left: Map[String, T])
def combine(right: Map[String, T]): Map[String, T] = {
(left.keySet ++ right.keySet) map { key => key -> (summon[Semigroup[T]].combine(left.get(key)) { right.get(key)} ) } toMap
}

Answer 1

You do not want to remove the Option, it is what will tell you if you need to combine the values because the key is present in both Maps; or otherwise, just preserve the value.
(left.keySet | right.keySet).iterator.map { key =>
val value = (left.get(key), right.get(key)) match {
case (Some(v1), Some(v2)) => v1.combine(v2)
case (None, Some(v)) => v
case (Some(v), None) => v
case (None, None) => ??? // Should never happend.
}
key -> value
}.toMap
See the code running here.

Answer 2

Option is a good thing :) It protects you from crashing when key is not in a map.
(left.keySet ++ right.keySet)
.map { key => key -> (left.get(key), right.get(key)) }
.flatMap { case (k, (l, r) =>
l.zip(r)
.map { case (x,y) => summon[Semigroup[T]].combine(x)(y)))
.orElse(l)
.orElse(r)
.map(key -> _)
}.toMap
Or, maybe make a special semigroup for options (I am not sure about scala3 syntax, but something like this I think):
given [T : Semigroup]: Semigroup[Option[T]] with
extension (left: Option[T]) def combine(right: Option[T]): Option[T] =
left.zip(right).map { case(l,r) => summon[Semigroup[T]].combine(l)(r) }
.orElse(l)
.orElse(r)
Then you can just write
(left.keySet ++ right.keySet).map { key =>
key -> summon[Semigroup[Option[T]].combine(left.get(key))(right.get(key))
}

Answer 3

I just thought about a better option :) You should not have to deal with merging map keys explicitly ...
(left.toSeq ++ right.toSeq)
.groupMapReduce(_._1)(_._2)(summon[Semigroup[T]].combine(_)(_))
groupMapReduce fееls a little like black magic, but it's basically a combination of groupBy(_.Ь1), mapValues(_.map(_._2)) (dropping the key from grouped lists), and reduce(combine) (combining the grouped values in the the list.