Enum TypeStructure 

enum TypeStructure {
    Simple(String),
    Generic {
        base: String,
        args: Vec<TypeStructure>,
    },
    Union(Vec<TypeStructure>),
}

Parsed structure of a type expression

Variants

Simple(String)

Simple type: “int”, “ClassA”

Generic

Generic type: “Optional[A]”, “Dict[str, int]”

Fields

base: String

args: Vec<TypeStructure>

Union(Vec<TypeStructure>)

Union type: “A | B | C”

Implementations

impl TypeStructure

fn parse(expr: &str) -> Self

Parse a type expression string into a TypeStructure

fn parse_tokens(tokens: &[Token]) -> Self

Parse a slice of tokens into a TypeStructure

fn try_parse_union(tokens: &[Token]) -> Option<Vec<Vec<Token>>>

Try to parse tokens as a union (A | B | C) Returns Some(vec![tokens_for_A, tokens_for_B, tokens_for_C]) if successful

fn try_parse_generic(tokens: &[Token]) -> Option<(Vec<Token>, Vec<Vec<Token>>)>

Try to parse tokens as a generic type Returns Some((base_tokens, vec![arg1_tokens, arg2_tokens, …])) if successful

fn split_by_comma_at_depth_zero(tokens: &[Token]) -> Vec<Vec<Token>>

Split tokens by commas at depth 0

fn tokens_to_string(tokens: &[Token]) -> String

Convert tokens to a string representation

Trait Implementations

impl Clone for TypeStructure

fn clone(&self) -> TypeStructure

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TypeStructure

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

Formats the value using the given formatter.

impl PartialEq for TypeStructure

fn eq(&self, other: &TypeStructure) -> 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 StructuralPartialEq for TypeStructure