cpython_18/instruction.md

You are working in `/workspace/cpython`, a source tree checked out at
the base commit for this task. Implement the requested behavior in the source
tree, then run:

```bash
lolbench-submit
```

Do not stop after editing files, running tests, or describing the solution. The
task is complete only when `lolbench-submit` has created
`/logs/artifacts/solution.patch`. If that file does not exist, continue
working and run `lolbench-submit` again.

That command writes your implementation diff to
`/logs/artifacts/solution.patch`, which is the artifact the Harbor verifier
will grade. Before running `lolbench-submit`, clean or revert any test files
you created or modified; test files must not be included in the final
`solution.patch`.

This environment has no outbound internet access — `curl`/`wget`, `git fetch`/`clone`, package installs, and web fetch/search will all fail. Implement the requirements using only the code already in the workspace and your own knowledge; do not attempt to fetch or search external resources.

Now please implement the following requirements in the source tree:

---

# PEP 820: PySlot: Unified slot system for the C API

## Abstract

Replace type and module slots with a new structure: a tagged anonymous
union with flags.
This improves type safety and allows adding new slots
in a more forward-compatible way.

API added in 3.15 (`PyModule_FromSlotsAndSpec` and the
new extension export hook)
will be changed to use the new slots.

The existing slot structures and related API is soft-deprecated.
(That is: they will continue to work without warnings, and it’ll be fully
documented and supported, but we plan to not add any new features to it.)

## Background

The C API in Python 3.14 contains two extendable structs used to provide
information when creating a new object: `PyType_Spec` and
`PyModuleDef`.

Each has a family of C API functions that create a Python object from it.
(Each family works as a single function, with optional arguments that
got added over time.) These are:

- `PyType_From*` functions, like `PyType_FromMetaclass`,
  for `PyType_Spec`;
- `PyModule_FromDef*` functions, like `PyModule_FromDefAndSpec`,
  for `PyModuleDef`.

Separating "input" structures from runtime objects allows the internal
structure of the object to stay opaque (in both the API and the ABI),
allowing future CPython versions (or even alternative implementations) to
change the details.

Both structures contain a *slots* field, essentially an array of
[tagged unions](https://en.wikipedia.org/wiki/Tagged_union)
(`void` pointers taged with an `int` ID).
This allows for future expansion.

In [PEP 793](https://peps.python.org/pep-0793/), new module creation API was added.
Instead of the `PyModuleDef` structure, it uses only an array of *slots*.
To replace the existing members of `PyModuleDef`, it adds
corresponding slot IDs -- for example, the module name is specified in a
`Py_mod_name` slot, rather than in `PyModuleDef.m_name`.
That PEP notes:

> The PyModuleDef_Slot struct does have some downsides compared to fixed
> fields.
> We believe these are fixable, but leave that out of scope of this PEP.

This proposal addresses the downsides.

## Motivation

The main shortcomings of the existing `PyModuleDef_Slot` and `PyType_Slot`
are:

Type safety
:   `void *` is used for data pointers, function pointers and small integers,
    requiring casting that works in practice on all relevant architectures,
    but is technically undefined or implementation-defined behaviour in C.

    For example: `Py_tp_doc` marks a string; `Py_mod_gil`
    a small integer, and `Py_tp_repr` a function; all must
    be cast to `void*`.

Limited forward compatibility
:   If an extension provides a slot ID that's unknown to the current
    interpreter, type/module creation will fail.
    This makes it cumbersome to use "optional" features – ones that should
    only take effect if the interpreter supports them.
    The recently added slots `Py_mod_gil` and
    `Py_mod_multiple_interpreters` are good examples.

    One workaround is to check the Python version, and omit slots
    that predate the current interpreter.
    This is cumbersome for users.
    It also constraints possible non-CPython implementations of the C API,
    preventing them from "cherry-picking" features introduced in newer CPython
    versions.

### Endorsements

This PEP is unusual in that it doesn't immediately help end users -- it needs
to be in place well before it starts being helpful.
In the words of a Cython maintainer,
[Da Woods](https://discuss.python.org/t/105552/2):

> I suspect Cython wouldn’t immediately use it (at least for classes… obviously
> if it goes into PEP 793 then we would for that).
> Just because it’s mostly targeted at future improvements rather than an
> immediate new feature. It looks usable though.

Instead, support comes from core devs who'll need change the C API, and want
do so in backwards-compatible ways:

- [Mark Shannon](https://discuss.python.org/t/105552/4):

  > This seems like a worthwhile improvement. Count me as a +1
- [Victor Stinner](https://discuss.python.org/t/105552/19):

  > I changed my mind and I’m now a supporter of PEP 820 :)
  > It took me a while but I now see the PEP 820 advantages: it enhances the
  > backward compatibility and the stable ABI.

## Example

This proposal adds API to create classes and modules from arrays of slots,
which can be specified as C literals using macros, like this:

```
static PySlot myClass_slots[] = {
   PySlot_STATIC(tp_name, "mymod.MyClass"),
   PySlot_SIZE(tp_extra_basicsize, sizeof(struct myClass)),
   PySlot_FUNC(tp_repr, myClass_repr),
   PySlot_INT64(tp_flags, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_MANAGED_DICT),
   PySlot_END,
}

// ...

PyObject *MyClass = PyType_FromSlots(myClass_slots);
```

The macros simplify hand-written literals.
For more complex use cases, like compatibility between several Python versions,
or templated/auto-generated slot arrays, as well as for non-C users of the
C API, the slot struct definitions can be written out.
For example, if the `nb_matrix_multiply` slot ([PEP 465](https://peps.python.org/pep-0465/)) was added in the
near future (say, CPython 3.17) rather than in 3.5, users could add it with
an "`OPTIONAL`" flag, making their class support the `@` operator only
on CPython versions with that operator:

```
static PySlot myClass_slots[] = {
   ...
   {   // skipped if not supported
       .sl_id=Py_nb_matrix_multiply,
       .sl_flags=PySlot_OPTIONAL,
       .sl_func=myClass_matmul,
   },
   PySlot_END,
}
```

## Rationale

Here we explain the design decisions in this proposal.

Some of the rationale is repeated from [PEP 793](https://peps.python.org/pep-0793/), which replaced
the `PyModuleDef` struct with an array of slots.

### Using slots

The main alternative to slots is using a versioned `struct` for input.

There are two variants of such a design:

- A large struct with fields for all info. As we can see with
  `PyTypeObject`, most of such a struct tends to be NULLs in practice.
  As more fields become obsolete, either the wastage grows, or we introduce new
  struct layouts (while keeping compatibility with the old ones for a while).
- A small struct with only the info necessary for initial creation, with other
  info added afterwards (with dedicated function calls, or Python-level
  `setattr`). This design:

  - makes it cumbersome to add/obsolete/adjust the required info (for example,
    in [PEP 697](https://peps.python.org/pep-0697/) I gave meaning to negative values of an existing field;
    adding a new field would be cleaner in similar situations);
  - increases the number of API calls between an extension and the interpreter.

  We believe that “batch” API for type/module creation makes sense,
  even if it partially duplicates an API to modify “live” objects.

### Using slots *only*

The classes `PyType_Spec` and `PyModuleDef` have explicit fields
in addition to a slots array. These include:

- Required information, such as the class name (`PyType_Spec.name`).
  This proposal adds a *slot* ID for the name, and makes it required.
- Non-pointers (`basicsize`, `flags`).
  Originally, slots were intended to
  only contain *function pointers*; they now contain *data pointers* as well as
  integers or flags. This proposal uses a union to handle types cleanly.
- Items added before the slots mechanism. The `PyModuleDef.m_slots`
  itself was repurposed from `m_reload` which was always NULL;
  the optional `m_traverse` or `m_methods` members predate it.

We can do without these fields, and have *only* an array of slots.
A wrapper class around the array would complicate the design.
If fields in such a class ever become obsolete, they are hard to remove or
repurpose.

### Nested slot tables

In this proposal, the array of slots can reference another array of slots,
which is treated as if it was merged into its “parent”, recursively.
This complicates slot handling inside the interpreter, but allows:

- Mixing dynamically allocated (or stack-allocated) slots with `static` ones.
  This solves the issue that lead to the `PyType_From*` family of
  functions expanding with values that typically can't be `static`.
  For example, the *module* argument to `PyType_FromModuleAndSpec`
  should be a heap-allocated module object.
- Sharing a subset of the slots to implement functionality
  common to several classes/modules.
- Easily including some slots conditionally, e.g. based on the Python version.

### Nested “legacy” slot tables

Similarly to nested arrays of `PyType_Slot`, we also propose supporting
arrays of “legacy” slots (`PyType_Slot` and `PyModuleDef_Slot`) in
the “new” slots, and vice versa.

This way, users can reuse code they already have written without
rewriting/reformatting,
and only use the “new” slots if they need any new features.

### Fixed-width integers

This proposal uses fixed-width integers (`uint16_t`) for slot IDs and
flags.
With the C `int` type, using more than 16 bits would not be portable,
but it would silently work on common platforms.
Using `int` but avoiding values over `UINT16_MAX` wastes 16 bits
on common platforms.

### Memory layout

On common 64-bit platforms, we can keep the size of the new struct the same
as the existing `PyType_Slot` and `PyModuleDef_Slot`. (The existing
struct waste 6 out of 16 bytes due to `int` portability and padding;
this proposal puts some of those bits to use for new features.)
On 32-bit platforms, this proposal calls for the same layout as on 64-bit,
doubling the size compared to the existing structs (from 8 bytes to 16).
For “configuration” data that's usually `static`, it should be OK.

The proposal does not use bit-fields and enums, whose memory representation is
compiler-dependent, causing issues when using the API from languages other
than C.

The structure is laid out assuming that a type's alignment matches its size.

### Single ID space

Currently, the numeric values of *module* and *type* slots overlap:

- `Py_bf_getbuffer` == `Py_mod_create` == 1
- `Py_bf_releasebuffer` == `Py_mod_exec` == 2
- `Py_mp_ass_subscript` == `Py_mod_multiple_interpreters` == 3
- `Py_mp_length` == `Py_mod_gil` == 4
- and similar for module slots added in CPython 3.15

This proposal use a single sequence for both, so future slots avoid this
overlap. This is to:

- Avoid *accidentally* using type slots for modules, and vice versa
- Allow external libraries or checkers to determine a slot's meaning
  (and type) based on the ID.

The 4 existing overlaps means we don't reach these goals right now,
but we can gradually migrate to new numeric IDs in a way that's transparent
to the user.

The main disadvantage is that any internal lookup tables will be either bigger
(if we use separate ones for types & modules, so they'll contain blanks),
or harder to manage (if they're merged).

### Deprecation warnings

Multiple slots are documented to not allow NULL values, but CPython allows
NULL for backwards compatibility.
Similarly, multiple slot IDs should not appear more than once in a single
array, but CPython allows such duplicates.

This is a maintenance issue, as CPython should preserve its undocumented
(and often untested) behaviour in these cases as the implementation is changed.

It also prevents API extensions.
For example, instead of adding the `Py_TPFLAGS_DISALLOW_INSTANTIATION`
flag in 3.10, we could have allowed settning the `Py_tp_new` slot to NULL for
the same effect.

To allow changing the edge case behaviour in the (far) future,
and to allow freedom for possible alternative implementations of the C API,
we'll start issuing runtime deprecation warnings in these cases.
To avoid flooding users with warnings for things that are outside of their
control, we'll only show deprecation warnings when the new API is used.

## Specification

A new `PySlot` structure will be defined as follows:

```
typedef struct PySlot {
    uint16_t sl_id;
    uint16_t sl_flags;
    union {
        uint32_t _sl_reserved;  // must be 0
    };
    union {
        void *sl_ptr;
        void (*sl_func)(void);
        Py_ssize_t sl_size;
        int64_t sl_int64;
        uint64_t sl_uint64;
    };
} PySlot;
```

- `sl_id`: A slot number, identifying what the slot does.
- `sl_flags`: Flags, defined below.
- 32 bits reserved for future extensions (expected to be enabled by
  future flags).
- An union with the data, whose type depends on the slot.

### New API

The following function will be added.
It will create the corresponding Python type object from the given
array of slots:

```
PyObject *PyType_FromSlots(const PySlot *slots);
```

With this function, the `Py_tp_token` slot may not be set to
`Py_TP_USE_SPEC` (i.e. `NULL`).

### Changed API

The `PyModule_FromSlotsAndSpec` function (added in CPython 3.15 in
[PEP 793](https://peps.python.org/pep-0793/)) will be *changed* to take the new slot structure:

```
PyObject *PyModule_FromSlotsAndSpec(const PySlot *slots, PyObject *spec)
```

The extension module export hook
added in [PEP 793](https://peps.python.org/pep-0793/) (PyModExport_{<name>}) will be *changed* to
return the new slot structure.
The `PyMODEXPORT_FUNC` macro will
be updated accordingly.

### General slot semantics

When slots are passed to a function that applies them, the function will not
modify the slot array, nor any data it points to (recursively).

After the function is done, the user is allowed to modify or deallocate the
array, and any data it points to (recursively), unless it's explicitly marked
as "static" (see `PySlot_STATIC` below).
This means the interpreter typically needs to make a copy of all data
in the struct, including `char *` text.

### Flags

`sl_flags` may set the following bits. Unassigned bits must be set to zero.

- `PySlot_OPTIONAL`: If the slot ID is unknown, the interpreter should
  ignore the slot entirely. (For example, if `nb_matrix_multiply` was being
  added to CPython now, your type could use this.)
- `PySlot_STATIC`: All data the slot points to is statically allocated
  and constant.
  Thus, the interpreter does not need to copy the information.
  This flag is implied for function pointers.

  The flag applies even to data the slot points to "indirectly", except for
  nested slots -- see pep820-nested-tables below -- which can have their
  own `PySlot_STATIC` flag.
  For example, if applied to a `Py_tp_members` slot that points to an
  *array* of `PyMemberDef` structures, then the entire array, as well as the
  `name` and `doc` strings in its elements, must be static and constant.
- `PySlot_INTPTR`: The data is stored in `sl_ptr`, and must be cast to
  the appropriate type.

  This flag simplifies porting from the existing `PyType_Slot` and
  `PyModuleDef_Slot`, where all slots work this way.

### Convenience macros

The following macros will be added to the API to simplify slot definition:

```
#define PySlot_DATA(NAME, VALUE) \
   {.sl_id=NAME, .sl_ptr=(void*)(VALUE)}

#define PySlot_FUNC(NAME, VALUE) \
   {.sl_id=NAME, .sl_func=(VALUE)}

#define PySlot_SIZE(NAME, VALUE) \
   {.sl_id=NAME, .sl_size=(VALUE)}

#define PySlot_INT64(NAME, VALUE) \
   {.sl_id=NAME, .sl_int64=(VALUE)}

#define PySlot_UINT64(NAME, VALUE) \
   {.sl_id=NAME, .sl_uint64=(VALUE)}

#define PySlot_STATIC_DATA(NAME, VALUE) \
   {.sl_id=NAME, .sl_flags=PySlot_STATIC, .sl_ptr=(VALUE)}

#define PySlot_END {0}
```

We'll also add two more macros that avoid named initializers,
for use in C++11-compatibile code.
Note that these cast the value to `void*`, so they do not improve type safety
over existing slots:

```
#define PySlot_PTR(NAME, VALUE) \
   {NAME, PySlot_INTPTR, {0}, {(void*)(VALUE)}}

#define PySlot_PTR_STATIC(NAME, VALUE) \
   {NAME, PySlot_INTPTR|Py_SLOT_STATIC, {0}, {(void*)(VALUE)}}
```

### Nested slot tables

A new slot, `Py_slot_subslots`, will be added to allow nesting slot tables.
Its value (`sl_ptr`) should point to an array of `PySlot` structures,
which will be treated as if they were part of the current slot array.
`sl_ptr` can be `NULL` to indicate that there are no slots.

Two more slots will allow similar nesting for existing slot structures:

- `Py_tp_slots` for an array of `PyType_Slot`
- `Py_mod_slots` for an array of `PyModuleDef_Slot`

Each `PyType_Slot` in the array will be converted to
(PySlot){.sl_id=slot, .sl_flags=PySlot_INTPTR, .sl_ptr=func},
and similar with `PyModuleDef_Slot`.

In the initial implementation, nesting depth will be limited to 5 levels.
This restriction may be lifted in the future.

### New slot IDs

The following new slot IDs, usable for both type and module
definitions, will be added:

- `Py_slot_end` (defined as `0`): Marks the end of a slots array.

  - The `PySlot_INTPTR` and `PySlot_STATIC` flags are ignored.
  - The `PySlot_OPTIONAL` flags is not allowed with `Py_slot_end`.
- `Py_slot_subslots`, `Py_tp_slots`, `Py_mod_slots`: see
  pep820-nested-tables above
- `Py_slot_invalid` (defined as `UINT16_MAX`, i.e. -1): treated as an
  unknown slot ID.

The following new slot IDs will be added to cover existing
members of `PyModuleDef`:

- `Py_tp_name` (mandatory for type creation)
- `Py_tp_basicsize` (of type `Py_ssize_t`)
- `Py_tp_extra_basicsize` (equivalent to setting `PyType_Spec.basicsize`
  to -extra_basicsize)
- `Py_tp_itemsize`
- `Py_tp_flags`

The following new slot IDs will be added to cover
arguments of `PyType_FromMetaclass`:

- `Py_tp_metaclass` (used to set `ob_type` after metaclass calculation)
- `Py_tp_module`

Note that `Py_tp_base` and `Py_tp_bases` already exist.
The interpreter will treat them identically: either can specify a class
object or a tuple of them.
`Py_tp_base` will be soft-deprecated in favour of `Py_tp_bases`.
Specifying both in a single definition will be deprecated (currently,
`Py_tp_bases` overrides `Py_tp_base`).

None of the new slots will be usable with `PyType_GetSlot`.
(This limitation may be lifted in the future, with C API WG approval.)

Of the new slots, only `Py_slot_end`, `Py_slot_subslots`, `Py_tp_slots`,
`Py_mod_slots` will be allowed in `PyType_Spec` and/or `PyModuleDef`.

### Slot renumbering

New slots IDs will have unique numeric values (that is, `Py_slot_*`,
`Py_tp_*` and `Py_mod_*` won't share IDs).

Slots numbered 1 through 4 (`Py_bf_getbuffer`...`Py_mp_length` and
`Py_mod_create`...`Py_mod_gil`) will be redefined as new
(larger) numbers.
The old numbers will remain as aliases, and will be used when compiling for
Stable ABI versions below 3.15.

Slots for members of `PyModuleDef`, which were added in
PEP 793, will be renumbered so that they have
unique IDs:

- `Py_mod_name`
- `Py_mod_doc`
- `Py_mod_state_size`
- `Py_mod_methods`
- `Py_mod_state_traverse`
- `Py_mod_state_clear`
- `Py_mod_state_free`

### Soft deprecation

These existing functions will be [soft-deprecated](https://peps.python.org/pep-0387/):

- `PyType_FromSpec`
- `PyType_FromSpecWithBases`
- `PyType_FromModuleAndSpec`
- `PyType_FromMetaclass`
- `PyModule_FromDefAndSpec`
- `PyModule_FromDefAndSpec2`
- `PyModule_ExecDef`

(As a reminder: soft-deprecated API is not scheduled for removal, does not
raise warnings, and remains documented and tested. However, no new
functionality will be added to it.)

Arrays of `PyType_Slot` or `PyModuleDef_Slot`, which are accepted by
these functions, can contain any slots, including "new" ones defined
in this PEP.
This includes nested "new-style" slots (`Py_slot_subslots`).

### Deprecation warnings

Functions that take `PySlot` arrays (but not functions that take
the older `PyType_Slot` or `PyModuleDef_Slot` arrays) will emit runtime
deprecation warnings for the following cases, for slots where the case is
currently disallowed in documentation but allowed by the runtime:

- setting a slot value to NULL:

  - all type slots except `Py_tp_doc`
  - `Py_mod_create`
  - `Py_mod_exec`
- repeating a slot ID in a single slots array (including sub-slot arrays
  added in this PEP):

  - all type slots, except slots where this is already a runtime error
    (`Py_tp_doc`, `Py_tp_members`)
  - `Py_mod_create`
  - `Py_mod_abi`

## Backwards Compatibility

This PEP proposes to change API that was already released in alpha versions of
Python 3.15.
This will inconvenience early adopters of that API, but -- as long as the
PEP is accepted and implemented before the first bety -- this change is within
the letter and spirit of our backwards compatibility policy.

Renumbering of slots is done in a backwards-compatible way.
Old values continue to be accepted, and are used when compiling for
earlier Stable ABI.

Some cases that are documented as illegal will begin emitting deprecation
warnings (see pep820-hard-deprecations).

Otherwise, this PEP only adds and soft-deprecates APIs, which is backwards
compatible.

## Security Implications

None known

## How to Teach This

Adjust the "Extending and Embedding" tutorial to use this.

## Reference Implementation

Draft implementation is available as [pull request #37 in the author's fork](https://github.com/encukou/cpython/pull/37).

## Rejected Ideas

See the pep820-rationale section for several alternative ideas.

### Third-party slot ID allocation

It was suggested to allow third parties to reserve slot IDs for their own use.
This would be mainly useful for alternate implementations. For example,
something like GraalPy might want custom type slots (e.g. an "inherits
from this Java class" slot).
Similarly, at one point PyPy had an extra `tp_pypy_flags` in their
typeobject struct.

This PEP does not specify a namespace mechanism.
One can be added in the future.
We're also free to reserve individual slot IDs for alternate implementations.

Note that slots are not a good way for *extension modules* to add extra data
to types or modules, as there is no API to retrieve the slots used to create
a specific object.

### Avoiding anonymous unions

This PEP proposes a struct with *anonymous unions*, which are not yet used in
CPython's documented public API.

There is no known issue with adding these, but the following notes may
be relevant:

- Anonymous unions are only supported in C since C11.
  But, CPython already requires the feature, and uses it for internal members
  of the `PyObject` struct.
- Until C++20, which adds C-style designated initializers, C++ initializers
  only allow setting the first member of a union.
  However, this is an issue for *named* unions as well.
  Avoiding unions entirely would mean losing most of the type-safety
  improvements of this PEP.

  Note that the proposed flag `PySlot_INTPTR`, and the workaround macros
  `PySlot_PTR` & `PySlot_PTR_STATIC`, allow using this API in
  code that needs to be compatible with C++11 or has similar union-related
  limitations.
- C++ doesn't have anonymous *structs*.
  This might surprise C programmers for whom anonymous structs/unions are
  a single language feature.
- Non-C/C++ language wrappers may need to give the union a name.
  This is fine.
  (Dear reader: if you need this, please open a CPython issue about
  exposing a preferred name in headers and documentation.)

For a bigger picture: anonymous unions can be a helpful tool for implemeting
tagged unions and for evolving public API in backwards-compatible ways.
This PEP intentionally opens the door to using them more often.

### Fallback slots

An earlier version of this PEP proposed a flag: `PySlot_HAS_FALLBACK`:

> If the flagged slot's ID is unknown, the interpreter will ignore the slot.
> If it's known, the interpreter should ignore subsequent slots up to
> (and including) the first one without HAS_FALLBACK.
>
> Effectively, consecutive slots with the HAS_FALLBACK flag, plus the first
> non-HAS_FALLBACK slot after them, form a "block" where the the interpreter
> will only consider the *first* slot in the block that it understands.
> If the entire block is to be optional, it should end with a
> slot with the OPTIONAL flag.

This flag may be added later, in the Python version where it's needed.
(For backwards compatibility, all slots flagged HAS_FALLBACK will also need
the OPTIONAL flag).

## Open Issues

None yet.

## Linked PEP 793 — PyModExport: A new entry point for C extension modules
### Abstract

In this PEP, we propose a new entry point for C extension modules, by which
one can define a module using an array of `PyModuleDef_Slot` structures
without an enclosing `PyModuleDef` structure.
This allows extension authors to avoid using a statically allocated
`PyObject`, lifting the most common obstacle to making one compiled library
file usable with both regular and free-threaded builds of CPython.

To make this viable, we also specify new module slot types to replace
`PyModuleDef`'s fields, and to allow adding a *token* similar to the
`Py_tp_token` used for type objects.

We also add an API for defining modules from slots dynamically.

The existing API (`PyInit_*`) is soft-deprecated.
(That is: it will continue to work without warnings, and it'll be fully
documented and supported, but we plan to not add any new features to it.)

### Background & Motivation

The memory layout of Python objects differs between regular and free-threading
builds.
So, an ABI that supports both regular and free-threading builds cannot include
the current `PyObject` memory layout. To stay compatible with existing ABI
(and API), it cannot support statically allocated Python objects.

There is one type of object that is needed in most extension modules
and is allocated statically in virtually all cases: the `PyModuleDef` returned
from the module export hooks (that is, `PyInit_*` functions).

Module export hooks (`PyInit_*` functions) can return two kinds of objects:

1. A fully initialized module object (for so-called
   *single-phase initialization*). This was the only option in 3.4 and below.
   Modules created this way have surprising (but backwards-compatible)
   behaviour around multiple interpreters or repeated loading.
   (Specifically, the *contents* of such a module's `__dict__` are shared
   across all instances of the module object.)

   The module returned is typically created using the `PyModule_Create`
   function, which requires a statically allocated (or at least long-lived)
   `PyModuleDef` struct.

   It is possible to bypass this using the lower-level `PyModule_New*` API.
   This avoids the need for `PyModuleDef`, but offers much less functionality.

2. A `PyModuleDef` object containing a description of how to create a module
   object. This option, *multi-phase initialization*, was introduced in
   [PEP 489](https://peps.python.org/pep-0489/); see its motivation for why it exists.

The interpreter cannot distinguish between these cases before the export hook
is called.

#### The interpreter switch

Python 3.12 added a way for modules to mark whether they may be
loaded in a subinterpreter: the `Py_mod_multiple_interpreters` slot.
Setting it to the “not supported” value signals that an extension
can only be loaded in the main interpreter.

Unfortunately, Python can only get this information by *calling* the
module export hook.
For single-phase modules, that creates the module object and runs arbitrary
initialization code.
For modules that set `Py_mod_multiple_interpreters` to “not supported”,
this initialization needs to happen in the main interpreter.

To make this work, if a new module is loaded in a sub-interpreter, Python
temporarily switches to the main interpreter, calls the export hook
there, and then either switches back and redoes the import, or fails.

This unnecessary and fragile extra work highlights the underlying design issue:
Python has no way to get information about an extension
before the extension can, potentially, fully initialize itself.

### Rationale

For avoiding the module export hook requiring a statically allocated
`PyObject*`, two options come to mind:

- Returning a *dynamically* allocated object, whose ownership is transferred
  to the interpreter. This stucture could be very similar to the existing
  `PyModuleDef`, since it needs to contain the same data.
  Unlike the existing `PyModuleDef`, this one would need to be
  reference-counted so that it both outlives “its” module and does not leak.

- Adding a new export hook, which does not return a `PyObject*`.

  This was considered already for Python 3.5 in [PEP 489](https://peps.python.org/pep-0489/), but rejected:

    Keeping only the PyInit hook name, even if it’s not entirely appropriate
    for exporting a definition, yielded a much simpler solution.

  Alas, after a decade of fixing the implications of this choice, the solution
  is no longer simple.

A new hook will also allow Python to avoid the second issue mentioned in
Motivation -- the interpreter switch.
Effectivelly, it will add a new phase to multi-phase initialization, in which
Python can check whether the module is compatible.

#### Using slots without a wrapper struct

The existing `PyModuleDef` is a struct with some fixed fields and
a “slots” array.
Unlike slots, the fixed fields cannot be individually deprecated and replaced.
This proposal does away with fixed fields and proposes using a slots array
directly, without a wrapper struct.

The `PyModuleDef_Slot` struct does have some downsides compared to fixed fields.
We believe these are fixable, but leave that out of scope of this PEP
(see “Improving slots in general” in the Possible Future Directions section).

#### Tokens

A static `PyModuleDef` has another purpose besides describing
how a module should be created.
As a statically allocated singleton that remains attached to the module object,
it allows extension authors to check whether a given Python module is “theirs”:
if a module object has a known `PyModuleDef`, its module state will have
a known memory layout.

An analogous issue was solved for types by adding `Py_tp_token`.
This proposal adds the same mechanism to modules.

Unlike types, the import mechanism often has a pointer that's known to be
suitable as a token value; in these cases it can provide a default token.
Thus, module tokens do not need a variant of the inelegant `Py_TP_USE_SPEC`.

To help extensions that straddle Python versions, `PyModuleDef` addresses
are used as default tokens, and where it's reasonable, they are made
interchangeable with tokens.

#### Soft-deprecating the existing export hook

The only reason for authors of *existing* extensions to switch to the
API proposed here is that it allows a single module for both free-threaded
and non-free-threaded builds.
It is important that Python *allows* that, but for many existing modules,
it is nowhere near worth losing compatibility with 3.14 and lower versions.

It is much too early to plan deprecation of the old API.

Instead, this PEP proposes to stop adding new features to the `PyInit_*`
scheme.
After all, the perfect time for extension authors to switch is when they want
to modify module initialization anyway.

### Specification

#### The export hook

When importing an extension module, Python will now first look for an export hook
like this:

```c
 PyModuleDef_Slot *PyModExport_<NAME>(void);
```
where `<NAME>` is the name of the module.
For non-ASCII names, it will instead look for `PyModExportU_<NAME>`,
with `<NAME>` encoded as for existing `PyInitU_*` hooks
(that is, *punycode*-encoded with hyphens replaced by underscores).

If not found, the import will continue as in previous Python versions (that is,
by looking up a `PyInit_*` or `PyInitU_*` function).

If found, Python will call the hook with no arguments.

On failure, the export hook must return NULL with an exception set.
This will cause the import to fail.
(Python will not fall back to `PyInit_*` on error.)

On success, the hook must return a pointer to an array of
`PyModuleDef_Slot` structs.
Python will then create a module based on the given slots by calling functions
proposed below: `PyModule_FromSlotsAndSpec` and `PyModule_Exec`.
See their description for requirements on the slots array.

The returned array and all data it points to (recursively) must remain valid
and constant until runtime shutdown.
(We expect functions to export a static constant, or one of several constants
chosen depending on, for example, `Py_Version`. Dynamic behaviour should
generally happen in the `Py_mod_create` and `Py_mod_exec` functions.)

#### Dynamic creation

A new function will be added to create a module from an array of slots:

```c
 PyObject *PyModule_FromSlotsAndSpec(const PyModuleDef_Slot *slots, PyObject *spec)
```
The *slots* argument must point to an array of `PyModuleDef_Slot` structures,
terminated by a slot with `slot=0` (typically written as `{0}` in C).
The `Py_mod_abi` slot is required: it records the ABI the module was built
against, so a *slots* array that omits `Py_mod_abi` raises `SystemError` when
the module is created.  Apart from that mandatory slot no particular slot is
required, though *slots* must not be `NULL`, and it follows that the minimal
input contains the `Py_mod_abi` slot together with the terminator slot.

> **Note:** Making `Py_mod_abi` mandatory follows the direction of PEP 803; this
> PEP's implementation already enforces the requirement, raising `SystemError`
> for a slot-based module definition that leaves it out.
The *spec* argument is a duck-typed ModuleSpec-like object, meaning that any
attributes defined for `importlib.machinery.ModuleSpec` have matching
semantics.
The `name` attribute is required, but this limitation may be lifted in the
future.
The `name` will be used *instead of* the `Py_mod_name` slot (just like
`PyModule_FromDefAndSpec` ignores `PyModuleDef.m_name`).

The slots arrays for both `PyModule_FromSlotsAndSpec` and the new export hook
will only allow up to one `Py_mod_exec` slot.
Arrays in `PyModuleDef.m_slots` may have more; this will not change.
This limitation is easy to work around and multiple `exec` slots are rarely
used .

For modules created without a `PyModuleDef`, the `Py_mod_create` function
will be called with `NULL` for the second argument (*def*).
(In the future, if we find a use case for passing the input slots array, a new
slot with an updated signature can be added.)

Unlike the `PyModExport_*` hook, the *slots* array may be changed or
destroyed after the `PyModule_FromSlotsAndSpec` call.
(That is, Python must take a copy of all input data.)
As an exception, any `PyMethodDef` array given by `Py_mod_methods`
must be statically allocated (or be otherwise guaranteed to outlive the
objects created from it). This limitation may be lifted in the future.

A new function, `PyModule_Exec`, will be added to run the `exec` slot(s) for a module.
This acts like `PyModule_ExecDef`, but supports modules created using slots,
and does not take an explicit *def*:

```c
 int PyModule_Exec(PyObject *module)
```
Calling this is required to fully initialize a module.
`PyModule_FromSlotsAndSpec` will *not* run it (just like
`PyModule_FromDefAndSpec` does not call `PyModule_ExecDef`).

For modules created from a *def*, calling this is equivalent to
calling `PyModule_ExecDef(module, PyModule_GetDef(module))`.

#### Tokens

Module objects will optionally store a “token”: a `void*` pointer
similar to `Py_tp_token` for types.

> **Note:** This is specialized functionality meant replace the
> **Note:** `PyType_GetModuleByDef` function; users that don't need
> **Note:** `PyType_GetModuleByDef` will most likely not need tokens either.
> **Note:** This section contains the technical specification;
> **Note:** for an example of intended usage, see `exampletype_repr` in the
> **Note:** `Example section <pep793-example>`.
If specified, using a new `Py_mod_token` slot, the module token must:

- outlive the module, so it's not reused for something else while the module
  exists; and
- "belong" to the extension module where the module lives, so it will not
  clash with other extension modules.

(Typically, it should be the slots array or `PyModuleDef` that a module is
created from, or another static constant for dynamically created modules.)

When the address of a `PyModuleDef` is used as a module's token,
the module should behave as if it was created from that `PyModuleDef`.
In particular, the module state must have matching layout and semantics.

Modules created using the `PyModule_FromSlotsAndSpec` or the
`PyModExport_<NAME>` export hook can use a new `Py_mod_token` slot
to set the token.

Modules created from a `PyModuleDef` will have the token set to that
definition. An explicit `Py_mod_token` slot will we rejected for these.
(This allows implementations to share storage for the token and def.)

For modules created via the new export hook, the token
will be set to the address of the slots array by default.
(This does **not** apply to modules created by `PyModule_FromSlotsAndSpec`,
as that function's input might not outlive the module.)

The token will not be set for non-`PyModuleType` instances.

A `PyModule_GetToken` function will be added to get the token.
Since the result may be `NULL`, it will be passed via a pointer; the function
will return 0 on success and -1 on failure:

```c
 int PyModule_GetToken(PyObject *, void **token_p)
```
A new `PyType_GetModuleByToken` function will be added, with a signature
like the existing `PyType_GetModuleByDef` but a `const void *token` argument,
and the same behaviour except matching tokens rather than only defs,
and returning a strong reference.

For easier backwards compatibility, the existing `PyType_GetModuleByDef`
will be changed to also allow a token (cast to a `PyModuleDef *` pointer) as
the *def* argument.
That is, `PyType_GetModuleByToken` and `PyType_GetModuleByDef` will differ
only in the formal signature of the second argument and by returning a
borrowed vs. strong reference.
(The `PyModule_GetDef` function will not get a similar change, as users may
access members of its result.)

#### New slots

For each field of the `PyModuleDef` struct, except ones from
`PyModuleDef_HEAD_INIT`, a new slot ID will be provided: `Py_mod_name`,
`Py_mod_doc`, `Py_mod_clear`, etc.
Slots related to the module state rather than the module object will
use a `Py_mod_state_` prefix.
See pep793-api-summary for a full list.

All new slots -- these and `Py_tp_token` discussed above -- may not be
repeated in the slots array, and may not be used in a
`PyModuleDef.m_slots` array.
They may not have a `NULL` value (instead, the slot can be omitted entirely).

Note that currently, for modules created from a *spec* (that is, using
`PyModule_FromDefAndSpec`), the `PyModuleDef.m_name` member is ignored
and the name from the spec is used instead.
All API proposed in this document creates modules from a *spec*, and it will
ignore `Py_mod_name` in the same way.
The slot will be optional, but extension authors are strongly encouraged to
include it for the benefit of future APIs, external tooling, debugging,
and introspection.

#### Bits & Pieces

A `PyMODEXPORT_FUNC` macro will be added, similar to the `PyMODINIT_FUNC`
macro but with `PyModuleDef_Slot *` as the return type.

A `PyModule_GetStateSize` function will be added to retrieve the size set
by `Py_mod_state_size` or `PyModuleDef.m_size`.
Since the result may be -1 (for single-phase-init modules), it will be output
via a pointer; the function will return 0 on success and -1 on failure:

```c
 int PyModule_GetStateSize(PyObject *, Py_ssize_t *result);
```
#### Soft-deprecating the existing export hook

The `PyInit_*` export hook will be
soft-deprecated .

#### New API summary
Python will load a new module export hook, with two variants:

```c
 PyModuleDef_Slot *PyModExport_<NAME>(void);
 PyModuleDef_Slot *PyModExportU_<ENCODED_NAME>(void);
```
The following functions will be added:

```c
 PyObject *PyModule_FromSlotsAndSpec(const PyModuleDef_Slot *, PyObject *spec)
 int PyModule_Exec(PyObject *)
 int PyModule_GetToken(PyObject *, void**)
 PyObject *PyType_GetModuleByToken(PyTypeObject *type, const void *token)
 int PyModule_GetStateSize(PyObject *, Py_ssize_t *result);
```
A new macro will be added:

```c
 PyMODEXPORT_FUNC
```
And new slot types (`#define`\d names for small integers):

- `Py_mod_name` (equivalent to `PyModuleDef.m_name`)
- `Py_mod_doc` (equivalent to `PyModuleDef.m_doc`)
- `Py_mod_state_size` (equivalent to `PyModuleDef.m_size`)
- `Py_mod_methods` (equivalent to `PyModuleDef.m_methods`)
- `Py_mod_state_traverse` (equivalent to `PyModuleDef.m_traverse`)
- `Py_mod_state_clear` (equivalent to `PyModuleDef.m_clear`)
- `Py_mod_state_free` (equivalent to `PyModuleDef.m_free`)
- `Py_mod_token` (see above)

All this will be added to the Limited API.

### Backwards Compatibility

If an existing module is ported to use the new mechanism, then
`PyModule_GetDef` will start returning `NULL` for it.
(This matches `PyModule_GetDef`'s current documentation.)
We claim that how a module was defined is an implementation detail of that
module, so this should not be considered a breaking change.

Similarly, the `PyType_GetModuleByDef` function may stop matching modules
whose definition changed. Module authors may avoid this by explicitly
setting a *def* as the *token*.

`PyType_GetModuleByDef` will now accept a module token as the *def* argument.
We specify a suitable restriction on using `PyModuleDef` addresses as tokens,
and non-`PyModuleDef` pointers were previously invalid input,
so this is not a backwards-compatibility issue.

The `Py_mod_create` function may now be called with `NULL` for the second
argument.
This could trip people porting from *def* to *slots*, so it needs to be
mentioned in porting notes.

#### Forward compatibility

If a module defines the new export hook, CPython versions that implement this
PEP will ignore the traditional `PyInit_*` hook.

Extensions that straddle Python versions are expected to define both hooks;
each build of CPython will “pick” the newest one that it supports.

#### Porting guide

Here is a guide to convert an existing module to the new API, including
some tricky edge cases.
It should be moved to a HOWTO in the documentation.

This guide is meant for hand-written modules. For code generators and language
wrappers, the pep793-shim below may be more useful.

1. Scan your code for uses of `PyModule_GetDef`. This function will
   return `NULL` for modules that use the new mechanism. Instead:

   * For getting the contents of the module's `PyModuleDef`, use the C struct
     directly. Alternatively, get attributes from the module using, for
     example, `PyModule_GetNameObject`, the `__doc__` attribute, and
     `PyModule_GetStateSize`.
     (Note that Python code can mutate a module's attributes.)
   * For testing if a module object is “yours”, use `PyModule_GetToken`
     instead.
     Later in this guide, you'll set the token to *be* the existing
     `PyModuleDef` structure.

1. Optionally, scan your code for uses of `PyType_GetModuleByDef`,
   and replace them with `PyType_GetModuleByToken`.
   Later in this guide, you'll set the token to *be* the existing
   `PyModuleDef` structure.

   (You may skip this step if targetting Python versions that don't expose
   `PyType_GetModuleByToken`, since `PyType_GetModuleByDef` is
   backwards-compatible.)

1. Look at the function identified by `Py_mod_create`, if any.
   Make sure that it does not use its second argument (`PyModuleDef`),
   as it will be called with `NULL`.
   Instead of the argument, use the existing `PyModuleDef` struct directly.
1. If using multiple `Py_mod_exec` slots, consolidate them: pick one of
   the functions, or write a new one, and call the others from it.
   Remove all but one `Py_mod_exec` slots.
1. Make a copy of the existing `PyModuleDef_Slot` array pointed to by
   the `m_slots` member of your `PyModuleDef`. If you don't have an
   existing slots array, create one like this:

   ```c
   static PyModuleDef_Slot module_slots[] = {
       {0}
   };
   ```

   Give this array a unique name.
   Further examples will assume that you've named it `module_slots`.

1. Add slots for all members of the existing `PyModuleDef` structure.
   See pep793-api-summary for a list of the new slots.
   For example, to add a name and docstring:

   ```c
   static PyModuleDef_Slot module_slots[] = {
       {Py_mod_name, "mymodule"},
       {Py_mod_doc, (char*)PyDoc_STR("my docstring")},
       // ... (keep existing slots here)
       {0}
   };
   ```

1. If you switched from `PyModule_GetDef` to `PyModule_GetToken`,
   and/or if you use `PyType_GetModuleByDef` or `PyType_GetModuleByToken`,
   add a `Py_mod_token` slot pointing to the existing `PyModuleDef` struct:

   ```c
   static PyModuleDef_Slot module_slots[] = {
       // ... (keep existing slots here)
       {Py_mod_token, &your_module_def},
       {0}
   };
   ```

1. Add a new export hook.

   ```c
   PyMODEXPORT_FUNC PyModExport_examplemodule(PyObject);

   PyMODEXPORT_FUNC
   PyModExport_examplemodule(void)
   {
       return module_slots;
   }
   ```

The new export hook will be used on Python 3.15 and above.
Once your module no longer supports lower versions:

1. Delete the `PyInit_` function.

1. If the existing `PyModuleDef` struct is used *only* for `Py_mod_token`
   and/or `PyType_GetModuleByToken`, you may remove the `Py_mod_token`
   line and replace `&your_module_def` with `module_slots` everywhere else.

1. Delete any unused data.
   The `PyModuleDef` struct and the original slots array are likely to be
   unused.

#### Backwards compatibility shim

It is possible to write a generic function that implements the “old” export
hook (`PyInit_`) in terms of the API proposed here.

The following implementation can be copied and pasted to a project; only the
names `PyInit_examplemodule` (twice) and `PyModExport_examplemodule` should
need adjusting.

When added to the pep793-example below and compiled with a
non-free-threaded build of this PEP's reference implementation, the resulting
extension is compatible with non-free-threading 3.9+ builds, in addition to a
free-threading build of the reference implementation.
(The module must be named without a version tag, e.g. `examplemodule.so`,
and be placed on `sys.path`.)

Full support for creating such modules will require backports of some new
API, and support in build/install tools. This is out of scope of this PEP.
(In particular, the demo “cheats” by using a subset of Limited API 3.15 that
*happens to work* on 3.9; a proper implementation would use Limited API 3.9
with backport shims for new API like `Py_mod_name`.)

This implementation places a few additional requirements on the slots array:

- Slots that correspond to `PyModuleDef` members must come first.
- A `Py_mod_name` slot is required.
- Any `Py_mod_token` must be set to `&module_def_and_token`, defined here.

pep-0793/shim.c
   :language: c

### Security Implications

None known

### How to Teach This

In addition to regular reference docs, the pep793-porting-notes should
be added as a new HOWTO.

### Example

pep-0793/examplemodule.c
   :language: c

### Reference Implementation

Implementation is tracked in
[GitHub issue #140550 ](https://github.com/python/cpython/issues/140550).

A draft implementation was available in a
[GitHub branch ](https://github.com/python/cpython/compare/main...encukou:cpython:modexport#files_bucket).

### Rejected Ideas

#### Exporting a data pointer rather than a function

This proposes a new module export *function*, which is expected to
return static constant data.
That data could be exported directly as a data pointer.

With a function, we avoid dealing with a new kind of exported symbol.

A function also allows the extension to introspect its environment in a limited
way -- for example, to tailor the returned data to the current Python version.

#### Changing `PyModuleDef` to not be `PyObject`

It is possible to change `PyModuleDef` to no longer include the `PyObject`
header, and continue using the current `PyInit_*` hook.
There are several issues with this approach:

- The import machinery would need to examine bit-patterns in the objects to
  distinguish between different memory layouts:

  - the “old” `PyObject`-based `PyModuleDef`, returned by current `abi3`
    extensions,
  - the new `PyModuleDef`,
  - `PyObject`-based module objects, for single-phase initialization.

  This is fragile, and places constraints on future changes to `PyObject`:
  the memory layouts need to stay *distinguishable* until both single-phase
  initialization and the current Stable ABI are no longer supported.

- `PyModuleDef_Init` is documented to “Ensure a module definition is a
  properly initialized Python object that correctly reports its type and
  a reference count.”
  This would need to change without warning, breaking any user code that treats
  `PyModuleDef`s as Python objects.

### Possible Future Directions

These ideas are out of scope for *this* proposal.

#### Improving slots in general

Slots -- and specifically the existing `PyModuleDef_Slot` -- do have a few
shortcomings. The most important are:

- Type safety: `void *` is used for data pointers, function pointers
  and small integers, requiring casting that is technically undefined
  behaviour in C -- but works in practice on all relevant architectures.
  (For example: `Py_tp_doc` marks a string; `Py_mod_gil` an integer.)

- Limited forward compatibility: if an extension provides a slot ID that's
  unknown to the current interpreter, module creation will fail.
  This makes it cumbersome to use “optional” features -- ones that should only
  take effect if the interpreter supports them.
  (The recently added slots `Py_mod_gil` and `Py_mod_multiple_interpreters`
  are good examples.)

  One workaround is to check `Py_Version` in the export function,
  and return a slot array suitable for the current interpreter.

#### Updating defaults

With a new API, we could update defaults for the
`Py_mod_multiple_interpreters` and `Py_mod_gil` slots.

#### The inittab

We'll need to allow `PyModuleDef`-less slots in the inittab --
that is, add a new variant of `PyImport_ExtendInittab`.
Should that be part of this PEP?

The inittab is used for embedding, where a common/stable ABI is not that
important. So, it might be OK to leave this to a later change.

*Source: https://peps.python.org/pep-0793/*

## Linked PEP 465 — A dedicated infix operator for matrix multiplication
### Abstract

This PEP proposes a new binary operator to be used for matrix
multiplication, called `@`.  (Mnemonic: `@` is `*` for
mATrices.)

### Specification

A new binary operator is added to the Python language, together
with the corresponding in-place version:

=======  ========================= ===============================
 Op      Precedence/associativity     Methods
=======  ========================= ===============================
`@`    Same as `*`             `__matmul__`, `__rmatmul__`
`@=`   n/a                       `__imatmul__`
=======  ========================= ===============================

No implementations of these methods are added to the builtin or
standard library types.  However, a number of projects have reached
consensus on the recommended semantics for these operations; see
`Intended usage details`_ below for details.

For details on how this operator will be implemented in CPython, see
`Implementation details`_.

### Motivation

#### Executive summary

In numerical code, there are two important operations which compete
for use of Python's `*` operator: elementwise multiplication, and
matrix multiplication.  In the nearly twenty years since the Numeric
library was first proposed, there have been many attempts to resolve
this tension ; none have been really satisfactory.
Currently, most numerical Python code uses `*` for elementwise
multiplication, and function/method syntax for matrix multiplication;
however, this leads to ugly and unreadable code in common
circumstances.  The problem is bad enough that significant amounts of
code continue to use the opposite convention (which has the virtue of
producing ugly and unreadable code in *different* circumstances), and
this API fragmentation across codebases then creates yet more
problems.  There does not seem to be any *good* solution to the
problem of designing a numerical API within current Python syntax --
only a landscape of options that are bad in different ways.  The
minimal change to Python syntax which is sufficient to resolve these
problems is the addition of a single new infix operator for matrix
multiplication.

Matrix multiplication has a singular combination of features which
distinguish it from other binary operations, which together provide a
uniquely compelling case for the addition of a dedicated infix
operator:

* Just as for the existing numerical operators, there exists a vast
  body of prior art supporting the use of infix notation for matrix
  multiplication across all fields of mathematics, science, and
  engineering; `@` harmoniously fills a hole in Python's existing
  operator system.

* `@` greatly clarifies real-world code.

* `@` provides a smoother onramp for less experienced users, who are
  particularly harmed by hard-to-read code and API fragmentation.

* `@` benefits a substantial and growing portion of the Python user
  community.

* `@` will be used frequently -- in fact, evidence suggests it may
  be used more frequently than `//` or the bitwise operators.

* `@` allows the Python numerical community to reduce fragmentation,
  and finally standardize on a single consensus duck type for all
  numerical array objects.

#### Background: What's wrong with the status quo?

When we crunch numbers on a computer, we usually have lots and lots of
numbers to deal with.  Trying to deal with them one at a time is
cumbersome and slow -- especially when using an interpreted language.
Instead, we want the ability to write down simple operations that
apply to large collections of numbers all at once.  The *n-dimensional
array* is the basic object that all popular numeric computing
environments use to make this possible.  Python has several libraries
that provide such arrays, with numpy being at present the most
prominent.

When working with n-dimensional arrays, there are two different ways
we might want to define multiplication.  One is elementwise
multiplication:

  [[1, 2],     [[11, 12],     [[1 * 11, 2 * 12],
   [3, 4]]  x   [13, 14]]  =   [3 * 13, 4 * 14]]

and the other is `matrix multiplication`_:

.. _matrix multiplication: https://en.wikipedia.org/wiki/Matrix_multiplication

```
[[1, 2],     [[11, 12],     [[1 * 11 + 2 * 13, 1 * 12 + 2 * 14],
 [3, 4]]  x   [13, 14]]  =   [3 * 11 + 4 * 13, 3 * 12 + 4 * 14]]
```

Elementwise multiplication is useful because it lets us easily and
quickly perform many multiplications on a large collection of values,
without writing a slow and cumbersome `for` loop.  And this works as
part of a very general schema: when using the array objects provided
by numpy or other numerical libraries, all Python operators work
elementwise on arrays of all dimensionalities.  The result is that one
can write functions using straightforward code like `a * b + c / d`,
treating the variables as if they were simple values, but then
immediately use this function to efficiently perform this calculation
on large collections of values, while keeping them organized using
whatever arbitrarily complex array layout works best for the problem
at hand.

Matrix multiplication is more of a special case.  It's only defined on
2d arrays (also known as "matrices"), and multiplication is the only
operation that has an important "matrix" version -- "matrix addition"
is the same as elementwise addition; there is no such thing as "matrix
bitwise-or" or "matrix floordiv"; "matrix division" and "matrix
to-the-power-of" can be defined but are not very useful, etc.
However, matrix multiplication is still used very heavily across all
numerical application areas; mathematically, it's one of the most
fundamental operations there is.

Because Python syntax currently allows for only a single
multiplication operator `*`, libraries providing array-like objects
must decide: either use `*` for elementwise multiplication, or use
`*` for matrix multiplication.  And, unfortunately, it turns out
that when doing general-purpose number crunching, both operations are
used frequently, and there are major advantages to using infix rather
than function call syntax in both cases.  Thus it is not at all clear
which convention is optimal, or even acceptable; often it varies on a
case-by-case basis.

Nonetheless, network effects mean that it is very important that we
pick *just one* convention.  In numpy, for example, it is technically
possible to switch between the conventions, because numpy provides two
different types with different `__mul__` methods.  For
`numpy.ndarray` objects, `*` performs elementwise multiplication,
and matrix multiplication must use a function call (`numpy.dot`).
For `numpy.matrix` objects, `*` performs matrix multiplication,
and elementwise multiplication requires function syntax.  Writing code
using `numpy.ndarray` works fine.  Writing code using
`numpy.matrix` also works fine.  But trouble begins as soon as we
try to integrate these two pieces of code together.  Code that expects
an `ndarray` and gets a `matrix`, or vice-versa, may crash or
return incorrect results.  Keeping track of which functions expect
which types as inputs, and return which types as outputs, and then
converting back and forth all the time, is incredibly cumbersome and
impossible to get right at any scale.  Functions that defensively try
to handle both types as input and DTRT, find themselves floundering
into a swamp of `isinstance` and `if` statements.

[PEP 238](https://peps.python.org/pep-0238/) split `/` into two operators: `/` and `//`.  Imagine the
chaos that would have resulted if it had instead split `int` into
two types: `classic_int`, whose `__div__` implemented floor
division, and `new_int`, whose `__div__` implemented true
division.  This, in a more limited way, is the situation that Python
number-crunchers currently find themselves in.

In practice, the vast majority of projects have settled on the
convention of using `*` for elementwise multiplication, and function
call syntax for matrix multiplication (e.g., using `numpy.ndarray`
instead of `numpy.matrix`).  This reduces the problems caused by API
fragmentation, but it doesn't eliminate them.  The strong desire to
use infix notation for matrix multiplication has caused a number of
specialized array libraries to continue to use the opposing convention
(e.g., scipy.sparse, pyoperators, pyviennacl) despite the problems
this causes, and `numpy.matrix` itself still gets used in
introductory programming courses, often appears in StackOverflow
answers, and so forth.  Well-written libraries thus must continue to
be prepared to deal with both types of objects, and, of course, are
also stuck using unpleasant funcall syntax for matrix multiplication.
After nearly two decades of trying, the numerical community has still
not found any way to resolve these problems within the constraints of
current Python syntax (see `Rejected alternatives to adding a new
operator`_ below).

This PEP proposes the minimum effective change to Python syntax that
will allow us to drain this swamp.  It splits `*` into two
operators, just as was done for `/`: `*` for elementwise
multiplication, and `@` for matrix multiplication.  (Why not the
reverse?  Because this way is compatible with the existing consensus,
and because it gives us a consistent rule that all the built-in
numeric operators also apply in an elementwise manner to arrays; the
reverse convention would lead to more special cases.)

So that's why matrix multiplication doesn't and can't just use `*`.
Now, in the rest of this section, we'll explain why it nonetheless
meets the high bar for adding a new operator.

#### Why should matrix multiplication be infix?

Right now, most numerical code in Python uses syntax like
`numpy.dot(a, b)` or `a.dot(b)` to perform matrix multiplication.
This obviously works, so why do people make such a fuss about it, even
to the point of creating API fragmentation and compatibility swamps?

Matrix multiplication shares two features with ordinary arithmetic
operations like addition and multiplication on numbers: (a) it is used
very heavily in numerical programs -- often multiple times per line of
code -- and (b) it has an ancient and universally adopted tradition of
being written using infix syntax.  This is because, for typical
formulas, this notation is dramatically more readable than any
function call syntax.  Here's an example to demonstrate:

One of the most useful tools for testing a statistical hypothesis is
the linear hypothesis test for OLS regression models.  It doesn't
really matter what all those words I just said mean; if we find
ourselves having to implement this thing, what we'll do is look up
some textbook or paper on it, and encounter many mathematical formulas
that look like:

    S = (H \beta - r)^T (H V H^T)^{-1} (H \beta - r)

Here the various variables are all vectors or matrices (details for
the curious: ).

Now we need to write code to perform this calculation. In current
numpy, matrix multiplication can be performed using either the
function or method call syntax. Neither provides a particularly
readable translation of the formula:

    import numpy as np
    from numpy.linalg import inv, solve

    # Using dot function:
    S = np.dot((np.dot(H, beta) - r).T,
               np.dot(inv(np.dot(np.dot(H, V), H.T)), np.dot(H, beta) - r))

    # Using dot method:
    S = (H.dot(beta) - r).T.dot(inv(H.dot(V).dot(H.T))).dot(H.dot(beta) - r)

With the `@` operator, the direct translation of the above formula
becomes:

    S = (H @ beta - r).T @ inv(H @ V @ H.T) @ (H @ beta - r)

Notice that there is now a transparent, 1-to-1 mapping between the
symbols in the original formula and the code that implements it.

Of course, an experienced programmer will probably notice that this is
not the best way to compute this expression.  The repeated computation
of H \beta - r should perhaps be factored out; and,
expressions of the form `dot(inv(A), B)` should almost always be
replaced by the more numerically stable `solve(A, B)`.  When using
`@`, performing these two refactorings gives us:

    # Version 1 (as above)
    S = (H @ beta - r).T @ inv(H @ V @ H.T) @ (H @ beta - r)

    # Version 2
    trans_coef = H @ beta - r
    S = trans_coef.T @ inv(H @ V @ H.T) @ trans_coef

    # Version 3
    S = trans_coef.T @ solve(H @ V @ H.T, trans_coef)

Notice that when comparing between each pair of steps, it's very easy
to see exactly what was changed.  If we apply the equivalent
transformations to the code using the .dot method, then the changes
are much harder to read out or verify for correctness:

    # Version 1 (as above)
    S = (H.dot(beta) - r).T.dot(inv(H.dot(V).dot(H.T))).dot(H.dot(beta) - r)

    # Version 2
    trans_coef = H.dot(beta) - r
    S = trans_coef.T.dot(inv(H.dot(V).dot(H.T))).dot(trans_coef)

    # Version 3
    S = trans_coef.T.dot(solve(H.dot(V).dot(H.T)), trans_coef)

Readability counts!  The statements using `@` are shorter, contain
more whitespace, can be directly and easily compared both to each
other and to the textbook formula, and contain only meaningful
parentheses.  This last point is particularly important for
readability: when using function-call syntax, the required parentheses
on every operation create visual clutter that makes it very difficult
to parse out the overall structure of the formula by eye, even for a
relatively simple formula like this one.  Eyes are terrible at parsing
non-regular languages.  I made and caught many errors while trying to
write out the 'dot' formulas above.  I know they still contain at
least one error, maybe more.  (Exercise: find it.  Or them.)  The
`@` examples, by contrast, are not only correct, they're obviously
correct at a glance.

If we are even more sophisticated programmers, and writing code that
we expect to be reused, then considerations of speed or numerical
accuracy might lead us to prefer some particular order of evaluation.
Because `@` makes it possible to omit irrelevant parentheses, we can
be certain that if we *do* write something like `(H @ V) @ H.T`,
then our readers will know that the parentheses must have been added
intentionally to accomplish some meaningful purpose.  In the `dot`
examples, it's impossible to know which nesting decisions are
important, and which are arbitrary.

Infix `@` dramatically improves matrix code usability at all stages
of programmer interaction.

#### Transparent syntax is especially crucial for non-expert programmers

A large proportion of scientific code is written by people who are
experts in their domain, but are not experts in programming.  And
there are many university courses run each year with titles like "Data
analysis for social scientists" which assume no programming
background, and teach some combination of mathematical techniques,
introduction to programming, and the use of programming to implement
these mathematical techniques, all within a 10-15 week period.  These
courses are more and more often being taught in Python rather than
special-purpose languages like R or Matlab.

For these kinds of users, whose programming knowledge is fragile, the
existence of a transparent mapping between formulas and code often
means the difference between succeeding and failing to write that code
at all.  This is so important that such classes often use the
`numpy.matrix` type which defines `*` to mean matrix
multiplication, even though this type is buggy and heavily
disrecommended by the rest of the numpy community for the
fragmentation that it causes.  This pedagogical use case is, in fact,
the *only* reason `numpy.matrix` remains a supported part of numpy.
Adding `@` will benefit both beginning and advanced users with
better syntax; and furthermore, it will allow both groups to
standardize on the same notation from the start, providing a smoother
on-ramp to expertise.

#### But isn't matrix multiplication a pretty niche requirement?

The world is full of continuous data, and computers are increasingly
called upon to work with it in sophisticated ways.  Arrays are the
lingua franca of finance, machine learning, 3d graphics, computer
vision, robotics, operations research, econometrics, meteorology,
computational linguistics, recommendation systems, neuroscience,
astronomy, bioinformatics (including genetics, cancer research, drug
discovery, etc.), physics engines, quantum mechanics, geophysics,
network analysis, and many other application areas.  In most or all of
these areas, Python is rapidly becoming a dominant player, in large
part because of its ability to elegantly mix traditional discrete data
structures (hash tables, strings, etc.) on an equal footing with
modern numerical data types and algorithms.

We all live in our own little sub-communities, so some Python users
may be surprised to realize the sheer extent to which Python is used
for number crunching -- especially since much of this particular
sub-community's activity occurs outside of traditional Python/FOSS
channels.  So, to give some rough idea of just how many numerical
Python programmers are actually out there, here are two numbers: In
2013, there were 7 international conferences organized specifically on
numerical Python  .  At PyCon 2014, ~20%
of the tutorials appear to involve the use of matrices
.

To quantify this further, we used Github's "search" function to look
at what modules are actually imported across a wide range of
real-world code (i.e., all the code on Github).  We checked for
imports of several popular stdlib modules, a variety of numerically
oriented modules, and various other extremely high-profile modules
like django and lxml (the latter of which is the #1 most downloaded
package on PyPI).  Starred lines indicate packages which export
array- or matrix-like objects which will adopt `@` if this PEP is
approved:

    Count of Python source files on Github matching given search terms
                     (as of 2014-04-10, ~21:00 UTC)
    ================ ==========  ===============  =======  ===========
    module           "import X"  "from X import"    total  total/numpy
    ================ ==========  ===============  =======  ===========
    sys                 2374638            63301  2437939         5.85
    os                  1971515            37571  2009086         4.82
    re                  1294651             8358  1303009         3.12
    numpy ************** 337916 ********** 79065 * 416981 ******* 1.00
    warnings             298195            73150   371345         0.89
    subprocess           281290            63644   344934         0.83
    django                62795           219302   282097         0.68
    math                 200084            81903   281987         0.68
    threading            212302            45423   257725         0.62
    pickle+cPickle       215349            22672   238021         0.57
    matplotlib           119054            27859   146913         0.35
    sqlalchemy            29842            82850   112692         0.27
    pylab *************** 36754 ********** 41063 ** 77817 ******* 0.19
    scipy *************** 40829 ********** 28263 ** 69092 ******* 0.17
    lxml                  19026            38061    57087         0.14
    zlib                  40486             6623    47109         0.11
    multiprocessing       25247            19850    45097         0.11
    requests              30896              560    31456         0.08
    jinja2                 8057            24047    32104         0.08
    twisted               13858             6404    20262         0.05
    gevent                11309             8529    19838         0.05
    pandas ************** 14923 *********** 4005 ** 18928 ******* 0.05
    sympy                  2779             9537    12316         0.03
    theano *************** 3654 *********** 1828 *** 5482 ******* 0.01
    ================ ==========  ===============  =======  ===========

These numbers should be taken with several grains of salt (see
footnote for discussion: ), but, to the extent they
can be trusted, they suggest that `numpy` might be the single
most-imported non-stdlib module in the entire Pythonverse; it's even
more-imported than such stdlib stalwarts as `subprocess`, `math`,
`pickle`, and `threading`.  And numpy users represent only a
subset of the broader numerical community that will benefit from the
`@` operator.  Matrices may once have been a niche data type
restricted to Fortran programs running in university labs and military
clusters, but those days are long gone.  Number crunching is a
mainstream part of modern Python usage.

In addition, there is some precedence for adding an infix operator to
handle a more-specialized arithmetic operation: the floor division
operator `//`, like the bitwise operators, is very useful under
certain circumstances when performing exact calculations on discrete
values.  But it seems likely that there are many Python programmers
who have never had reason to use `//` (or, for that matter, the
bitwise operators).  `@` is no more niche than `//`.

#### So `@` is good for matrix formulas, but how common are those really?

We've seen that `@` makes matrix formulas dramatically easier to
work with for both experts and non-experts, that matrix formulas
appear in many important applications, and that numerical libraries
like numpy are used by a substantial proportion of Python's user base.
But numerical libraries aren't just about matrix formulas, and being
important doesn't necessarily mean taking up a lot of code: if matrix
formulas only occurred in one or two places in the average
numerically-oriented project, then it still wouldn't be worth adding a
new operator.  So how common is matrix multiplication, really?

When the going gets tough, the tough get empirical.  To get a rough
estimate of how useful the `@` operator will be, the table below
shows the rate at which different Python operators are actually used
in the stdlib, and also in two high-profile numerical packages -- the
scikit-learn machine learning library, and the nipy neuroimaging
library -- normalized by source lines of code (SLOC).  Rows are sorted
by the 'combined' column, which pools all three code bases together.
The combined column is thus strongly weighted towards the stdlib,
which is much larger than both projects put together (stdlib: 411575
SLOC, scikit-learn: 50924 SLOC, nipy: 37078 SLOC). 

The `dot` row (marked `******`) counts how common matrix multiply
operations are in each codebase.

```
====  ======  ============  ====  ========
  op  stdlib  scikit-learn  nipy  combined
====  ======  ============  ====  ========
   =    2969          5536  4932      3376 / 10,000 SLOC
   -     218           444   496       261
   +     224           201   348       231
  ==     177           248   334       196
   *     156           284   465       192
   %     121           114   107       119
  **      59           111   118        68
  !=      40            56    74        44
   /      18           121   183        41
   >      29            70   110        39
  +=      34            61    67        39
   <      32            62    76        38
  >=      19            17    17        18
  <=      18            27    12        18
 dot ***** 0 ********** 99 ** 74 ****** 16
   |      18             1     2        15
   &      14             0     6        12
  <<      10             1     1         8
  //       9             9     1         8
  -=       5            21    14         8
  *=       2            19    22         5
  /=       0            23    16         4
  >>       4             0     0         3
   ^       3             0     0         3
   ~       2             4     5         2
  |=       3             0     0         2
  &=       1             0     0         1
 //=       1             0     0         1
  ^=       1             0     0         0
 **=       0             2     0         0
  %=       0             0     0         0
 <<=       0             0     0         0
 >>=       0             0     0         0
====  ======  ============  ====  ========
```

These two numerical packages alone contain ~780 uses of matrix
multiplication.  Within these packages, matrix multiplication is used
more heavily than most comparison operators (`<` `!=` `<=`
`>=`).  Even when we dilute these counts by including the stdlib
into our comparisons, matrix multiplication is still used more often
in total than any of the bitwise operators, and 2x as often as `//`.
This is true even though the stdlib, which contains a fair amount of
integer arithmetic and no matrix operations, makes up more than 80% of
the combined code base.

By coincidence, the numeric libraries make up approximately the same
proportion of the 'combined' codebase as numeric tutorials make up of
PyCon 2014's tutorial schedule, which suggests that the 'combined'
column may not be *wildly* unrepresentative of new Python code in
general.  While it's impossible to know for certain, from this data it
seems entirely possible that across all Python code currently being
written, matrix multiplication is already used more often than `//`
and the bitwise operations.

#### But isn't it weird to add an operator with no stdlib uses?

It's certainly unusual (though extended slicing existed for some time
builtin types gained support for it, `Ellipsis` is still unused
within the stdlib, etc.).  But the important thing is whether a change
will benefit users, not where the software is being downloaded from.
It's clear from the above that `@` will be used, and used heavily.
And this PEP provides the critical piece that will allow the Python
numerical community to finally reach consensus on a standard duck type
for all array-like objects, which is a necessary precondition to ever
adding a numerical array type to the stdlib.

### Compatibility considerations

Currently, the only legal use of the `@` token in Python code is at
statement beginning in decorators.  The new operators are both infix;
the one place they can never occur is at statement beginning.
Therefore, no existing code will be broken by the addition of these
operators, and there is no possible parsing ambiguity between
decorator-@ and the new operators.

Another important kind of compatibility is the mental cost paid by
users to update their understanding of the Python language after this
change, particularly for users who do not work with matrices and thus
do not benefit.  Here again, `@` has minimal impact: even
comprehensive tutorials and references will only need to add a
sentence or two to fully document this PEP's changes for a
non-numerical audience.

### Intended usage details

This section is informative, rather than normative -- it documents the
consensus of a number of libraries that provide array- or matrix-like
objects on how `@` will be implemented.

This section uses the numpy terminology for describing arbitrary
multidimensional arrays of data, because it is a superset of all other
commonly used models.  In this model, the *shape* of any array is
represented by a tuple of integers.  Because matrices are
two-dimensional, they have len(shape) == 2, while 1d vectors have
len(shape) == 1, and scalars have shape == (), i.e., they are "0
dimensional".  Any array contains prod(shape) total entries.  Notice
that `prod(()) == 1`_ (for the same reason that sum(()) == 0); scalars
are just an ordinary kind of array, not a special case.  Notice also
that we distinguish between a single scalar value (shape == (),
analogous to `1`), a vector containing only a single entry (shape ==
(1,), analogous to `[1]`), a matrix containing only a single entry
(shape == (1, 1), analogous to `[[1]]`), etc., so the dimensionality
of any array is always well-defined.  Other libraries with more
restricted representations (e.g., those that support 2d arrays only)
might implement only a subset of the functionality described here.

.. _prod(()) == 1: https://en.wikipedia.org/wiki/Empty_product

#### Semantics

The recommended semantics for `@` for different inputs are:

* 2d inputs are conventional matrices, and so the semantics are
  obvious: we apply conventional matrix multiplication.  If we write
  `arr(2, 3)` to represent an arbitrary 2x3 array, then ``arr(2, 3)
  @ arr(3, 4)`` returns an array with shape (2, 4).

* 1d vector inputs are promoted to 2d by prepending or appending a '1'
  to the shape, the operation is performed, and then the added
  dimension is removed from the output.  The 1 is always added on the
  "outside" of the shape: prepended for left arguments, and appended
  for right arguments.  The result is that matrix @ vector and vector
  @ matrix are both legal (assuming compatible shapes), and both
  return 1d vectors; vector @ vector returns a scalar.  This is
  clearer with examples.

  * `arr(2, 3) @ arr(3, 1)` is a regular matrix product, and returns
    an array with shape (2, 1), i.e., a column vector.

  * `arr(2, 3) @ arr(3)` performs the same computation as the
    previous (i.e., treats the 1d vector as a matrix containing a
    single *column*, shape = (3, 1)), but returns the result with
    shape (2,), i.e., a 1d vector.

  * `arr(1, 3) @ arr(3, 2)` is a regular matrix product, and returns
    an array with shape (1, 2), i.e., a row vector.

  * `arr(3) @ arr(3, 2)` performs the same computation as the
    previous (i.e., treats the 1d vector as a matrix containing a
    single *row*, shape = (1, 3)), but returns the result with shape
    (2,), i.e., a 1d vector.

  * `arr(1, 3) @ arr(3, 1)` is a regular matrix product, and returns
    an array with shape (1, 1), i.e., a single value in matrix form.

  * `arr(3) @ arr(3)` performs the same computation as the
    previous, but returns the result with shape (), i.e., a single
    scalar value, not in matrix form.  So this is the standard inner
    product on vectors.

  An infelicity of this definition for 1d vectors is that it makes
  `@` non-associative in some cases (`(Mat1 @ vec) @ Mat2` !=
  `Mat1 @ (vec @ Mat2)`).  But this seems to be a case where
  practicality beats purity: non-associativity only arises for strange
  expressions that would never be written in practice; if they are
  written anyway then there is a consistent rule for understanding
  what will happen (`Mat1 @ vec @ Mat2` is parsed as ``(Mat1 @ vec)
  @ Mat2`, just like `a - b - c``); and, not supporting 1d vectors
  would rule out many important use cases that do arise very commonly
  in practice.  No-one wants to explain to new users why to solve the
  simplest linear system in the obvious way, they have to type
  `(inv(A) @ b[:, np.newaxis]).flatten()` instead of `inv(A) @ b`,
  or perform an ordinary least-squares regression by typing
  `solve(X.T @ X, X @ y[:, np.newaxis]).flatten()` instead of
  `solve(X.T @ X, X @ y)`.  No-one wants to type ``(a[np.newaxis, :]
  @ b[:, np.newaxis])[0, 0]` instead of `a @ b`` every time they
  compute an inner product, or ``(a[np.newaxis, :] @ Mat @ b[:,
  np.newaxis])[0, 0]` for general quadratic forms instead of `a @
  Mat @ b``.  In addition, sage and sympy (see below) use these
  non-associative semantics with an infix matrix multiplication
  operator (they use `*`), and they report that they haven't
  experienced any problems caused by it.

* For inputs with more than 2 dimensions, we treat the last two
  dimensions as being the dimensions of the matrices to multiply, and
  'broadcast' across the other dimensions.  This provides a convenient
  way to quickly compute many matrix products in a single operation.
  For example, `arr(10, 2, 3) @ arr(10, 3, 4)` performs 10 separate
  matrix multiplies, each of which multiplies a 2x3 and a 3x4 matrix
  to produce a 2x4 matrix, and then returns the 10 resulting matrices
  together in an array with shape (10, 2, 4).  The intuition here is
  that we treat these 3d arrays of numbers as if they were 1d arrays
  *of matrices*, and then apply matrix multiplication in an
  elementwise manner, where now each 'element' is a whole matrix.
  Note that broadcasting is not limited to perfectly aligned arrays;
  in more complicated cases, it allows several simple but powerful
  tricks for controlling how arrays are aligned with each other; see
   for details.  (In particular, it turns out that
  when broadcasting is taken into account, the standard scalar *
  matrix product is a special case of the elementwise multiplication
  operator `*`.)

  If one operand is >2d, and another operand is 1d, then the above
  rules apply unchanged, with 1d->2d promotion performed before
  broadcasting.  E.g., `arr(10, 2, 3) @ arr(3)` first promotes to
  `arr(10, 2, 3) @ arr(3, 1)`, then broadcasts the right argument to
  create the aligned operation `arr(10, 2, 3) @ arr(10, 3, 1)`,
  multiplies to get an array with shape (10, 2, 1), and finally
  removes the added dimension, returning an array with shape (10, 2).
  Similarly, `arr(2) @ arr(10, 2, 3)` produces an intermediate array
  with shape (10, 1, 3), and a final array with shape (10, 3).

* 0d (scalar) inputs raise an error.  Scalar * matrix multiplication
  is a mathematically and algorithmically distinct operation from
  matrix @ matrix multiplication, and is already covered by the
  elementwise `*` operator.  Allowing scalar @ matrix would thus
  both require an unnecessary special case, and violate TOOWTDI.

#### Adoption

We group existing Python projects which provide array- or matrix-like
types based on what API they currently use for elementwise and matrix
multiplication.

**Projects which currently use * for elementwise multiplication, and
function/method calls for matrix multiplication:**

The developers of the following projects have expressed an intention
to implement `@` on their array-like types using the above
semantics:

* numpy
* pandas
* blaze
* theano

The following projects have been alerted to the existence of the PEP,
but it's not yet known what they plan to do if it's accepted.  We
don't anticipate that they'll have any objections, though, since
everything proposed here is consistent with how they already do
things:

* pycuda
* panda3d

**Projects which currently use * for matrix multiplication, and
function/method calls for elementwise multiplication:**

The following projects have expressed an intention, if this PEP is
accepted, to migrate from their current API to the elementwise-`*`,
matmul-`@` convention (i.e., this is a list of projects whose API
fragmentation will probably be eliminated if this PEP is accepted):

* numpy (`numpy.matrix`)
* scipy.sparse
* pyoperators
* pyviennacl

The following projects have been alerted to the existence of the PEP,
but it's not known what they plan to do if it's accepted (i.e., this
is a list of projects whose API fragmentation may or may not be
eliminated if this PEP is accepted):

* cvxopt

**Projects which currently use * for matrix multiplication, and which
don't really care about elementwise multiplication of matrices:**

There are several projects which implement matrix types, but from a
very different perspective than the numerical libraries discussed
above.  These projects focus on computational methods for analyzing
matrices in the sense of abstract mathematical objects (i.e., linear
maps over free modules over rings), rather than as big bags full of
numbers that need crunching.  And it turns out that from the abstract
math point of view, there isn't much use for elementwise operations in
the first place; as discussed in the Background section above,
elementwise operations are motivated by the bag-of-numbers approach.
So these projects don't encounter the basic problem that this PEP
exists to address, making it mostly irrelevant to them; while they
appear superficially similar to projects like numpy, they're actually
doing something quite different.  They use `*` for matrix
multiplication (and for group actions, and so forth), and if this PEP
is accepted, their expressed intention is to continue doing so, while
perhaps adding `@` as an alias.  These projects include:

* sympy
* sage

### Implementation details

New functions `operator.matmul` and `operator.__matmul__` are
added to the standard library, with the usual semantics.

A corresponding function ``PyObject* PyObject_MatrixMultiply(PyObject
*o1, PyObject *o2)`` is added to the C API.

A new AST node is added named `MatMult`, along with a new token
`ATEQUAL` and new bytecode opcodes `BINARY_MATRIX_MULTIPLY` and
`INPLACE_MATRIX_MULTIPLY`.

Two new type slots are added; whether this is to `PyNumberMethods`
or a new `PyMatrixMethods` struct remains to be determined.

### Rationale for specification details

#### Choice of operator

Why `@` instead of some other spelling?  There isn't any consensus
across other programming languages about how this operator should be
named ; here we discuss the various options.

Restricting ourselves only to symbols present on US English keyboards,
the punctuation characters that don't already have a meaning in Python
expression context are: `@`, backtick, `$`, `!`, and `?`.  Of
these options, `@` is clearly the best; `!` and `?` are already
heavily freighted with inapplicable meanings in the programming
context, backtick has been banned from Python by BDFL pronouncement
(see [PEP 3099](https://peps.python.org/pep-3099/)), and `$` is uglier, even more dissimilar to `*` and
\cdot, and has Perl/PHP baggage.  `$` is probably the
second-best option of these, though.

Symbols which are not present on US English keyboards start at a
significant disadvantage (having to spend 5 minutes at the beginning
of every numeric Python tutorial just going over keyboard layouts is
not a hassle anyone really wants).  Plus, even if we somehow overcame
the typing problem, it's not clear there are any that are actually
better than `@`.  Some options that have been suggested include:

* U+00D7 MULTIPLICATION SIGN: `A × B`
* U+22C5 DOT OPERATOR: `A ⋅ B`
* U+2297 CIRCLED TIMES: `A ⊗ B`
* U+00B0 DEGREE: `A ° B`

What we need, though, is an operator that means "matrix
multiplication, as opposed to scalar/elementwise multiplication".
There is no conventional symbol with this meaning in either
programming or mathematics, where these operations are usually
distinguished by context.  (And U+2297 CIRCLED TIMES is actually used
conventionally to mean exactly the wrong things: elementwise
multiplication -- the "Hadamard product" -- or outer product, rather
than matrix/inner product like our operator).  `@` at least has the
virtue that it *looks* like a funny non-commutative operator; a naive
user who knows maths but not programming couldn't look at `A * B`
versus `A × B`, or `A * B` versus `A ⋅ B`, or `A * B` versus
`A ° B` and guess which one is the usual multiplication, and which
one is the special case.

Finally, there is the option of using multi-character tokens.  Some
options:

* Matlab and Julia use a `.*` operator.  Aside from being visually
  confusable with `*`, this would be a terrible choice for us
  because in Matlab and Julia, `*` means matrix multiplication and
  `.*` means elementwise multiplication, so using `.*` for matrix
  multiplication would make us exactly backwards from what Matlab and
  Julia users expect.

* APL apparently used `+.×`, which by combining a multi-character
  token, confusing attribute-access-like . syntax, and a unicode
  character, ranks somewhere below U+2603 SNOWMAN on our candidate
  list.  If we like the idea of combining addition and multiplication
  operators as being evocative of how matrix multiplication actually
  works, then something like `+*` could be used -- though this may
  be too easy to confuse with `*+`, which is just multiplication
  combined with the unary `+` operator.

* [PEP 211](https://peps.python.org/pep-0211/) suggested `~*`.  This has the downside that it sort of
  suggests that there is a unary `*` operator that is being combined
  with unary `~`, but it could work.

* R uses `%*%` for matrix multiplication.  In R this forms part of a
  general extensible infix system in which all tokens of the form
  `%foo%` are user-defined binary operators.  We could steal the
  token without stealing the system.

* Some other plausible candidates that have been suggested: `><` (=
  ascii drawing of the multiplication sign ×); the footnote operator
  `[*]` or `|*|` (but when used in context, the use of vertical
  grouping symbols tends to recreate the nested parentheses visual
  clutter that was noted as one of the major downsides of the function
  syntax we're trying to get away from); `^*`.

So, it doesn't matter much, but `@` seems as good or better than any
of the alternatives:

* It's a friendly character that Pythoneers are already used to typing
  in decorators, but the decorator usage and the math expression
  usage are sufficiently dissimilar that it would be hard to confuse
  them in practice.

* It's widely accessible across keyboard layouts (and thanks to its
  use in email addresses, this is true even of weird keyboards like
  those in phones).

* It's round like `*` and \cdot.

* The mATrices mnemonic is cute.

* The swirly shape is reminiscent of the simultaneous sweeps over rows
  and columns that define matrix multiplication

* Its asymmetry is evocative of its non-commutative nature.

* Whatever, we have to pick something.

#### Precedence and associativity

There was a long discussion  about
whether `@` should be right- or left-associative (or even something
more exotic ). Almost all Python operators are
left-associative, so following this convention would be the simplest
approach, but there were two arguments that suggested matrix
multiplication might be worth making right-associative as a special
case:

First, matrix multiplication has a tight conceptual association with
function application/composition, so many mathematically sophisticated
users have an intuition that an expression like R S x proceeds
from right-to-left, with first S transforming the vector
x, and then R transforming the result. This isn't
universally agreed (and not all number-crunchers are steeped in the
pure-math conceptual framework that motivates this intuition
), but at the least this
intuition is more common than for other operations like :math:`2 \cdot
3 \cdot 4` which everyone reads as going from left-to-right.

Second, if expressions like `Mat @ Mat @ vec` appear often in code,
then programs will run faster (and efficiency-minded programmers will
be able to use fewer parentheses) if this is evaluated as ``Mat @ (Mat
@ vec)` then if it is evaluated like `(Mat @ Mat) @ vec``.

However, weighing against these arguments are the following:

Regarding the efficiency argument, empirically, we were unable to find
any evidence that `Mat @ Mat @ vec` type expressions actually
dominate in real-life code. Parsing a number of large projects that
use numpy, we found that when forced by numpy's current funcall syntax
to choose an order of operations for nested calls to `dot`, people
actually use left-associative nesting slightly *more* often than
right-associative nesting .  And anyway,
writing parentheses isn't so bad -- if an efficiency-minded programmer
is going to take the trouble to think through the best way to evaluate
some expression, they probably *should* write down the parentheses
regardless of whether they're needed, just to make it obvious to the
next reader that they order of operations matter.

In addition, it turns out that other languages, including those with
much more of a focus on linear algebra, overwhelmingly make their
matmul operators left-associative. Specifically, the `@` equivalent
is left-associative in R, Matlab, Julia, IDL, and Gauss. The only
exceptions we found are Mathematica, in which `a @ b @ c` would be
parsed non-associatively as `dot(a, b, c)`, and APL, in which all
operators are right-associative. There do not seem to exist any
languages that make `@` right-associative and `*`
left-associative. And these decisions don't seem to be controversial
-- I've never seen anyone complaining about this particular aspect of
any of these other languages, and the left-associativity of `*`
doesn't seem to bother users of the existing Python libraries that use
`*` for matrix multiplication. So, at the least we can conclude from
this that making `@` left-associative will certainly not cause any
disasters. Making `@` right-associative, OTOH, would be exploring
new and uncertain ground.

And another advantage of left-associativity is that it is much easier
to learn and remember that `@` acts like `*`, than it is to
remember first that `@` is unlike other Python operators by being
right-associative, and then on top of this, also have to remember
whether it is more tightly or more loosely binding than
`*`. (Right-associativity forces us to choose a precedence, and
intuitions were about equally split on which precedence made more
sense. So this suggests that no matter which choice we made, no-one
would be able to guess or remember it.)

On net, therefore, the general consensus of the numerical community is
that while matrix multiplication is something of a special case, it's
not special enough to break the rules, and `@` should parse like
`*` does.

#### (Non)-Definitions for built-in types

No `__matmul__` or `__matpow__` are defined for builtin numeric
types (`float`, `int`, etc.) or for the `numbers.Number`
hierarchy, because these types represent scalars, and the consensus
semantics for `@` are that it should raise an error on scalars.

We do not -- for now -- define a `__matmul__` method on the standard
`memoryview` or `array.array` objects, for several reasons.  Of
course this could be added if someone wants it, but these types would
require quite a bit of additional work beyond `__matmul__` before
they could be used for numeric work -- e.g., they have no way to do
addition or scalar multiplication either! -- and adding such
functionality is beyond the scope of this PEP.  In addition, providing
a quality implementation of matrix multiplication is highly
non-trivial.  Naive nested loop implementations are very slow and
shipping such an implementation in CPython would just create a trap
for users.  But the alternative -- providing a modern, competitive
matrix multiply -- would require that CPython link to a BLAS library,
which brings a set of new complications.  In particular, several
popular BLAS libraries (including the one that ships by default on
OS X) currently break the use of `multiprocessing` .
Together, these considerations mean that the cost/benefit of adding
`__matmul__` to these types just isn't there, so for now we'll
continue to delegate these problems to numpy and friends, and defer a
more systematic solution to a future proposal.

There are also non-numeric Python builtins which define `__mul__`
(`str`, `list`, ...).  We do not define `__matmul__` for these
types either, because why would we even do that.

#### Non-definition of matrix power

Earlier versions of this PEP also proposed a matrix power operator,
`@@`, analogous to `**`.  But on further consideration, it was
decided that the utility of this was sufficiently unclear that it
would be better to leave it out for now, and only revisit the issue if
-- once we have more experience with `@` -- it turns out that `@@`
is truly missed. 

### Rejected alternatives to adding a new operator

Over the past few decades, the Python numeric community has explored a
variety of ways to resolve the tension between matrix and elementwise
multiplication operations.  [PEP 211](https://peps.python.org/pep-0211/) and [PEP 225](https://peps.python.org/pep-0225/), both proposed in 2000
and last seriously discussed in 2008 , were early
attempts to add new operators to solve this problem, but suffered from
serious flaws; in particular, at that time the Python numerical
community had not yet reached consensus on the proper API for array
objects, or on what operators might be needed or useful (e.g., [PEP 225](https://peps.python.org/pep-0225/)
proposes 6 new operators with unspecified semantics).  Experience
since then has now led to consensus that the best solution, for both
numeric Python and core Python, is to add a single infix operator for
matrix multiply (together with the other new operators this implies
like `@=`).

We review some of the rejected alternatives here.

**Use a second type that defines __mul__ as matrix multiplication:**
As discussed above (`Background: What's wrong with the status quo?`_),
this has been tried this for many years via the `numpy.matrix` type
(and its predecessors in Numeric and numarray).  The result is a
strong consensus among both numpy developers and developers of
downstream packages that `numpy.matrix` should essentially never be
used, because of the problems caused by having conflicting duck types
for arrays.  (Of course one could then argue we should *only* define
`__mul__` to be matrix multiplication, but then we'd have the same
problem with elementwise multiplication.)  There have been several
pushes to remove `numpy.matrix` entirely; the only counter-arguments
have come from educators who find that its problems are outweighed by
the need to provide a simple and clear mapping between mathematical
notation and code for novices (see `Transparent syntax is especially
crucial for non-expert programmers`_).  But, of course, starting out
newbies with a dispreferred syntax and then expecting them to
transition later causes its own problems.  The two-type solution is
worse than the disease.

**Add lots of new operators, or add a new generic syntax for defining
infix operators:** In addition to being generally un-Pythonic and
repeatedly rejected by BDFL fiat, this would be using a sledgehammer
to smash a fly.  The scientific python community has consensus that
adding one operator for matrix multiplication is enough to fix the one
otherwise unfixable pain point. (In retrospect, we all think [PEP 225](https://peps.python.org/pep-0225/)
was a bad idea too -- or at least far more complex than it needed to
be.)

**Add a new @ (or whatever) operator that has some other meaning in
general Python, and then overload it in numeric code:** This was the
approach taken by [PEP 211](https://peps.python.org/pep-0211/), which proposed defining `@` to be the
equivalent of `itertools.product`.  The problem with this is that
when taken on its own terms, it's pretty clear that
`itertools.product` doesn't actually need a dedicated operator.  It
hasn't even been deemed worth of a builtin.  (During discussions of
this PEP, a similar suggestion was made to define `@` as a general
purpose function composition operator, and this suffers from the same
problem; `functools.compose` isn't even useful enough to exist.)
Matrix multiplication has a uniquely strong rationale for inclusion as
an infix operator.  There almost certainly don't exist any other
binary operations that will ever justify adding any other infix
operators to Python.

**Add a .dot method to array types so as to allow "pseudo-infix"
A.dot(B) syntax:** This has been in numpy for some years, and in many
cases it's better than dot(A, B).  But it's still much less readable
than real infix notation, and in particular still suffers from an
extreme overabundance of parentheses.  See `Why should matrix
multiplication be infix?`_ above.

**Use a 'with' block to toggle the meaning of * within a single code
block**: E.g., numpy could define a special context object so that
we'd have:

    c = a * b   # element-wise multiplication
    with numpy.mul_as_dot:
        c = a * b  # matrix multiplication

However, this has two serious problems: first, it requires that every
array-like type's `__mul__` method know how to check some global
state (`numpy.mul_is_currently_dot` or whatever).  This is fine if
`a` and `b` are numpy objects, but the world contains many
non-numpy array-like objects.  So this either requires non-local
coupling -- every numpy competitor library has to import numpy and
then check `numpy.mul_is_currently_dot` on every operation -- or
else it breaks duck-typing, with the above code doing radically
different things depending on whether `a` and `b` are numpy
objects or some other sort of object.  Second, and worse, `with`
blocks are dynamically scoped, not lexically scoped; i.e., any
function that gets called inside the `with` block will suddenly find
itself executing inside the mul_as_dot world, and crash and burn
horribly -- if you're lucky.  So this is a construct that could only
be used safely in rather limited cases (no function calls), and which
would make it very easy to shoot yourself in the foot without warning.

**Use a language preprocessor that adds extra numerically-oriented
operators and perhaps other syntax:** (As per recent BDFL suggestion:
) This suggestion seems based on the idea that
numerical code needs a wide variety of syntax additions.  In fact,
given `@`, most numerical users don't need any other operators or
syntax; it solves the one really painful problem that cannot be solved
by other means, and that causes painful reverberations through the
larger ecosystem.  Defining a new language (presumably with its own
parser which would have to be kept in sync with Python's, etc.), just
to support a single binary operator, is neither practical nor
desirable.  In the numerical context, Python's competition is
special-purpose numerical languages (Matlab, R, IDL, etc.).  Compared
to these, Python's killer feature is exactly that one can mix
specialized numerical code with code for XML parsing, web page
generation, database access, network programming, GUI libraries, and
so forth, and we also gain major benefits from the huge variety of
tutorials, reference material, introductory classes, etc., which use
Python.  Fragmenting "numerical Python" from "real Python" would be a
major source of confusion.  A major motivation for this PEP is to
*reduce* fragmentation.  Having to set up a preprocessor would be an
especially prohibitive complication for unsophisticated users.  And we
use Python because we like Python!  We don't want
almost-but-not-quite-Python.

**Use overloading hacks to define a "new infix operator" like *dot*,
as in a well-known Python recipe:** (See: ) Beautiful is
better than ugly.  This is... not beautiful.  And not Pythonic.  And
especially unfriendly to beginners, who are just trying to wrap their
heads around the idea that there's a coherent underlying system behind
these magic incantations that they're learning, when along comes an
evil hack like this that violates that system, creates bizarre error
messages when accidentally misused, and whose underlying mechanisms
can't be understood without deep knowledge of how object oriented
systems work.

**Use a special "facade" type to support syntax like arr.M * arr:**
This is very similar to the previous proposal, in that the `.M`
attribute would basically return the same object as `arr *dot` would,
and thus suffers the same objections about 'magicalness'.  This
approach also has some non-obvious complexities: for example, while
`arr.M * arr` must return an array, `arr.M * arr.M` and
`arr * arr.M` must return facade objects, or else `arr.M * arr.M * arr`
and `arr * arr.M * arr` will not work.  But this means that facade
objects must be able to recognize both other array objects and other
facade objects (which creates additional complexity for writing
interoperating array types from different libraries who must now
recognize both each other's array types and their facade types).  It
also creates pitfalls for users who may easily type `arr * arr.M` or
`arr.M * arr.M` and expect to get back an array object; instead,
they will get a mysterious object that throws errors when they attempt
to use it.  Basically with this approach users must be careful to
think of `.M*` as an indivisible unit that acts as an infix operator
-- and as infix-operator-like token strings go, at least `*dot*`
is prettier looking (look at its cute little ears!).

*Source: https://peps.python.org/pep-0465/*

## Linked PEP 697 — Limited C API for Extending Opaque Types
### Abstract

Add [Limited C API ](https://docs.python.org/3.11/c-api/stable.html#stable-application-binary-interface)
support for extending some types with opaque data
by allowing code to only deal with data specific to a particular (sub)class.

This mechanism is required to be usable with `PyHeapTypeObject`.

This PEP does not propose allowing to extend non-dynamically sized variable
sized objects such as `tuple` or `int` due to their different memory layout
and perceived lack of demand for doing so.  This PEP leaves room to do so in
the future via the same mechanism if ever desired.

### Motivation

The motivating problem this PEP solves is attaching C-level state
to custom types --- i.e. metaclasses (subclasses of
python:type).

This is often needed in “wrappers” that expose another type
system (e.g. C++, Java, Rust) as Python classes.
These typically need to attach information about the “wrapped” non-Python
class to the Python type object.

This should be possible to do in the Limited API, so that the language wrappers
or code generators can be used to create Stable ABI extensions.
(See [PEP 652](https://peps.python.org/pep-0652/) for the benefits of providing a stable ABI.)

Extending `type` is an instance of a more general problem:
extending a class while maintaining loose coupling – that is,
not depending on the memory layout used by the superclass.
(That's a lot of jargon; see Rationale for a concrete example of extending
`list`.)

### Rationale

#### Extending opaque types

In the Limited API, most `struct`s are opaque: their size and memory layout
are not exposed, so they can be changed in new versions of CPython (or
alternate implementations of the C API).

This means that the usual subclassing pattern -- making the `struct`
used for instances of the *base* type be the first element of the `struct`
used for instances of the *derived* type -- does not work.
To illustrate with code, the [example from the tutorial ](https://docs.python.org/3.11/extending/newtypes_tutorial.html#subclassing-other-types)
extends PyListObject (python:list)
using the following `struct`:

```c
 typedef struct {
     PyListObject list;
     int state;
 } SubListObject;
```
This won't compile in the Limited API, since `PyListObject` is opaque (to
allow changes as features and optimizations are implemented).

Instead, this PEP proposes using a `struct` with only the state needed
in the subclass, that is:

```c
 typedef struct {
     int state;
 } SubListState;

 // (or just `typedef int SubListState;` in this case)
```
The subclass can now be completely decoupled from the memory layout (and size)
of the superclass.

This is possible today. To use such a struct:

* when creating the class, use `PyListObject->tp_basicsize + sizeof(SubListState)`
  as `PyType_Spec.basicsize`;
* when accessing the data, use `PyListObject->tp_basicsize` as the offset
  into the instance (`PyObject*`).

However, this has disadvantages:

* The base's `basicsize` may not be properly aligned, causing issues
  on some architectures if not mitigated. (These issues can be particularly
  nasty if alignment changes in a new release.)
* `PyTypeObject.tp_basicsize` is not exposed in the
  Limited API, so extensions that support Limited API need to
  use `PyObject_GetAttrString(obj, "__basicsize__")`.
  This is cumbersome, and unsafe in edge cases (the Python attribute can
  be overridden).
* Variable-size objects are not handled
  (see `Extending variable-size objects`_ below).

To make this easy (and even *best practice* for projects that choose loose
coupling over maximum performance), this PEP proposes an API to:

1. During class creation, specify that `SubListState`
   should be “appended” to `PyListObject`, without passing any additional
   details about `list`. (The interpreter itself gets all necessary info,
   like `tp_basicsize`, from the base).

   This will be specified by a negative `PyType_Spec.basicsize`:
   `-sizeof(SubListState)`.

2. Given an instance, and the subclass `PyTypeObject*`,
   get a pointer to the `SubListState`.
   A new function, `PyObject_GetTypeData`, will be added for this.

The base class is not limited to `PyListObject`, of course: it can be used to
extend any base class whose instance `struct` is opaque, unstable across
releases, or not exposed at all -- including python:type
(`PyHeapTypeObject`) or third-party extensions
(for example, NumPy arrays ).

For cases where no additional state is needed, a zero `basicsize` will be
allowed: in that case, the base's `tp_basicsize` will be inherited.
(This currently works, but lacks explicit documentation and tests.)

The `tp_basicsize` of the new class will be set to the computed total size,
so code that inspects classes will continue working as before.

#### Extending variable-size objects

Additional considerations are needed to subclass
variable-sized objects 
while maintaining loose coupling:
the variable-sized data can collide with subclass data (`SubListState` in
the example above).

Currently, CPython doesn't provide a way to prevent such collisions.
So, the proposed mechanism of extending opaque classes (negative
`base->tp_itemsize`) will *fail* by default.

We could stop there, but since the motivating type --- `PyHeapTypeObject` ---
is variable sized, we need a safe way to allow subclassing it.
A bit of background first:

Variable-size layouts
.....................

There are two main memory layouts for variable-sized objects.

In types such as `int` or `tuple`, the variable data is stored at a fixed
offset.
If subclasses need additional space, it must be added after any variable-sized
data:

   PyTupleObject:
   ┌───────────────────┬───┬───┬╌╌╌╌┐
   │ PyObject_VAR_HEAD │var. data   │
   └───────────────────┴───┴───┴╌╌╌╌┘

   tuple subclass:
   ┌───────────────────┬───┬───┬╌╌╌╌┬─────────────┐
   │ PyObject_VAR_HEAD │var. data   │subclass data│
   └───────────────────┴───┴───┴╌╌╌╌┴─────────────┘

In other types, like `PyHeapTypeObject`, variable-sized data always lives at
the end of the instance's memory area:

   heap type:
   ┌───────────────────┬──────────────┬───┬───┬╌╌╌╌┐
   │ PyObject_VAR_HEAD │Heap type data│var. data   │
   └───────────────────┴──────────────┴───┴───┴╌╌╌╌┘

   type subclass:
   ┌───────────────────┬──────────────┬─────────────┬───┬───┬╌╌╌╌┐
   │ PyObject_VAR_HEAD │Heap type data│subclass data│var. data   │
   └───────────────────┴──────────────┴─────────────┴───┴───┴╌╌╌╌┘

The first layout enables fast access to the items array.
The second allows subclasses to ignore the variable-sized array (assuming
they use offsets from the start of the object to access their data).

Since this PEP focuses on `PyHeapTypeObject`, it proposes an API to allow
subclassing for the second variant.
Support for the first can be added later *as an API-compatible change*
(though your PEP author doubts it'd be worth the effort).

Extending classes with the `PyHeapTypeObject`-like layout
...........................................................

This PEP proposes a type flag, `Py_TPFLAGS_ITEMS_AT_END`, which will indicate
the `PyHeapTypeObject`-like layout.
This can be set in two ways:

* the superclass can set the flag, allowing subclass authors to not care about
  the fact that `itemsize` is involved, or
* the new subclass sets the flag, asserting that the author knows the
  superclass is suitable (but perhaps hasn't been updated to use the flag yet).

This flag will be necessary to extend a variable-sized type using negative
`basicsize`.

An alternative to a flag would be to require subclass authors to know that the
base uses a compatible layout (e.g. from documentation).
A past version of this PEP proposed a new
`PyType_Slot` for it.
This turned out to be hard to explain, and goes against the idea of decoupling
the subclass from the base layout.

The new flag will be used to allow safely extending variable-sized types:
creating a type with `spec->basicsize < 0` and `base->tp_itemsize > 0`
will require the flag.

Additionally, this PEP proposes a helper function to get the variable-sized
data of a given instance, if it uses the new `Py_TPFLAGS_ITEMS_AT_END` flag.
This hides the necessary pointer arithmetic behind an API
that can potentially be adapted to other layouts in the future (including,
potentially, a VM-managed layout).

Big picture
...........

To make it easier to verify that all cases are covered, here's a scary-looking
big-picture decision tree.

> **Note:** The individual cases are easier to explain in isolation (see the
> **Note:** [reference implementation](Reference Implementation_) for draft docs).
* `spec->basicsize > 0`: No change to the status quo. (The base
  class layout is known.)

* `spec->basicsize == 0`: (Inheriting the basicsize)

  * `base->tp_itemsize == 0`: The item size is set to `spec->tp_itemsize`.
    (No change to status quo.)
  * `base->tp_itemsize > 0`: (Extending a variable-size class)

    * `spec->itemsize == 0`: The item size is inherited.
      (No change to status quo.)
    * `spec->itemsize > 0`: The item size is set. (This is hard to use safely,
      but it's CPython's current behavior.)

* `spec->basicsize < 0`: (Extending the basicsize)

  * `base->tp_itemsize == 0`: (Extending a fixed-size class)

    * `spec->itemsize == 0`: The item size is set to 0.
    * `spec->itemsize > 0`: Fail. (We'd need to add an `ob_size`, which is
      only possible for trivial types -- and the trivial layout must be known.)

  * `base->tp_itemsize > 0`: (Extending a variable-size class)

    * `spec->itemsize == 0`: (Inheriting the itemsize)

      * `Py_TPFLAGS_ITEMS_AT_END` used: itemsize is inherited.
      * `Py_TPFLAGS_ITEMS_AT_END` not used: Fail. (Possible conflict.)

    * `spec->itemsize > 0`: Fail. (Changing/extending the item size can't be
      done safely.)

Setting `spec->itemsize < 0` is always an error.
This PEP does not propose any mechanism to *extend* `tp->itemsize`
rather than just inherit it.

#### Relative member offsets

One more piece of the puzzle is `PyMemberDef.offset`.
Extensions that use a subclass-specific `struct` (`SubListState` above)
will get a way to specify “relative” offsets (offsets based from this
`struct`) rather than “absolute” ones (based off the `PyObject` struct).

One way to do it would be to automatically assume “relative” offsets
when creating a class using the new API.
However, this implicit assumption would be too surprising.

To be more explicit, this PEP proposes a new flag for “relative” offsets.
At least initially, this flag will serve only as a check against misuse
(and a hint for reviewers).
It must be present if used with the new API, and must not be used otherwise.

### Specification

In the code blocks below, only function headers are part of the specification.
Other code (the size/offset calculations) are details of the initial CPython
implementation, and subject to change.

#### Relative `basicsize`

The `basicsize` member of `PyType_Spec` will be allowed to be zero or
negative.
In that case, its absolute value will specify how much *extra* storage space
instances of the new class require, in addition to the basicsize of the
base class.
That is, the basicsize of the resulting class will be:

```c
type->tp_basicsize = _align(base->tp_basicsize) + _align(-spec->basicsize);
```
where `_align` rounds up to a multiple of `alignof(max_align_t)`.

When `spec->basicsize` is zero, basicsize will be inherited
directly instead, i.e. set to `base->tp_basicsize` without aligning.
(This already works; explicit tests and documentation will be added.)

On an instance, the memory area specific to a subclass -- that is, the
“extra space” that subclass reserves in addition its base -- will be available
through a new function, `PyObject_GetTypeData`.
In CPython, this function will be defined as:

```c
void *
PyObject_GetTypeData(PyObject *obj, PyTypeObject *cls) {
    return (char *)obj + _align(cls->tp_base->tp_basicsize);
}
```
Another function will be added to retrieve the size of this memory area:

```c
Py_ssize_t
PyType_GetTypeDataSize(PyTypeObject *cls) {
    return cls->tp_basicsize - _align(cls->tp_base->tp_basicsize);
}
```
The result may be higher than requested by `-basicsize`. It is safe to
use all of it (e.g. with `memset`).

The new `*Get*` functions come with an important caveat, which will be
pointed out in documentation: They may only be used for classes created using
negative `PyType_Spec.basicsize`. For other classes, their behavior is
undefined.
(Note that this allows the above code to assume `cls->tp_base` is not
`NULL`.)

#### Inheriting `itemsize`

When `spec->itemsize` is zero, `tp_itemsize` will be inherited
from the base.
(This already works; explicit tests and documentation will be added.)

A new type flag, `Py_TPFLAGS_ITEMS_AT_END`, will be added.
This flag can only be set on types with non-zero `tp_itemsize`.
It indicates that the variable-sized portion of an instance
is stored at the end of the instance's memory.

The default metatype (`PyType_Type`) will set this flag.

A new function, `PyObject_GetItemData`, will be added to access the
memory reserved for variable-sized content of types with the new flag.
In CPython it will be defined as:

```c
void *
PyObject_GetItemData(PyObject *obj) {
    if (!PyType_HasFeature(Py_TYPE(obj), Py_TPFLAGS_ITEMS_AT_END) {
        <fail with TypeError>
    }
    return (char *)obj + Py_TYPE(obj)->tp_basicsize;
}
```
This function will initially *not* be added to the Limited API.

Extending a class with positive `base->itemsize` using
negative `spec->basicsize` will fail unless `Py_TPFLAGS_ITEMS_AT_END`
is set, either on the base or in `spec->flags`.
(See `Extending variable-size objects`_ for a full explanation.)

Extending a class with positive `spec->itemsize` using negative
`spec->basicsize` will fail.

#### Relative member offsets

In types defined using negative `PyType_Spec.basicsize`, the offsets of
members defined via `Py_tp_members` must be relative to the
extra subclass data, rather than the full `PyObject` struct.
This will be indicated by a new flag in `PyMemberDef.flags`:
`Py_RELATIVE_OFFSET`.

In the initial implementation, the new flag will be redundant. It only serves
to make the offset's changed meaning clear, and to help avoid mistakes.
It will be an error to *not* use `Py_RELATIVE_OFFSET` with negative
`basicsize`, and it will be an error to use it in any other context
(i.e. direct or indirect calls to `PyDescr_NewMember`, `PyMember_GetOne`,
`PyMember_SetOne`).

CPython will adjust the offset and clear the `Py_RELATIVE_OFFSET` flag when
initializing a type.
This means that:

* the created type's `tp_members` will not match the input
  definition's `Py_tp_members` slot, and
* any code that reads `tp_members` will not need to handle the flag.

### List of new API

The following new functions/values are proposed.

These will be added to the Limited API/Stable ABI:

* `void * PyObject_GetTypeData(PyObject *obj, PyTypeObject *cls)`
* `Py_ssize_t PyType_GetTypeDataSize(PyTypeObject *cls)`
* `Py_TPFLAGS_ITEMS_AT_END` flag for `PyTypeObject.tp_flags`
* `Py_RELATIVE_OFFSET` flag for `PyMemberDef.flags`

These will be added to the public C API only:

* `void *PyObject_GetItemData(PyObject *obj)`

### Backwards Compatibility

No backwards compatibility concerns are known.

### Assumptions

The implementation assumes that an instance's memory
between `type->tp_base->tp_basicsize` and `type->tp_basicsize` offsets
“belongs” to `type` (except variable-length types).
This is not documented explicitly, but CPython up to version 3.11 relied on it
when adding `__dict__` to subclasses, so it should be safe.

### Security Implications

None known.

### How to Teach This

The initial implementation will include reference documentation
and a What's New entry, which should be enough for the target audience
-- authors of C extension libraries.

### Reference Implementation

A reference implementation is in the [extend-opaque branch ](https://github.com/python/cpython/compare/main...encukou:cpython:extend-opaque)
in the `encukou/cpython` GitHub repo.

### Possible Future Enhancements

#### Alignment & Performance

The proposed implementation may waste some space if instance structs
need smaller alignment than `alignof(max_align_t)`.
Also, dealing with alignment makes the calculation slower than it could be
if we could rely on `base->tp_basicsize` being properly aligned for the
subtype.

In other words, the proposed implementation focuses on safety and ease of use,
and trades space and time for it.
If it turns out that this is a problem, the implementation can be adjusted
without breaking the API:

- The offset to the type-specific buffer can be stored, so
  `PyObject_GetTypeData` effectively becomes
  `(char *)obj + cls->ht_typedataoffset`, possibly speeding things up at
  the cost of an extra pointer in the class.
- Then, a new `PyType_Slot` can specify the desired alignment, to
  reduce space requirements for instances.

#### Other layouts for variable-size types

A flag like `Py_TPFLAGS_ITEMS_AT_END` could be added to signal the
“tuple-like” layout described in `Extending variable-size objects`_,
and all mechanisms this PEP proposes could be adapted to support it.
Other layouts could be added as well.
However, it seems there'd be very little practical benefit,
so it's just a theoretical possibility.

### Rejected Ideas

Instead of a negative `spec->basicsize`, a new `PyType_Spec` flag could've
been added.  The effect would be the same to any existing code accessing these
internals without up to date knowledge of the change as the meaning of the
field value is changing in this situation.

*Source: https://peps.python.org/pep-0697/*

## Linked PEP 387 — Backwards Compatibility Policy
### Abstract

This PEP outlines Python's backwards compatibility policy.

### Rationale

As one of the most used programming languages today , the
Python core language and its standard library play a critical role in
millions of applications and libraries. This is fantastic. However, it
means the development team must be very careful not to break this
existing 3rd party code with new releases.

This PEP takes the perspective that "backwards incompatibility" means
preexisting code ceases to comparatively function after a change. It is
acknowledged that this is not a concrete definition, but the expectation
is people in general understand what is meant by
"backwards incompatibility", and if they are unsure they may ask the
Python development team and/or steering council for guidance.

### Backwards Compatibility Rules

This policy applies to all public APIs.  These include:

- Syntax and behavior of these constructs as defined by the reference
  manual.

- The C-API.

- Function, class, module, attribute, and method names and types.

- Given a set of arguments, the return value, side effects, and raised
  exceptions of a function.  This does not preclude changes from
  reasonable bug fixes.

- The position and expected types of arguments and returned values.

- Behavior of classes with regards to subclasses: the conditions under
  which overridden methods are called.

- Documented exceptions and the semantics which lead to their raising.

- Exceptions commonly raised in EAFP scenarios.

Others are explicitly not part of the public API.  They can change or
be removed at any time in any way.  These include:

- Function, class, module, attribute, method, and C-API names and
  types that are prefixed by "_" (except special names).

- Anything documented publicly as being private.
  Note that if something is not documented at all, it is *not*
  automatically considered private.

- Imported modules (unless explicitly documented as part of the public
  API; e.g. importing the `bacon` module in the `spam` does not
  automatically mean `spam.bacon` is part of the public API unless
  it is documented as such).

- Inheritance patterns of internal classes.

- Test suites.  (Anything in the `Lib/test` directory or test
  subdirectories of packages.)

- Backward compatibility rules do not apply to any module or API that is
  explicitly documented as **Provisional** per [PEP 411](https://peps.python.org/pep-0411/).

#### Basic policy for backwards compatibility

* In general, incompatibilities should have a large benefit to
  breakage ratio, and the incompatibility should be easy to resolve in
  affected code.  For example, adding an stdlib module with the same
  name as a third party package is generally not acceptable.  Adding
  a method or attribute that conflicts with 3rd party code through
  inheritance, however, is likely reasonable.

* Unless it is going through the deprecation process below, the
  behavior of an API *must* not change in an incompatible fashion
  between any two consecutive releases.  Python's yearly release
  process ([PEP 602](https://peps.python.org/pep-0602/)) means that the deprecation period must last at
  least two years.

* Similarly a feature cannot be removed without notice between any two
  consecutive releases.

* For changes that are unable to raise a deprecation warning, consult
  with the steering council.

* The steering council may grant exceptions to this policy. In
  particular, they may shorten the required deprecation period for a
  feature. Exceptions are only granted for extreme situations such as
  dangerously broken or insecure features or features no one could
  reasonably be depending on (e.g., support for completely obsolete
  platforms).

### Soft Deprecation

A soft deprecation can be used when using an API which should no longer
be used to write new code, but it remains safe to continue using it in
existing code. The API remains documented and tested, but will not be
developed further (no enhancement).

The main difference between a "soft" and a (regular) "hard" deprecation
is that the soft deprecation does not imply scheduling the removal of
the deprecated API.

Another difference is that a soft deprecation does not issue a warning:
it's only mentioned in the documentation, whereas usually a "hard"
deprecation issues a `DeprecationWarning` warning at runtime. The
documentation of a soft deprecation should explain why the API should be
avoided, and if possible propose a replacement.

If the decision is made to deprecate (in the regular sense) a feature
that is currently soft deprecated, the deprecation must follow the
`Backwards Compatibility Rules`_ (i.e., there is no exception because
the feature is already soft deprecated).

### Making Incompatible Changes

Making an incompatible change is a gradual process performed over
several releases:

1. Discuss the change.
   Depending on the degree of incompatibility, this could be on
   [Discourse ](https://discuss.python.org/),
   the [issue tracker ](https://github.com/python/cpython/issues/),
   or in an appropriate workgroup or SIG.
   If the discussion reaches consensus a PEP  or
   similar document may be written.
   Hopefully users of the affected API will pipe up to comment.

2. Add a warning to the current `main` branch.
   If behavior is changing, the API may gain a new
   function or method to perform the new behavior; old usage should
   raise the warning.  If an API is being removed, simply warn
   whenever it is entered.  `DeprecationWarning` is the usual
   warning category to use, but `PendingDeprecationWarning` may be
   used in special cases where the old and new versions of the API will
   coexist for many releases .  The warning message should
   include the release the incompatibility is expected to become the
   default and a link to an issue that users can post feedback to.
   When feasible, also change [typeshed ](https://github.com/python/typeshed)
   to add the `@deprecated` decorator (see [PEP 702](https://peps.python.org/pep-0702/)) to the deprecated API,
   so that users of static type checkers have another way to learn
   about the deprecation.

   For C API, a compiler warning generated by the `Py_DEPRECATED` macro
   is also acceptable.

3. Wait for the warning to appear in at least two minor Python
   versions of the same major version, or one minor version in an older
   major version (e.g., for a warning in Python 3.10.0, you either wait
   until at least Python 3.12 or Python 4.0 to make the change). It is
   preferred, though, to wait 5 years before removal (e.g., warn starting in
   Python 3.10, removal in 3.15; this happens to coincide with the current
   lifetime of a minor release of Python).

   - If the expected maintenance overhead and security risk of the
     deprecated behavior is small (e.g. an old function is reimplemented
     in terms of a new, more general one), it can stay indefinitely
     (or until the situation changes).

   - If the deprecated feature is replaced by a new one, it should
     generally be removed only after the last Python version
     *without* the new feature reaches end of support.

4. See if there's any feedback.  Users not involved in the original
   discussions may comment now after seeing the warning.  Perhaps
   reconsider.

5. The behavior change or feature removal may now be made default or
   permanent having reached the declared version. Remove the old
   version and warning.

6. If a warning cannot be provided to users, consult with the steering
   council.

### Changelog

* 2025-Jan-27: Updated to prefer a 5-year deprecation period before removal.
* 2023-Nov-14: Added `@deprecated` decorator per [PEP 702](https://peps.python.org/pep-0702/).
* 2023-Jul-03: Added the Soft Deprecation section, as discussed in
  https://discuss.python.org/t/27957.
* 2023-Jun-26: Multiple smaller updates and clarifications, discussed in
  https://discuss.python.org/t/22042.
* 2022-Apr-04: Added explicit notes to ask the Steering Council
  in several exceptional cases.
* 2021-Apr-16: Clarified how long a warning must be emitted before
  a change can be made.
* 2020-Jul-20: Initial accepted version.

*Source: https://peps.python.org/pep-0387/*