Base implementation of PEP 696

Co-authored-by: Marc Mueller <[email protected]>

Author: Gobot1234

Doc/library/typing.rst

@@ -1292,6 +1292,22 @@ These are not used in annotations. They are building blocks for creating generic
 
        c = concatenate('one', b'two')  # error: type variable 'A' can be either str or bytes in a function call, but not both
 
+    If a generic type is commonly generic over just one type you can use
+    ``default`` to specify this type::
+
+        T = TypeVar("T", default=int)
+
+        class Box(Generic[T]):
+            def __init__(self, value: T | None = None):
+                self.value = value
+
+        reveal_type(Box())                      # type is Box[int]
+        reveal_type(Box(value="Hello World!"))  # type is Box[str]
+
+    A TypeVar without a default cannot follow a TypeVar with a default.
+
+    .. TODO add more about this
+
     At runtime, ``isinstance(x, T)`` will raise :exc:`TypeError`.  In general,
     :func:`isinstance` and :func:`issubclass` should not be used with types.
 
@@ -1395,6 +1411,8 @@ These are not used in annotations. They are building blocks for creating generic
 
     See :pep:`646` for more details on type variable tuples.
 
+    .. TODO docs on default
+
     .. versionadded:: 3.11
 
 .. data:: Unpack
@@ -1423,7 +1441,7 @@ These are not used in annotations. They are building blocks for creating generic
 
    .. versionadded:: 3.11
 
-.. class:: ParamSpec(name, *, bound=None, covariant=False, contravariant=False)
+.. class:: ParamSpec(name, *, bound=None, default=..., covariant=False, contravariant=False)
 
    Parameter specification variable.  A specialized version of
    :class:`type variables <TypeVar>`.

Lib/test/test_typing.py

@@ -1,52 +1,35 @@
-import contextlib
+import abc
 import collections
-from collections import defaultdict
-from functools import lru_cache, wraps
+import contextlib
 import inspect
 import itertools
 import pickle
 import re
 import sys
-import warnings
-from unittest import TestCase, main, skipUnless, skip
-from unittest.mock import patch
-from copy import copy, deepcopy
-
-from typing import Any, NoReturn, Never, assert_never
-from typing import overload, get_overloads, clear_overloads
-from typing import TypeVar, TypeVarTuple, Unpack, AnyStr
-from typing import T, KT, VT  # Not in __all__.
-from typing import Union, Optional, Literal
-from typing import Tuple, List, Dict, MutableMapping
-from typing import Callable
-from typing import Generic, ClassVar, Final, final, Protocol
-from typing import assert_type, cast, runtime_checkable
-from typing import get_type_hints
-from typing import get_origin, get_args
-from typing import override
-from typing import is_typeddict
-from typing import reveal_type
-from typing import dataclass_transform
-from typing import no_type_check, no_type_check_decorator
-from typing import Type
-from typing import NamedTuple, NotRequired, Required, TypedDict
-from typing import IO, TextIO, BinaryIO
-from typing import Pattern, Match
-from typing import Annotated, ForwardRef
-from typing import Self, LiteralString
-from typing import TypeAlias
-from typing import ParamSpec, Concatenate, ParamSpecArgs, ParamSpecKwargs
-from typing import TypeGuard
-import abc
 import textwrap
+import types
 import typing
+import warnings
 import weakref
-import types
-
-from test.support import import_helper, captured_stderr, cpython_only
-from test import mod_generics_cache
-from test import _typed_dict_helper
-
+from collections import defaultdict
+from copy import copy, deepcopy
+from functools import lru_cache, wraps
+from test import _typed_dict_helper, mod_generics_cache
+from test.support import captured_stderr, cpython_only, import_helper
+from typing import (IO, KT, VT, Annotated, Any, AnyStr,  # Not in __all__.
+                    BinaryIO, Callable, ClassVar, Concatenate, Dict, Final,
+                    ForwardRef, Generic, List, Literal, LiteralString, Match,
+                    MutableMapping, NamedTuple, Never, NoReturn, NotRequired,
+                    Optional, ParamSpec, ParamSpecArgs, ParamSpecKwargs,
+                    Pattern, Protocol, Required, Self, T, TextIO, Tuple, Type,
+                    TypeAlias, TypedDict, TypeGuard, TypeVar, TypeVarTuple,
+                    Union, Unpack, assert_never, assert_type, cast,
+                    clear_overloads, dataclass_transform, final, get_args,
+                    get_origin, get_overloads, get_type_hints, is_typeddict,
+                    no_type_check, no_type_check_decorator, overload, override,
+                    reveal_type, runtime_checkable)
+from unittest import TestCase, main, skip, skipUnless
+from unittest.mock import patch
 
 py_typing = import_helper.import_fresh_module('typing', blocked=['_typing'])
 c_typing = import_helper.import_fresh_module('typing', fresh=['_typing'])
@@ -447,6 +430,22 @@ def test_bound_errors(self):
         with self.assertRaises(TypeError):
             TypeVar('X', str, float, bound=Employee)
 
+    def test_default_error(self):
+        with self.assertRaises(TypeError):
+            TypeVar('X', default=Union)
+
+    def test_default_ordering(self):
+        T = TypeVar("T")
+        U = TypeVar("U", default=int)
+        V = TypeVar("V", default=float)
+
+        class Foo(Generic[T, U]): ...
+        with self.assertRaises(TypeError):
+            class Bar(Generic[U, T]): ...
+
+        class Baz(Foo[V]): ...
+
+
     def test_missing__name__(self):
         # See bpo-39942
         code = ("import typing\n"
@@ -3698,22 +3697,24 @@ def test_immutability_by_copy_and_pickle(self):
         TPB = TypeVar('TPB', bound=int)
         TPV = TypeVar('TPV', bytes, str)
         PP = ParamSpec('PP')
-        for X in [TP, TPB, TPV, PP,
+        TD = TypeVar('TD', default=int)
+        for X in [TP, TPB, TPV, PP, TD,
                   List, typing.Mapping, ClassVar, typing.Iterable,
                   Union, Any, Tuple, Callable]:
             with self.subTest(thing=X):
                 self.assertIs(copy(X), X)
                 self.assertIs(deepcopy(X), X)
                 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
                     self.assertIs(pickle.loads(pickle.dumps(X, proto)), X)
-        del TP, TPB, TPV, PP
+        del TP, TPB, TPV, PP, TD
 
         # Check that local type variables are copyable.
         TL = TypeVar('TL')
         TLB = TypeVar('TLB', bound=int)
         TLV = TypeVar('TLV', bytes, str)
         PL = ParamSpec('PL')
-        for X in [TL, TLB, TLV, PL]:
+        TDL = TypeVar('TDL', default=int)
+        for X in [TL, TLB, TLV, PL, TDL]:
             with self.subTest(thing=X):
                 self.assertIs(copy(X), X)
                 self.assertIs(deepcopy(X), X)
@@ -4415,6 +4416,7 @@ def test_errors(self):
 # We need this to make sure that `@no_type_check` respects `__module__` attr:
 from test import ann_module8
 
+
 @no_type_check
 class NoTypeCheck_Outer:
     Inner = ann_module8.NoTypeCheck_Outer.Inner
@@ -6981,7 +6983,7 @@ def stuff(a: BinaryIO) -> bytes:
     def test_io_submodule(self):
         with warnings.catch_warnings(record=True) as w:
             warnings.filterwarnings("default", category=DeprecationWarning)
-            from typing.io import IO, TextIO, BinaryIO, __all__, __name__
+            from typing.io import IO, BinaryIO, TextIO, __all__, __name__
             self.assertIs(IO, typing.IO)
             self.assertIs(TextIO, typing.TextIO)
             self.assertIs(BinaryIO, typing.BinaryIO)
@@ -8058,6 +8060,7 @@ class AllTests(BaseTestCase):
 
     def test_all(self):
         from typing import __all__ as a
+
         # Just spot-check the first and last of every category.
         self.assertIn('AbstractSet', a)
         self.assertIn('ValuesView', a)

Lib/typing.py

@@ -250,16 +250,27 @@ def _collect_parameters(args):
         _collect_parameters((T, Callable[P, T])) == (T, P)
     """
     parameters = []
+    seen_default = False
     for t in args:
         # We don't want __parameters__ descriptor of a bare Python class.
         if isinstance(t, type):
             continue
         if hasattr(t, '__typing_subst__'):
             if t not in parameters:
+                if t.__default__ is not None:
+                    seen_default = True
+                elif seen_default:
+                    raise TypeError("TypeVarLike without a default follows one with a default")
+
                 parameters.append(t)
         else:
             for x in getattr(t, '__parameters__', ()):
                 if x not in parameters:
+                    if x.__default__ is not None:
+                        seen_default = True
+                    elif seen_default:
+                        raise TypeError("TypeVarLike without a default follows one with a default")
+
                     parameters.append(x)
     return tuple(parameters)
 
@@ -956,7 +967,24 @@ def __mro_entries__(self, bases):
         raise TypeError(f"Cannot subclass an instance of {type(self).__name__}")
 
 
-class TypeVar(_Final, _Immutable, _BoundVarianceMixin, _PickleUsingNameMixin,
+_marker = object()
+
+
+class _DefaultMixin:
+    """Mixin for TypeVarLike defaults."""
+
+    def __init__(self, default):
+        if isinstance(default, (tuple, list)):
+            self.__default__ = default.__class__(
+                (_type_check(d, "Defaults must all be types") for d in default)
+            )
+        elif default != _marker:
+            self.__default__ = _type_check(default, "Default must be a type")
+        else:
+            self.__default__ = None
+
+
+class TypeVar(_Final, _Immutable, _BoundVarianceMixin, _PickleUsingNameMixin, _DefaultMixin,
               _root=True):
     """Type variable.
 
@@ -1001,10 +1029,11 @@ def longest(x: A, y: A) -> A:
     Note that only type variables defined in global scope can be pickled.
     """
 
-    def __init__(self, name, *constraints, bound=None,
+    def __init__(self, name, *constraints, bound=None, default=_marker,
                  covariant=False, contravariant=False):
         self.__name__ = name
         super().__init__(bound, covariant, contravariant)
+        _DefaultMixin.__init__(self, default)
         if constraints and bound is not None:
             raise TypeError("Constraints cannot be combined with bound=...")
         if constraints and len(constraints) == 1:
@@ -1024,7 +1053,7 @@ def __typing_subst__(self, arg):
         return arg
 
 
-class TypeVarTuple(_Final, _Immutable, _PickleUsingNameMixin, _root=True):
+class TypeVarTuple(_Final, _Immutable, _PickleUsingNameMixin, _DefaultMixin, _root=True):
     """Type variable tuple.
 
     Usage:
@@ -1049,8 +1078,9 @@ class C(Generic[*Ts]): ...
     Note that only TypeVarTuples defined in global scope can be pickled.
     """
 
-    def __init__(self, name):
+    def __init__(self, name, *, default=_marker):
         self.__name__ = name
+        _DefaultMixin.__init__(self, default)
 
         # Used for pickling.
         def_mod = _caller()
@@ -1160,7 +1190,7 @@ def __mro_entries__(self, bases):
         raise TypeError(f"Cannot subclass an instance of {type(self).__name__}")
 
 
-class ParamSpec(_Final, _Immutable, _BoundVarianceMixin, _PickleUsingNameMixin,
+class ParamSpec(_Final, _Immutable, _BoundVarianceMixin, _PickleUsingNameMixin, _DefaultMixin,
                 _root=True):
     """Parameter specification variable.
 
@@ -1215,9 +1245,10 @@ def args(self):
     def kwargs(self):
         return ParamSpecKwargs(self)
 
-    def __init__(self, name, *, bound=None, covariant=False, contravariant=False):
+    def __init__(self, name, *, bound=None, default=None, covariant=False, contravariant=False):
         self.__name__ = name
         super().__init__(bound, covariant, contravariant)
+        _DefaultMixin.__init__(self, default)
         def_mod = _caller()
         if def_mod != 'typing':
             self.__module__ = def_mod