Add docs

Explain by-type imports on the doc page.
Also, add a test for wildcards in bounds.

Author: odersky

docs/docs/reference/contextual/import-implied.md

@@ -8,6 +8,7 @@ A special form of import is used to import implied instances. Example:
 object A {
   class TC
   implied tc for TC
+  implied
   def f given TC = ???
 }
 object B {
@@ -28,6 +29,35 @@ There are two main benefits arising from these rules:
    instances can be anonymous, so the usual recourse of using named imports is not
    practical.
 
+### Importing By Type
+
+Since implied instances can be anonymous it is not always practical to import them by their name, and wildcard imports are typically used instead. By-type imports provide a more specific alternative to wildcard imports, which makes it clearer what is imported. Example:
+
+```scala
+import implied A.{for TC}
+```
+This imports any implied instance in `A` that has a type which conforms tp `TC`. There can be several bounding types following a `for` and bounding types can contain wildcards.
+For instance, assuming the object
+```scala
+object Instances {
+  implied intOrd for Ordering[Int]
+  implied [T: Ordering] listOrd for Ordering[List[T]]
+  implied ec for ExecutionContext = ...
+  implied im for Monoid[Int]
+}
+```
+the import
+```
+import implied Instances.{for Ordering[_], ExecutionContext}
+```
+would import the `intOrd`, `listOrd`, and `ec` instances but leave out the `im` instance, since it fits none of the specified bounds.
+
+By-type imports can be mixed with by-name imports. If both are present in an import clause, by-type imports come last. For instance, the import clause
+```
+import implied Instances.{im, for Ordering[_]}
+```
+would import `im`, `intOrd`, and `listOrd` but leave out `ec`. By-type imports cannot be mixed with a wildcard import in the same import clause.
+
 ### Migration
 
 The rules for `import implied` above have the consequence that a library

tests/run/implied-for.scala

@@ -4,22 +4,22 @@ object A {
 
   class B extends T
   class C extends T
-  class D
+  class D[T]
 
   implied b for B
   implied c for C
   implied t for T
-  implied d for D
+  implied d for D[Int]
 }
 
 object Test extends App {
   import A._
-  import implied A.{t, for B, D}
+  import implied A.{t, for B, D[_]}
 
   val x1: B = b
   val x2: T = t
-  val x3: D = d
+  val x3: D[Int] = d
 
   assert(the[T].isInstanceOf[B])
-  assert(the[D].isInstanceOf[D])
+  assert(the[D[Int]].isInstanceOf[D[_]])
 }