Enum ComparableStmt 

pub enum ComparableStmt<'a> {
    FunctionDef(StmtFunctionDef<'a>),
    ClassDef(StmtClassDef<'a>),
    Return(StmtReturn<'a>),
    Delete(StmtDelete<'a>),
    Assign(StmtAssign<'a>),
    AugAssign(StmtAugAssign<'a>),
    AnnAssign(StmtAnnAssign<'a>),
    For(StmtFor<'a>),
    While(StmtWhile<'a>),
    If(StmtIf<'a>),
    With(StmtWith<'a>),
    Match(StmtMatch<'a>),
    Raise(StmtRaise<'a>),
    Try(StmtTry<'a>),
    TypeAlias(StmtTypeAlias<'a>),
    Assert(StmtAssert<'a>),
    Import(StmtImport<'a>),
    ImportFrom(StmtImportFrom<'a>),
    Global(StmtGlobal<'a>),
    Nonlocal(StmtNonlocal<'a>),
    IpyEscapeCommand(StmtIpyEscapeCommand<'a>),
    Expr(StmtExpr<'a>),
    Pass,
    Break,
    Continue,
}

Variants

FunctionDef(StmtFunctionDef<'a>)

ClassDef(StmtClassDef<'a>)

Return(StmtReturn<'a>)

Delete(StmtDelete<'a>)

Assign(StmtAssign<'a>)

AugAssign(StmtAugAssign<'a>)

AnnAssign(StmtAnnAssign<'a>)

For(StmtFor<'a>)

While(StmtWhile<'a>)

If(StmtIf<'a>)

With(StmtWith<'a>)

Match(StmtMatch<'a>)

Raise(StmtRaise<'a>)

Try(StmtTry<'a>)

TypeAlias(StmtTypeAlias<'a>)

Assert(StmtAssert<'a>)

Import(StmtImport<'a>)

ImportFrom(StmtImportFrom<'a>)

Global(StmtGlobal<'a>)

Nonlocal(StmtNonlocal<'a>)

IpyEscapeCommand(StmtIpyEscapeCommand<'a>)

Expr(StmtExpr<'a>)

Pass

Break

Continue

Trait Implementations

impl<'a> Debug for ComparableStmt<'a>

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

Formats the value using the given formatter.

impl<'a> From<&'a Stmt> for ComparableStmt<'a>

fn from(stmt: &'a Stmt) -> Self

Converts to this type from the input type.

impl<'a> Hash for ComparableStmt<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq for ComparableStmt<'a>

fn eq(&self, other: &ComparableStmt<'a>) -> 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<'a> Eq for ComparableStmt<'a>

impl<'a> StructuralPartialEq for ComparableStmt<'a>