层次结构的类型 class 实现
Type class implementation for hierarchy
我正在研究 Scala 并尝试为自定义类型实现一些抽象。为混凝土 类 定义 scalaz 幺半群非常简单。但是如何为类型层次声明一个 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() 在上面的例子中可行吗?
这样编译:
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
}
}
我正在研究 Scala 并尝试为自定义类型实现一些抽象。为混凝土 类 定义 scalaz 幺半群非常简单。但是如何为类型层次声明一个 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() 在上面的例子中可行吗?
这样编译:
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
}
}