Enum PyExpr 

pub enum PyExpr {
    Literal(PyLiteral),
    Name(String),
    BinOp {
        left: Box<PyExpr>,
        op: BinOp,
        right: Box<PyExpr>,
    },
    UnaryOp {
        op: UnaryOp,
        operand: Box<PyExpr>,
    },
    Call {
        func: Box<PyExpr>,
        args: Vec<PyExpr>,
        kwargs: HashMap<String, PyExpr>,
    },
    Attribute {
        value: Box<PyExpr>,
        attr: String,
    },
    Subscript {
        value: Box<PyExpr>,
        index: Box<PyExpr>,
    },
    Slice {
        value: Box<PyExpr>,
        lower: Option<Box<PyExpr>>,
        upper: Option<Box<PyExpr>>,
        step: Option<Box<PyExpr>>,
    },
    List(Vec<PyExpr>),
    Tuple(Vec<PyExpr>),
    Dict {
        keys: Vec<PyExpr>,
        values: Vec<PyExpr>,
    },
    Set(Vec<PyExpr>),
    ListComp {
        element: Box<PyExpr>,
        generators: Vec<Comprehension>,
    },
    IfExp {
        test: Box<PyExpr>,
        body: Box<PyExpr>,
        orelse: Box<PyExpr>,
    },
    Lambda {
        args: Vec<String>,
        body: Box<PyExpr>,
    },
    Compare {
        left: Box<PyExpr>,
        op: CmpOp,
        right: Box<PyExpr>,
    },
    BoolOp {
        op: BoolOp,
        left: Box<PyExpr>,
        right: Box<PyExpr>,
    },
    Await(Box<PyExpr>),
    Yield(Option<Box<PyExpr>>),
}

Python expression types

Variants

Literal(PyLiteral)

Literal value

Name(String)

Variable name

BinOp

Binary operation: a + b, x * y

Fields

left: Box<PyExpr>

op: BinOp

right: Box<PyExpr>

UnaryOp

Unary operation: -x, not y

Fields

op: UnaryOp

operand: Box<PyExpr>

Call

Function call: func(args)

Fields

func: Box<PyExpr>

args: Vec<PyExpr>

kwargs: HashMap<String, PyExpr>

Attribute

Attribute access: obj.attr

Fields

value: Box<PyExpr>

attr: String

Subscript

Subscript: list[0], dict[“key”]

Fields

value: Box<PyExpr>

index: Box<PyExpr>

Slice

Slice: list[1:3], list[:5], list[2:], list[1:10:2]

Fields

value: Box<PyExpr>

lower: Option<Box<PyExpr>>

upper: Option<Box<PyExpr>>

step: Option<Box<PyExpr>>

List(Vec<PyExpr>)

List literal: [1, 2, 3]

Tuple(Vec<PyExpr>)

Tuple literal: (1, 2, 3)

Dict

Dict literal: {“a”: 1, “b”: 2}

Fields

keys: Vec<PyExpr>

values: Vec<PyExpr>

Set(Vec<PyExpr>)

Set literal: {1, 2, 3}

ListComp

List comprehension: [x*2 for x in range(10)]

Fields

element: Box<PyExpr>

generators: Vec<Comprehension>

IfExp

Conditional expression: x if condition else y

Fields

test: Box<PyExpr>

body: Box<PyExpr>

orelse: Box<PyExpr>

Lambda

Lambda: lambda x: x + 1

Fields

args: Vec<String>

body: Box<PyExpr>

Compare

Comparison: x == y, a < b

Fields

left: Box<PyExpr>

op: CmpOp

right: Box<PyExpr>

BoolOp

Boolean operation: and, or

Fields

op: BoolOp

left: Box<PyExpr>

right: Box<PyExpr>

Await(Box<PyExpr>)

Await expression: await expr

Yield(Option<Box<PyExpr>>)

Yield expression: yield expr

Trait Implementations

impl Clone for PyExpr

fn clone(&self) -> PyExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PyExpr

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PyExpr

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for PyExpr

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

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 PyExpr