diff --git a/pep.rst b/pep.rst index 8a5e898..27355e1 100644 --- a/pep.rst +++ b/pep.rst @@ -29,8 +29,8 @@ perform complex metaprogramming, especially in libraries and frameworks. The type system typically cannot model metaprogramming. To bridge the gap between metaprogramming and the type -system, some libraries come with custom mypy plugins (though then -other typecheckers suffer). The case of dataclass-like transformations +system, some libraries come with custom mypy plugins. +The case of dataclass-like transformations was considered common enough that a special-case ``@dataclass_transform`` decorator was added specifically to cover that case (:pep:`681`). The problem with this approach is that many @@ -62,7 +62,9 @@ Prisma-style ORMs `Prisma <#prisma_>`_, a popular ORM for TypeScript, allows writing database queries in TypeScript like -(adapted from `this example <#prisma-example_>`_):: +(adapted from `this example <#prisma-example_>`_): + +.. code-block:: typescript const user = await prisma.user.findMany({ select: { @@ -72,7 +74,9 @@ database queries in TypeScript like }, }); -for which the inferred type of ``user`` will be something like:: +for which the inferred type of ``user`` will be something like: + +.. code-block:: typescript { email: string; @@ -88,7 +92,7 @@ for which the inferred type of ``user`` will be something like:: Here, the output type is an intersection of the existing information about the type of ``prisma.user`` (a TypeScript type reflected from the database ``user`` table) and the type of the argument to -the ``findMany`` method. It returns an array of objects containing +the ``findMany()`` method. It returns an array of objects containing the properties of ``user`` that were explicitly requested; where ``posts`` is a "relation" referencing another type. @@ -141,7 +145,8 @@ would have a dynamically computed return type ``list[]`` where:: content: str Even further, an IDE could offer code completion for -all arguments of the ``db.select()`` call, recursively. +all arguments of the ``db.select()`` call (matching the +actual database column names), recursively. (Example code for implementing this :ref:`below `.) @@ -152,7 +157,7 @@ Automatically deriving FastAPI CRUD models In the `FastAPI tutorial <#fastapi-tutorial_>`_, they show how to build CRUD endpoints for a simple ``Hero`` type. At its heart is a series of class definitions used both to define the database interface -and to perform validation/filtering of the data in the endpoint:: +and to perform validation and filtering of the data in the endpoint:: class HeroBase(SQLModel): name: str = Field(index=True) @@ -251,9 +256,8 @@ dataclasses-style method generation We would additionally like to be able to generate method signatures based on the attributes of an object. The most well-known example of -this is probably generating ``__init__`` methods for dataclasses, -which we present a simplified example of. (In our test suites, this is -merged with the FastAPI-style example above, but it need not be). +this is generating ``__init__`` methods for dataclasses, +which we present a simplified example of. This kind of pattern is widespread enough that :pep:`PEP 681 <681>` was created to represent a lowest-common denominator subset of what @@ -345,9 +349,8 @@ Extended Callables ------------------ We introduce a new extended callable proposal for expressing arbitrarily -complex callable types. The goal here is not really to produce a new -syntax to write in annotations (it seems less pleasant to write than -callback protocols are), but to provide a way of constructing the types +complex callable types. The goal here is not to have a new +syntax to write in annotations, but to provide a way of constructing the types that is amenable to creating and introspecting callable types using the other features of this PEP. @@ -538,16 +541,15 @@ members and function params have "associated" type members, which can be accessed by dot notation: ``m.name``, ``m.type``, etc. This operation is not lifted over union types. Using it on the wrong -sort of type will be an error. (At least, it must be that way at -runtime, and we probably want typechecking to match.) +sort of type will be an error. It must be that way at runtime, +and we want typechecking to match. Type operators -------------- -In some sections below we write things like ``Literal[int]`` to mean -"a literal that is of type ``int``". I don't think I'm really -proposing to add that as a notion, but we could. +Note that in some sections below we write things like ``Literal[int]`` to mean +"a literal that is of type ``int``". .. _boolean-ops: @@ -557,8 +559,8 @@ Boolean operators * ``IsAssignable[T, S]``: Returns a boolean literal type indicating whether ``T`` is assignable to ``S``. - (That is, it is a "consistent subtype". This is subtyping extended - to gradual types.) + That is, it is a "consistent subtype". This is subtyping extended + to gradual types. * ``IsEquivalent[T, S]``: Equivalent to ``IsAssignable[T, S] and IsAssignable[S, T]``. @@ -678,8 +680,6 @@ Object creation * ``NewTypedDict[*Ps: Member]`` - Creates a new ``TypedDict`` with items specified by the ``Member`` arguments. - .. TODO: Do we want a way to specify ``extra_items``? - Note that we are not currently proposing any way to create *nominal* classes or any way to make new *generic* types. @@ -767,9 +767,6 @@ Raise error Update class '''''''''''' -N.B: This is kind of sketchy but it is I think needed for defining -base classes and type decorators that do ``dataclass`` like things. - * ``UpdateClass[*Ps: Member]``: A special form that *updates* an existing nominal class with new members (possibly overriding old ones, or removing them by making them have type ``Never``).