Enum espr::ast::Type

pub enum Type {
    Simple(SimpleType),
    Named(String),
    Set {
        base: Box<Type>,
        bound: Option<Bound>,
    },
    Bag {
        base: Box<Type>,
        bound: Option<Bound>,
    },
    List {
        base: Box<Type>,
        bound: Option<Bound>,
        unique: bool,
    },
    Array {
        base: Box<Type>,
        bound: Option<Bound>,
        unique: bool,
        optional: bool,
    },
    Enumeration {
        extensibility: Extensibility,
        items: Vec<String>,
    },
    Select {
        extensibility: Extensibility,
        types: Vec<String>,
    },
    Aggregate {
        base: Box<Type>,
        label: Option<String>,
    },
    GenericEntity(Option<String>),
    Generic(Option<String>),
}

Parameter type appears when using the type e.g. in attribute definition, function parameter, and so on.

Variants

Simple(SimpleType)

Tuple Fields of Simple

0: SimpleType

Named(String)

Tuple Fields of Named

0: String

Set

Fields of Set

base: Box<Type>bound: Option<Bound>

Bag

Fields of Bag

base: Box<Type>bound: Option<Bound>

List

Fields of List

base: Box<Type>bound: Option<Bound>unique: bool

Array

Fields of Array

base: Box<Type>bound: Option<Bound>unique: booloptional: bool

Enumeration

Fields of Enumeration

extensibility: Extensibilityitems: Vec<String>

Select

Fields of Select

extensibility: Extensibilitytypes: Vec<String>

Aggregate

Fields of Aggregate

base: Box<Type>label: Option<String>

GenericEntity(Option<String>)

Tuple Fields of GenericEntity

0: Option<String>

Generic(Option<String>)

Tuple Fields of Generic

0: Option<String>

Trait Implementations

impl Clone for Type

fn clone(&self) -> Type

Returns a copy 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 PartialEq<Type> for Type

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl StructuralPartialEq for Type