string隐式转换的二义性问题

scala标准库在Predef对象中定义了两个String的隐式转换：

implicit def augmentString(x: String): StringOps
implicit def wrapString(s: String): WrappedString

而StringOps和WrappedString有一些重复的方法，如count：
�StringOps中定义了count方法

def count(p: (Char) ⇒ Boolean): Int
Counts the number of elements in the traversable or iterator which satisfy a predicate.

WrappedString也有count方法

def count(p: (Char) ⇒ Boolean): Int
Counts the number of elements in the traversable or iterator which satisfy a predicate.

�两个count方法��完全一样，应该存在二义性问题啊。试着在REPL中写了�一�段隐式转换的代码，果然会提示有二义性：

case class A1(a: Int) {
  def guess = a * 10
}

case class A2(a: Int) {
  def guess = a * 100
}       

implicit def Int2A1(a: Int) = new A1(a)
implicit def Int2A2(a: Int) = new A2(a)

scala> 1.guess
<console>:14: error: type mismatch;
 found   : Int(1)
 required: ?{def guess: ?}
Note that implicit conversions are not applicable because they are ambiguous:
 both method Int2A1 of type (a: Int)A1
 and method Int2A2 of type (a: Int)A2
 are possible conversion functions from Int(1) to ?{def guess: ?}
       1.guess
       ^
<console>:14: error: value guess is not a member of Int
       1.guess

但是从上一篇隐式转换的文章可以知道"hello".count不但没有报错，还会选择StringOps.count。�为什么会这样呢？

�隐式转换的优化级

在Martin Odersky亲自写的《Programming in Scala(Third Edition)》21.7节最后有下面这一段说明：

The old implicit conversion to a Scala collection (now named WrappedString) is retained. However, there is a more specific conversion supplied fromString to a new type called StringOps. StringOps has many methods such as reverse, but instead of returning a collection, they return a String. The conversion to StringOps is defined directly in Predef, whereas the conversion to a Scala collection is defined in a new class, LowPriorityImplicits, which is extended by Predef. Whenever a choice exists between these two conversions, the compiler chooses the conversion to StringOps, because it's defined in a subclass of the class where the other conversion is defined.

简而言之，编译器之所以会选择StringOps而不是WrappedString，是因为StringOps更特化(more specific)。为什么说StringOps更特化呢？让�我们先看看Predef对象的�继承关系：

object Predef extends LowPriorityImplicits with DeprecatedPredef {
  /* ��忽略了很多�东东... */
  /** @group conversions-string */
  @inline implicit def augmentString(x: String): StringOps = new StringOps(x)
}
private[scala] abstract class LowPriorityImplicits {
  /* ��忽略了很多�东东... */
  /** @group conversions-string */
  implicit def wrapString(s: String): WrappedString = if (s ne null) new WrappedString(s) else null
}

String到StringOps的隐式转换是定义在Predef对象中的，而String到WrappedString的�隐式转换是在定义在Predef的���父类LowPriorityImplicits中，所以前者比后者更特化。
�还是在《Programming in Scala(Third Edition)》21.7节，有一��段更详细的说明：

one implicit conversion is more specific than another if one of the following applies:

• The argument type of the former is a subtype of the latter's.
• Both conversions are methods, and the enclosing class of the former extends the enclosing class of the latter.

Odersky�又解释道：

The motivation to revisit this issue and revise the rule was to improve interoperation between Java collections, Scala collections, and strings.

又试着在REPL写了一段测试代码，的确如此：

case class A1(a: Int) {
  def guess = a * 10
  def what = a
}

case class A2(a: Int) {
  def guess = a * 100
}       

class BaseImplicits {
  implicit def Int2A1(a: Int) = new A1(a)
}

object SpecificImplicits extends BaseImplicits {
  implicit def Int2A2(a: Int) = new A2(a)
} 

scala> import SpecificImplicits._
import SpecificImplicits._

scala> 1.guess
res1: Int = 100

scala> 1.what
res2: Int = 1