Cross-write page Context Bounds

- remove tag “Scala 3 only”
- add a link to the page that explains context parameters and inferred terms
- remove paragraph that shows anonymous context parameters
- fix link to the FAQ
- also cross-write the FAQ entry

Author: julienrf

_overviews/FAQ/index.md

@@ -149,9 +149,9 @@ See [this]({{ site.baseurl }}/tutorials/FAQ/initialization-order.html).
 
 See the [Scala 2.13 Collections Guide](https://docs.scala-lang.org/overviews/collections-2.13/introduction.html).
 
-### What are context bounds (`[T : Foo]`)?
+### What are context bounds?
 
-It's syntactic sugar for an `implicit` parameter of type `Foo[T]`.
+It's syntactic sugar for a context parameter (an `implicit` parameter in Scala 2, or a `using` parameter in Scala 3).
 
 More details in this [Stack Overflow answer](https://stackoverflow.com/a/4467012).
 

_overviews/scala3-book/ca-context-bounds.md

@@ -1,66 +1,48 @@
 ---
 title: Context Bounds
 type: section
-description: This page demonstrates Context Bounds in Scala 3.
+description: This page demonstrates Context Bounds in Scala.
 languages: [zh-cn]
 num: 61
 previous-page: ca-given-using-clauses
 next-page: ca-given-imports
 ---
-<span class="tag tag-inline">Scala 3 only</span>
 
-
-{% comment %}
-- TODO: define "context parameter"
-- TODO: define "synthesized" and "synthesized arguments"
-{% endcomment %}
-
-In many situations the name of a _context parameter_ doesn’t have to be mentioned explicitly, since it’s only used by the compiler in synthesized arguments for other context parameters.
+In many situations the name of a [context parameter]({% link _overviews/scala3-book/ca-given-using-clauses.md %}#using-clauses) doesn’t have to be mentioned explicitly, since it’s only used by the compiler in synthesized arguments for other context parameters.
 In that case you don’t have to define a parameter name, and can just provide the parameter type.
 
 
 ## Background
 
 For example, this `maximum` method takes a _context parameter_ of type `Ord`, only to pass it on as an argument to `max`:
 
-{% tabs context-bounds-max-named-param %}
-
-{% tab 'Scala 3 Only' %}
+{% tabs context-bounds-max-named-param class=tabs-scala-version %}
 
+{% tab 'Scala 2' %}
 ```scala
-def maximum[A](xs: List[A])(using ord: Ord[A]): A =
+def maximum[A](xs: List[A])(implicit ord: Ord[A]): A =
   xs.reduceLeft(max(ord))
 ```
-
 {% endtab %}
 
-{% endtabs %}
-
-In that code the parameter name `ord` isn’t actually required; it can be passed on as an inferred argument to `max`, so you just state that `maximum` uses the type `Ord[A]` without giving it a name:
-
-{% tabs context-bounds-no-param-name %}
-
-{% tab 'Scala 3 Only' %}
-
+{% tab 'Scala 3' %}
 ```scala
-def maximum[A](xs: List[A])(using Ord[A]): A =
-  xs.reduceLeft(max)
+def maximum[A](xs: List[A])(using ord: Ord[A]): A =
+  xs.reduceLeft(max(ord))
 ```
-
 {% endtab %}
 
 {% endtabs %}
 
-
 ## Context bounds
 
-Given that background, a _context bound_ is a shorthand syntax for expressing the pattern of, “a context parameter that depends on a type parameter.”
+Given that background, a _context bound_ is a shorthand syntax for expressing the pattern of, “a context parameter applied to a type parameter.”
 
 Using a context bound, the `maximum` method can be written like this:
 
 {% tabs context-bounds-max-rewritten %}
 
-{% tab 'Scala 3 Only' %}
+{% tab 'Scala 2 and 3' %}
 
 ```scala
 def maximum[A: Ord](xs: List[A]): A = xs.reduceLeft(max)
@@ -71,6 +53,7 @@ def maximum[A: Ord](xs: List[A]): A = xs.reduceLeft(max)
 {% endtabs %}
 
 
-A bound like `: Ord` on a type parameter `A` of a method or class indicates a context parameter with `Ord[A]`.
+A bound like `: Ord` on a type parameter `A` of a method or class indicates a context parameter with type `Ord[A]`.
+Under the hood, the compiler transforms this syntax into the one shown in the Background section.
 
-For more information about context bounds, see the [“What are context bounds?”](https://docs.scala-lang.org/tutorials/FAQ/context-bounds.html) section of the Scala FAQ.
+For more information about context bounds, see the [“What are context bounds?”]({% link _overviews/FAQ/index.md %}#what-are-context-bounds) section of the Scala FAQ.

_overviews/scala3-book/ca-given-using-clauses.md

@@ -63,7 +63,7 @@ def renderWidget(items: List[String])(using c: Config): String = ???
 {% endtab %}
 {% endtabs %}
 
-By starting a parameter section with the keyword `using`, we tell the Scala compiler that at the callsite it should automatically find an argument with the correct type.
+By starting a parameter section with the keyword `using`, we tell the Scala compiler that at the call-site it should automatically find an argument with the correct type.
 The Scala compiler thus performs **term inference**.
 
 In our call to `renderWidget(List("cart"))` the Scala compiler will see that there is a term of type `Config` in scope (the `c`) and automatically provide it to `renderWidget`.