title: Scala import statement incorrectly imports implicit value
body: <p>I am trying to add <code>~=</code> <em>operator</em> to <code>Double</code> in Scala. The below is my attempt:</p>
  <pre class="lang-scala prettyprint-override"><code>package mypackage
  
  object Implicits {
  
    case class MyEpsilon(value: Double) // Wrapper class for implicit argument
  
    implicit class MyDouble(val v: Double) extends AnyVal {
      /**
       * Return true if 2 doubles are approximately equal
       */
      def ~=(other: Double)(implicit epsilon: MyEpsilon): Boolean = {
        scala.math.abs(v - other) &lt;= epsilon.value
      }
  
      /**
       * The same as above, but implicit value type is Double
       */
      def ~~=(other: Double)(implicit epsilon: Double): Boolean = {
        scala.math.abs(v - other) &lt;= epsilon
      }
    }
  
    implicit val defaultDouble: Double = 1e-6
    implicit val defaultMyEpsilon: MyEpsilon = MyEpsilon(1e-6)
  
  }
  </code></pre>
  <p>So that when we write <code>1.0 ~= 1.01</code>, Scala should implicitly convert <code>1.0</code> to <code>MyDouble</code> class, which has <code>~=</code> method.</p>
  <p><strong>Question:</strong>
  But why does the following code work for <code>~=</code> without having to define an implicit value of type <code>MyEpsilon</code>?
  (On the other hand, as expected, <code>~~=</code> doesn't work, because we need to define a local implicit value of type <code>Double</code>.)</p>
  <pre class="lang-scala prettyprint-override"><code>import mypackage.Implicits.MyDouble // Try to import only &quot;MyDouble&quot; class
  
  val a: Double = 1.0
  val b: Double = 1.0 + 1e-3
  
  val res0 = (a ~= b) // Why does this work without having to define implicit value of type &quot;MyEpsilon&quot;?
  
  // Below doesn't work unless we define a local implicit value of type &quot;Double&quot;
  // error: could not find implicit value for parameter epsilon: Double
  val res1 = (a ~~= b)
  </code></pre>