title: Implicit conversion gets too eager with an implicit parameter
body: <p>I want to define a type safe equal matcher with an implicit formatter:</p>
  
  <pre><code>trait Formatter[T] {
    def format(t : T) : String
  }
  
  implicit val StringFormatter : Formatter[String] = new Formatter[String] { def format(s: String) = s"'$s'" }
  implicit def AnyFormatter[T] : Formatter[T] = new Formatter[T] { def format(t : T) = t.toString }
  
  class MatcherOps[T : Formatter]( t : T) {
    def must_==(other : T) {
      if( t != other ) println( implicitly[Formatter[T]].format(other) ) else println("OK")
    }
  } 
  
  implicit def ToMatcherOps[T : Formatter](t : T) = new MatcherOps[T](t)
  </code></pre>
  
  <p>The following works as expected:</p>
  
  <pre><code>"ha" must_== "ho"
  </code></pre>
  
  <p>it is compiled (<code>scalac -Xprint:typer</code>) into</p>
  
  <pre><code>$anon.this.ToMatcherOps[String]("ha")($anon.this.StringFormatter).must_==("ho");
  </code></pre>
  
  <p>But then I would expect this to not compile:</p>
  
  <pre><code>List(1,2) must_== Set(1,2)
  </code></pre>
  
  <p>And instead it compiles (<code>scalac -Xprint:typer</code>) to</p>
  
  <pre><code>$anon.this.ToMatcherOps[Object]($anon.this.ToMatcherOps[List[Int]](immutable.this.List.apply[Int](1, 2))($anon.this.AnyFormatter[List[Int]]))($anon.this.AnyFormatter[Object]).must_==(scala.this.Predef.Set.apply[Int](1, 2))
  </code></pre>
  
  <p>As you can see ToMatcherOps is called twice!</p>
  
  <p>If I take the implicit formatter out of the way:</p>
  
  <pre><code>implicit def ToMatcherOps[T](t : T) = new MatcherOps[T](t)
  </code></pre>
  
  <p>Then compiling fails as expected:</p>
  
  <pre><code>error: type mismatch;
    found   : scala.collection.immutable.Set[Int]
    required: List[Int]
  List(1,2) must_== Set(1,2)
                       ^
  </code></pre>
  
  <p>But of course <code>ToMatcherOps</code> is unable to provide a sensible <code>Formatter</code> (<code>scalac -Xprint:typer</code>):</p>
  
  <pre><code>implicit private def ToMatcherOps[T &gt;: Nothing &lt;: Any](t: T): this.MatcherOps[T] = new this.MatcherOps[T](t)($anon.this.AnyFormatter[T]);
  </code></pre>
  
  <p>Any idea how to work around this?
  Thanks</p>