Enum erg_parser::ast::Expr

pub enum Expr {
    Literal(Literal),
    Accessor(Accessor),
    List(List),
    Tuple(Tuple),
    Dict(Dict),
    Set(Set),
    Record(Record),
    BinOp(BinOp),
    UnaryOp(UnaryOp),
    Call(Call),
    DataPack(DataPack),
    Lambda(Lambda),
    TypeAscription(TypeAscription),
    Def(Def),
    Methods(Methods),
    ClassDef(ClassDef),
    PatchDef(PatchDef),
    ReDef(ReDef),
    Compound(Compound),
    InlineModule(InlineModule),
    Dummy(Dummy),
}

Expression(式)

Variants

Literal(Literal)

Accessor(Accessor)

List(List)

Tuple(Tuple)

Dict(Dict)

Set(Set)

Record(Record)

BinOp(BinOp)

UnaryOp(UnaryOp)

Call(Call)

DataPack(DataPack)

Lambda(Lambda)

TypeAscription(TypeAscription)

Def(Def)

Methods(Methods)

ClassDef(ClassDef)

PatchDef(PatchDef)

ReDef(ReDef)

Compound(Compound)

InlineModule(InlineModule)

Dummy(Dummy)

for mapping to Python AST

Implementations

impl Expr

pub fn is_match_call(&self) -> bool

pub fn is_const_acc(&self) -> bool

pub const fn is_definition(&self) -> bool

pub const fn name(&self) -> &'static str

pub fn need_to_be_closed(&self) -> bool

pub fn get_name(&self) -> Option<&Str>

pub fn local(name: &str, lineno: u32, col_begin: u32, col_end: u32) -> Self

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

pub fn static_local(name: &'static str) -> Self

pub fn attr(self, ident: Identifier) -> Accessor

pub fn attr_expr(self, ident: Identifier) -> Self

pub fn subscr(self, index: Expr, r_sqbr: Token) -> Accessor

pub fn subscr_expr(self, index: Expr, r_sqbr: Token) -> Self

pub fn tuple_attr(self, index: Literal) -> Accessor

pub fn tuple_attr_expr(self, index: Literal) -> Self

pub fn type_app(self, type_args: TypeAppArgs) -> Accessor

pub fn call(self, args: Args) -> Call

pub fn call_expr(self, args: Args) -> Self

pub fn call1(self, expr: Expr) -> Self

pub fn call2(self, expr1: Expr, expr2: Expr) -> Self

pub fn type_asc(self, t_spec: TypeSpecWithOp) -> TypeAscription

pub fn type_asc_expr(self, t_spec: TypeSpecWithOp) -> Self

pub fn bin_op(self, op: Token, rhs: Expr) -> BinOp

pub fn unary_op(self, op: Token) -> UnaryOp

pub fn complexity(&self) -> usize

Return the complexity of the expression in terms of type inference. For function calls, type inference is performed sequentially, starting with the least complex argument.

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl Display for Expr

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

Formats the value using the given formatter.

impl From<Accessor> for Expr

fn from(v: Accessor) -> Self

Converts to this type from the input type.

impl From<BinOp> for Expr

fn from(v: BinOp) -> Self

Converts to this type from the input type.

impl From<Call> for Expr

fn from(v: Call) -> Self

Converts to this type from the input type.

impl From<ClassDef> for Expr

fn from(v: ClassDef) -> Self

Converts to this type from the input type.

impl From<Compound> for Expr

fn from(v: Compound) -> Self

Converts to this type from the input type.

impl From<DataPack> for Expr

fn from(v: DataPack) -> Self

Converts to this type from the input type.

impl From<Def> for Expr

fn from(v: Def) -> Self

Converts to this type from the input type.

impl From<Dict> for Expr

fn from(v: Dict) -> Self

Converts to this type from the input type.

impl From<Dummy> for Expr

fn from(v: Dummy) -> Self

Converts to this type from the input type.

impl From<Identifier> for Expr

fn from(ident: Identifier) -> Self

Converts to this type from the input type.

impl From<InlineModule> for Expr

fn from(v: InlineModule) -> Self

Converts to this type from the input type.

impl From<Lambda> for Expr

fn from(v: Lambda) -> Self

Converts to this type from the input type.

impl From<List> for Expr

fn from(v: List) -> Self

Converts to this type from the input type.

impl From<Literal> for Expr

fn from(v: Literal) -> Self

Converts to this type from the input type.

impl From<Methods> for Expr

fn from(v: Methods) -> Self

Converts to this type from the input type.

impl From<NormalRecord> for Expr

fn from(record: NormalRecord) -> Self

Converts to this type from the input type.

impl From<NormalSet> for Expr

fn from(set: NormalSet) -> Self

Converts to this type from the input type.

impl From<NormalTuple> for Expr

fn from(tuple: NormalTuple) -> Self

Converts to this type from the input type.

impl From<PatchDef> for Expr

fn from(v: PatchDef) -> Self

Converts to this type from the input type.

impl From<ReDef> for Expr

fn from(v: ReDef) -> Self

Converts to this type from the input type.

impl From<Record> for Expr

fn from(v: Record) -> Self

Converts to this type from the input type.

impl From<Set> for Expr

fn from(v: Set) -> Self

Converts to this type from the input type.

impl From<Tuple> for Expr

fn from(v: Tuple) -> Self

Converts to this type from the input type.

impl From<TypeAscription> for Expr

fn from(v: TypeAscription) -> Self

Converts to this type from the input type.

impl From<UnaryOp> for Expr

fn from(v: UnaryOp) -> Self

Converts to this type from the input type.

impl FromIterator<Expr> for Block

fn from_iter<I: IntoIterator<Item = Expr>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<Expr> for Module

fn from_iter<T: IntoIterator<Item = Expr>>(iter: T) -> Self

Creates a value from an iterator.

impl Hash for Expr

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Locational for Expr

fn loc(&self) -> Location

NOTE: loc cannot be treated as a light method when self is a large grammatical element. If possible, delay the computation by passing &impl Locational or other means.

fn ln_begin(&self) -> Option<u32>

1-origin

fn ln_end(&self) -> Option<u32>

fn col_begin(&self) -> Option<u32>

0-origin

fn col_end(&self) -> Option<u32>

impl NestedDisplay for Expr

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

impl PartialEq for Expr

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

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

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

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

impl Stream<Expr> for Block

fn payload(self) -> Vec<Expr>

fn ref_payload(&self) -> &Vec<Expr>

fn ref_mut_payload(&mut self) -> &mut Vec<Expr>

fn clear(&mut self)

fn len(&self) -> usize

fn size(&self) -> usize

fn is_empty(&self) -> bool

fn insert(&mut self, idx: usize, elem: T)

fn remove(&mut self, idx: usize) -> T

fn push(&mut self, elem: T)

fn append<S>(&mut self, s: &mut S)

where S: Stream<T>,

fn pop(&mut self) -> Option<T>

fn lpop(&mut self) -> Option<T>

fn get(&self, idx: usize) -> Option<&T>

fn get_mut(&mut self, idx: usize) -> Option<&mut T>

fn first(&self) -> Option<&T>

fn first_mut(&mut self) -> Option<&mut T>

fn last(&self) -> Option<&T>

fn last_mut(&mut self) -> Option<&mut T>

fn iter(&self) -> Iter<'_, T>

fn iter_mut(&mut self) -> IterMut<'_, T>

fn take_all(&mut self) -> Vec<T>

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = T>,

fn split_off(&mut self, at: usize) -> Vec<T>

fn retain(&mut self, f: impl FnMut(&T) -> bool)

Remove all elements that don’t satisfy the predicate.

fn concat(self, other: Self) -> Self

impl Stream<Expr> for Compound

fn payload(self) -> Vec<Expr>

fn ref_payload(&self) -> &Vec<Expr>

fn ref_mut_payload(&mut self) -> &mut Vec<Expr>

fn clear(&mut self)

fn len(&self) -> usize

fn size(&self) -> usize

fn is_empty(&self) -> bool

fn insert(&mut self, idx: usize, elem: T)

fn remove(&mut self, idx: usize) -> T

fn push(&mut self, elem: T)

fn append<S>(&mut self, s: &mut S)

where S: Stream<T>,

fn pop(&mut self) -> Option<T>

fn lpop(&mut self) -> Option<T>

fn get(&self, idx: usize) -> Option<&T>

fn get_mut(&mut self, idx: usize) -> Option<&mut T>

fn first(&self) -> Option<&T>

fn first_mut(&mut self) -> Option<&mut T>

fn last(&self) -> Option<&T>

fn last_mut(&mut self) -> Option<&mut T>

fn iter(&self) -> Iter<'_, T>

fn iter_mut(&mut self) -> IterMut<'_, T>

fn take_all(&mut self) -> Vec<T>

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = T>,

fn split_off(&mut self, at: usize) -> Vec<T>

fn retain(&mut self, f: impl FnMut(&T) -> bool)

Remove all elements that don’t satisfy the predicate.

fn concat(self, other: Self) -> Self

impl Stream<Expr> for Dummy

fn ref_payload(&self) -> &Vec<Expr>

fn ref_mut_payload(&mut self) -> &mut Vec<Expr>

fn payload(self) -> Vec<Expr>

fn clear(&mut self)

fn len(&self) -> usize

fn size(&self) -> usize

fn is_empty(&self) -> bool

fn insert(&mut self, idx: usize, elem: T)

fn remove(&mut self, idx: usize) -> T

fn push(&mut self, elem: T)

fn append<S>(&mut self, s: &mut S)

where S: Stream<T>,

fn pop(&mut self) -> Option<T>

fn lpop(&mut self) -> Option<T>

fn get(&self, idx: usize) -> Option<&T>

fn get_mut(&mut self, idx: usize) -> Option<&mut T>

fn first(&self) -> Option<&T>

fn first_mut(&mut self) -> Option<&mut T>

fn last(&self) -> Option<&T>

fn last_mut(&mut self) -> Option<&mut T>

fn iter(&self) -> Iter<'_, T>

fn iter_mut(&mut self) -> IterMut<'_, T>

fn take_all(&mut self) -> Vec<T>

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = T>,

fn split_off(&mut self, at: usize) -> Vec<T>

fn retain(&mut self, f: impl FnMut(&T) -> bool)

Remove all elements that don’t satisfy the predicate.

fn concat(self, other: Self) -> Self

impl Stream<Expr> for Module

fn payload(self) -> Vec<Expr>

fn ref_payload(&self) -> &Vec<Expr>

fn ref_mut_payload(&mut self) -> &mut Vec<Expr>

fn clear(&mut self)

fn len(&self) -> usize

fn size(&self) -> usize

fn is_empty(&self) -> bool

fn insert(&mut self, idx: usize, elem: T)

fn remove(&mut self, idx: usize) -> T

fn push(&mut self, elem: T)

fn append<S>(&mut self, s: &mut S)

where S: Stream<T>,

fn pop(&mut self) -> Option<T>

fn lpop(&mut self) -> Option<T>

fn get(&self, idx: usize) -> Option<&T>

fn get_mut(&mut self, idx: usize) -> Option<&mut T>

fn first(&self) -> Option<&T>

fn first_mut(&mut self) -> Option<&mut T>

fn last(&self) -> Option<&T>

fn last_mut(&mut self) -> Option<&mut T>

fn iter(&self) -> Iter<'_, T>

fn iter_mut(&mut self) -> IterMut<'_, T>

fn take_all(&mut self) -> Vec<T>

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = T>,

fn split_off(&mut self, at: usize) -> Vec<T>

fn retain(&mut self, f: impl FnMut(&T) -> bool)

Remove all elements that don’t satisfy the predicate.

fn concat(self, other: Self) -> Self

impl TryFrom<&ParamListPattern> for Expr

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: &ParamListPattern) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&ParamPattern> for Expr

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: &ParamPattern) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&ParamTuplePattern> for Expr

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: &ParamTuplePattern) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Expr> for Call

type Error = ()

The type returned in the event of a conversion error.

fn try_from(expr: Expr) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for Expr

impl StructuralPartialEq for Expr