Replace the implicitly with summon in the code example for NotGiven

Author: ShapelessCat

docs/docs/reference/contextual/givens.md

@@ -27,6 +27,7 @@ given listOrd[T](using ord: Ord[T]): Ord[List[T]] with
          if fst != 0 then fst else compare(xs1, ys1)
 
 ```
+
 This code defines a trait `Ord` with two given instances. `intOrd` defines
 a given for the type `Ord[Int]` whereas `listOrd[T]` defines givens
 for `Ord[List[T]]` for all types `T` that come with a given instance for `Ord[T]`
@@ -39,20 +40,24 @@ parameters](./using-clauses.md).
 
 The name of a given can be left out. So the definitions
 of the last section can also be expressed like this:
+
 ```scala
 given Ord[Int] with
    ...
 given [T](using Ord[T]): Ord[List[T]] with
    ...
 ```
+
 If the name of a given is missing, the compiler will synthesize a name from
 the implemented type(s).
 
 **Note** The name synthesized by the compiler is chosen to be readable and reasonably concise. For instance, the two instances above would get the names:
+
 ```scala
 given_Ord_Int
 given_Ord_List_T
 ```
+
 The precise rules for synthesizing names are found [here](./relationship-implicits.html#anonymous-given-instances). These rules do not guarantee absence of name conflicts between
 given instances of types that are "too similar". To avoid conflicts one can
 use named instances.
@@ -62,15 +67,18 @@ use named instances.
 ## Alias Givens
 
 An alias can be used to define a given instance that is equal to some expression. E.g.:
+
 ```scala
 given global: ExecutionContext = ForkJoinPool()
 ```
+
 This creates a given `global` of type `ExecutionContext` that resolves to the right
 hand side `ForkJoinPool()`.
 The first time `global` is accessed, a new `ForkJoinPool` is created, which is then
 returned for this and all subsequent accesses to `global`. This operation is thread-safe.
 
 Alias givens can be anonymous as well, e.g.
+
 ```scala
 given Position = enclosingTree.position
 given (using config: Config): Factory = MemoizingFactory(config)
@@ -83,11 +91,13 @@ but it can only implement a single type.
 
 Given aliases can have the `inline` and `transparent` modifiers.
 Example:
+
 ```scala
 transparent inline given mkAnnotations[A, T]: Annotations[A, T] = ${
   // code producing a value of a subtype of Annotations
 }
 ```
+
 Since `mkAnnotations` is `transparent`, the type of an application is the type of its right hand side, which can be a proper subtype of the declared result type `Annotations[A, T]`.
 
 ## Pattern-Bound Given Instances
@@ -100,14 +110,17 @@ for given Context <- applicationContexts do
 pair match
    case (ctx @ given Context, y) => ...
 ```
+
 In the first fragment above, anonymous given instances for class `Context` are established by enumerating over `applicationContexts`. In the second fragment, a given `Context`
 instance named `ctx` is established by matching against the first half of the `pair` selector.
 
 In each case, a pattern-bound given instance consists of `given` and a type `T`. The pattern matches exactly the same selectors as the type ascription pattern `_: T`.
 
 ## Negated Givens
 
-Scala 2's somewhat puzzling behavior with respect to ambiguity has been exploited to implement the analogue of a "negated" search in implicit resolution, where a query Q1 fails if some other query Q2 succeeds and Q1 succeeds if Q2 fails. With the new cleaned up behavior these techniques no longer work. But the new special type `scala.util.NotGiven` now implements negation directly.
+Scala 2's somewhat puzzling behavior with respect to ambiguity has been exploited to implement the analogue of a "negated" search in implicit resolution,
+where a query Q1 fails if some other query Q2 succeeds and Q1 succeeds if Q2 fails. With the new cleaned up behavior these techniques no longer work.
+But the new special type `scala.util.NotGiven` now implements negation directly.
 
 For any query type `Q`, `NotGiven[Q]` succeeds if and only if the implicit
 search for `Q` fails, for example:
@@ -124,8 +137,8 @@ object Foo:
 
 @main def test() =
    given Tagged[Int] with {}
-   assert(implicitly[Foo[Int]].value) // fooTagged is found
-   assert(!implicitly[Foo[String]].value) // fooNotTagged is found
+   assert(summon[Foo[Int]].value) // fooTagged is found
+   assert(!summon[Foo[String]].value) // fooNotTagged is found
 ```
 
 ## Given Instance Initialization
@@ -152,7 +165,7 @@ A given instance starts with the reserved word `given` and an optional _signatur
 defines a name and/or parameters for the instance. It is followed by `:`. There are three kinds
 of given instances:
 
- - A _structural instance_ contains one or more types or constructor applications, followed by `with` and a template body
-that contains member definitions of the instance.
- - An _alias instance_ contains a type, followed by `=` and a right hand side expression.
- - An _abstract instance_ contains just the type, which is not followed by anything.
+- A _structural instance_ contains one or more types or constructor applications,
+  followed by `with` and a template body that contains member definitions of the instance.
+- An _alias instance_ contains a type, followed by `=` and a right hand side expression.
+- An _abstract instance_ contains just the type, which is not followed by anything.