Enum Expression 

pub enum Expression {
    Literal(Literal),
    Name(String),
    BinaryOp {
        left: Box<Expression>,
        operator: BinaryOperator,
        right: Box<Expression>,
    },
    UnaryOp {
        operator: UnaryOperator,
        operand: Box<Expression>,
    },
    BoolOp {
        operator: BoolOperator,
        values: Vec<Expression>,
    },
    Compare {
        left: Box<Expression>,
        ops: Vec<CompareOperator>,
        comparators: Vec<Expression>,
    },
    Call {
        func: Box<Expression>,
        args: Vec<Expression>,
        keywords: Vec<Keyword>,
    },
    Attribute {
        value: Box<Expression>,
        attr: String,
    },
    Subscript {
        value: Box<Expression>,
        slice: Box<Expression>,
    },
    List {
        elts: Vec<Expression>,
    },
    Tuple {
        elts: Vec<Expression>,
    },
    Slice {
        lower: Option<Box<Expression>>,
        upper: Option<Box<Expression>>,
        step: Option<Box<Expression>>,
    },
    Dict {
        keys: Vec<Option<Expression>>,
        values: Vec<Expression>,
    },
    Set {
        elts: Vec<Expression>,
    },
    ListComp {
        elt: Box<Expression>,
        generators: Vec<Comprehension>,
    },
    DictComp {
        key: Box<Expression>,
        value: Box<Expression>,
        generators: Vec<Comprehension>,
    },
    SetComp {
        elt: Box<Expression>,
        generators: Vec<Comprehension>,
    },
    GeneratorExp {
        elt: Box<Expression>,
        generators: Vec<Comprehension>,
    },
    Lambda {
        args: Vec<Parameter>,
        body: Box<Expression>,
    },
    IfExp {
        test: Box<Expression>,
        body: Box<Expression>,
        orelse: Box<Expression>,
    },
    JoinedStr {
        values: Vec<Expression>,
    },
    FormattedValue {
        value: Box<Expression>,
        conversion: usize,
        format_spec: Option<Box<Expression>>,
    },
    Yield(Option<Box<Expression>>),
    YieldFrom(Box<Expression>),
    Await(Box<Expression>),
    Starred {
        value: Box<Expression>,
        is_double: bool,
    },
}

Represents a Python expression.

Variants

Literal(Literal)

Literal value

Name(String)

Identifier name

BinaryOp

Binary operation

Fields

left: Box<Expression>

Left operand

operator: BinaryOperator

Binary operator

right: Box<Expression>

Right operand

UnaryOp

Unary operation

Fields

operator: UnaryOperator

Unary operator

operand: Box<Expression>

Operand

BoolOp

Boolean operation (and, or)

Fields

operator: BoolOperator

Boolean operator

values: Vec<Expression>

List of values

Compare

Comparison operation

Fields

left: Box<Expression>

Leftmost operand

ops: Vec<CompareOperator>

Comparison operators

comparators: Vec<Expression>

Subsequent operands

Call

Function call

Fields

func: Box<Expression>

Function being called

args: Vec<Expression>

Positional arguments

keywords: Vec<Keyword>

Keyword arguments

Attribute

Attribute access

Fields

value: Box<Expression>

Base expression

attr: String

Attribute name

Subscript

Subscript access

Fields

value: Box<Expression>

Base expression

slice: Box<Expression>

Slice or index expression

List

List literal

Fields

elts: Vec<Expression>

List elements

Tuple

Tuple literal

Fields

elts: Vec<Expression>

Tuple elements

Slice

Slice expression

Fields

lower: Option<Box<Expression>>

Optional lower bound

upper: Option<Box<Expression>>

Optional upper bound

step: Option<Box<Expression>>

Optional step

Dict

Dictionary literal

Fields

keys: Vec<Option<Expression>>

Optional keys

values: Vec<Expression>

Values

Set

Set literal

Fields

elts: Vec<Expression>

Set elements

ListComp

List comprehension

Fields

elt: Box<Expression>

Result expression

generators: Vec<Comprehension>

Generators

DictComp

Dictionary comprehension

Fields

key: Box<Expression>

Key expression

value: Box<Expression>

Value expression

generators: Vec<Comprehension>

Generators

SetComp

Set comprehension

Fields

elt: Box<Expression>

Result expression

generators: Vec<Comprehension>

Generators

GeneratorExp

Generator expression

Fields

elt: Box<Expression>

Result expression

generators: Vec<Comprehension>

Generators

Lambda

Lambda expression

Fields

args: Vec<Parameter>

Lambda arguments

body: Box<Expression>

Lambda body

IfExp

Conditional expression (ternary operator)

Fields

test: Box<Expression>

Test expression

body: Box<Expression>

Body expression

orelse: Box<Expression>

Else expression

JoinedStr

f-string

Fields

values: Vec<Expression>

f-string parts

FormattedValue

Formatted value within an f-string

Fields

value: Box<Expression>

Value to format

conversion: usize

Conversion type

format_spec: Option<Box<Expression>>

Optional format specification

Yield(Option<Box<Expression>>)

Yield expression

YieldFrom(Box<Expression>)

Yield from expression

Await(Box<Expression>)

Await expression

Starred

Starred expression (*args, **kwargs)

Fields

value: Box<Expression>

Value being starred

is_double: bool

Whether it’s a double star (**kwargs)

Implementations

impl Expression

pub fn name(name: impl Into<String>) -> Self

Creates a name expression.

pub fn string(value: impl Into<String>) -> Self

Creates a string literal expression.

pub fn integer(value: i64) -> Self

Creates an integer literal expression.

pub fn float(value: f64) -> Self

Creates a float literal expression.

pub fn boolean(value: bool) -> Self

Creates a boolean literal expression.

pub fn none() -> Self

Creates a None literal 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 PartialEq for Expression

fn eq(&self, other: &Expression) -> 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 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.

impl StructuralPartialEq for Expression