1

groupByと呼んでいるペアのリストがあります。ただし、groupByは値にペアの両方の部分を含め、「グループ化」されていないペアの部分のみを含めたいと思います。

List(1->2, 1->3, 2->3) groupBy (_._1)

scala.collection.immutable.Map [Int、List [（Int、Int）]] = Map（1-> List（（1,2）、（1,3））、2-> List（（2,3） ））

Mapエントリにマップし、重複キーを削除するメソッドを作成しました。

def removeDupeKeyFromPair[A, B](m: Map[A, List[Pair[A, B]]]): Map[A, List[B]] =
  m map { case(k, vlist) => k -> { vlist map { case(dupe, b) => b } } }

List[Pair[A,B]]しかし、これをどこからC[Pair[A,B]]どこまで一般化したいC<:Iterableので、やってみました

def removeDupeKeyFromPair[A, B, C[Pair[A, B]] <: Iterable[Pair[A, B]]]
                         (m: Map[A, C[Pair[A, B]]]): Map[A, C[B]]

しかし、これは

エラー：Bはタイプパラメータを取りません、予想されます：2

これらのタイプを正しく表現するにはどうすればよいですか？

編集： これは私にとっての学習演習であるため、別の解決策を見つけるよりも、特定のタイプを適切に表現する方法に興味があります。他の解決策について学ぶことも素晴らしいですが。

4

3 に答える 3

3

値を変更したいだけの場合はMap、次を使用できますmapValues。

scala> List(1->2, 1->3, 2->3) groupBy (_._1) mapValues (_.map(_._2))
res2: scala.collection.immutable.Map[Int,List[Int]] = Map(2 -> List(3), 1 -> List(2, 3))

または、もう少し読みやすい方法で：

scala> List(1->2, 1->3, 2->3) groupBy (_._1) mapValues (lst => lst.map { case(_ ,b) => b })
res3: scala.collection.immutable.Map[Int,List[Int]] = Map(2 -> List(3), 1 -> List(2, 3))
于 2013-02-13T16:57:52.410 に答える
1

使用する意味は何C<:Iterableですか？

定義する場合：

def removeDupeKeyFromPair[A,B](m: Map[A, Iterable[(A,B)]]) : Map[A, Iterable[B]]=
      m map { case(k, vlist) => k -> { vlist map { case(dupe, b) => b } } }

リストでそのメソッドを呼び出すと、が返されMap[A, List[B]]ます。これはBuilder、scalaコレクションのメカニズムによるものです。

于 2013-02-13T18:05:05.067 に答える
1

これらのようなものをより一般的にするために、特殊な型クラスを使用することができます。mapおよびのようなメソッドに使用されるものflatMapはFilterMonadicです。

FilterMonadicを使用するようにマップメソッドを指定しますCanBuildFrom。ほとんどの組み込みコレクションクラスには、利用可能なものの1つがあります。その後、次のように使用できます。

def removeDupeKeyFromPair[A, B, 
  // Define a type C that has type arguments and extends FilterMonadic
  C[X] <: FilterMonadic[X, C[X]], 
  // Define the type that will be returned (provided by the implicit CanBuildFrom)
  That](
    // Use C instead of List    
    m: Map[A, C[(A, B)]])(
      // Define the CanBuildFrom that is required by the map method
      implicit bf:CanBuildFrom[C[(A, B)], B, That]): Map[A, That] =

        // actual logic
        m.map { case (k, vlist) =>
          k -> vlist.map { case (dupe, b) => b }
        }

編集

(A, B)代わりに表記を使用したことに注意してくださいPair[A, B]

于 2013-02-13T19:32:32.920 に答える