Scala 隐式参数通过传递一个函数作为参数来感受adnvatage

Question

我试着感受implicit的优势Scala 中的参数。 ( 编辑 :使用匿名函数时的特殊情况。请查看此问题中的链接)

我尝试基于 this 进行简单的模拟邮政。哪里解释了如何Action工作于 PlayFramework .这也与that有关.

以下代码用于此目的:

object ImplicitArguments extends App {

  implicit val intValue = 1 // this is exiting value to be passed implicitly to everyone who might use it

  def fun(block: Int=>String): String = { // we do not use _implicit_ here !
    block(2)  // ?? how to avoid passing '2' but make use of that would be passed implicitly ?
  }

  // here we use _implicit_ keyword to make it know that the value should be passed !
  val result = fun{ implicit intValue =>  {  // this is my 'block'
                         intValue.toString     // (which is anonymous function)
                       }
  }

 println(result) // prints 2

}

我想打印“1”。

如何避免传递魔法“2”但使用隐式定义的“1”？

另见 case我们不使用的地方 implicit在定义中，但它在那里，因为匿名函数传递了 implicit .

编辑:
以防万一，我发布了另一个示例 - 简单模拟如何玩' Action作品:

  object ImplicitArguments extends App {

  case class Request(msg:String)

  implicit val request = Request("my request")

  case class Result(msg:String)

  case class Action(result:Result)
  object Action {
    def apply(block:Request => Result):Action = {
     val result = block(...) // what should be here ??
     new Action(result)
    }
  }

  val action = Action { implicit request =>
    Result("Got request [" + request + "]")
  }

  println(action)

}

Answer 1

隐式不会像这样工作。没有魔法。它们只是(通常)隐藏的参数，因此在调用函数时会被解析。

有两种方法可以使您的代码工作。

您可以修复 fun 的所有调用的隐含值

def fun(block: Int=>String): String = { 
  block(implicitly[Int]) 
}

implicitly是在 Predef 中定义的函数。再次没有魔法。这是它的定义

def implicitly[A](implicit value: A) = value

但这意味着它会在 时解析隐式值。申报 fun而不是每次调用。

如果要为不同的调用使用不同的值，则需要添加隐式参数

def fun(block: Int=>String)(implicit value: Int): String = { 
  block(value) 
}

这将取决于调用站点的隐式作用域。你可以像这样轻松地覆盖它

val result = fun{ _.toString }(3)

结果将是 "3"因为显式 3在末尾。然而，没有办法神奇地改变 fun从您的声明中获取隐式作用域中的值。

我希望你现在更好地理解隐式，一开始可能有点棘手。