如何使用Monoid Scala？

Question

trait Monoid[A] {
  def op(a1: A, a2: A): A

  def zero: A
}

def mapMergeMonoid[K, V](V: Monoid[V]): Monoid[Map[K, V]] = new Monoid[Map[K, V]] {
    override def op(a1: Map[K, V], a2: Map[K, V]): Map[K, V] =
      (a1.keySet ++ a2.keySet).foldLeft(zero) {
        (acc, k) => acc.updated(k, V.op(a1.getOrElse(k, V.zero), a2.getOrElse(k, V.zero)))
      }

    override def zero: Map[K, V] = Map[K, V]()
  }

据我了解，我可以用这个 Monoid 连接 2 个地图。但我不明白，如何使用它。我必须在 (V: Monoid[V]) 参数中加入什么才能在之后使用 op 方法并在其中放置 2 个地图。

Answer 1

假设我们要合并两个 Map[Int, String]

类型的地图

val a1: Map[Int, String] = Map(1 -> "Picard")
val a2: Map[Int, String] = Map(1 -> "Worf", 2 -> "Data")

然后 V 变成 String 这意味着我们需要提供 Monoid[String] 实例以指定 V 将如何组合

val stringMonoid: Monoid[String] = new Monoid[String] {
  override def op(a1: String, a2: String) = a1 + a2
  override def zero = ""
}

把它放在一起我们有

mapMergeMonoid(stringMonoid).op(a1, a2)

输出

res0: Map[Int,String] = Map(1 -> PicardWorf, 2 -> Data)

概念上，monoid provides a way of combining values, so when defining how to combine maps of type Map[K, V] it makes sense we would need to also specify how the values V of the map combine themselves. Hence Monoid[V] is a 定义中的组成元素Monoid[Map[K, V]]：

Map[A, B] is a Monoid if B is a Monoid

Answer 2

Monoid 是一个 typeclass。因此，建议学习我们如何在 Scala 中对它们建模，它使用 implicits.
具体来说 Monoid[Map[K, V]] 的情况被称为 类型类派生 ，因为我们首先需要证明 V 有 [=41] =]一个Monoid，为了证明Map[K, V]也有一个，对所有Ks.

这是定义此类 typeclass 及其实例及其操作/语法的规范方法。

trait Monoid[A] { def op(a1: A, a2: A): A def zero: A } object Monoid { implicit final val IntMonoid: Monoid[Int] = new Monoid[Int] { override final def op(i1: Int, i2: Int): Int = i1 + i2 override final val zero: Int = 0 } implicit def mapMonoid[K, V](implicit vm: Monoid[V]): Monoid[Map[K, V]] = new Monoid[Map[K, V]] { override final def op(m1: Map[K, V], m2: Map[K, V]): Map[K, V] = (m1.keySet | m2.keySet).foldLeft(this.zero) { case (acc, key) => acc + (key -> vm.op( m1.getOrElse(key, default = vm.zero), m2.getOrElse(key, default = vm.zero) )) } override final val zero: Map[K, V] = Map.empty } } object syntax { object monoid { implicit class MonoidOps[A] (private val a1: A) { def |+| (a2: A)(implicit M: Monoid[A]): A = M.op(a1, a2) } } }

然后你可以像这样使用：

import syntax.monoid._ // Provides the |+| operator. Map('a' -> 1, 'b' -> 2) |+| Map('b' -> 3, 'c' -> 5) // res: scala.collection.immutable.Map[Char,Int] = Map(a -> 1, b -> 5, c -> 5)

最后，值得一提的是，虽然我相信第一次手工完成这些事情对于真正了解它们的工作原理非常有用。鼓励使用提供这些抽象的稳定且可用于生产的库，例如 Cats.

scalafiddle

如何使用Monoid Scala？

How to use Monoid Scala?

functional-programming

scala

scalaz

monoids

scala-cats