Enum lovm2::prelude::Expr

pub enum Expr {
    Access(Access),
    Call(Call),
    Conv(Conv),
    DynamicValue(Initialize),
    Iter(Iter),
    Operation1(Operator1, Box<Expr, Global>),
    Operation2(Operator2, Box<Expr, Global>, Box<Expr, Global>),
    Slice(Slice),
    Value {
        val: Value,
        boxed: bool,
    },
    Variable(Variable),
}

Expressions and operations that produce Values

Variants

Access(Access)

Call(Call)

Conv(Conv)

DynamicValue(Initialize)

Iter(Iter)

Operation1(Operator1, Box<Expr, Global>)

Operation2(Operator2, Box<Expr, Global>, Box<Expr, Global>)

Slice(Slice)

Value

Fields of Value

val: Valueboxed: bool

Variable(Variable)

Implementations

impl Expr

pub fn from_opn(op: Operator2, args: Vec<Expr, Global>) -> Expr

pub fn from_op(op: &Operator2, left: Expr, right: Expr) -> Expr

impl Expr

pub fn boxed(self) -> Expr

pub fn is_const(&self) -> bool

pub fn eval(&self, ctx: &Context) -> Result<Value, Lovm2Error>

pub fn dict() -> Expr

pub fn list() -> Expr

pub fn pow<T, U>(left: T, right: U) -> Expr where
    T: Into<Expr>,
    U: Into<Expr>, 

impl Expr

pub fn add<T, U>(left: T, right: U) -> Expr where
    T: Into<Expr>,
    U: Into<Expr>, 

pub fn sub<T, U>(left: T, right: U) -> Expr where
    T: Into<Expr>,
    U: Into<Expr>, 

pub fn mul<T, U>(left: T, right: U) -> Expr where
    T: Into<Expr>,
    U: Into<Expr>, 

pub fn div<T, U>(left: T, right: U) -> Expr where
    T: Into<Expr>,
    U: Into<Expr>, 

pub fn rem<T, U>(left: T, right: U) -> Expr where
    T: Into<Expr>,
    U: Into<Expr>, 

pub fn shl<T, U>(left: T, right: U) -> Expr where
    T: Into<Expr>,
    U: Into<Expr>, 

pub fn shr<T, U>(left: T, right: U) -> Expr where
    T: Into<Expr>,
    U: Into<Expr>, 

pub fn and<T, U>(left: T, right: U) -> Expr where
    T: Into<Expr>,
    U: Into<Expr>, 

pub fn or<T, U>(left: T, right: U) -> Expr where
    T: Into<Expr>,
    U: Into<Expr>, 

pub fn xor<T, U>(left: T, right: U) -> Expr where
    T: Into<Expr>,
    U: Into<Expr>, 

pub fn eq<T, U>(left: T, right: U) -> Expr where
    T: Into<Expr>,
    U: Into<Expr>, 

pub fn ne<T, U>(left: T, right: U) -> Expr where
    T: Into<Expr>,
    U: Into<Expr>, 

pub fn ge<T, U>(left: T, right: U) -> Expr where
    T: Into<Expr>,
    U: Into<Expr>, 

pub fn gt<T, U>(left: T, right: U) -> Expr where
    T: Into<Expr>,
    U: Into<Expr>, 

pub fn le<T, U>(left: T, right: U) -> Expr where
    T: Into<Expr>,
    U: Into<Expr>, 

pub fn lt<T, U>(left: T, right: U) -> Expr where
    T: Into<Expr>,
    U: Into<Expr>, 

pub fn not<T>(expr: T) -> Expr where
    T: Into<Expr>, 

Trait Implementations

impl Clone for Expr

pub fn clone(&self) -> Expr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl<'_> From<&'_ Variable> for Expr

pub fn from(v: &Variable) -> Expr

Performs the conversion.

impl From<Access> for Expr

pub fn from(access: Access) -> Expr

Performs the conversion.

impl From<Call> for Expr

pub fn from(call: Call) -> Expr

Performs the conversion.

impl From<Conv> for Expr

pub fn from(conv: Conv) -> Expr

Performs the conversion.

impl From<Expr> for Access

pub fn from(expr: Expr) -> Access

Performs the conversion.

impl From<Initialize> for Expr

pub fn from(init: Initialize) -> Expr

Performs the conversion.

impl From<Iter> for Expr

pub fn from(it: Iter) -> Expr

Performs the conversion.

impl From<Slice> for Expr

pub fn from(slice: Slice) -> Expr

Performs the conversion.

impl<T> From<T> for Expr where
    T: Into<Value>, 

pub fn from(val: T) -> Expr

Performs the conversion.

impl From<Variable> for Expr

pub fn from(v: Variable) -> Expr

Performs the conversion.

impl HirLowering for Expr

pub fn lower<'hir, 'lir>(&'hir self, runtime: &mut HirLoweringRuntime<'lir>) where
    'hir: 'lir,