Update the relationship-implicits.md to use up to date concept names

Author: ShapelessCat

docs/docs/reference/contextual/relationship-implicits.md

@@ -12,34 +12,45 @@ Many, but not all, of the new contextual abstraction features in Scala 3 can be
 Given instances can be mapped to combinations of implicit objects, classes and implicit methods.
 
  1. Given instances without parameters are mapped to implicit objects. E.g.,
+
     ```scala
     given intOrd as Ord[Int] { ... }
     ```
+
     maps to
+
     ```scala
     implicit object IntOrd extends Ord[Int] { ... }
     ```
+
  2. Parameterized givens are mapped to combinations of classes and implicit methods. E.g.,
+
     ```scala
       given listOrd[T](using ord: Ord[T]) as Ord[List[T]] { ... }
     ```
+
     maps to
+
     ```scala
     class ListOrd[T](implicit ord: Ord[T]) extends Ord[List[T]] { ... }
     final implicit def ListOrd[T](implicit ord: Ord[T]): ListOrd[T] = new ListOrd[T]
     ```
+
  3. Alias givens map to implicit methods or implicit lazy vals. If an alias has neither type nor context parameters,
     it is treated as a lazy val, unless the right hand side is a simple reference, in which case we can use a forwarder to
     that reference without caching it.
 
 Examples:
+
 ```scala
 given global as ExecutionContext = new ForkJoinContext()
 
 val ctx: Context
 given Context = ctx
 ```
+
 would map to
+
 ```scala
 final implicit lazy val global: ExecutionContext = new ForkJoinContext()
 final implicit def given_Context = ctx
@@ -48,29 +59,35 @@ final implicit def given_Context = ctx
 ### Anonymous Given Instances
 
 Anonymous given instances get compiler synthesized names, which are generated in a reproducible way from the implemented type(s). For example, if the names of the `IntOrd` and `ListOrd` givens above were left out, the following names would be synthesized instead:
+
 ```scala
 given given_Ord_Int as Ord[Int] { ... }
 given given_Ord_List_T[T](using ord: Ord[T]) as Ord[List[T]] { ... }
 ```
+
 The synthesized type names are formed from
 
- - the prefix `given_`,
- - the simple name(s) of the implemented type(s), leaving out any prefixes,
- - the simple name(s) of the toplevel argument type constructors to these types.
+1. the prefix `given_`,
+2. the simple name(s) of the implemented type(s), leaving out any prefixes,
+3. the simple name(s) of the toplevel argument type constructors to these types.
 
 Tuples are treated as transparent, i.e. a type `F[(X, Y)]` would get the synthesized name
 `F_X_Y`. Directly implemented function types `A => B` are represented as `A_to_B`. Function types used as arguments to other type constructors are represented as `Function`.
 
-### Given Clauses
+### Using Clauses
+
+Using clauses correspond largely to Scala-2's implicit parameter clauses. E.g.
 
-Given clauses correspond largely to Scala-2's implicit parameter clauses. E.g.
 ```scala
 def max[T](x: T, y: T)(using ord: Ord[T]): T
 ```
+
 would be written
+
 ```scala
 def max[T](x: T, y: T)(implicit ord: Ord[T]): T
 ```
+
 in Scala 2. The main difference concerns applications of such parameters.
 Explicit arguments to parameters of using clauses _must_ be written using `(using ...)`,
 mirroring the definition syntax. E.g, `max(2, 3)(using IntOrd)`.
@@ -88,29 +105,33 @@ Context bounds are the same in both language versions. They expand to the respec
 
 **Note:** To ease migration, context bounds in Dotty map for a limited time to old-style implicit parameters for which arguments can be passed either in a using clause or
 in a normal argument list. Once old-style implicits are deprecated, context bounds
-will map to with clauses instead.
+will map to using clauses instead.
 
 ### Extension Methods
 
 Extension methods have no direct counterpart in Scala 2, but they can be simulated with implicit classes. For instance, the extension method
+
 ```scala
 extension (c: Circle) def circumference: Double = c.radius * math.Pi * 2
 ```
+
 could be simulated to some degree by
+
 ```scala
 implicit class CircleDecorator(c: Circle) extends AnyVal {
   def circumference: Double = c.radius * math.Pi * 2
 }
 ```
+
 Abstract extension methods in traits that are implemented in given instances have no direct counterpart in Scala-2. The only way to simulate these is to make implicit classes available through imports. The Simulacrum macro library can automate this process in some cases.
 
 ### Type class Derivation
 
 Type class derivation has no direct counterpart in the Scala 2 language. Comparable functionality can be achieved by macro-based libraries such as Shapeless, Magnolia, or scalaz-deriving.
 
-### Implicit Function Types
+### Context Function Types
 
-Implicit function types have no analogue in Scala 2.
+Context function types have no analogue in Scala 2.
 
 ### Implicit By-Name Parameters
 
@@ -121,16 +142,21 @@ Implicit by-name parameters are not supported in Scala 2, but can be emulated to
 ### Implicit Conversions
 
 Implicit conversion methods in Scala 2 can be expressed as given instances of the `scala.Conversion` class in Dotty. E.g. instead of
+
 ```scala
 implicit def stringToToken(str: String): Token = new Keyword(str)
 ```
+
 one can write
+
 ```scala
 given stringToToken as Conversion[String, Token] {
   def apply(str: String): Token = KeyWord(str)
 }
 ```
+
 or
+
 ```scala
 given stringToToken as Conversion[String, Token] = KeyWord(_)
 ```
@@ -143,10 +169,13 @@ Implicit classes in Scala 2 are often used to define extension methods, which ar
 
 Implicit `val` definitions in Scala 2 can be expressed in Dotty using a regular `val` definition and an alias given.
 E.g., Scala 2's
+
 ```scala
 lazy implicit val pos: Position = tree.sourcePos
 ```
+
 can be expressed in Dotty as
+
 ```scala
 lazy val pos: Position = tree.sourcePos
 given Position = pos
@@ -155,10 +184,13 @@ given Position = pos
 ### Abstract Implicits
 
 An abstract implicit `val` or `def` in Scala 2 can be expressed in Dotty using a regular abstract definition and an alias given. E.g., Scala 2's
+
 ```scala
 implicit def symDecorator: SymDecorator
 ```
+
 can be expressed in Dotty as
+
 ```scala
 def symDecorator: SymDecorator
 given SymDecorator = symDecorator