層次結構的類型類實現

Question

我正在研究Scala，並嘗試為自定義類型實現一些抽象。 為具體類定義scalaz monoid非常簡單。 但是如何為類型層次結構聲明一個Monoid？ 假設此代碼：

sealed trait Base
case class A(v:Int) extends Base
object N extends Base

object Main {
  // Wanna one monoid for all the Base's
  implicit val baseMonoid = new Monoid[Base] {
    override def append(f1: Base, f2: => Base): Base = f1 match {
      case A(x) => f2 match {
        case A(y) => A(x + y)
        case N => A(x)
      }
      case N => f2
    }
    override def zero = N
  }

  def main(args: Array[String]): Unit = {
    println(∅[Base] |+| A(3) |+| A(2)) // Compiles
    println(A(3) |+| A(2)) // Not compiles
  }
}

如何使狀態A（）| + | B（）在上面的示例中可行嗎？

Answer 1

這樣編譯：

import scalaz._, Scalaz._

sealed trait Base
case class A(a: Int) extends Base
case class B(b: Int) extends Base
object N extends Base

object BullShit {
  // Wanna one monoid for all the Base's

  implicit val sg: Semigroup[Base] = new Semigroup[Base] {
    override def append(f1: Base, f2: => Base): Base = f1 match {
      case A(a) => f2 match {
        case A(a1) => A(a + a1)
        case B(b) => A(a + b)
        case N => N
      }
      case B(b) => f2 match {
        case A(a) => B(a + b)
        case B(b1) => B(b + b1)
        case N => N
      }
      case N => f2
    }

  }

  println((A(1): Base) |+| (B(2): Base))
}

如果您告訴Scala可怕的類型推斷者您的意思，則您的示例將編譯：

sealed trait Base
case class A(v: Int) extends Base
object N extends Base

object Main {
  // Wanna one monoid for all the Base's
  implicit val baseMonoid = new Monoid[Base] {
    override def append(f1: Base, f2: => Base): Base = f1 match {
      case A(x) => f2 match {
        case A(y) => A(x + y)
        case N => A(x)
      }
      case N => f2
    }
    override def zero = N
  }

  def main(args: Array[String]): Unit = {
    import scalaz._, Scalaz._
    println(∅[Base] |+| A(3) |+| A(2)) // Compiles
    println((A(3): Base) |+| (A(2): Base)) // now it compiles
  }
}