Scala：具有可遍历值的Map的隐式证据？

Question

I'm trying to write a generic invert method that takes a Map from keys of type A to values that are collections of type B and converts it to a Map with keys of type B and collections of A using the same original collection type.

My goal is to make this method a member of a MyMap[A,B] class that offers extensions of the basic library methods, where Map s are implicitly converted to MyMap s. I am able to do this implicit conversion for a generic map, but I want to further specify that the invert method should only work in the case where B is a collection.

I lack the understanding of scala's collections framework to accomplish this - I've scoured the net for thorough introductory explanations of the signatures that look like a hodgepodge of Repr , CC , That , and CanBuildFrom , but I don't really understand how all these pieces fit together well enough to construct the method signature on my own. Please don't just give me the working signature for this case - I want to understand how the signatures of methods that use generic collections work in a broader sense so I'm able to do this independently going forward. Alternatively, feel free to reference an online resource that elaborates on this - I was unable to find one that was comprehensive and clear.

EDIT

I seem to have gotten it to work with the following code. If I did something wrong or you see something that can be improved, please comment & answer with a more optimal alternative.

class MyMap[A, B](val _map: Map[A, B]) {
  def invert[E, CC[E]](
    implicit ev1: B =:= CC[E],
    ev2: CC[E] <:< TraversableOnce[E],
    cbf: CanBuildFrom[CC[A], A, CC[A]]
  ): Map[E, CC[A]] = {
    val inverted = scala.collection.mutable.Map.empty[E, Builder[A, CC[A]]]
    for {
      (key, values) <- _map
      value <- values.asInstanceOf[CC[E]]
    } {
      if (!inverted.contains(value)) {
        inverted += (value -> cbf())
      }
      inverted.get(value).foreach(_ += key)
    }
    return inverted.map({ case (k,v) => (k -> v.result) }).toMap
  }
}

Answer 1

I started from your code and ended up with this:

implicit class MyMap[A, B, C[B] <: Traversable[B]](val _map: Map[A, C[B]]) {

  def invert(implicit cbf: CanBuildFrom[C[A], A, C[A]]): Map[B, C[A]] = {
    val inverted = scala.collection.mutable.Map.empty[B, Builder[A, C[A]]]
    for ((k, vs) <- _map; v <- vs) {
      inverted.getOrElseUpdate(v, cbf()) += k
    }

    inverted.map({ case (k, v) => (k -> v.result)}).toMap
  }
}

val map = Map("a"-> List(1,2,3), "b" -> List(1,2))

println(map.invert) //Map(2 -> List(a, b), 1 -> List(a, b), 3 -> List(a))