Scala PartialFunction 可以是 Monoid 吗？

Question

我认为 PartialFunction 可以是 Monoid。我的思维过程正确吗？ 例如，

import scalaz._
import scala.{PartialFunction => -->}

implicit def partialFunctionSemigroup[A,B]:Semigroup[A-->B] = new Semigroup[A-->B]{
  def append(s1: A-->B, s2: => A-->B): A-->B = s1.orElse(s2)
}

implicit def partialFunctionZero[A,B]:Zero[A-->B] = new Zero[A-->B]{
  val zero = new (A-->B){
    def isDefinedAt(a:A) = false
    def apply(a:A) = sys.error("error")
  }
}

但当前版本 Scalaz(6.0.4) 不包括在内。没有包含某些内容是否有原因？

Answer 1

让我们从不同的角度来看待这一点。

PartialFunction[A, B] 与 A => 同构选项[B]。 （实际上，为了能够检查它是否是为给定的 A 定义的而不触发 B 的计算，您需要 A => LazyOption[B ])

因此，如果我们能找到一个 Monoid[A =>;选项[B]]我们已经证明了你的断言。

给定Monoid[Z]，我们可以形成Monoid[A => Z] 如下：

implicit def readerMonoid[Z: Monoid] = new Monoid[A => Z] {
   def zero = (a: A) => Monoid[Z].zero
   def append(f1: A => Z, f2: => A => Z) = (a: A) => Monoid[Z].append(f1(a), f2(a))
}

那么，如果我们使用 Option[B] 作为我们的 Z，我们会得到什么幺半群呢？ Scalaz 提供了三个。主实例需要一个 Semigroup[B]。

implicit def optionMonoid[B: Semigroup] = new Monoid[Option[B]] {
  def zero = None
  def append(o1: Option[B], o2: => Option[B]) = o1 match {
    case Some(b1) => o2 match {
       case Some(b2) => Some(Semigroup[B].append(b1, b2)))
       case None => Some(b1)
    case None => o2 match {
       case Some(b2) => Some(b2)
       case None => None
    }
  }
}

使用这个：

scala> Monoid[Option[Int]].append(Some(1), Some(2))
res9: Option[Int] = Some(3)

但这并不是组合两个选项的唯一方法。如果两个选项都是 Some，我们可以简单地选择两个选项中的第一个或最后一个，而不是附加两个选项的内容。两个触发这个，我们用称为标记类型的技巧创建一个独特的类型。这在本质上与 Haskell 的 newtype 类似。

scala> import Tags._
import Tags._

scala> Monoid[Option[Int] @@ First].append(Tag(Some(1)), Tag(Some(2)))
res10: scalaz.package.@@[Option[Int],scalaz.Tags.First] = Some(1)

scala> Monoid[Option[Int] @@ Last].append(Tag(Some(1)), Tag(Some(2)))
res11: scalaz.package.@@[Option[Int],scalaz.Tags.Last] = Some(2)

通过其 Monoid 附加的 Option[A] @@ First 使用与示例相同的 orElse 语义。

因此，将所有这些放在一起：

scala> Monoid[A => Option[B] @@ First]
res12: scalaz.Monoid[A => scalaz.package.@@[Option[B],scalaz.Tags.First]] = 
       scalaz.std.FunctionInstances0$anon$13@7e71732c

Answer 2

不，这看起来不错，满足（非交换）幺半群的两个要求。有趣的想法。您想支持什么用例？

Answer 3

你的零肯定违反了恒等元素的公理，但我认为恒等（部分）函数就可以了。

您的追加也不满足 Monoid 定律，但您可以调用 andThen （组合）来代替 orElse。但这仅适用于 A == B：

implicit def partialFunctionSemigroup[A]: Semigroup[A --> A] = new Semigroup[A --> A] {
  def append(s1: A --> A, s2: => A --> A): A-->A = s1 andThen s2
}

implicit def partialFunctionZero[A]: Zero[A --> A] = new Zero[A --> A] {
  val zero = new (A --> A) {
    def isDefinedAt(a:A) = true
    def apply(a:A) = a
  }
}