Skip to main content

Expr

rustpython_ruff_python_ast

Enum Expr

pub enum Expr {
Show 33 variants
    BoolOp(ExprBoolOp),
    Named(ExprNamed),
    BinOp(ExprBinOp),
    UnaryOp(ExprUnaryOp),
    Lambda(ExprLambda),
    If(ExprIf),
    Dict(ExprDict),
    Set(ExprSet),
    ListComp(ExprListComp),
    SetComp(ExprSetComp),
    DictComp(ExprDictComp),
    Generator(ExprGenerator),
    Await(ExprAwait),
    Yield(ExprYield),
    YieldFrom(ExprYieldFrom),
    Compare(ExprCompare),
    Call(ExprCall),
    FString(ExprFString),
    TString(ExprTString),
    StringLiteral(ExprStringLiteral),
    BytesLiteral(ExprBytesLiteral),
    NumberLiteral(ExprNumberLiteral),
    BooleanLiteral(ExprBooleanLiteral),
    NoneLiteral(ExprNoneLiteral),
    EllipsisLiteral(ExprEllipsisLiteral),
    Attribute(ExprAttribute),
    Subscript(ExprSubscript),
    Starred(ExprStarred),
    Name(ExprName),
    List(ExprList),
    Tuple(ExprTuple),
    Slice(ExprSlice),
    IpyEscapeCommand(ExprIpyEscapeCommand),
}

Expand description

See also expr

Variants§

BoolOp(ExprBoolOp)

Named(ExprNamed)

BinOp(ExprBinOp)

UnaryOp(ExprUnaryOp)

Lambda(ExprLambda)

If(ExprIf)

Dict(ExprDict)

Set(ExprSet)

ListComp(ExprListComp)

SetComp(ExprSetComp)

DictComp(ExprDictComp)

Generator(ExprGenerator)

Await(ExprAwait)

Yield(ExprYield)

YieldFrom(ExprYieldFrom)

Compare(ExprCompare)

Call(ExprCall)

FString(ExprFString)

TString(ExprTString)

StringLiteral(ExprStringLiteral)

BytesLiteral(ExprBytesLiteral)

NumberLiteral(ExprNumberLiteral)

BooleanLiteral(ExprBooleanLiteral)

NoneLiteral(ExprNoneLiteral)

EllipsisLiteral(ExprEllipsisLiteral)

Attribute(ExprAttribute)

Subscript(ExprSubscript)

Starred(ExprStarred)

Name(ExprName)

List(ExprList)

Tuple(ExprTuple)

Slice(ExprSlice)

IpyEscapeCommand(ExprIpyEscapeCommand)

Implementations§

impl Expr

pub const fn is_bool_op_expr(&self) -> bool

pub fn bool_op_expr(self) -> Option<ExprBoolOp>

pub fn expect_bool_op_expr(self) -> ExprBoolOp

pub fn as_bool_op_expr_mut(&mut self) -> Option<&mut ExprBoolOp>

pub fn as_bool_op_expr(&self) -> Option<&ExprBoolOp>

pub const fn is_named_expr(&self) -> bool

pub fn named_expr(self) -> Option<ExprNamed>

pub fn expect_named_expr(self) -> ExprNamed

pub fn as_named_expr_mut(&mut self) -> Option<&mut ExprNamed>

pub fn as_named_expr(&self) -> Option<&ExprNamed>

pub const fn is_bin_op_expr(&self) -> bool

pub fn bin_op_expr(self) -> Option<ExprBinOp>

pub fn expect_bin_op_expr(self) -> ExprBinOp

pub fn as_bin_op_expr_mut(&mut self) -> Option<&mut ExprBinOp>

pub fn as_bin_op_expr(&self) -> Option<&ExprBinOp>

pub const fn is_unary_op_expr(&self) -> bool

pub fn unary_op_expr(self) -> Option<ExprUnaryOp>

pub fn expect_unary_op_expr(self) -> ExprUnaryOp

pub fn as_unary_op_expr_mut(&mut self) -> Option<&mut ExprUnaryOp>

pub fn as_unary_op_expr(&self) -> Option<&ExprUnaryOp>

pub const fn is_lambda_expr(&self) -> bool

pub fn lambda_expr(self) -> Option<ExprLambda>

pub fn expect_lambda_expr(self) -> ExprLambda

pub fn as_lambda_expr_mut(&mut self) -> Option<&mut ExprLambda>

pub fn as_lambda_expr(&self) -> Option<&ExprLambda>

pub const fn is_if_expr(&self) -> bool

pub fn if_expr(self) -> Option<ExprIf>

pub fn expect_if_expr(self) -> ExprIf

pub fn as_if_expr_mut(&mut self) -> Option<&mut ExprIf>

pub fn as_if_expr(&self) -> Option<&ExprIf>

pub const fn is_dict_expr(&self) -> bool

pub fn dict_expr(self) -> Option<ExprDict>

pub fn expect_dict_expr(self) -> ExprDict

pub fn as_dict_expr_mut(&mut self) -> Option<&mut ExprDict>

pub fn as_dict_expr(&self) -> Option<&ExprDict>

pub const fn is_set_expr(&self) -> bool

pub fn set_expr(self) -> Option<ExprSet>

pub fn expect_set_expr(self) -> ExprSet

pub fn as_set_expr_mut(&mut self) -> Option<&mut ExprSet>

pub fn as_set_expr(&self) -> Option<&ExprSet>

pub const fn is_list_comp_expr(&self) -> bool

pub fn list_comp_expr(self) -> Option<ExprListComp>

pub fn expect_list_comp_expr(self) -> ExprListComp

pub fn as_list_comp_expr_mut(&mut self) -> Option<&mut ExprListComp>

pub fn as_list_comp_expr(&self) -> Option<&ExprListComp>

pub const fn is_set_comp_expr(&self) -> bool

pub fn set_comp_expr(self) -> Option<ExprSetComp>

pub fn expect_set_comp_expr(self) -> ExprSetComp

pub fn as_set_comp_expr_mut(&mut self) -> Option<&mut ExprSetComp>

pub fn as_set_comp_expr(&self) -> Option<&ExprSetComp>

pub const fn is_dict_comp_expr(&self) -> bool

pub fn dict_comp_expr(self) -> Option<ExprDictComp>

pub fn expect_dict_comp_expr(self) -> ExprDictComp

pub fn as_dict_comp_expr_mut(&mut self) -> Option<&mut ExprDictComp>

pub fn as_dict_comp_expr(&self) -> Option<&ExprDictComp>

pub const fn is_generator_expr(&self) -> bool

pub fn generator_expr(self) -> Option<ExprGenerator>

pub fn expect_generator_expr(self) -> ExprGenerator

pub fn as_generator_expr_mut(&mut self) -> Option<&mut ExprGenerator>

pub fn as_generator_expr(&self) -> Option<&ExprGenerator>

pub const fn is_await_expr(&self) -> bool

pub fn await_expr(self) -> Option<ExprAwait>

pub fn expect_await_expr(self) -> ExprAwait

pub fn as_await_expr_mut(&mut self) -> Option<&mut ExprAwait>

pub fn as_await_expr(&self) -> Option<&ExprAwait>

pub const fn is_yield_expr(&self) -> bool

pub fn yield_expr(self) -> Option<ExprYield>

pub fn expect_yield_expr(self) -> ExprYield

pub fn as_yield_expr_mut(&mut self) -> Option<&mut ExprYield>

pub fn as_yield_expr(&self) -> Option<&ExprYield>

pub const fn is_yield_from_expr(&self) -> bool

pub fn yield_from_expr(self) -> Option<ExprYieldFrom>

pub fn expect_yield_from_expr(self) -> ExprYieldFrom

pub fn as_yield_from_expr_mut(&mut self) -> Option<&mut ExprYieldFrom>

pub fn as_yield_from_expr(&self) -> Option<&ExprYieldFrom>

pub const fn is_compare_expr(&self) -> bool

pub fn compare_expr(self) -> Option<ExprCompare>

pub fn expect_compare_expr(self) -> ExprCompare

pub fn as_compare_expr_mut(&mut self) -> Option<&mut ExprCompare>

pub fn as_compare_expr(&self) -> Option<&ExprCompare>

pub const fn is_call_expr(&self) -> bool

pub fn call_expr(self) -> Option<ExprCall>

pub fn expect_call_expr(self) -> ExprCall

pub fn as_call_expr_mut(&mut self) -> Option<&mut ExprCall>

pub fn as_call_expr(&self) -> Option<&ExprCall>

pub const fn is_f_string_expr(&self) -> bool

pub fn f_string_expr(self) -> Option<ExprFString>

pub fn expect_f_string_expr(self) -> ExprFString

pub fn as_f_string_expr_mut(&mut self) -> Option<&mut ExprFString>

pub fn as_f_string_expr(&self) -> Option<&ExprFString>

pub const fn is_t_string_expr(&self) -> bool

pub fn t_string_expr(self) -> Option<ExprTString>

pub fn expect_t_string_expr(self) -> ExprTString

pub fn as_t_string_expr_mut(&mut self) -> Option<&mut ExprTString>

pub fn as_t_string_expr(&self) -> Option<&ExprTString>

pub const fn is_string_literal_expr(&self) -> bool

pub fn string_literal_expr(self) -> Option<ExprStringLiteral>

pub fn expect_string_literal_expr(self) -> ExprStringLiteral

pub fn as_string_literal_expr_mut(&mut self) -> Option<&mut ExprStringLiteral>

pub fn as_string_literal_expr(&self) -> Option<&ExprStringLiteral>

pub const fn is_bytes_literal_expr(&self) -> bool

pub fn bytes_literal_expr(self) -> Option<ExprBytesLiteral>

pub fn expect_bytes_literal_expr(self) -> ExprBytesLiteral

pub fn as_bytes_literal_expr_mut(&mut self) -> Option<&mut ExprBytesLiteral>

pub fn as_bytes_literal_expr(&self) -> Option<&ExprBytesLiteral>

pub const fn is_number_literal_expr(&self) -> bool

pub fn number_literal_expr(self) -> Option<ExprNumberLiteral>

pub fn expect_number_literal_expr(self) -> ExprNumberLiteral

pub fn as_number_literal_expr_mut(&mut self) -> Option<&mut ExprNumberLiteral>

pub fn as_number_literal_expr(&self) -> Option<&ExprNumberLiteral>

pub const fn is_boolean_literal_expr(&self) -> bool

pub fn boolean_literal_expr(self) -> Option<ExprBooleanLiteral>

pub fn expect_boolean_literal_expr(self) -> ExprBooleanLiteral

pub fn as_boolean_literal_expr_mut(&mut self) -> Option<&mut ExprBooleanLiteral>

pub fn as_boolean_literal_expr(&self) -> Option<&ExprBooleanLiteral>

pub const fn is_none_literal_expr(&self) -> bool

pub fn none_literal_expr(self) -> Option<ExprNoneLiteral>

pub fn expect_none_literal_expr(self) -> ExprNoneLiteral

pub fn as_none_literal_expr_mut(&mut self) -> Option<&mut ExprNoneLiteral>

pub fn as_none_literal_expr(&self) -> Option<&ExprNoneLiteral>

pub const fn is_ellipsis_literal_expr(&self) -> bool

pub fn ellipsis_literal_expr(self) -> Option<ExprEllipsisLiteral>

pub fn expect_ellipsis_literal_expr(self) -> ExprEllipsisLiteral

pub fn as_ellipsis_literal_expr_mut( &mut self, ) -> Option<&mut ExprEllipsisLiteral>

pub fn as_ellipsis_literal_expr(&self) -> Option<&ExprEllipsisLiteral>

pub const fn is_attribute_expr(&self) -> bool

pub fn attribute_expr(self) -> Option<ExprAttribute>

pub fn expect_attribute_expr(self) -> ExprAttribute

pub fn as_attribute_expr_mut(&mut self) -> Option<&mut ExprAttribute>

pub fn as_attribute_expr(&self) -> Option<&ExprAttribute>

pub const fn is_subscript_expr(&self) -> bool

pub fn subscript_expr(self) -> Option<ExprSubscript>

pub fn expect_subscript_expr(self) -> ExprSubscript

pub fn as_subscript_expr_mut(&mut self) -> Option<&mut ExprSubscript>

pub fn as_subscript_expr(&self) -> Option<&ExprSubscript>

pub const fn is_starred_expr(&self) -> bool

pub fn starred_expr(self) -> Option<ExprStarred>

pub fn expect_starred_expr(self) -> ExprStarred

pub fn as_starred_expr_mut(&mut self) -> Option<&mut ExprStarred>

pub fn as_starred_expr(&self) -> Option<&ExprStarred>

pub const fn is_name_expr(&self) -> bool

pub fn name_expr(self) -> Option<ExprName>

pub fn expect_name_expr(self) -> ExprName

pub fn as_name_expr_mut(&mut self) -> Option<&mut ExprName>

pub fn as_name_expr(&self) -> Option<&ExprName>

pub const fn is_list_expr(&self) -> bool

pub fn list_expr(self) -> Option<ExprList>

pub fn expect_list_expr(self) -> ExprList

pub fn as_list_expr_mut(&mut self) -> Option<&mut ExprList>

pub fn as_list_expr(&self) -> Option<&ExprList>

pub const fn is_tuple_expr(&self) -> bool

pub fn tuple_expr(self) -> Option<ExprTuple>

pub fn expect_tuple_expr(self) -> ExprTuple

pub fn as_tuple_expr_mut(&mut self) -> Option<&mut ExprTuple>

pub fn as_tuple_expr(&self) -> Option<&ExprTuple>

pub const fn is_slice_expr(&self) -> bool

pub fn slice_expr(self) -> Option<ExprSlice>

pub fn expect_slice_expr(self) -> ExprSlice

pub fn as_slice_expr_mut(&mut self) -> Option<&mut ExprSlice>

pub fn as_slice_expr(&self) -> Option<&ExprSlice>

pub const fn is_ipy_escape_command_expr(&self) -> bool

pub fn ipy_escape_command_expr(self) -> Option<ExprIpyEscapeCommand>

pub fn expect_ipy_escape_command_expr(self) -> ExprIpyEscapeCommand

pub fn as_ipy_escape_command_expr_mut( &mut self, ) -> Option<&mut ExprIpyEscapeCommand>

pub fn as_ipy_escape_command_expr(&self) -> Option<&ExprIpyEscapeCommand>

impl Expr

pub fn is_literal_expr(&self) -> bool

Returns true if the expression is a literal expression.

A literal expression is either a string literal, bytes literal, integer, float, complex number, boolean, None, or ellipsis (...).

pub fn as_literal_expr(&self) -> Option<LiteralExpressionRef<'_>>

Returns LiteralExpressionRef if the expression is a literal expression.

pub fn precedence(&self) -> OperatorPrecedence

Return the OperatorPrecedence of this expression

Trait Implementations§

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value. Read more

1.0.0 · Source§

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

Performs copy-assignment from source. Read more

impl Debug for Expr

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

Formats the value using the given formatter. Read more

impl<'a> From<&'a Expr> for AnyNodeRef<'a>

fn from(node: &'a Expr) -> AnyNodeRef<'a>

Converts to this type from the input type.

impl<'a> From<&'a Expr> for AnyRootNodeRef<'a>

fn from(node: &'a Expr) -> AnyRootNodeRef<'a>

Converts to this type from the input type.

impl<'a> From<&'a Expr> for ArgOrKeyword<'a>

fn from(arg: &'a Expr) -> Self

Converts to this type from the input type.

impl<'a> From<&'a Expr> for ComparableExpr<'a>

fn from(expr: &'a Expr) -> Self

Converts to this type from the input type.

impl<'a> From<&'a Expr> for ExprRef<'a>

fn from(node: &'a Expr) -> Self

Converts to this type from the input type.

impl<'a> From<&'a Expr> for HashableExpr<'a>

fn from(expr: &'a Expr) -> Self

Converts to this type from the input type.

impl From<&Expr> for OperatorPrecedence

fn from(expr: &Expr) -> Self

Converts to this type from the input type.

impl From<BytesLiteral> for Expr

fn from(payload: BytesLiteral) -> Self

Converts to this type from the input type.

impl From<ExprAttribute> for Expr

fn from(node: ExprAttribute) -> Self

Converts to this type from the input type.

impl From<ExprAwait> for Expr

fn from(node: ExprAwait) -> Self

Converts to this type from the input type.

impl From<ExprBinOp> for Expr

fn from(node: ExprBinOp) -> Self

Converts to this type from the input type.

impl From<ExprBoolOp> for Expr

fn from(node: ExprBoolOp) -> Self

Converts to this type from the input type.

impl From<ExprBooleanLiteral> for Expr

fn from(node: ExprBooleanLiteral) -> Self

Converts to this type from the input type.

impl From<ExprBytesLiteral> for Expr

fn from(node: ExprBytesLiteral) -> Self

Converts to this type from the input type.

impl From<ExprCall> for Expr

fn from(node: ExprCall) -> Self

Converts to this type from the input type.

impl From<ExprCompare> for Expr

fn from(node: ExprCompare) -> Self

Converts to this type from the input type.

impl From<ExprDict> for Expr

fn from(node: ExprDict) -> Self

Converts to this type from the input type.

impl From<ExprDictComp> for Expr

fn from(node: ExprDictComp) -> Self

Converts to this type from the input type.

impl From<ExprEllipsisLiteral> for Expr

fn from(node: ExprEllipsisLiteral) -> Self

Converts to this type from the input type.

impl From<ExprFString> for Expr

fn from(node: ExprFString) -> Self

Converts to this type from the input type.

impl From<ExprGenerator> for Expr

fn from(node: ExprGenerator) -> Self

Converts to this type from the input type.

impl From<ExprIf> for Expr

fn from(node: ExprIf) -> Self

Converts to this type from the input type.

impl From<ExprIpyEscapeCommand> for Expr

fn from(node: ExprIpyEscapeCommand) -> Self

Converts to this type from the input type.

impl From<ExprLambda> for Expr

fn from(node: ExprLambda) -> Self

Converts to this type from the input type.

impl From<ExprList> for Expr

fn from(node: ExprList) -> Self

Converts to this type from the input type.

impl From<ExprListComp> for Expr

fn from(node: ExprListComp) -> Self

Converts to this type from the input type.

impl From<ExprName> for Expr

fn from(node: ExprName) -> Self

Converts to this type from the input type.

impl From<ExprNamed> for Expr

fn from(node: ExprNamed) -> Self

Converts to this type from the input type.

impl From<ExprNoneLiteral> for Expr

fn from(node: ExprNoneLiteral) -> Self

Converts to this type from the input type.

impl From<ExprNumberLiteral> for Expr

fn from(node: ExprNumberLiteral) -> Self

Converts to this type from the input type.

impl From<ExprSet> for Expr

fn from(node: ExprSet) -> Self

Converts to this type from the input type.

impl From<ExprSetComp> for Expr

fn from(node: ExprSetComp) -> Self

Converts to this type from the input type.

impl From<ExprSlice> for Expr

fn from(node: ExprSlice) -> Self

Converts to this type from the input type.

impl From<ExprStarred> for Expr

fn from(node: ExprStarred) -> Self

Converts to this type from the input type.

impl From<ExprStringLiteral> for Expr

fn from(node: ExprStringLiteral) -> Self

Converts to this type from the input type.

impl From<ExprSubscript> for Expr

fn from(node: ExprSubscript) -> Self

Converts to this type from the input type.

impl From<ExprTString> for Expr

fn from(node: ExprTString) -> Self

Converts to this type from the input type.

impl From<ExprTuple> for Expr

fn from(node: ExprTuple) -> Self

Converts to this type from the input type.

impl From<ExprUnaryOp> for Expr

fn from(node: ExprUnaryOp) -> Self

Converts to this type from the input type.

impl From<ExprYield> for Expr

fn from(node: ExprYield) -> Self

Converts to this type from the input type.

impl From<ExprYieldFrom> for Expr

fn from(node: ExprYieldFrom) -> Self

Converts to this type from the input type.

impl From<FString> for Expr

fn from(payload: FString) -> Self

Converts to this type from the input type.

impl From<StringLiteral> for Expr

fn from(payload: StringLiteral) -> Self

Converts to this type from the input type.

impl From<TString> for Expr

fn from(payload: TString) -> Self

Converts to this type from the input type.

impl HasNodeIndex for Expr

fn node_index(&self) -> &AtomicNodeIndex

Returns the AtomicNodeIndex for this node.

impl PartialEq for Expr

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

Tests for self and other values to be equal, and is used by ==.

1.0.0 · Source§

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 Ranged for Expr

fn range(&self) -> TextRange

The range of this item in the source text.

fn start(&self) -> TextSize

The start offset of this item in the source text.

fn end(&self) -> TextSize

The end offset of this item in the source text.

impl<'a> TryFrom<&'a Expr> for StringLike<'a>

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: &'a Expr) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> TryFrom<AnyRootNodeRef<'a>> for &'a Expr

type Error = ()

The type returned in the event of a conversion error.

fn try_from(node: AnyRootNodeRef<'a>) -> Result<&'a Expr, ()>

Performs the conversion.

impl StructuralPartialEq for Expr

Auto Trait Implementations§

impl !Freeze for Expr

impl RefUnwindSafe for Expr

impl Send for Expr

impl Sync for Expr

impl Unpin for Expr

impl UnsafeUnpin for Expr

impl UnwindSafe for Expr

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> CloneToUninit for T
where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)

Performs copy-assignment from self to dest. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into<U> for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

impl<T> ToOwned for T
where T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T, U> TryFrom<U> for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.