Enum Expression

pub enum Expression {
    Literal(Literal),
    Var(String),
    Binary {
        op: BinaryOp,
        left: Box<Expression>,
        right: Box<Expression>,
    },
    Unary {
        op: UnaryOp,
        expr: Box<Expression>,
    },
    Call {
        name: String,
        args: Vec<Expression>,
    },
    Index {
        array: Box<Expression>,
        index: Box<Expression>,
    },
    Member {
        object: Box<Expression>,
        field: String,
    },
    Cast {
        ty: Type,
        expr: Box<Expression>,
    },
    ThreadIdx(Dimension),
    BlockIdx(Dimension),
    BlockDim(Dimension),
    GridDim(Dimension),
    WarpPrimitive {
        op: WarpOp,
        args: Vec<Expression>,
    },
}

Expression types

Variants

Literal(Literal)

Literal values

Var(String)

Variable reference

Binary

Binary operation

Fields

op: BinaryOp

left: Box<Expression>

right: Box<Expression>

Unary

Unary operation

Fields

op: UnaryOp

expr: Box<Expression>

Call

Function call

Fields

name: String

args: Vec<Expression>

Index

Array access

Fields

array: Box<Expression>

index: Box<Expression>

Member

Member access

Fields

object: Box<Expression>

field: String

Cast

Cast expression

Fields

ty: Type

expr: Box<Expression>

ThreadIdx(Dimension)

Thread index access

BlockIdx(Dimension)

Block index access

BlockDim(Dimension)

Block dimension access

GridDim(Dimension)

Grid dimension access

WarpPrimitive

Warp-level primitives

Fields

op: WarpOp

args: Vec<Expression>

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Expression

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Expression

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.