Question

我有一个隐式方法：

def f(x: String)(implicit dispatcher: ExecutionContextExecutor, mat: ActorMaterializer) = ???

我想创建一个像这样的辅助方法：

def g1(y: String) = f("uri1" + y)
def g2(y: String) = f("uri2" + y)

当然，对于方法no implicits found for parameter ex: ExecutionContext，它不能编译为g。

我不想在implicits中重复g声明。
那么，这种情况的惯用解决方案是什么？

Answer 1

惯用的解决方案是重复隐式参数。

如果您多次重复同一组隐式参数，那么惯用的解决方案是引入您的类型类（或仅单个隐式），而不是那组隐式，并使用此类型类。

不是惯用的解决方案是引入宏注释，该注释将为方法生成隐式参数部分。

有时您可以将隐式传递到更高级别

class MyClass(implicit val ec: ExecutionContext) extends ExecutionContextAware {
  def f(x: String) = ???
  def g(y: String) = f("xxx" + y)
}

trait ExecutionContextAware {
  implicit def ec: ExecutionContext
}

或

trait MyTrait extends ExecutionContextAware {
  def f(x: String) = ???
  def g(y: String) = f("xxx" + y)
}

object Impl extends ExecutionContextAware {
  implicit def ec: ExecutionContext = ExecutionContext.Implicits.global
}

trait ExecutionContextAware {
  implicit def ec: ExecutionContext
}

还可以举一个有关typeclass的例子吗？

假设您有多个类型类

trait TC1[A] {
  def foo = ???
}
trait TC2[A] {
  def bar = ???
}

并且您必须在方法中重复它们

def f[A](implicit tc1: TC1[A], tc2: TC2[A]) = ???

1。。然后，您可以介绍类型类

trait TC[A] {
  def foo
  def bar
}

通过TC1，TC2，...

object TC {
  implicit def mkTC[A](implicit tc1: TC1[A], tc2: TC2[A]): TC[A] = new TC[A] {
    def foo = tc1.foo
    def bar = tc2.bar
  }
}

并使用它

def f[A](implicit tc: TC[A]) = ???

2。。另一种方法是

trait TC[A] {
  implicit def tc1: TC1[A]
  implicit def tc2: TC2[A]
}

object TC {
  implicit def mkTC[A](implicit _tc1: TC1[A], _tc2: TC2[A]): TC[A] = new TC[A] {
    implicit def tc1: TC1[A] = _tc1
    implicit def tc2: TC2[A] = _tc2
  }
}

def f[A](implicit tc: TC[A]) = {
  import tc._
  ???
}

在您使用ExecutionContextExecutor，ActorMaterializer的示例中（例如，按照第二种方法），您可以介绍

trait MyImplicit {
  implicit def dispatcher: ExecutionContextExecutor
  implicit def mat: ActorMaterializer
}

并替换

def f(x: String)(implicit dispatcher: ExecutionContextExecutor, mat: ActorMaterializer) = ???

使用

def f(x: String)(implicit mi: MyImplicit) = {
  import mi._
  ???
}

如何在Scala中将具有隐式的方法与另一个方法包装在一起？

1 个答案: