Revert to standard implicit syntax in docs

Better not to mix different proposals.

Author: odersky

docs/docs/reference/derivation.md

@@ -12,9 +12,9 @@ enum Tree[T] derives Eq, Ordering, Pickling {
 ```
 The `derives` clause generates implicit instances of the `Eq`, `Ordering`, and `Pickling` traits in the companion object `Tree`:
 ```scala
-impl [T: Eq] of Eq[Tree[T]] = Eq.derived
-impl [T: Ordering] of Ordering[Tree[T]] = Ordering.derived
-impl [T: Pickling] of Pickling[Tree[T]] = Pickling.derived
+implicit def derived$Eq [T: Eq]: Eq[Tree[T]] = Eq.derived
+implicit def derived$Ordering [T: Ordering]: Ordering[Tree[T]] = Ordering.derived
+implicit def derived$Pickling [T: Pickling]: Pickling[Tree[T]] = Pickling.derived
 ```
 
 **Note**: This page uses the new syntax proposed for implicits that is explored in #5448. This is not yet an endorsement of that syntax, but rather a way to experiment with it.
@@ -47,7 +47,7 @@ A trait or class can appear in a `derives` clause if
 
 These two conditions ensure that the synthesized derived instances for the trait are well-formed. The type and implementation of a `derived` method are arbitrary, but typically it has a definition like this:
 ```scala
-  def derived[T] with (ev: Generic[T]) = ...
+  def derived[T](implicit ev: Generic[T]) = ...
 ```
 That is, the `derived` method takes an implicit parameter of type `Generic` that determines the _shape_ of the deriving type `T` and it computes the typeclass implementation according to that shape. Implicit `Generic` instances are generated automatically for all types that have a `derives` clause. One can also derive `Generic` alone, which means a `Generic` instance is generated without any other type class instances. E.g.:
 ```scala
@@ -100,9 +100,15 @@ is represented as `T *: Unit` since there is no direct syntax for such tuples: `
 
 ### The Generic TypeClass
 
-For every class `C[T_1,...,T_n]` with a `derives` clause, the compiler generates in the companion object of `C` a type class instance like this:
+For every class `C[T_1,...,T_n]` with a `derives` clause, the compiler generates in the companion object of `C` an implicit instance of `Generic[C[T_1,...,T_n]]` that follows
+the outline below:
 ```scala
-impl [T_1, ..., T_n] of Generic[C[T_1,...,T_n]] { type Shape = ... } = ...
+class derived$Generic[T_1, ..., T_n] extends Generic[C[T_1,...,T_n]] {
+  type Shape = ...
+  ...
+}
+implicit def derived$Generic[T_1,...,T_n]]: derived$Generic[T_1,...,T_n]] =
+  new derived$Generic[T_1,...,T_n]]
 ```
 where the right hand side of `Shape` is the shape type of `C[T_1,...,T_n]`.
 For instance, the definition
@@ -117,13 +123,15 @@ would produce:
 object Result {
   import scala.compiletime.Shape._
 
-  impl [T, E] of Generic[Result[T, E]] {
+  class derived$Generic[T, E] extends Generic[Result[T, E]] {
     type Shape = Cases[(
       Case[Ok[T], T *: Unit],
       Case[Err[E], E *: Unit]
     )]
     ...
   }
+  implicit def derived$Generic[T, E]: derived$Generic[T, E] =
+    new derived$Generic[T, E]
 }
 ```
 The `Generic` class is defined in package `scala.reflect`.
@@ -219,7 +227,7 @@ trait Eq[T] {
 We need to implement a method `Eq.derived` that produces an instance of `Eq[T]` provided
 there exists evidence of type `Generic[T]`. Here's a possible solution:
 ```scala
-  inline def derived[T, S <: Shape] with (ev: Generic[T]): Eq[T] = new Eq[T] {
+  inline def derived[T, S <: Shape](implicit ev: Generic[T]): Eq[T] = new Eq[T] {
     def eql(x: T, y: T): Boolean = {
       val mx = ev.reflect(x)                    // (1)
       val my = ev.reflect(y)                    // (2)
@@ -316,7 +324,7 @@ calling the `error` method defined in `scala.compiletime`.
 **Example:** Here is a slightly polished and compacted version of the code that's generated by inline expansion for the derived `Eq` instance of class `Tree`.
 
 ```scala
-impl Eq_Tree_impl[T] with (elemEq: Eq[T]) of Eq[Tree[T]] {
+implicit def Eq_Tree_impl[T](implicit elemEq: Eq[T]): Eq[T] = new Eq[Tree[T]] {
   def eql(x: Tree[T], y: Tree[T]): Boolean = {
     val ev = implOf[Generic[Tree[T]]]
     val mx = ev.reflect(x)
@@ -342,7 +350,7 @@ One important difference between this approach and Scala-2 typeclass derivation
 Sometimes one would like to derive a typeclass instance for an ADT after the ADT is defined, without being able to change the code of the ADT itself.
 To do this, simply define an instance with the `derived` method of the typeclass as right hand side. E.g, to implement `Ordering` for `Option`, define:
 ```scala
-impl [T: Ordering] of Ordering[Option[T]] = Ordering.derived
+implicit def derived$Ordering[T: Ordering]: Ordering[Option[T]] = Ordering.derived
 ```
 Usually, the `Ordering.derived` clause has an implicit parameter of type
 `Generic[Option[T]]`. Since the `Option` trait has a `derives` clause,