We're not using docutils, replace :code: with inline literals

Author: hugovk

pep-0613.rst

@@ -38,7 +38,7 @@ diagnosis of malformed type aliases downstream.
 
 The following examples each include an illustration of some of the suboptimal
 or confusing behaviors resulting from existing implicit alias declarations.
-We also introduce explicit aliases of the format :code:`TypeName: TypeAlias = Expression`
+We also introduce explicit aliases of the format ``TypeName: TypeAlias = Expression``
 here for the sake of comparison, but the syntax is discussed in further detail
 in later sections.
 
@@ -50,10 +50,10 @@ Forward References:
   MyType = "ClassName"
   def foo() -> MyType: ...
 
-This code snippet should not error so long as :code:`ClassName` is defined
+This code snippet should not error so long as ``ClassName`` is defined
 later on. However, a type checker is forced to assume that MyType is a value
 assignment rather than a type alias, and therefore may throw spurious errors
-that (1) :code:`MyType` is an unannotated global string, and (2) :code:`MyType`
+that (1) ``MyType`` is an unannotated global string, and (2) ``MyType``
 cannot be used as a return annotation because it is not a valid type.
 
 ::
@@ -62,7 +62,7 @@ cannot be used as a return annotation because it is not a valid type.
   def foo() -> MyType: ...
 
 Explicit aliases remove ambiguity so neither of the above errors will be
-thrown. Additionally, if something is wrong with :code:`ClassName`
+thrown. Additionally, if something is wrong with ``ClassName``
 (i.e., it’s not actually defined later), the type checker can throw an error.
 
 
@@ -74,11 +74,11 @@ Error Messaging:
   MyType1 = InvalidType
   MyType2 = MyGeneric(int)  # i.e., intention was MyGeneric[int]
 
-A type checker should warn on this code snippet that :code:`InvalidType` is not
+A type checker should warn on this code snippet that ``InvalidType`` is not
 a valid type, and therefore cannot be used to annotate an expression or to
 construct a type alias. Instead, type checkers are forced to throw spurious
-errors that (1) :code:`MyType` is a global expression missing an annotation,
-and (2) :code:`MyType` is not a valid type in all usages of :code:`MyType`
+errors that (1) ``MyType`` is a global expression missing an annotation,
+and (2) ``MyType`` is not a valid type in all usages of ``MyType``
 across the codebase.
 
 ::
@@ -87,9 +87,9 @@ across the codebase.
   MyType2: TypeAlias = MyGeneric(int)
 
 With explicit aliases, the type checker has enough information to error on the
-actual definition of the bad type alias, and explain why: that :code:`MyGeneric(int)`
-and code:`InvalidType` are not valid types. When the value expression is no longer
-evaluated as a global value, unactionable type errors on all usages of :code:`MyType`
+actual definition of the bad type alias, and explain why: that ``MyGeneric(int)``
+and ``InvalidType`` are not valid types. When the value expression is no longer
+evaluated as a global value, unactionable type errors on all usages of ``MyType``
 across the codebase can be suppressed.
 
 Scope Restrictions:
@@ -101,8 +101,8 @@ Scope Restrictions:
   def foo() -> None:
     x = ClassName
 
-The outer :code:`x` is a valid type alias, but type checkers must error if the
-inner :code:`x` is ever used as a type because type aliases cannot be defined
+The outer ``x`` is a valid type alias, but type checkers must error if the
+inner ``x`` is ever used as a type because type aliases cannot be defined
 inside a nested scope.
 This is confusing because the alias declaration rule is not explicit, and because
 a type error will not be thrown on the location of the inner type alias declaration
@@ -158,7 +158,7 @@ Explicit syntax:
 
 Note: The examples above illustrate implicit and explicit alias declarations in
 isolation. For the sake of backwards compatibility, type checkers should support
-both simultaneously, meaning an untyped global expression :code:`x = int` will
+both simultaneously, meaning an untyped global expression ``x = int`` will
 still be considered a valid type alias.
 
 
@@ -192,11 +192,11 @@ This looks a lot like an uninitialized variable.
   MyType = TypeAlias[int]
 
 Along with the option above, this format potentially adds confusion around
-what the runtime value of :code:`MyType` is.
+what the runtime value of ``MyType`` is.
 
 
-In comparison, the chosen syntax option :code:`MyType: TypeAlias = int` is
-appealing because it still sticks with the :code:`MyType = int` assignment
+In comparison, the chosen syntax option ``MyType: TypeAlias = int`` is
+appealing because it still sticks with the ``MyType = int`` assignment
 syntax, and adds some information for the type checker purely as an annotation.