1

给定 a Map[Int, Set[Int]]，我如何修改 Map 的单个值，在此过程中生成一个新值，例如：

val x = Map(1 -> Set(1,2,3))
x(1) + 5 // This creates a new Set, but not a new Map

val y = x(1) change { x => x + 5 }
// The previous functionality is what I'm looking for
// z: Set[Int]] = List(Set(1, 2, 3, 5))
4

7 回答 7

5

正如 Robin Green 所说，镜头是为这项工作而制造的。事实上，您需要一个局部镜头，因为地图是键 -> 值的局部函数。

Scalaz 7 包含将mapVPLens部分镜头 ( PLens) 设置为所选键处的值的功能：

import scalaz.PLens._
val x = Map(1 -> Set(1,2,3))

mapVPLens(1) mod ((_: Set[Int]) + 5, x) // Map(1 -> Set(1, 2, 3, 5))

修改不存在键的值将无效：

mapVPLens(9) mod ((_: Set[Int]) + 5, x) // Map(1 -> Set(1,2,3))
于 2013-01-21T22:21:40.543 回答
4

在 Scala 2.10 中：

implicit class ChangeableMap[K,V]( val m: Map[K,V] ) extends AnyVal {
  def change( k: K )( transform: V => V ): Map[K,V] = {
    m.get( k ).map{ v => m + (k-> transform(v)) }.getOrElse( m )
  }
}

一些测试：

scala>val x = Map(1 -> Set(1,2,3), 2 -> Set(4,5))
x: scala.collection.immutable.Map[Int,scala.collection.immutable.Set[Int]] = Map(1 -> Set(1, 2, 3), 2 -> Set(4, 5))
scala> x.change(1) { x => x + 5 }
res1: Map[Int,scala.collection.immutable.Set[Int]] = Map(1 -> Set(1, 2, 3, 5), 2 -> Set(4, 5))

如果您使用的是 scala 2.9，则可以：

class ChangeableMap[K,V]( m: Map[K,V] ) {
  def change( k: K )( transform: V => V ): Map[K,V] = {
    m.get( k ).map{ v => m + (k-> transform(v)) }.getOrElse( m )
  }
}
implicit def toChangeableMap[K,V]( m: Map[K,V] ) = new ChangeableMap[K,V]( m )
于 2013-01-21T22:02:11.943 回答
3

使用镜头！

但是，定义镜头的 Scalaz 6 没有针对您的情况的特定预制镜头，这意味着您需要做更多的工作 - 尽管如果您的地图反过来包含在另一个对象中，它确实有（隐藏得很好) 支持这种情况。Scalaz 7 将配备独立地图的镜头。

此外，镜头只是成对的功能，不需要语言支持，因此您可以自己滚动。

于 2013-01-21T21:19:44.667 回答
1

解决此问题的一种非常惯用的方法如下（感谢Viktor Klang）：

val x = Map(1 -> Set(1,2,3), 2 -> Set(1), 3 -> Set(5))
x.map { case (1, v) => (1, v + 5); case x => x }
// res0: Map(1 -> Set(1, 2, 3, 5))

或者很好地打包成一个类以及一个隐式：

class ChangeableMap[K,V](map:Map[K,V]) {
    def change(index:K)(f:V => V) = map.map {
        case (`index`, v:V) => (index, f(v))
        case x => x
    }
}

object ChangeableMap {
    implicit def fromMap[K,V](map:Map[K,V]) = new ChangeableMap(map)
}

使用先前的声明，以下将起作用：

x.change(1) { x => x + 5 }
x.change(1) { _ + 5 }
// res1:  Map(1 -> Set(1, 2, 3, 5))

请注意，这可能不是最快的解决方案，因为 Scala 将（可能尚未确认）迭代整个地图！

一个可能更快的实现如下（尽管我还没有验证它是否真的更快）：

class ChangeableMap[K,V](map:Map[K,V]) {
    def change(index:K)(f:V => V) = map.get(index) match {
        case Some(x) => map + ((index, f(x)))
        case None => map
    }
}
于 2013-01-21T21:08:25.450 回答
1

这是我们代码库中的一个。

/**
 * Alters a value in a map.
 *
 * modifyMap :: Map k v -> k -> (Maybe v -> Maybe v) -> Map k v
 * See Haskell's Data.Map.alter
 *
 * @param m   the map to modify
 * @param key the key to modify the value of
 * @param mod a function that takes the existing value (if any) and returns an optional new value
 *
 * @return the modified map
 */
def modifyMap[K,V](m: Map[K,V], key: K)
                  (mod: (Option[V] ⇒ Option[V])): Map[K,V] = {
  mod(m.get(key)) match {
    case Some(newVal) ⇒ m + (key → newVal)
    case None ⇒ m - key
  }
}

以下是你如何使用它：

modifyMap(myMap, "someKey") { 
  case Some(someVal) => 
    // present
    if (condition) 
      Some(valueDerivedFrom(someVal)) // provide a new mapping for someKey
    else 
      None // someKey will now be unset
  case None => 
    // wasn't present
    if (condition)
      Some(newValue) // provide a new value for someKey
    else
      None // leave someKey unset
}
于 2013-01-21T21:14:35.500 回答
1

我认为最简单的方法是使用scala.collection.mutable.Map.

import scala.collection.mutable.Map

val m = Map(1 -> Set(1,2,3))
m.update(1, m(1) + 5)
// now the Map looks like this: Map(1 -> Set(1,2,3,5))

如果你得到一个不可变的 Map，你可以简单地将它转换为一个可变的，方法是：

val n: collection.mutale.Map(m.toSeq: _*)

如果您需要返回不可变的 Map，这也适用于其他方式。

于 2013-01-22T09:20:45.883 回答
0

如前所述，您可以使用 Partial Lens 来解决此类问题，scalaz和Monocle实现了它。以下是使用 Monocle 的方法：

import monocle.syntax.taversal._ // to use |->>
import monocle.syntax.at._       // to use at

val x = Map(1 -> Set(1,2,3))

x |->> at(1) modify(_ + 5) == Map(1 -> Set(1,2,3,5))
于 2014-05-12T11:01:40.077 回答