Remove documentation changes

Author: cdce8p

docs/source/cheat_sheet.rst

@@ -103,7 +103,7 @@ Functions
            i += 1
 
    # There's an alternative syntax for functions with many arguments
-   def send_email(address,     # type: str | List[str]
+   def send_email(address,     # type: Union[str, List[str]]
                   sender,      # type: str
                   cc,          # type: Optional[List[str]]
                   bcc,         # type: Optional[List[str]]
@@ -126,8 +126,7 @@ When you're puzzled or when things are complicated
    reveal_type(1) # -> Revealed type is 'builtins.int'
 
    # Use Union when something could be one of a few types
-   # Python 3.9+ (or List[Union[int, str]])
-   x = [3, 5, "test", "fun"]  # type: List[int | str]
+   x = [3, 5, "test", "fun"]  # type: List[Union[int, str]]
 
    # Use Any if you don't know the type of something or it's too
    # dynamic to write a type for

docs/source/cheat_sheet_py3.rst

@@ -143,8 +143,7 @@ When you're puzzled or when things are complicated
    reveal_type(1)  # -> Revealed type is 'builtins.int'
 
    # Use Union when something could be one of a few types
-   # Python 3.9+ (or List[Union[int,str]])
-   x: List[int | str]] = [3, 5, "test", "fun"]
+   x: List[Union[int, str]] = [3, 5, "test", "fun"]
 
    # Use Any if you don't know the type of something or it's too
    # dynamic to write a type for

docs/source/generics.rst

@@ -443,8 +443,7 @@ will reject this function:
 
 .. code-block:: python
 
-   def union_concat(x: str | bytes, y: str | bytes) -> str | bytes:
-   # or def union_concat(x: Union[str, bytes], y: Union[str, bytes]) -> Union[str, bytes]:
+   def union_concat(x: Union[str, bytes], y: Union[str, bytes]) -> Union[str, bytes]:
        return x + y  # Error: can't concatenate str and bytes
 
 Another interesting special case is calling ``concat()`` with a

docs/source/getting_started.rst

@@ -211,15 +211,14 @@ ints or strings, but no other types. You can express this using the :py:data:`~t
 
    from typing import Union
 
-   def normalize_id(user_id: int | str) -> str:
-   # or def normalize_id(user_id: Union[int, str]) -> str:
+   def normalize_id(user_id: Union[int, str]) -> str:
        if isinstance(user_id, int):
            return 'user-{}'.format(100000 + user_id)
        else:
            return user_id
 
 Similarly, suppose that you want the function to accept only strings or ``None``. You can
-again use :py:data:`~typing.Union` and use ``str | None`` (or ``Union[str, None]``) -- or alternatively, use the type
+again use :py:data:`~typing.Union` and use ``Union[str, None]`` -- or alternatively, use the type
 ``Optional[str]``. These two types are identical and interchangeable: ``Optional[str]``
 is just a shorthand or *alias* for ``Union[str, None]``. It exists mostly as a convenience
 to help function signatures look a little cleaner:

docs/source/kinds_of_types.rst

@@ -208,8 +208,8 @@ Python functions often accept values of two or more different
 types. You can use :ref:`overloading <function-overloading>` to
 represent this, but union types are often more convenient.
 
-Use the ``T1|...|Tn`` (or ``Union[T1, ..., Tn]``) type constructor to construct a union
-type. For example, if an argument has type ``int|str`` (or ``Union[int, str]``), both
+Use the ``Union[T1, ..., Tn]`` type constructor to construct a union
+type. For example, if an argument has type ``Union[int, str]``, both
 integers and strings are valid argument values.
 
 You can use an :py:func:`isinstance` check to narrow down a union type to a
@@ -219,7 +219,7 @@ more specific type:
 
    from typing import Union
 
-   def f(x: int | str) -> None:
+   def f(x: Union[int, str]) -> None:
        x + 1     # Error: str + int is not valid
        if isinstance(x, int):
            # Here type of x is int.
@@ -248,7 +248,7 @@ Optional types and the None type
 
 You can use the :py:data:`~typing.Optional` type modifier to define a type variant
 that allows ``None``, such as ``Optional[int]`` (``Optional[X]`` is
-the preferred shorthand for ``X | None`` or ``Union[X, None]``):
+the preferred shorthand for ``Union[X, None]``):
 
 .. code-block:: python
 
@@ -560,15 +560,15 @@ In certain situations, type names may end up being long and painful to type:
 
 .. code-block:: python
 
-   def f() -> List[Dict[Tuple[int, str], Set[int]]] | Tuple[str, List[str]]:
+   def f() -> Union[List[Dict[Tuple[int, str], Set[int]]], Tuple[str, List[str]]]:
        ...
 
 When cases like this arise, you can define a type alias by simply
 assigning the type to a variable:
 
 .. code-block:: python
 
-   AliasType = List[Dict[Tuple[int, str], Set[int]]] | Tuple[str, List[str]]
+   AliasType = Union[List[Dict[Tuple[int, str], Set[int]]], Tuple[str, List[str]]]
 
    # Now we can use AliasType in place of the full name:
 

docs/source/literal_types.rst

@@ -30,9 +30,9 @@ precise type signature for this function using ``Literal[...]`` and overloads:
     # provides a regular bool:
 
     @overload
-    def fetch_data(raw: bool) -> bytes | str: ...
+    def fetch_data(raw: bool) -> Union[bytes, str]: ...
 
-    def fetch_data(raw: bool) -> bytes | str:
+    def fetch_data(raw: bool) -> Union[bytes, str]:
         # Implementation is omitted
         ...
 

docs/source/more_types.rst

@@ -203,7 +203,7 @@ Our first attempt at writing this function might look like this:
     def mouse_event(x1: int,
                     y1: int,
                     x2: Optional[int] = None,
-                    y2: Optional[int] = None) -> ClickEvent | DragEvent:
+                    y2: Optional[int] = None) -> Union[ClickEvent, DragEvent]:
         if x2 is None and y2 is None:
             return ClickEvent(x1, y1)
         elif x2 is not None and y2 is not None:
@@ -247,7 +247,7 @@ to more accurately describe the function's behavior:
     def mouse_event(x1: int,
                     y1: int,
                     x2: Optional[int] = None,
-                    y2: Optional[int] = None) -> ClickEvent | DragEvent:
+                    y2: Optional[int] = None) -> Union[ClickEvent, DragEvent]:
         if x2 is None and y2 is None:
             return ClickEvent(x1, y1)
         elif x2 is not None and y2 is not None:
@@ -281,7 +281,7 @@ return type by using overloads like so:
         @overload
         def __getitem__(self, index: slice) -> Sequence[T]: ...
 
-        def __getitem__(self, index: int | slice) -> T | Sequence[T]:
+        def __getitem__(self, index: Union[int, slice]) -> Union[T, Sequence[T]]:
             if isinstance(index, int):
                 # Return a T here
             elif isinstance(index, slice):
@@ -378,7 +378,7 @@ matching variant returns:
 
 .. code-block:: python
 
-    some_list: List[int] | List[str]
+    some_list: Union[List[int], List[str]]
 
     # output3 is of type 'Union[float, str]'
     output3 = summarize(some_list)
@@ -466,7 +466,7 @@ the following unsafe overload definition:
     @overload
     def unsafe_func(x: object) -> str: ...
 
-    def unsafe_func(x: object) -> int | str:
+    def unsafe_func(x: object) -> Union[int, str]:
         if isinstance(x, int):
             return 42
         else:
@@ -532,8 +532,8 @@ Type checking the implementation
 The body of an implementation is type-checked against the
 type hints provided on the implementation. For example, in the
 ``MyList`` example up above, the code in the body is checked with
-argument list ``index: int | slice`` and a return type of
-``T | Sequence[T]``. If there are no annotations on the
+argument list ``index: Union[int, slice]`` and a return type of
+``Union[T, Sequence[T]]``. If there are no annotations on the
 implementation, then the body is not type checked. If you want to
 force mypy to check the body anyways, use the :option:`--check-untyped-defs <mypy --check-untyped-defs>`
 flag (:ref:`more details here <untyped-definitions-and-calls>`).

docs/source/type_inference_and_annotations.rst

@@ -30,7 +30,7 @@ variable type annotation:
 
    from typing import Union
 
-   x: int | str = 1
+   x: Union[int, str] = 1
 
 Without the type annotation, the type of ``x`` would be just ``int``. We
 use an annotation to give it a more general type ``Union[int, str]`` (this
@@ -42,15 +42,15 @@ type:
 
 .. code-block:: python
 
-   x: int | str = 1.1  # Error!
+   x: Union[int, str] = 1.1  # Error!
 
 The variable annotation syntax is available starting from Python 3.6.
 In earlier Python versions, you can use a special comment after an
 assignment statement to declare the type of a variable:
 
 .. code-block:: python
 
-   x = 1  # type: int | str
+   x = 1  # type: Union[int, str]
 
 We'll use both syntax variants in examples. The syntax variants are
 mostly interchangeable, but the variable annotation syntax allows