什么时候在Scala中使用隐式参数是有意义的,可以考虑哪些替代scal

def badIdea(n: Int)(implicit s: String) = s * n

想象的原因并不需要太多：如果其他人采用这一政策,你会对同样的事情产生相互矛盾的冲突.最好避免它.

但谁真的想在每次需要时手动填充scala.concurrent.ExecutionContext(实际上到处都是)？

所以关键是：当你有一个特殊类型的东西时,特别是如果它的簿记可能需要手动覆盖,但大多数应该做正确的事情,然后使用隐式参数. (这通常也包括类型类.)

那你真的需要一个字符串怎么办？好吧,包装它(至少正式 – 这里它是一个值类,所以在某些情况下它只会传递字符串)：

class MyWrappedString(val underlying: String) extends AnyVal {}
implicit val myString = new MyWrappedString("bird")
def decentIdea(n: Int)(implicit mws: MyWrappedString) = mws.underlying * n

scala> decentIdea(2)  // In the bush?
res14: String = birdbird

或者,如果您认为某些其他逻辑很有用,请编写一个包含额外类型参数的包装器：

class ImplicitWithValue[K,V](val value: V) {
  // Any extra generic logic goes here
}
object ImplicitWithValue {
  class ValuePart[K] {
    def apply[V](v: V) = new ImplicitWithValue[K,V](v)
  }
  private val genericValuePart = new ValuePart[Any]
  private def typedValuePart[K] = genericValuePart.asInstanceOf[ValuePart[K]]
  def apply[K] = typedValuePart[K]
}

然后你可以

trait Marker1
implicit val implicit1 = ImplicitWithValue[Marker1]("fish")

def goodIdea(n: Int)(implicit ms: ImplicitWithValue[Marker1,String]) = ms.value * n

scala> goodIdea(3)
res17: String = fishfishfish