PEP-785: fix links and formatting

Author: Zac-HD

peps/pep-0785.rst

@@ -19,7 +19,8 @@ propose adding two new methods to exception objects:
 
 - :meth:`!BaseException.preserve_context`, a context manager which
   saves and restores the :attr:`!self.__context__` attribute of ``self``,
-  so that raising the exception within an ``except:`` block.
+  so that re-raising the exception within another handler does not overwrite
+  the existing context.
 
 We expect this to enable more concise expression of error handling logic in
 many medium-complexity cases. Without them, exception-group handlers will
@@ -121,38 +122,30 @@ Usage example:
         with first.preserve_context():
             raise first
 
-Without ``.preserve_context()``, this could would have to either:
+Without ``.preserve_context()``, this code would have to either:
 
 * arrange for the exception to be raised *after* the ``except*`` block,
   making code difficult to follow in nontrivial cases, or
 * discard the existing ``__context__`` of the ``first`` exception, replacing
   it with an ``ExceptionGroup`` which is simply an implementation detail, or
-* use ``try/except`` instead of ``except*``, handling the possibility that
-  the group doesn't contain an ``HTTPException`` at all,[#catch-raw-group]_ or
-* implement the semantics of ``.preserve_context()`` inline::
-
-    prev_ctx = first.__context__
-    try:
-        raise first  # or `raise first from None`, etc.
-    finally:
-        first.__context__ = prev_ctx
-        del prev_ctx  # break gc cycle
-
-  which is not *literally unheard-of*, but remains very very rare.
+* use ``try/except`` instead of ``except*``, handling the possibility that the
+  group doesn't contain an ``HTTPException`` at all,\ [#catch-raw-group]_ or
+* implement the semantics of ``.preserve_context()`` inline; while this is not
+  *literally unheard-of*, it remains very rare.
 
 
 Backwards Compatibility
 =======================
 
 Adding new methods to built-in classes, especially those as widely used as
 ``BaseException``, can have substantial impacts. However, GitHub search shows
-no collisions for these method names (`zero hits <flat-exceptions>`_ and
-`three unrelated hits <preserve-context>`_ respectively). If user-defined
-methods with these names exist in private code they will shadow those proposed
-in the PEP, without changing runtime behavior.
+no collisions for these method names (`zero hits`__ and
+`three unrelated hits`__ respectively). If user-defined methods with these
+names exist in private code they will shadow those proposed in the PEP,
+without changing runtime behavior.
 
-.. _flat-exceptions: https://github.com/search?q=%2F%5C.flat_exceptions%5C%28%2F+language%3APython&type=code
-.. _preserve-context: https://github.com/search?q=%2F%5C.preserve_context%5C%28%2F+language%3APython&type=code
+__ https://github.com/search?q=%2F%5C.flat_exceptions%5C%28%2F+language%3APython&type=code
+__ https://github.com/search?q=%2F%5C.preserve_context%5C%28%2F+language%3APython&type=code
 
 
 How to Teach This
@@ -165,13 +158,14 @@ In intermediate classes, we recommend teaching ``.flat_exceptions()`` together
 with the ``.split()`` and ``.subgroup()`` methods, and mentioning
 ``.preserve_context()`` as an advanced option to address specific pain points.
 
-Both the API reference and the existing `ExceptionGroup tutorial
-<https://docs.python.org/3/tutorial/errors.html#exception-groups>`_ should
-be updated to demonstrate and explain the new methods. The tutorial should
-include examples of common patterns where ``.flat_exceptions()`` and
+Both the API reference and the existing `ExceptionGroup tutorial`__
+should be updated to demonstrate and explain the new methods. The tutorial
+should include examples of common patterns where ``.flat_exceptions()`` and
 ``.preserve_context()`` help simplify error handling logic. Downstream
 libraries which often use exception groups could include similar docs.
 
+__ https://docs.python.org/3/tutorial/errors.html#raising-and-handling-multiple-unrelated-exceptions
+
 We have also designed lint rules for inclusion in ``flake8-async`` which will
 suggest using ``.flat_exceptions()`` when iterating over ``group.exceptions``
 or re-raising a leaf exception, and suggest using ``.preserve_context()`` when
@@ -288,7 +282,6 @@ Add utility functions instead of methods
 
 Rather than adding methods to exceptions, we could provide utility functions
 like the reference implementations above.
-
 There are however several reasons to prefer methods: there's no obvious place
 where helper functions should live, they take exactly one argument which must
 be an instance of ``BaseException``, and methods are both more convenient and
@@ -369,15 +362,15 @@ Footnotes
       `six <https://github.com/PaLora16/ExceptionsGroupsValidators/blob/41152a86eec695168fdec74653694658ddc788fc/main.py#L39-L44>`__,
       `seven <https://github.com/reactive-python/reactpy/blob/178fc05de7756f7402ed2ee1e990af0bdad42d9e/src/reactpy/backend/starlette.py#L164-L170>`__)
 
-    indicating that more than a quarter of _all_ hits for this fairly general
+    indicating that more than a quarter of *all* hits for this fairly general
     search would benefit from the methods proposed in this PEP.
 
 .. [#catch-raw-group]
     This remains very rare, and most cases duplicate logic across
     ``except FooError:`` and ``except ExceptionGroup:  # containing FooError``
-    clauses rather than using something like the as_group trick.
-    We expect that ``except*`` will be widely used in such cases, before
-    the methods proposed by this PEP are widely available.
+    clauses rather than using something like the ``as_group()`` trick.
+    We expect that ``except*`` will be widely used in such cases by the time
+    that the methods proposed by this PEP are widely available.
 
 
 Copyright