Trait rustpython_ast::fold::Fold

source · 
pub trait Fold<U> {
    type TargetU;
    type Error;


Show 19 methods    fn map_user(&mut self, user: U) -> Result<Self::TargetU, Self::Error>;

    fn fold_mod(
        &mut self,
        node: Mod<U>
    ) -> Result<Mod<Self::TargetU>, Self::Error> { ... }
    fn fold_stmt(
        &mut self,
        node: Stmt<U>
    ) -> Result<Stmt<Self::TargetU>, Self::Error> { ... }
    fn fold_expr(
        &mut self,
        node: Expr<U>
    ) -> Result<Expr<Self::TargetU>, Self::Error> { ... }
    fn fold_expr_context(
        &mut self,
        node: ExprContext
    ) -> Result<ExprContext, Self::Error> { ... }
    fn fold_boolop(&mut self, node: Boolop) -> Result<Boolop, Self::Error> { ... }
    fn fold_operator(&mut self, node: Operator) -> Result<Operator, Self::Error> { ... }
    fn fold_unaryop(&mut self, node: Unaryop) -> Result<Unaryop, Self::Error> { ... }
    fn fold_cmpop(&mut self, node: Cmpop) -> Result<Cmpop, Self::Error> { ... }
    fn fold_comprehension(
        &mut self,
        node: Comprehension<U>
    ) -> Result<Comprehension<Self::TargetU>, Self::Error> { ... }
    fn fold_excepthandler(
        &mut self,
        node: Excepthandler<U>
    ) -> Result<Excepthandler<Self::TargetU>, Self::Error> { ... }
    fn fold_arguments(
        &mut self,
        node: Arguments<U>
    ) -> Result<Arguments<Self::TargetU>, Self::Error> { ... }
    fn fold_arg(
        &mut self,
        node: Arg<U>
    ) -> Result<Arg<Self::TargetU>, Self::Error> { ... }
    fn fold_keyword(
        &mut self,
        node: Keyword<U>
    ) -> Result<Keyword<Self::TargetU>, Self::Error> { ... }
    fn fold_alias(
        &mut self,
        node: Alias<U>
    ) -> Result<Alias<Self::TargetU>, Self::Error> { ... }
    fn fold_withitem(
        &mut self,
        node: Withitem<U>
    ) -> Result<Withitem<Self::TargetU>, Self::Error> { ... }
    fn fold_match_case(
        &mut self,
        node: MatchCase<U>
    ) -> Result<MatchCase<Self::TargetU>, Self::Error> { ... }
    fn fold_pattern(
        &mut self,
        node: Pattern<U>
    ) -> Result<Pattern<Self::TargetU>, Self::Error> { ... }
    fn fold_type_ignore(
        &mut self,
        node: TypeIgnore
    ) -> Result<TypeIgnore, Self::Error> { ... }

}

Required Associated Types§

Required Methods§

Provided Methods§

Implementors§