May 3, 2024 · Feb 29, 2024 · Feb 29, 2024 · Feb 29, 2024 · Feb 29, 2024 · Mar 1, 2024
diff --git a/Doc/library/typing.rst b/Doc/library/typing.rst

   .. attribute:: __default__

      The default value of the type variable, if any. This attribute is ``None``
      if the type variable has no default, and :class:`types.NoneType`
      if the default is set to ``None``.
      The default value of the type variable, or :data:`typing.NoDefault` if it
      has no default.

      .. versionadded:: 3.13

   .. method:: has_default()

      Return whether or not the type variable has a default value. This is equivalent
      to checking whether :attr:`__default__` is not equal to :data:`typing.NoDefault`,
      except that it does not force evaluation of the
      :ref:`lazily evaluated <lazy-evaluation>` default value.

      .. versionadded:: 3.13


   .. attribute:: __default__

      The default value of the type variable tuple, if any. This attribute is ``None``
      if the type variable tuple has no default, and :class:`types.NoneType`
      if the default is set to ``None``.
      The default value of the type variable tuple, or :data:`typing.NoDefault` if it
      has no default.

      .. versionadded:: 3.13

   .. method:: has_default()

      Return whether or not the type variable tuple has a default value. This is equivalent
      to checking whether :attr:`__default__` is not equal to :data:`typing.NoDefault`,
      except that it does not force evaluation of the
      :ref:`lazily evaluated <lazy-evaluation>` default value.

      .. versionadded:: 3.13


   .. attribute:: __default__

      The default value of the parameter specification, if any. This attribute is ``None``
      if the parameter specification has no default, and :class:`types.NoneType`
      if the default is set to ``None``.
      The default value of the parameter specification, or :data:`typing.NoDefault` if it
      has no default.

      .. versionadded:: 3.13

   .. method:: has_default()

      Return whether or not the parameter specification has a default value. This is equivalent
      to checking whether :attr:`__default__` is not equal to :data:`typing.NoDefault`,
      except that it does not force evaluation of the
      :ref:`lazily evaluated <lazy-evaluation>` default value.

      .. versionadded:: 3.13


   A sentinel object used to indicate that a type parameter has no default
   value. For example:


   .. doctest::


      >>> T = TypeVar("T")
      >>> T.__default__ is typing.NoDefault
      True
diff --git a/Lib/test/test_type_params.py b/Lib/test/test_type_params.py
 import weakref
 from test.support import requires_working_socket, check_syntax_error, run_code

 from typing import Generic, Sequence, TypeVar, TypeVarTuple, ParamSpec, get_args
 from typing import Generic,NoDefault,Sequence, TypeVar, TypeVarTuple, ParamSpec, get_args


 class TypeParamsInvalidTest(unittest.TestCase):
        self.assertEqual(type_params[0].__name__, "T")
        self.assertIs(type_params[0].__bound__, Foo)
        self.assertEqual(type_params[0].__constraints__, ())
        self.assertIs(type_params[0].__default__,None)
        self.assertIs(type_params[0].__default__,NoDefault)

        self.assertEqual(type_params[1].__name__, "U")
        self.assertIs(type_params[1].__bound__, None)
        self.assertEqual(type_params[1].__constraints__, (Foo, Foo))
        self.assertIs(type_params[1].__default__,None)
        self.assertIs(type_params[1].__default__,NoDefault)

    def test_evaluation_error(self):
        class Foo[T: Undefined, U: (Undefined,)]:
            type_params[0].__bound__
        self.assertEqual(type_params[0].__constraints__, ())
        self.assertIs(type_params[1].__bound__, None)
        self.assertIs(type_params[0].__default__,None)
        self.assertIs(type_params[1].__default__,None)
        self.assertIs(type_params[0].__default__,NoDefault)
        self.assertIs(type_params[1].__default__,NoDefault)
        with self.assertRaises(NameError):
            type_params[1].__constraints__

        T, U, V = ns["func"].__type_params__
        self.assertIs(T.__default__, int)
        self.assertIs(U.__default__, float)
        self.assertIs(V.__default__,type(None))
        self.assertIs(V.__default__, None)

    def test_defaults_on_class(self):
        ns = run_code("""
        T, U, V = ns["C"].__type_params__
        self.assertIs(T.__default__, int)
        self.assertIs(U.__default__, float)
        self.assertIs(V.__default__,type(None))
        self.assertIs(V.__default__, None)

    def test_defaults_on_type_alias(self):
        ns = run_code("""
        T, U, V = ns["Alias"].__type_params__
        self.assertIs(T.__default__, int)
        self.assertIs(U.__default__, float)
        self.assertIs(V.__default__,type(None))
        self.assertIs(V.__default__, None)

    def test_starred_invalid(self):
        check_syntax_error(self, "type Alias[T = *int] = int")
diff --git a/Lib/test/test_typing.py b/Lib/test/test_typing.py
    def test_typevar(self):
        T = TypeVar('T', default=int)
        self.assertEqual(T.__default__, int)
        self.assertTrue(T.has_default())
        self.assertIsInstance(T, TypeVar)

        class A(Generic[T]): ...
        U = TypeVar('U')
        U_None = TypeVar('U_None', default=None)
        self.assertIs(U.__default__, NoDefault)
        self.assertFalse(U.has_default())
        self.assertIs(U_None.__default__, None)
        self.assertTrue(U_None.has_default())

        class X[T]: ...
        T, = X.__type_params__
        self.assertIs(T.__default__, NoDefault)
        self.assertFalse(T.has_default())

    def test_paramspec(self):
        P = ParamSpec('P', default=(str, int))
        self.assertEqual(P.__default__, (str, int))
        self.assertTrue(P.has_default())
        self.assertIsInstance(P, ParamSpec)

        class A(Generic[P]): ...
        U = ParamSpec('U')
        U_None = ParamSpec('U_None', default=None)
        self.assertIs(U.__default__, NoDefault)
        self.assertFalse(U.has_default())
        self.assertIs(U_None.__default__, None)
        self.assertTrue(U_None.has_default())

        class X[**P]: ...
        P, = X.__type_params__
        self.assertIs(P.__default__, NoDefault)
        self.assertFalse(P.has_default())

    def test_typevartuple(self):
        Ts = TypeVarTuple('Ts', default=Unpack[Tuple[str, int]])
        self.assertEqual(Ts.__default__, Unpack[Tuple[str, int]])
        self.assertTrue(Ts.has_default())
        self.assertIsInstance(Ts, TypeVarTuple)

        class A(Generic[Unpack[Ts]]): ...
        U = TypeVarTuple('U')
        U_None = TypeVarTuple('U_None', default=None)
        self.assertIs(U.__default__, NoDefault)
        self.assertFalse(U.has_default())
        self.assertIs(U_None.__default__, None)
        self.assertTrue(U_None.has_default())

        class X[**Ts]: ...
        Ts, = X.__type_params__
        self.assertIs(Ts.__default__, NoDefault)
        self.assertFalse(Ts.has_default())

    def test_no_default_after_non_default(self):
        DefaultStrT = TypeVar('DefaultStrT', default=str)
diff --git a/Lib/typing.py b/Lib/typing.py
                        parameters.append(collected)
        elif hasattr(t, '__typing_subst__'):
            if t not in parameters:
                if type_var_tuple_encountered and t.__default__ is not NoDefault:
                if type_var_tuple_encountered and t.has_default():
                    raise TypeError('Type parameter with a default'
                                    ' follows TypeVarTuple')

                if t.__default__ is not NoDefault:
                if t.has_default():
                    default_encountered = True
                elif default_encountered:
                    raise TypeError(f'Type parameter {t!r} without a default'
            # the number of arguments being passed not matching the number
            # of parameters: all parameters that aren't explicitly
            # specialized in this call are parameters with default values.
            if cls.__parameters__[actual_len].__default__ is not NoDefault:
            if cls.__parameters__[actual_len].has_default():
                return

            expected_len -= sum(p.__default__ is not NoDefault for p in cls.__parameters__)
            expected_len -= sum(p.has_default() for p in cls.__parameters__)
            expect_val = f"at least {expected_len}"
        else:
            expect_val = expected_len
    elif left + right > alen:
        raise TypeError(f"Too few arguments for {alias};"
                        f" actual {alen}, expected at least {plen-1}")
    if left == alen - right and self.__default__ is not NoDefault:
    if left == alen - right and self.has_default():
        replacement = _unpack_args(self.__default__)
    else:
        replacement = args[left: alen - right]
 def _paramspec_prepare_subst(self, alias, args):
    params = alias.__parameters__
    i = params.index(self)
    if i == len(args) and self.__default__ is not NoDefault:
    if i == len(args) and self.has_default():
        args = [*args, self.__default__]
    if i >= len(args):
        raise TypeError(f"Too few arguments for {alias}")
diff --git a/Objects/clinic/typevarobject.c.h b/Objects/clinic/typevarobject.c.h
Original file line number	Diff line number	Diff line change
Expand Up		@@ -1756,9 +1756,17 @@ without the dedicated syntax, as documented below.

		.. attribute:: __default__

		The default value of the type variable, if any. This attribute is ``None``
		if the type variable has no default, and :class:`types.NoneType`
		if the default is set to ``None``.
		The default value of the type variable, or :data:`typing.NoDefault` if it
		has no default.

		.. versionadded:: 3.13

		.. method:: has_default()

		Return whether or not the type variable has a default value. This is equivalent
		to checking whether :attr:`__default__` is not equal to :data:`typing.NoDefault`,
		except that it does not force evaluation of the
JelleZijlstra marked this conversation as resolved. OutdatedShow resolvedHide resolved
		:ref:`lazily evaluated <lazy-evaluation>` default value.

		.. versionadded:: 3.13

Expand DownExpand Up		@@ -1886,9 +1894,17 @@ without the dedicated syntax, as documented below.

		.. attribute:: __default__

		The default value of the type variable tuple, if any. This attribute is ``None``
		if the type variable tuple has no default, and :class:`types.NoneType`
		if the default is set to ``None``.
		The default value of the type variable tuple, or :data:`typing.NoDefault` if it
		has no default.

		.. versionadded:: 3.13

		.. method:: has_default()

		Return whether or not the type variable tuple has a default value. This is equivalent
		to checking whether :attr:`__default__` is not equal to :data:`typing.NoDefault`,
		except that it does not force evaluation of the
JelleZijlstra marked this conversation as resolved. OutdatedShow resolvedHide resolved
		:ref:`lazily evaluated <lazy-evaluation>` default value.

		.. versionadded:: 3.13

Expand DownExpand Up		@@ -1974,9 +1990,17 @@ without the dedicated syntax, as documented below.

		.. attribute:: __default__

		The default value of the parameter specification, if any. This attribute is ``None``
		if the parameter specification has no default, and :class:`types.NoneType`
		if the default is set to ``None``.
		The default value of the parameter specification, or :data:`typing.NoDefault` if it
		has no default.

		.. versionadded:: 3.13

		.. method:: has_default()

		Return whether or not the parameter specification has a default value. This is equivalent
		to checking whether :attr:`__default__` is not equal to :data:`typing.NoDefault`,
		except that it does not force evaluation of the
JelleZijlstra marked this conversation as resolved. OutdatedShow resolvedHide resolved
		:ref:`lazily evaluated <lazy-evaluation>` default value.

		.. versionadded:: 3.13

Expand DownExpand Up		@@ -3213,9 +3237,9 @@ Introspection helpers

		A sentinel object used to indicate that a type parameter has no default
		value. For example:


		.. doctest::


		>>> T = TypeVar("T")
		>>> T.__default__ is typing.NoDefault
		True
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -6,7 +6,7 @@
		import weakref
		from test.support import requires_working_socket, check_syntax_error, run_code

		from typing import Generic, Sequence, TypeVar, TypeVarTuple, ParamSpec, get_args
		from typing import Generic,NoDefault,Sequence, TypeVar, TypeVarTuple, ParamSpec, get_args


		class TypeParamsInvalidTest(unittest.TestCase):
Expand DownExpand Up		@@ -599,12 +599,12 @@ class Foo[T: Foo, U: (Foo, Foo)]:
		self.assertEqual(type_params[0].__name__, "T")
		self.assertIs(type_params[0].__bound__, Foo)
		self.assertEqual(type_params[0].__constraints__, ())
		self.assertIs(type_params[0].__default__,None)
		self.assertIs(type_params[0].__default__,NoDefault)

		self.assertEqual(type_params[1].__name__, "U")
		self.assertIs(type_params[1].__bound__, None)
		self.assertEqual(type_params[1].__constraints__, (Foo, Foo))
		self.assertIs(type_params[1].__default__,None)
		self.assertIs(type_params[1].__default__,NoDefault)

		def test_evaluation_error(self):
		class Foo[T: Undefined, U: (Undefined,)]:
Expand All		@@ -615,8 +615,8 @@ class Foo[T: Undefined, U: (Undefined,)]:
		type_params[0].__bound__
		self.assertEqual(type_params[0].__constraints__, ())
		self.assertIs(type_params[1].__bound__, None)
		self.assertIs(type_params[0].__default__,None)
		self.assertIs(type_params[1].__default__,None)
		self.assertIs(type_params[0].__default__,NoDefault)
		self.assertIs(type_params[1].__default__,NoDefault)
		with self.assertRaises(NameError):
		type_params[1].__constraints__

Expand DownExpand Up		@@ -1182,7 +1182,7 @@ def func[T=int, *U=float, V=None]():
		T, U, V = ns["func"].__type_params__
		self.assertIs(T.__default__, int)
		self.assertIs(U.__default__, float)
		self.assertIs(V.__default__,type(None))
		self.assertIs(V.__default__, None)

		def test_defaults_on_class(self):
		ns = run_code("""
Expand All		@@ -1193,7 +1193,7 @@ class C[T=int, *U=float, V=None]:
		T, U, V = ns["C"].__type_params__
		self.assertIs(T.__default__, int)
		self.assertIs(U.__default__, float)
		self.assertIs(V.__default__,type(None))
		self.assertIs(V.__default__, None)

		def test_defaults_on_type_alias(self):
		ns = run_code("""
Expand All		@@ -1203,7 +1203,7 @@ def test_defaults_on_type_alias(self):
		T, U, V = ns["Alias"].__type_params__
		self.assertIs(T.__default__, int)
		self.assertIs(U.__default__, float)
		self.assertIs(V.__default__,type(None))
		self.assertIs(V.__default__, None)

		def test_starred_invalid(self):
		check_syntax_error(self, "type Alias[T = *int] = int")
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -584,6 +584,7 @@ class TypeParameterDefaultsTests(BaseTestCase):
		def test_typevar(self):
		T = TypeVar('T', default=int)
		self.assertEqual(T.__default__, int)
		self.assertTrue(T.has_default())
		self.assertIsInstance(T, TypeVar)

		class A(Generic[T]): ...
Expand All		@@ -593,15 +594,19 @@ def test_typevar_none(self):
		U = TypeVar('U')
		U_None = TypeVar('U_None', default=None)
		self.assertIs(U.__default__, NoDefault)
		self.assertFalse(U.has_default())
		self.assertIs(U_None.__default__, None)
		self.assertTrue(U_None.has_default())

		class X[T]: ...
		T, = X.__type_params__
		self.assertIs(T.__default__, NoDefault)
		self.assertFalse(T.has_default())

		def test_paramspec(self):
		P = ParamSpec('P', default=(str, int))
		self.assertEqual(P.__default__, (str, int))
		self.assertTrue(P.has_default())
		self.assertIsInstance(P, ParamSpec)

		class A(Generic[P]): ...
Expand All		@@ -614,15 +619,19 @@ def test_paramspec_none(self):
		U = ParamSpec('U')
		U_None = ParamSpec('U_None', default=None)
		self.assertIs(U.__default__, NoDefault)
		self.assertFalse(U.has_default())
		self.assertIs(U_None.__default__, None)
		self.assertTrue(U_None.has_default())

		class X[**P]: ...
		P, = X.__type_params__
		self.assertIs(P.__default__, NoDefault)
		self.assertFalse(P.has_default())

		def test_typevartuple(self):
		Ts = TypeVarTuple('Ts', default=Unpack[Tuple[str, int]])
		self.assertEqual(Ts.__default__, Unpack[Tuple[str, int]])
		self.assertTrue(Ts.has_default())
		self.assertIsInstance(Ts, TypeVarTuple)

		class A(Generic[Unpack[Ts]]): ...
Expand DownExpand Up		@@ -691,11 +700,14 @@ def test_typevartuple_none(self):
		U = TypeVarTuple('U')
		U_None = TypeVarTuple('U_None', default=None)
		self.assertIs(U.__default__, NoDefault)
		self.assertFalse(U.has_default())
		self.assertIs(U_None.__default__, None)
		self.assertTrue(U_None.has_default())

		class X[**Ts]: ...
		Ts, = X.__type_params__
		self.assertIs(Ts.__default__, NoDefault)
		self.assertFalse(Ts.has_default())

		def test_no_default_after_non_default(self):
		DefaultStrT = TypeVar('DefaultStrT', default=str)
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -286,11 +286,11 @@ def _collect_parameters(args):
		parameters.append(collected)
		elif hasattr(t, '__typing_subst__'):
		if t not in parameters:
		if type_var_tuple_encountered and t.__default__ is not NoDefault:
		if type_var_tuple_encountered and t.has_default():
		raise TypeError('Type parameter with a default'
		' follows TypeVarTuple')

		if t.__default__ is not NoDefault:
		if t.has_default():
		default_encountered = True
		elif default_encountered:
		raise TypeError(f'Type parameter {t!r} without a default'
Expand DownExpand Up		@@ -325,10 +325,10 @@ def _check_generic_specialization(cls, arguments):
		# the number of arguments being passed not matching the number
		# of parameters: all parameters that aren't explicitly
		# specialized in this call are parameters with default values.
		if cls.__parameters__[actual_len].__default__ is not NoDefault:
		if cls.__parameters__[actual_len].has_default():
		return

		expected_len -= sum(p.__default__ is not NoDefault for p in cls.__parameters__)
		expected_len -= sum(p.has_default() for p in cls.__parameters__)
		expect_val = f"at least {expected_len}"
		else:
		expect_val = expected_len
Expand DownExpand Up		@@ -1126,7 +1126,7 @@ def _typevartuple_prepare_subst(self, alias, args):
		elif left + right > alen:
		raise TypeError(f"Too few arguments for {alias};"
		f" actual {alen}, expected at least {plen-1}")
		if left == alen - right and self.__default__ is not NoDefault:
		if left == alen - right and self.has_default():
		replacement = _unpack_args(self.__default__)
		else:
		replacement = args[left: alen - right]
Expand All		@@ -1152,7 +1152,7 @@ def _paramspec_subst(self, arg):
		def _paramspec_prepare_subst(self, alias, args):
		params = alias.__parameters__
		i = params.index(self)
		if i == len(args) and self.__default__ is not NoDefault:
		if i == len(args) and self.has_default():
		args = [*args, self.__default__]
		if i >= len(args):
		raise TypeError(f"Too few arguments for {alias}")
Expand Down