Enum Type 

pub enum Type {
    Name(Path),
    Subscript {
        base: Path,
        args: Vec<Type>,
    },
    Optional(Box<Type>),
    Annotated {
        base: Box<Type>,
        markers: Vec<Expr>,
    },
}

A type annotation.

Python writes an annotation as an expression, so every form here is also an Expr as far as the grammar is concerned. They are separate types anyway: a rule that could put an arbitrary expression where an annotation belongs could put list[1] there, and nothing between the rule and the file would notice.

Variants

Name(Path)

A name or a dotted name: int, a.b.Point.

Subscript

base[arg, ...] — list[int], tuple[int, int].

Fields

base: Path

What is subscripted.

args: Vec<Type>

The arguments, in written order.

Optional(Box<Type>)

typing.Optional[T].

Its own form rather than a Type::Subscript: Optional takes exactly one argument, and the tree is where that is true.

Annotated

typing.Annotated[T, m, ...] — the type, and what it means.

The one place an Expr appears inside a Type, because that is what typing.Annotated is: a type paired with values a static checker passes through and a reader at run time can read back with typing.get_type_hints(..., include_extras=True).

Fields

base: Box<Type>

The type a checker sees.

markers: Vec<Expr>

The metadata, in written order; never empty.

Implementations

impl Type

pub fn name(text: &str) -> Self

A type spelled by one name.

pub fn subscript(base: Path, args: Vec<Self>) -> Self

base[args].

Trait Implementations

impl Clone for Type

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Type

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Type

impl PartialEq for Type

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Type