Enum mamba::core::construct::Core

pub enum Core {
    FromImport {
        from: Box<Core>,
        import: Box<Core>,
    },
    Import {
        imports: Vec<Core>,
    },
    ImportAs {
        imports: Vec<Core>,
        _as: Vec<Core>,
    },
    ClassDef {
        name: Box<Core>,
        parents: Vec<Core>,
        definitions: Vec<Core>,
    },
    FunctionCall {
        function: Box<Core>,
        args: Vec<Core>,
    },
    PropertyCall {
        object: Box<Core>,
        property: Box<Core>,
    },
    Id {
        lit: String,
    },
    Type {
        lit: String,
        generics: Vec<Core>,
    },
    IdType {
        lit: String,
        ty: Box<Core>,
    },
    Assign {
        left: Box<Core>,
        right: Box<Core>,
    },
    VarDef {
        private: bool,
        id: Box<Core>,
        right: Box<Core>,
    },
    FunDef {
        private: bool,
        id: Box<Core>,
        args: Vec<Core>,
        ret_ty: Option<Box<Core>>,
        body: Box<Core>,
    },
    FunArg {
        vararg: bool,
        id: Box<Core>,
        default: Box<Core>,
    },
    AnonFun {
        args: Vec<Core>,
        body: Box<Core>,
    },
    Block {
        statements: Vec<Core>,
    },
    Float {
        float: String,
    },
    Int {
        int: String,
    },
    ENum {
        num: String,
        exp: String,
    },
    Str {
        _str: String,
    },
    FStr {
        _str: String,
    },
    Bool {
        _bool: bool,
    },
    Tuple {
        elements: Vec<Core>,
    },
    Set {
        elements: Vec<Core>,
    },
    List {
        elements: Vec<Core>,
    },
    GeOp,
    Ge {
        left: Box<Core>,
        right: Box<Core>,
    },
    GeqOp,
    Geq {
        left: Box<Core>,
        right: Box<Core>,
    },
    LeOp,
    Le {
        left: Box<Core>,
        right: Box<Core>,
    },
    LeqOp,
    Leq {
        left: Box<Core>,
        right: Box<Core>,
    },
    Not {
        expr: Box<Core>,
    },
    Is {
        left: Box<Core>,
        right: Box<Core>,
    },
    IsN {
        left: Box<Core>,
        right: Box<Core>,
    },
    EqOp,
    Eq {
        left: Box<Core>,
        right: Box<Core>,
    },
    NeqOp,
    Neq {
        left: Box<Core>,
        right: Box<Core>,
    },
    IsA {
        left: Box<Core>,
        right: Box<Core>,
    },
    And {
        left: Box<Core>,
        right: Box<Core>,
    },
    Or {
        left: Box<Core>,
        right: Box<Core>,
    },
    AddOp,
    Add {
        left: Box<Core>,
        right: Box<Core>,
    },
    AddU {
        expr: Box<Core>,
    },
    SubOp,
    Sub {
        left: Box<Core>,
        right: Box<Core>,
    },
    SubU {
        expr: Box<Core>,
    },
    MulOp,
    Mul {
        left: Box<Core>,
        right: Box<Core>,
    },
    ModOp,
    Mod {
        left: Box<Core>,
        right: Box<Core>,
    },
    PowOp,
    Pow {
        left: Box<Core>,
        right: Box<Core>,
    },
    DivOp,
    Div {
        left: Box<Core>,
        right: Box<Core>,
    },
    FDivOp,
    FDiv {
        left: Box<Core>,
        right: Box<Core>,
    },
    Sqrt {
        expr: Box<Core>,
    },
    BAnd {
        left: Box<Core>,
        right: Box<Core>,
    },
    BOr {
        left: Box<Core>,
        right: Box<Core>,
    },
    BXOr {
        left: Box<Core>,
        right: Box<Core>,
    },
    BOneCmpl {
        expr: Box<Core>,
    },
    BLShift {
        left: Box<Core>,
        right: Box<Core>,
    },
    BRShift {
        left: Box<Core>,
        right: Box<Core>,
    },
    For {
        expr: Box<Core>,
        col: Box<Core>,
        body: Box<Core>,
    },
    Range {
        from: Box<Core>,
        to: Box<Core>,
        step: Box<Core>,
    },
    If {
        cond: Box<Core>,
        then: Box<Core>,
    },
    IfElse {
        cond: Box<Core>,
        then: Box<Core>,
        _else: Box<Core>,
    },
    Ternary {
        cond: Box<Core>,
        then: Box<Core>,
        _else: Box<Core>,
    },
    Dictionary {
        expr: Box<Core>,
        cases: Vec<Core>,
    },
    DefaultDictionary {
        expr: Box<Core>,
        cases: Vec<Core>,
        default: Box<Core>,
    },
    KeyValue {
        key: Box<Core>,
        value: Box<Core>,
    },
    While {
        cond: Box<Core>,
        body: Box<Core>,
    },
    In {
        left: Box<Core>,
        right: Box<Core>,
    },
    Break,
    Continue,
    Return {
        expr: Box<Core>,
    },
    Print {
        expr: Box<Core>,
    },
    UnderScore,
    Pass,
    None,
    Empty,
    Comment {
        comment: String,
    },
    TryExcept {
        setup: Option<Box<Core>>,
        _try: Box<Core>,
        except: Vec<Core>,
    },
    Except {
        id: Box<Core>,
        class: Box<Core>,
        body: Box<Core>,
    },
    ExceptNoClass {
        id: Box<Core>,
        body: Box<Core>,
    },
    Raise {
        error: Box<Core>,
    },
    With {
        resource: Box<Core>,
        expr: Box<Core>,
    },
    WithAs {
        resource: Box<Core>,
        _as: Box<Core>,
        expr: Box<Core>,
    },
}

Variants

FromImport

Fields of FromImport

from: Box<Core>import: Box<Core>

Import

Fields of Import

imports: Vec<Core>

ImportAs

Fields of ImportAs

imports: Vec<Core>_as: Vec<Core>

ClassDef

Fields of ClassDef

name: Box<Core>parents: Vec<Core>definitions: Vec<Core>

FunctionCall

Fields of FunctionCall

function: Box<Core>args: Vec<Core>

PropertyCall

Fields of PropertyCall

object: Box<Core>property: Box<Core>

Id

Fields of Id

lit: String

Type

Fields of Type

lit: Stringgenerics: Vec<Core>

IdType

Fields of IdType

lit: Stringty: Box<Core>

Assign

Fields of Assign

left: Box<Core>right: Box<Core>

VarDef

Fields of VarDef

private: boolid: Box<Core>right: Box<Core>

FunDef

Fields of FunDef

private: boolid: Box<Core>args: Vec<Core>ret_ty: Option<Box<Core>>body: Box<Core>

FunArg

Fields of FunArg

vararg: boolid: Box<Core>default: Box<Core>

AnonFun

Fields of AnonFun

args: Vec<Core>body: Box<Core>

Block

Fields of Block

statements: Vec<Core>

Float

Fields of Float

float: String

Int

Fields of Int

int: String

ENum

Fields of ENum

num: Stringexp: String

Str

Fields of Str

_str: String

FStr

Fields of FStr

_str: String

Bool

Fields of Bool

_bool: bool

Tuple

Fields of Tuple

elements: Vec<Core>

Set

Fields of Set

elements: Vec<Core>

List

Fields of List

elements: Vec<Core>

GeOp

Ge

Fields of Ge

left: Box<Core>right: Box<Core>

GeqOp

Geq

Fields of Geq

left: Box<Core>right: Box<Core>

LeOp

Le

Fields of Le

left: Box<Core>right: Box<Core>

LeqOp

Leq

Fields of Leq

left: Box<Core>right: Box<Core>

Not

Fields of Not

expr: Box<Core>

Is

Fields of Is

left: Box<Core>right: Box<Core>

IsN

Fields of IsN

left: Box<Core>right: Box<Core>

EqOp

Eq

Fields of Eq

left: Box<Core>right: Box<Core>

NeqOp

Neq

Fields of Neq

left: Box<Core>right: Box<Core>

IsA

Fields of IsA

left: Box<Core>right: Box<Core>

And

Fields of And

left: Box<Core>right: Box<Core>

Or

Fields of Or

left: Box<Core>right: Box<Core>

AddOp

Add

Fields of Add

left: Box<Core>right: Box<Core>

AddU

Fields of AddU

expr: Box<Core>

SubOp

Sub

Fields of Sub

left: Box<Core>right: Box<Core>

SubU

Fields of SubU

expr: Box<Core>

MulOp

Mul

Fields of Mul

left: Box<Core>right: Box<Core>

ModOp

Mod

Fields of Mod

left: Box<Core>right: Box<Core>

PowOp

Pow

Fields of Pow

left: Box<Core>right: Box<Core>

DivOp

Div

Fields of Div

left: Box<Core>right: Box<Core>

FDivOp

FDiv

Fields of FDiv

left: Box<Core>right: Box<Core>

Sqrt

Fields of Sqrt

expr: Box<Core>

BAnd

Fields of BAnd

left: Box<Core>right: Box<Core>

BOr

Fields of BOr

left: Box<Core>right: Box<Core>

BXOr

Fields of BXOr

left: Box<Core>right: Box<Core>

BOneCmpl

Fields of BOneCmpl

expr: Box<Core>

BLShift

Fields of BLShift

left: Box<Core>right: Box<Core>

BRShift

Fields of BRShift

left: Box<Core>right: Box<Core>

For

Fields of For

expr: Box<Core>col: Box<Core>body: Box<Core>

Range

Fields of Range

from: Box<Core>to: Box<Core>step: Box<Core>

If

Fields of If

cond: Box<Core>then: Box<Core>

IfElse

Fields of IfElse

cond: Box<Core>then: Box<Core>_else: Box<Core>

Ternary

Fields of Ternary

cond: Box<Core>then: Box<Core>_else: Box<Core>

Dictionary

Fields of Dictionary

expr: Box<Core>cases: Vec<Core>

DefaultDictionary

Fields of DefaultDictionary

expr: Box<Core>cases: Vec<Core>default: Box<Core>

KeyValue

Fields of KeyValue

key: Box<Core>value: Box<Core>

While

Fields of While

cond: Box<Core>body: Box<Core>

In

Fields of In

left: Box<Core>right: Box<Core>

Break

Continue

Return

Fields of Return

expr: Box<Core>

Print

Fields of Print

expr: Box<Core>

UnderScore

Pass

None

Empty

Comment

Fields of Comment

comment: String

TryExcept

Fields of TryExcept

setup: Option<Box<Core>>_try: Box<Core>except: Vec<Core>

Except

Fields of Except

id: Box<Core>class: Box<Core>body: Box<Core>

ExceptNoClass

Fields of ExceptNoClass

id: Box<Core>body: Box<Core>

Raise

Fields of Raise

error: Box<Core>

With

Fields of With

resource: Box<Core>expr: Box<Core>

WithAs

Fields of WithAs

resource: Box<Core>_as: Box<Core>expr: Box<Core>

Trait Implementations

impl Clone for Core

fn clone(&self) -> Core

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Eq for Core

impl PartialEq<Core> for Core

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

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

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

This method tests for !=.

impl Debug for Core

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

Formats the value using the given formatter.

impl Hash for Core

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, 

Feeds a slice of this type into the given [Hasher].

impl StructuralPartialEq for Core

impl StructuralEq for Core