Enum TypeInfo

pub enum TypeInfo {
    Any,
    None,
    NoReturn,
    Callable(Option<Vec<TypeInfo>>, Box<TypeInfo>),
    Tuple(Option<Vec<TypeInfo>>),
    UnsizedTypedTuple(Box<TypeInfo>),
    Class {
        module: ModuleName,
        name: Cow<'static, str>,
        type_vars: Vec<TypeInfo>,
    },
}

Designation of a Python type.

This enum is used to handle advanced types, such as types with generics. Its Display implementation can be used to convert to the type hint notation (e.g. List[int]).

Variants

Any

The type typing.Any, which represents any possible value (unknown type).

None

The type typing.None.

NoReturn

The type typing.NoReturn, which represents functions that never return (they can still panic / throw, similar to never in Rust).

Callable(Option<Vec<TypeInfo>>, Box<TypeInfo>)

The type typing.Callable.

The first argument represents the parameters of the callable:

• Some of a vector of types to represent the signature,
• None if the signature is unknown (allows any number of arguments with type Any).

The second argument represents the return type.

Tuple(Option<Vec<TypeInfo>>)

The type typing.tuple.

The argument represents the contents of the tuple:

• Some of a vector of types to represent the accepted types,
• Some of an empty vector for the empty tuple,
• None if the number and type of accepted values is unknown.

If the number of accepted values is unknown, but their type is, use Self::UnsizedTypedTuple.

UnsizedTypedTuple(Box<TypeInfo>)

The type typing.Tuple.

Use this variant to represent a tuple of unknown size but of known types.

If the type is unknown, or if the number of elements is known, use Self::Tuple.

Class

A Python class.

Fields

module: ModuleName

The module this class comes from.

name: Cow<'static, str>

The name of this class, as it appears in a type hint.

type_vars: Vec<TypeInfo>

The generics accepted by this class (empty vector if this class is not generic).

Implementations

impl TypeInfo

pub fn module_name(&self) -> Option<&str>

Returns the module in which a type is declared.

Returns None if the type is declared in the current module.

pub fn name(&self) -> Cow<'_, str>

Returns the name of a type.

The name of a type is the part of the hint that is not generic (e.g. List instead of List[int]).

impl TypeInfo

pub fn optional_of(t: TypeInfo) -> TypeInfo

The Python Optional type.

pub fn union_of(types: &[TypeInfo]) -> TypeInfo

The Python Union type.

pub fn list_of(t: TypeInfo) -> TypeInfo

The Python List type.

pub fn sequence_of(t: TypeInfo) -> TypeInfo

The Python Sequence type.

pub fn set_of(t: TypeInfo) -> TypeInfo

The Python Set type.

pub fn frozen_set_of(t: TypeInfo) -> TypeInfo

The Python FrozenSet type.

pub fn iterable_of(t: TypeInfo) -> TypeInfo

The Python Iterable type.

pub fn iterator_of(t: TypeInfo) -> TypeInfo

The Python Iterator type.

pub fn dict_of(k: TypeInfo, v: TypeInfo) -> TypeInfo

The Python Dict type.

pub fn mapping_of(k: TypeInfo, v: TypeInfo) -> TypeInfo

The Python Mapping type.

pub fn builtin(name: &'static str) -> TypeInfo

Convenience factory for non-generic builtins (e.g. int).

Trait Implementations

impl Clone for TypeInfo

fn clone(&self) -> TypeInfo

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TypeInfo

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

Formats the value using the given formatter.

impl Display for TypeInfo

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

Formats the value using the given formatter.

impl PartialEq for TypeInfo

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for TypeInfo

impl StructuralPartialEq for TypeInfo