title: Why does this explicit call of a Scala method allow it to be implicitly resolved?
body: <p>Why does this code fail to compile, but compiles successfully when I uncomment the indicated line? (I'm using Scala 2.8 nightly). It seems that explicitly calling <code>string2Wrapper</code> allows it to be used implicitly from that point on.</p>
  
  <pre><code>class A {
    import Implicits.string2Wrapper
    def foo() {
       //string2Wrapper("A") ==&gt; "B" // &lt;-- uncomment
    } 
    def bar() {
      "A" ==&gt; "B"
      "B" ==&gt; "C"
      "C" ==&gt; "D"
    }
    object Implicits {
      implicit def string2Wrapper(s: String) = new Wrapper(s)
      class Wrapper(s: String) {
        def ==&gt;(s2: String) {}
      }
    }
  }
  </code></pre>
  
  <p><strong>Edit</strong>: thanks for the answers so far,  which include a pointer to Martin Odersky's comment,</p>
  
  <blockquote>
    <p>"An implicit conversion without explicit result type is visible only in the text
    following its own definition. That way, we avoid the cyclic reference errors."</p>
  </blockquote>
  
  <p>I'd still be interested in finding out 1) what is the danger of "cyclic reference errors"?, and 2) Why does an explicit call make any difference?</p>