pub trait Fold<U> {
type TargetU;
type Error;
type UserContext;
Show 97 methods
// Required methods
fn will_map_user(&mut self, user: &U) -> Self::UserContext;
fn map_user(
&mut self,
user: U,
context: Self::UserContext
) -> Result<Self::TargetU, Self::Error>;
// Provided methods
fn will_map_user_cfg(
&mut self,
_user: &EmptyRange<U>
) -> EmptyRange<Self::TargetU> { ... }
fn map_user_cfg(
&mut self,
_user: EmptyRange<U>,
_context: EmptyRange<Self::TargetU>
) -> Result<EmptyRange<Self::TargetU>, Self::Error> { ... }
fn fold<X: Foldable<U, Self::TargetU>>(
&mut self,
node: X
) -> Result<X::Mapped, Self::Error> { ... }
fn fold_mod(
&mut self,
node: Mod<U>
) -> Result<Mod<Self::TargetU>, Self::Error> { ... }
fn fold_mod_module(
&mut self,
node: ModModule<U>
) -> Result<ModModule<Self::TargetU>, Self::Error> { ... }
fn fold_mod_interactive(
&mut self,
node: ModInteractive<U>
) -> Result<ModInteractive<Self::TargetU>, Self::Error> { ... }
fn fold_mod_expression(
&mut self,
node: ModExpression<U>
) -> Result<ModExpression<Self::TargetU>, Self::Error> { ... }
fn fold_mod_function_type(
&mut self,
node: ModFunctionType<U>
) -> Result<ModFunctionType<Self::TargetU>, Self::Error> { ... }
fn fold_stmt(
&mut self,
node: Stmt<U>
) -> Result<Stmt<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_function_def(
&mut self,
node: StmtFunctionDef<U>
) -> Result<StmtFunctionDef<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_async_function_def(
&mut self,
node: StmtAsyncFunctionDef<U>
) -> Result<StmtAsyncFunctionDef<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_class_def(
&mut self,
node: StmtClassDef<U>
) -> Result<StmtClassDef<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_return(
&mut self,
node: StmtReturn<U>
) -> Result<StmtReturn<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_delete(
&mut self,
node: StmtDelete<U>
) -> Result<StmtDelete<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_assign(
&mut self,
node: StmtAssign<U>
) -> Result<StmtAssign<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_type_alias(
&mut self,
node: StmtTypeAlias<U>
) -> Result<StmtTypeAlias<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_aug_assign(
&mut self,
node: StmtAugAssign<U>
) -> Result<StmtAugAssign<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_ann_assign(
&mut self,
node: StmtAnnAssign<U>
) -> Result<StmtAnnAssign<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_for(
&mut self,
node: StmtFor<U>
) -> Result<StmtFor<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_async_for(
&mut self,
node: StmtAsyncFor<U>
) -> Result<StmtAsyncFor<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_while(
&mut self,
node: StmtWhile<U>
) -> Result<StmtWhile<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_if(
&mut self,
node: StmtIf<U>
) -> Result<StmtIf<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_with(
&mut self,
node: StmtWith<U>
) -> Result<StmtWith<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_async_with(
&mut self,
node: StmtAsyncWith<U>
) -> Result<StmtAsyncWith<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_match(
&mut self,
node: StmtMatch<U>
) -> Result<StmtMatch<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_raise(
&mut self,
node: StmtRaise<U>
) -> Result<StmtRaise<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_try(
&mut self,
node: StmtTry<U>
) -> Result<StmtTry<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_try_star(
&mut self,
node: StmtTryStar<U>
) -> Result<StmtTryStar<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_assert(
&mut self,
node: StmtAssert<U>
) -> Result<StmtAssert<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_import(
&mut self,
node: StmtImport<U>
) -> Result<StmtImport<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_import_from(
&mut self,
node: StmtImportFrom<U>
) -> Result<StmtImportFrom<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_global(
&mut self,
node: StmtGlobal<U>
) -> Result<StmtGlobal<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_nonlocal(
&mut self,
node: StmtNonlocal<U>
) -> Result<StmtNonlocal<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_expr(
&mut self,
node: StmtExpr<U>
) -> Result<StmtExpr<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_pass(
&mut self,
node: StmtPass<U>
) -> Result<StmtPass<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_break(
&mut self,
node: StmtBreak<U>
) -> Result<StmtBreak<Self::TargetU>, Self::Error> { ... }
fn fold_stmt_continue(
&mut self,
node: StmtContinue<U>
) -> Result<StmtContinue<Self::TargetU>, Self::Error> { ... }
fn fold_expr(
&mut self,
node: Expr<U>
) -> Result<Expr<Self::TargetU>, Self::Error> { ... }
fn fold_expr_bool_op(
&mut self,
node: ExprBoolOp<U>
) -> Result<ExprBoolOp<Self::TargetU>, Self::Error> { ... }
fn fold_expr_named_expr(
&mut self,
node: ExprNamedExpr<U>
) -> Result<ExprNamedExpr<Self::TargetU>, Self::Error> { ... }
fn fold_expr_bin_op(
&mut self,
node: ExprBinOp<U>
) -> Result<ExprBinOp<Self::TargetU>, Self::Error> { ... }
fn fold_expr_unary_op(
&mut self,
node: ExprUnaryOp<U>
) -> Result<ExprUnaryOp<Self::TargetU>, Self::Error> { ... }
fn fold_expr_lambda(
&mut self,
node: ExprLambda<U>
) -> Result<ExprLambda<Self::TargetU>, Self::Error> { ... }
fn fold_expr_if_exp(
&mut self,
node: ExprIfExp<U>
) -> Result<ExprIfExp<Self::TargetU>, Self::Error> { ... }
fn fold_expr_dict(
&mut self,
node: ExprDict<U>
) -> Result<ExprDict<Self::TargetU>, Self::Error> { ... }
fn fold_expr_set(
&mut self,
node: ExprSet<U>
) -> Result<ExprSet<Self::TargetU>, Self::Error> { ... }
fn fold_expr_list_comp(
&mut self,
node: ExprListComp<U>
) -> Result<ExprListComp<Self::TargetU>, Self::Error> { ... }
fn fold_expr_set_comp(
&mut self,
node: ExprSetComp<U>
) -> Result<ExprSetComp<Self::TargetU>, Self::Error> { ... }
fn fold_expr_dict_comp(
&mut self,
node: ExprDictComp<U>
) -> Result<ExprDictComp<Self::TargetU>, Self::Error> { ... }
fn fold_expr_generator_exp(
&mut self,
node: ExprGeneratorExp<U>
) -> Result<ExprGeneratorExp<Self::TargetU>, Self::Error> { ... }
fn fold_expr_await(
&mut self,
node: ExprAwait<U>
) -> Result<ExprAwait<Self::TargetU>, Self::Error> { ... }
fn fold_expr_yield(
&mut self,
node: ExprYield<U>
) -> Result<ExprYield<Self::TargetU>, Self::Error> { ... }
fn fold_expr_yield_from(
&mut self,
node: ExprYieldFrom<U>
) -> Result<ExprYieldFrom<Self::TargetU>, Self::Error> { ... }
fn fold_expr_compare(
&mut self,
node: ExprCompare<U>
) -> Result<ExprCompare<Self::TargetU>, Self::Error> { ... }
fn fold_expr_call(
&mut self,
node: ExprCall<U>
) -> Result<ExprCall<Self::TargetU>, Self::Error> { ... }
fn fold_expr_formatted_value(
&mut self,
node: ExprFormattedValue<U>
) -> Result<ExprFormattedValue<Self::TargetU>, Self::Error> { ... }
fn fold_expr_joined_str(
&mut self,
node: ExprJoinedStr<U>
) -> Result<ExprJoinedStr<Self::TargetU>, Self::Error> { ... }
fn fold_expr_constant(
&mut self,
node: ExprConstant<U>
) -> Result<ExprConstant<Self::TargetU>, Self::Error> { ... }
fn fold_expr_attribute(
&mut self,
node: ExprAttribute<U>
) -> Result<ExprAttribute<Self::TargetU>, Self::Error> { ... }
fn fold_expr_subscript(
&mut self,
node: ExprSubscript<U>
) -> Result<ExprSubscript<Self::TargetU>, Self::Error> { ... }
fn fold_expr_starred(
&mut self,
node: ExprStarred<U>
) -> Result<ExprStarred<Self::TargetU>, Self::Error> { ... }
fn fold_expr_name(
&mut self,
node: ExprName<U>
) -> Result<ExprName<Self::TargetU>, Self::Error> { ... }
fn fold_expr_list(
&mut self,
node: ExprList<U>
) -> Result<ExprList<Self::TargetU>, Self::Error> { ... }
fn fold_expr_tuple(
&mut self,
node: ExprTuple<U>
) -> Result<ExprTuple<Self::TargetU>, Self::Error> { ... }
fn fold_expr_slice(
&mut self,
node: ExprSlice<U>
) -> Result<ExprSlice<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_excepthandler_except_handler(
&mut self,
node: ExceptHandlerExceptHandler<U>
) -> Result<ExceptHandlerExceptHandler<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_pattern_match_value(
&mut self,
node: PatternMatchValue<U>
) -> Result<PatternMatchValue<Self::TargetU>, Self::Error> { ... }
fn fold_pattern_match_singleton(
&mut self,
node: PatternMatchSingleton<U>
) -> Result<PatternMatchSingleton<Self::TargetU>, Self::Error> { ... }
fn fold_pattern_match_sequence(
&mut self,
node: PatternMatchSequence<U>
) -> Result<PatternMatchSequence<Self::TargetU>, Self::Error> { ... }
fn fold_pattern_match_mapping(
&mut self,
node: PatternMatchMapping<U>
) -> Result<PatternMatchMapping<Self::TargetU>, Self::Error> { ... }
fn fold_pattern_match_class(
&mut self,
node: PatternMatchClass<U>
) -> Result<PatternMatchClass<Self::TargetU>, Self::Error> { ... }
fn fold_pattern_match_star(
&mut self,
node: PatternMatchStar<U>
) -> Result<PatternMatchStar<Self::TargetU>, Self::Error> { ... }
fn fold_pattern_match_as(
&mut self,
node: PatternMatchAs<U>
) -> Result<PatternMatchAs<Self::TargetU>, Self::Error> { ... }
fn fold_pattern_match_or(
&mut self,
node: PatternMatchOr<U>
) -> Result<PatternMatchOr<Self::TargetU>, Self::Error> { ... }
fn fold_type_ignore(
&mut self,
node: TypeIgnore<U>
) -> Result<TypeIgnore<Self::TargetU>, Self::Error> { ... }
fn fold_type_ignore_type_ignore(
&mut self,
node: TypeIgnoreTypeIgnore<U>
) -> Result<TypeIgnoreTypeIgnore<Self::TargetU>, Self::Error> { ... }
fn fold_type_param(
&mut self,
node: TypeParam<U>
) -> Result<TypeParam<Self::TargetU>, Self::Error> { ... }
fn fold_type_param_type_var(
&mut self,
node: TypeParamTypeVar<U>
) -> Result<TypeParamTypeVar<Self::TargetU>, Self::Error> { ... }
fn fold_type_param_param_spec(
&mut self,
node: TypeParamParamSpec<U>
) -> Result<TypeParamParamSpec<Self::TargetU>, Self::Error> { ... }
fn fold_type_param_type_var_tuple(
&mut self,
node: TypeParamTypeVarTuple<U>
) -> Result<TypeParamTypeVarTuple<Self::TargetU>, Self::Error> { ... }
fn fold_arg_with_default(
&mut self,
node: ArgWithDefault<U>
) -> Result<ArgWithDefault<Self::TargetU>, Self::Error> { ... }
}