Enum Expr 

pub enum Expr {
    Literal(Literal),
    Path(Path),
    Call {
        func: Path,
        args: Vec<Arg>,
    },
    Tuple(Vec<Expr>),
    List(Vec<Expr>),
    Dict(Vec<(Expr, Expr)>),
    Attribute {
        value: Box<Expr>,
        name: Ident,
    },
    Index {
        value: Box<Expr>,
        index: Box<Expr>,
    },
    Slice {
        start: Option<Box<Expr>>,
        end: Option<Box<Expr>>,
    },
    Unary {
        op: &'static str,
        value: Box<Expr>,
    },
    Paren(Box<Expr>),
    Binary {
        op: &'static str,
        lhs: Box<Expr>,
        rhs: Box<Expr>,
    },
    Annotation(Box<Type>),
}

An expression.

Variants

Literal(Literal)

A literal.

Path(Path)

A name or a dotted name.

Call

func(args).

Fields

func: Path

What is called.

args: Vec<Arg>

The arguments, in written order.

Tuple(Vec<Expr>)

(a, b).

List(Vec<Expr>)

[a, b].

A list and not a tuple, which is a different value: a tuple cannot be written into, and the reader’s collection slots are exactly what has to be.

Dict(Vec<(Expr, Expr)>)

{k: v}.

Attribute

value.name — an attribute of something that is not a bare name.

Expr::Path already spells a.b.C, and that is a dotted name: every segment is an identifier. This is the other thing — an attribute of a computed value, v[i].key, zd_h.member_id — which a path cannot hold because its object is not a name.

Fields

value: Box<Expr>

What the attribute is taken of.

name: Ident

The attribute.

Index

value[index].

Fields

value: Box<Expr>

What is subscripted.

index: Box<Expr>

The subscript.

Slice

start:end — a slice, which is a subscript and nothing else.

Only ever the index of an Expr::Index; Python has no other position a slice is an expression in. Both ends are optional and an absent one is written as nothing, which is what v[:n] is. No step: §7.3.1.2.1.12.3’s TRIM keeps a prefix, and a stride would be a form with no producer.

Fields

start: Option<Box<Expr>>

Where the slice starts, absent for the beginning.

end: Option<Box<Expr>>

Where it ends, absent for the end.

Unary

op value, written as given.

not x and ~x. The operator carries its own trailing space where Python needs one, because notx is an identifier and ~x takes none — a renderer that inserted a space would be deciding which of the two this is.

Fields

op: &'static str

The operator, as written, including any trailing space.

value: Box<Expr>

The operand.

Paren(Box<Expr>)

Parentheses written on purpose.

Expr::Binary brackets itself, so this is for the forms that do not: a Expr::Unary whose operand binds more loosely than the operator, and anywhere the walk asks for a bracket outright.

Binary

lhs op rhs.

Fields

op: &'static str

The operator, as written.

lhs: Box<Expr>

The left operand.

rhs: Box<Expr>

The right operand.

Annotation(Box<Type>)

A type written where a value belongs.

Which is exactly what a Python type alias is: X = list[int] is an assignment whose right-hand side is an annotation. Without this the two sides would need two spellings of the same syntax, and they could drift.

Implementations

impl Expr

pub fn name(text: &str) -> Self

An expression that is one name.

pub fn int(value: i128) -> Self

An integer literal.

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl Eq for Expr

impl PartialEq for Expr

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Expr