Enum TypeAst 

pub enum TypeAst {
    Prim {
        name: String,
        loc: Option<Loc>,
    },
    Lit {
        v: Value,
        loc: Option<Loc>,
    },
    Range {
        lo: Value,
        hi: Value,
        excl: bool,
        loc: Option<Loc>,
    },
    Pattern {
        re: String,
        loc: Option<Loc>,
    },
    Record {
        members: Vec<MemberAst>,
        open: bool,
        loc: Option<Loc>,
    },
    Map {
        key: Box<TypeAst>,
        val: Box<TypeAst>,
        loc: Option<Loc>,
    },
    Array {
        elem: Box<TypeAst>,
        lo: Option<Value>,
        hi: Option<Value>,
        excl: bool,
        loc: Option<Loc>,
    },
    Union {
        arms: Vec<TypeAst>,
        loc: Option<Loc>,
    },
    Isect {
        arms: Vec<TypeAst>,
        loc: Option<Loc>,
    },
    Func {
        params: Vec<TypeAst>,
        ret: Box<TypeAst>,
        loc: Option<Loc>,
    },
    Named {
        name: String,
        args: Vec<TypeAst>,
        preds: Option<Vec<Rc<Expr>>>,
        ext: Option<Box<TypeAst>>,
        loc: Option<Loc>,
    },
}

a type expression (§3; chapter 11)

Variants

Prim

a primitive type by name

Fields

name: String

the name

loc: Option<Loc>

the source range

Lit

a literal type

Fields

v: Value

the literal

loc: Option<Loc>

the source range

Range

a numeric range

Fields

lo: Value

the lower bound

hi: Value

the upper bound

excl: bool

whether the upper bound is excluded

loc: Option<Loc>

the source range

Pattern

a string pattern

Fields

re: String

the pattern’s text

loc: Option<Loc>

the source range

Record

a record type

Fields

members: Vec<MemberAst>

its members

open: bool

whether it is open (...)

loc: Option<Loc>

the source range

Map

a map type

Fields

key: Box<TypeAst>

the key type

val: Box<TypeAst>

the value type

loc: Option<Loc>

the source range

Array

an array type

Fields

elem: Box<TypeAst>

the element type

lo: Option<Value>

the lower size bound

hi: Option<Value>

the upper size bound

excl: bool

whether the upper bound is excluded

loc: Option<Loc>

the source range

Union

a union

Fields

arms: Vec<TypeAst>

its arms

loc: Option<Loc>

the source range

Isect

an intersection

Fields

arms: Vec<TypeAst>

its arms

loc: Option<Loc>

the source range

Func

a function type

Fields

params: Vec<TypeAst>

the parameter types

ret: Box<TypeAst>

the return type

loc: Option<Loc>

the source range

Named

a named type, with its arguments, predicates, and extension

Fields

name: String

the name

args: Vec<TypeAst>

its type arguments

preds: Option<Vec<Rc<Expr>>>

its predicates, when refined

ext: Option<Box<TypeAst>>

its extension ({ … })

loc: Option<Loc>

the source range

Implementations

impl TypeAst

pub fn loc(&self) -> Option<Loc>

The source range.

pub fn set_loc(&mut self, l: Loc)

Record the source range.

Trait Implementations

impl Clone for TypeAst

fn clone(&self) -> TypeAst

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TypeAst

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

Formats the value using the given formatter.