Ich muss in Scala oft eine "rechteckige" Sammlung von Sammlungen transponieren, zB: eine Liste von Karten, eine Karte von Listen, eine Karte von Karten, eine Reihe von Listen, eine Karte von Gruppen usw. Da Sammlungen einheitlich sein können Wird als Zuordnung von einer bestimmten Domäne zu einer Co-Domäne betrachtet (z. B .: Eine Liste [A] / Array [A] ist eine Zuordnung von der Int-Domäne zur A-Co-Domäne, Set [A] ist eine Zuordnung von der A domain to the Boolean co-domain etc.), möchte ich eine saubere, generische Funktion schreiben, um eine Transponierungsoperation durchzuführen (z. B .: eine Karte von Listen in die transponierte Liste von Karten umwandeln). Ich habe jedoch Probleme, weil Scala außer dem Operator () keine einheitliche API zu haben scheint, um Sammlungen abstrakt als Zuordnungen anzuzeigen.

So schreibe ich am Ende eine separate Transponierung für jede Art von Collection-of-Collections wie folgt:

def transposeMapOfLists[A,B]( mapOfLists: Map[A,List[B]] ) : List[Map[A,B]] = {
  val k = ( mapOfLists keys ) toList
  val l = ( k map { mapOfLists(_) } ) transpose;
  l map {  v => ( k zip v ) toMap }
}

def transposeListOfMaps[A,B]( listOfMaps: List[Map[A,B]]) : Map[A,List[B]] = {
  val k = ( listOfMaps(0) keys ) toList
  val l = ( listOfMaps map { m => k map { m(_) } } ) transpose;
  ( k zip l ) toMap
}

def transposeMapOfMaps[A,B,C]( mapOfMaps: Map[A,Map[B,C]] ) : Map[B,Map[A,C]] = {
  val k = ( mapOfMaps keys ) toList
  val listOfMaps = k map { mapOfMaps(_) }
  val mapOfLists = transposeListOfMaps( listOfMaps )
  mapOfLists map { p => ( p._1, ( k zip p._2 ) toMap ) }
}

Kann mir jemand helfen, diese Methoden in einer generischen Sammlung von Sammlungen umzusetzen? Es wird mir (und sicher auch anderen) dabei helfen, einige nützliche Scala-Funktionen zu erlernen.

ps: Ich habe die Ausnahmebehandlung ignoriert und angenommen, dass die Eingabesammlung von Sammlungen rechteckig ist, d. h. dass alle Domänenelemente der inneren Sammlungen dieselbe Menge bilden.