Question

我想直接使用类型类的函数，而不必引用隐式证据对象。

现在我已经以推荐的方式实现了类型类（至少我认为是这样）：

object Main {
    import Implicits._
    import Implicits.monoidInt._

    def main(args: Array[String]): Unit = {
        println(addTwice(1,2))
    }
}

object Implicits {
    implicit object monoidInt extends Monoid[Int] {
        def zero: Int = 0
        def append(x: Int, y: Int): Int = x + y
    }
}

trait Monoid[A] {
    def zero: A
    def append(x: A, y: A): A
}

而不是像addTwice那样写：

def addTwice[A](x: A, y: A)(implicit ev: Monoid[A]): A = {
        ev.append(ev.append(x,y), y)
}

我想写：

def addTwice[A: Monoid[A]](x: A, y: A): A = x.append(y).append(y)

这可能吗？

Answer 1

是的，这是可能的。你需要所谓的Ops。它允许向具有定义的类型类实例的类的对象添加方法。

您定义具有该值的MonoidOps特征和类型类的实例，然后在其方法中使用它们，因此基本上它封装了该ev变量的用法。

然后定义从A到MonoidOps[A]的转换，它设置对象以及通过隐式参数获取的实例。

trait Monoid[A] {
    def zero: A
    def append(x: A, y: A): A
}

object Implicits {
    implicit object monoidInt extends Monoid[Int] {
        def zero: Int = 0
        def append(x: Int, y: Int): Int = x + y
    }

    trait MonoidOps[A] {
        def instance: Monoid[A]
        def self: A
        def |+|(y: A): A = instance.append(self, y)
    }

    implicit def toMonoidOps[A](target: A)(implicit M: Monoid[A]) = new MonoidOps[A] {
        val instance = M
        val self = target
    }
}

import Implicits._

def addTwice[A: Monoid](x: A, y: A): A = x |+| y |+| y

scala> println(addTwice(1,2))
5

MonoidOps和toMonoidOps可以替换为隐式类，如下所示：

implicit class MonoidOps[A](val self: A)(implicit M: Monoid[A]) {
    def |+|(y: A): A = M.append(self, y)
}

查看可为您生成样板文件的simulacrum项目。

直接使用Scala类型类而没有隐式证据对象

1 个答案: