blocks|key|2962660|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2962661|显式调用foo(i2,+s1)，但是您失去了使用implicit+String+|ordered-list-item|offset|length|style|CODE|2962662|Define+def+foo1(a:+Int)(implicit+b:+String)=foo(a,b)的好处，于是您调用了foo1(i2)|2962663|2962664|entityMap^0|0|4|B|O|F|0|7|19|1Q|8|0|0^^$0|@$1|2|3|-4|4|5|6|M|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|N|7|@$D|O|E|P|F|G]|$D|Q|E|R|F|G]]|8|@]|9|$]]|$1|H|3|I|4|C|6|S|7|@$D|T|E|U|F|G]|$D|V|E|W|F|G]]|8|@]|9|$]]|$1|J|3|-4|4|5|6|X|7|@]|8|@]|9|$]]|$1|K|3|-4|4|5|6|Y|7|@]|8|@]|9|$]]]|L|$]]

<ol>
<li>Explicitly call <code>foo(i2, s1)</code> but you loose the benefit of the use of the <code>implicit String</code> </li>
<li>Define <code>def foo1(a: Int)(implicit b: String)=foo(a,b)</code> and you call <code>foo1(i2)</code></li>
</ol>

blocks|key|161535|text|我能补充的就是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|161536|def+foo(implicit+a:+Int,+b:+String)+=+println(a,+b)
implicit+val+i1+=+1
implicit+val+s+=+""
val+i2+=+2
foo(i2,+implicitly[String])|code-block|syntax|javascript|161537|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

All I can add is:

<pre><code>def foo(implicit a: Int, b: String) = println(a, b)
implicit val i1 = 1
implicit val s = ""
val i2 = 2
foo(i2, implicitly[String])
</code></pre>

blocks|key|2750043|text|如果您的方法有许多隐式参数(我有时在我的项目中有)，而您有时只想显式指定其中一个，并让其他参数隐式解析，则可以像我的另一个答案中所示的那样，为每个其他参数编写implicitly。但有时您会更改该方法的签名，或者显式参数位于该参数列表的中间，那么您可以使用以下结构使客户端代码更具可读性：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2750044|假设你有一些类型和它们的隐式虚拟对象：|2750045|trait+I1;+implicit+object+I1+extends+I1
trait+I2;+implicit+object+I2+extends+I2
trait+I3;+implicit+object+I3+extends+I3
trait+I4;+implicit+object+I4+extends+I4
trait+I5;+implicit+object+I5+extends+I5
trait+I6;+implicit+object+I6+extends+I6|code-block|syntax|javascript|2750046|现在，您有了使用这些隐式的方法foo1：|2750047|def+foo1(implicit+i1:+I1,+i2:+I2,+i3:+I3,+i4:+I4,+i5:+I5,+i6:+I6)+{
++println(i1,+i2,+i3,+i4,+i5,+i6)
}|2750048|现在，您通常希望显式地指定i4:+I4。所以你写道：|2750049|val+i4+=+new+I4+{}
foo1(implicitly,+implicitly,+implicitly,+i4,+implicitly,+implicitly)|2750050|丑陋！|2750051|使用以下代码(应该放在方法foo2的严格作用域中，并可能重命名)用于所有隐式的包装：|2750052|object+Implicits+{
++def+apply(i4:+I4)(implicit+i1:+I1,+i2:+I2,+i3:+I3,+i5:+I5,+i6:+I6)+=+new+Implicits(i1,+i2,+i3,+i4,+i5,+i6)
++implicit+def+applying(implicit+i1:+I1,+i2:+I2,+i3:+I3,+i4:+I4,+i5:+I5,+i6:+I6)+=+new+Implicits(i1,+i2,+i3,+i4,+i5,+i6)
}
class+Implicits(val+i1:+I1,+val+i2:+I2,+val+i3:+I3,+val+i4:+I4,+val+i5:+I5,+val+i6:+I6)|2750053|和相关的方法foo2|2750054|def+foo2(implicit+implicits:+Implicits)+=+{
++import+implicits._
++println(i1,+i2,+i3,+i4,+i5,+i6)
}|2750055|您现在可以通过以下方式调用foo2而不是foo1：|2750056|locally+{
++foo2+//+using+implicit+dummy+objects+I1,+...,+I6+from+above
++//+or+with+explicit+I4:
++val+i4+=+new+I4+{}
++foo2(Implicits(i4))
}|2750057|entityMap^0|27|A|0|0|0|F|4|0|0|D|6|0|0|0|D|4|0|0|6|4|0|0|D|4|K|4|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1D|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1E|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1F|8|@$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|O|3|P|5|J|7|1I|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1J|8|@$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|S|3|T|5|J|7|1M|8|@]|D|@]|E|$K|L]]|$1|U|3|V|5|6|7|1N|8|@]|D|@]|E|$]]|$1|W|3|X|5|6|7|1O|8|@$9|1P|A|1Q|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|J|7|1R|8|@]|D|@]|E|$K|L]]|$1|10|3|11|5|6|7|1S|8|@$9|1T|A|1U|B|C]]|D|@]|E|$]]|$1|12|3|13|5|J|7|1V|8|@]|D|@]|E|$K|L]]|$1|14|3|15|5|6|7|1W|8|@$9|1X|A|1Y|B|C]|$9|1Z|A|20|B|C]]|D|@]|E|$]]|$1|16|3|17|5|J|7|21|8|@]|D|@]|E|$K|L]]|$1|18|3|-4|5|6|7|22|8|@]|D|@]|E|$]]]|19|$]]

In case your method has many implicit parameters (I sometimes have in my projects) and you sometimes want to just specify one of them explicit and let the others been resolved implicitly you can write <code>implicitly</code> for every other parameter like showed in my other answer. But sometimes you will change the signature of that method or the explicit parameter is in the middle of that parameter list, then you can make more readable client code with the following construct:

Suppose you have some types and their implicit dummy objects: 

<pre><code>trait I1; implicit object I1 extends I1
trait I2; implicit object I2 extends I2
trait I3; implicit object I3 extends I3
trait I4; implicit object I4 extends I4
trait I5; implicit object I5 extends I5
trait I6; implicit object I6 extends I6
</code></pre>

Now you have your method <code>foo1</code> that uses these implicits:

<pre><code>def foo1(implicit i1: I1, i2: I2, i3: I3, i4: I4, i5: I5, i6: I6) {
 println(i1, i2, i3, i4, i5, i6)
}
</code></pre>

Now you often want to explicitly specify <code>i4: I4</code>. So you write:

<pre><code>val i4 = new I4 {}
foo1(implicitly, implicitly, implicitly, i4, implicitly, implicitly)
</code></pre>

Ugly! 
With the following (should be placed in tight scope to method <code>foo2</code> and perhaps renamed) wrapper for all implicits:

<pre><code>object Implicits {
 def apply(i4: I4)(implicit i1: I1, i2: I2, i3: I3, i5: I5, i6: I6) = new Implicits(i1, i2, i3, i4, i5, i6)
 implicit def applying(implicit i1: I1, i2: I2, i3: I3, i4: I4, i5: I5, i6: I6) = new Implicits(i1, i2, i3, i4, i5, i6)
}
class Implicits(val i1: I1, val i2: I2, val i3: I3, val i4: I4, val i5: I5, val i6: I6)
</code></pre>

and the related method <code>foo2</code>:

<pre><code>def foo2(implicit implicits: Implicits) = {
 import implicits._
 println(i1, i2, i3, i4, i5, i6)
}
</code></pre>

you can now call <code>foo2</code> instead of <code>foo1</code> the following way:

<pre><code>locally {
 foo2 // using implicit dummy objects I1, ..., I6 from above
 // or with explicit I4:
 val i4 = new I4 {}
 foo2(Implicits(i4))
}
</code></pre>

blocks|key|161539|text|我知道这是一个古老的问题，但它可能仍然很有趣。一种很好的方法是隐式使用默认值：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|161540|scala>+def+foo(a:+Int+=+implicitly[Int],+b:+String+=+implicitly[String])+=+println(a,b)

scala>+foo()
(10,boo)

scala>+foo(50)
(50,boo)

scala>+foo(b="bar")
(10,bar)|code-block|syntax|javascript|161541|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I know it's an old question but it still may be interesting.
A nice way to do it is using implicitly as a default value:

<pre class="lang-scala prettyprint-override"><code>scala&gt; def foo(a: Int = implicitly[Int], b: String = implicitly[String]) = println(a,b)

scala&gt; foo()
(10,boo)

scala&gt; foo(50)
(50,boo)

scala&gt; foo(b="bar")
(10,bar)
</code></pre>

blocks|key|2750081|text|您可以创建一个新的内部作用域并在其中定义一个新的implicit+val。优点是当你有多个函数调用时，这种方式你可以在一个地方覆盖所有函数的隐式调用：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2750082|def+foo(implicit+a:Int,+b:String)+=+println(a,b).

implicit+val+i+=+1
implicit+val+s+=+""

foo+//+call+with+original+implicits

{
++implicit+val+i+=+2

++foo+//+call+with+a+new+Int+implicit

++foo+//+call+with+a+new+Int+implicit+again

}|code-block|syntax|javascript|2750083|注意:新的隐式必须与原始隐式具有相同的变量名，以便将其隐藏，否则您将得到一个关于隐含值不明确的编译器错误。|2750084|entityMap^0|O|C|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

You can create a new inner scope and define a new <code>implicit val</code> in it. The advantage is than when you have multiple function calls, this way you can override the one implicit for all of them in one place:

<pre><code>def foo(implicit a:Int, b:String) = println(a,b).

implicit val i = 1
implicit val s = ""

foo // call with original implicits

{
 implicit val i = 2

 foo // call with a new Int implicit

 foo // call with a new Int implicit again

}
</code></pre>

Note: the new implicit must have the same variable name as the original one, so that it hides it, otherwise you will get a compiler error about ambiguous implicit values.

Let's consider the function:

<code>def foo(implicit a:Int, b:String) = println(a,b)</code>.

Now, let us assume that there is an implicit <code>String</code> and <code>Int</code> (<code>implicit val i1=1</code>) in scope but we want to pass an other, not implicit <code>Int</code> (<code>val i2=2</code>) explicitly to <code>foo</code> .

How can we do that ? Is it possible?
Thanks for reading.

Scala: Passing one implicit parameter implicitly and the other explicitly. Is it possible?

编译器

让我们考虑一下下面的函数：def foo(implicit a:Int, b:String) = println(a,b)。现在，让我们假设作用域中有一个隐式的String和Int (implicit val i1=1)，但是我们想显式地传递另一个而不是隐式Int (val i2=2)给foo。我们如何做到这一点？有可...

问Scala:隐式传递一个隐式参数，显式传递另一个。有可能吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Scala:隐式传递一个隐式参数，显式传递另一个。有可能吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Scala:隐式传递一个隐式参数，显式传递另一个。有可能吗？
EN