Enum Op 

pub enum Op {
    Do,
    As,
    Block,
    Array,
    ArRep,
    Group,
    Tuple,
    MetaInner,
    MetaOuter,
    Try,
    Index,
    Call,
    Pub,
    Const,
    Static,
    Macro,
    Loop,
    If,
    While,
    Break,
    Return,
    Continue,
    Dot,
    RangeEx,
    RangeIn,
    Neg,
    Not,
    Identity,
    Refer,
    Deref,
    Mul,
    Div,
    Rem,
    Add,
    Sub,
    Shl,
    Shr,
    And,
    Xor,
    Or,
    Lt,
    Leq,
    Eq,
    Neq,
    Geq,
    Gt,
    LogAnd,
    LogXor,
    LogOr,
    Set,
    MulSet,
    DivSet,
    RemSet,
    AddSet,
    SubSet,
    ShlSet,
    ShrSet,
    AndSet,
    XorSet,
    OrSet,
}

Conlang’s AST is partitioned by data representation, so it considers any expression which is composed solely of keywords, symbols, and other expressions as operator expressions.

This includes:

• Do-sequence expressions: Expr ; Expr
• Type-cast expressions Expr as Expr
• Binding-modifier expressions: pub Expr, #[Expr] Expr
• Block and Group expressions: {Expr?}, (Expr?)
• Control flow: if, while, loop, match, break, return
• Function calls Expr (Expr,*)
• Traditional binary and unary operators (add, sub, neg, assign)

Variants

Do

Expr (; Expr)*

As

Expr as Expr

Block

{ Expr }

Array

[ Expr,* ]

ArRep

[ Expr ; Expr ]

Group

( Expr )

Tuple

Expr (, Expr)*

MetaInner

#![ Expr ]

MetaOuter

#[ Expr ]

Try

Expr '?'

Index

Expr [ Expr ]

Call

Expr ( Expr )

Pub

pub Expr

Const

const Expr

Static

static Expr

Macro

macro Expr

Loop

loop Expr

If

if Expr Expr (else Expr)?

While

while Expr Expr (else Expr)?

Break

break Expr

Return

return Expr

Continue

continue

Dot

Expr . Expr

RangeEx

Expr? ..Expr

RangeIn

Expr? ..=Expr

Neg

-Expr

Not

!Expr

Identity

!!Expr

Refer

&Expr

Deref

*Expr

Mul

Expr * Expr

Div

Expr / Expr

Rem

Expr % Expr

Add

Expr + Expr

Sub

Expr - Expr

Shl

Expr << Expr

Shr

Expr >> Expr

And

Expr & Expr

Xor

Expr ^ Expr

Or

Expr | Expr

Lt

Expr < Expr

Leq

Expr <= Expr

Eq

Expr == Expr

Neq

Expr != Expr

Geq

Expr >= Expr

Gt

Expr > Expr

LogAnd

Expr && Expr

LogXor

Expr ^^ Expr

LogOr

Expr || Expr

Set

Expr = Expr

MulSet

Expr *= Expr

DivSet

Expr /= Expr

RemSet

Expr %= Expr

AddSet

Expr += Expr

SubSet

Expr -= Expr

ShlSet

Expr <<= Expr

ShrSet

Expr >>= Expr

AndSet

Expr &= Expr

XorSet

Expr ^= Expr

OrSet

Expr |= Expr

Trait Implementations

impl Clone for Op

fn clone(&self) -> Op

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Op

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

Formats the value using the given formatter.

impl Display for Op

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

Formats the value using the given formatter.

impl Hash for Op

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<A: AstTypes> Match<A> for Op

fn recurse(_: &mut Subst<A>, pat: &Self, expr: &Self) -> bool

Implements recursive Subst-building for Self

fn apply(&mut self, _sub: &Subst<A>)

With self as the pattern, recursively applies the Subst

fn apply_rule(&mut self, pat: &Self, template: &Self) -> bool

where Self: Sized + Clone,

Applies a substitution rule from pat to template on self

fn match_with(&self, pat: &Self) -> Option<Subst<A>>

Matches self against the provided pattern

impl PartialEq for Op

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

impl Eq for Op

impl StructuralPartialEq for Op