通配符导入,然后隐藏特定隐式?

Wildcard Import, then Hide Particular Implicit?

给定以下带有 2 个隐式的对象:

scala> object Foo {
     |  implicit def stringToInt(x: String) = 555
     |  implicit def stringToBoolean(x: String) = true
     | }
warning: there were two feature warnings; re-run with -feature for details
defined object Foo

我可以使用它们:

scala> def f(x: Int) = x
f: (x: Int)Int

scala> import Foo._
import Foo._

scala> f("asdf")
res0: Int = 555

scala> def g(b: Boolean) = b
g: (b: Boolean)Boolean

scala> g("asdfasdf")
res1: Boolean = true

然后,我尝试禁用 stringToInt 隐式。

scala> import Foo.{stringToInt => _}
import Foo.{stringToInt=>_}

但是,显然,这没有用。

scala> f("adsfasdf")
res2: Int = 555

通配符导入隐式后,是否可以隐藏它们?

基本上,我想使用所有 Foo 的隐式,减去一个 stringToInt

注意 - 当然我可以只做 import Foo.stringToBoolean,但是,对于我的场景,Foo 有大约 25 个导入,我想使用其中的 24 个。所以用all再减1更简洁

REPL 只是近似从历史中导入的内容,一种近似总是使用导入的隐式。

在普通代码中,您可以通过隐藏标识符来禁用隐式。

最佳镜头是:

scala> object X { val stringToInt = 0 }
defined object X

scala> import X._
import X._

scala> f("asdf")
<console>:20: error: type mismatch;
 found   : String("asdf")
 required: Int
       f("asdf")
         ^

scala> implicit val stringToInt = 0
stringToInt: Int = 0

想法是将阴影变量引入当前行的 REPL 模板范围。

存在禁止特定导入的现有语法。它是 renaming/aliasing 导入语法的扩展:

import scala.collection.concurrent.{ Map => CMap } // Import concurrent Map, but alias it to "CMap", so the predef-imported "Map" isn't shadowed.

要隐藏导入,您可以将其别名为“_”:

import scala.collection.mutable.{ Map, TrieMap => _ } // Import Map, but not TrieMap

同样,要导入除特定条目之外的所有对象,请使用:

import Foo.{ stringToInt => _, _ }

scala> def g(b: Boolean) = b
g: (b: Boolean)Boolean

scala> g("asdfasdf")
res1: Boolean = true

scala> def f(x: Int) = x
f: (x: Int)Int

scala> f("asdf")
<console>:13: error: type mismatch;
 found   : String("asdf")
 required: Int
              f("asdf")
                ^