Trait Foldable 

pub trait Foldable<A: AstTypes, B: AstTypes>: Sized {
    type Out;

    // Required methods
    fn fold_in<F: Fold<A, B> + ?Sized>(
        self,
        folder: &mut F,
    ) -> Result<Self::Out, F::Error>;
    fn children<F: Fold<A, B> + ?Sized>(
        self,
        folder: &mut F,
    ) -> Result<Self::Out, F::Error>;
}

Implements depth-first traversal for folders

Required Associated Types

type Out

The return type of the associated Fold function

Required Methods

fn fold_in<F: Fold<A, B> + ?Sized>( self, folder: &mut F, ) -> Result<Self::Out, F::Error>

Calls Self’s appropriate Folder function(s)

fn children<F: Fold<A, B> + ?Sized>( self, folder: &mut F, ) -> Result<Self::Out, F::Error>

Destructures self, calling Foldable::fold_in on all foldable members, and rebuilds a Self out of the results.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<T, A, B> Foldable<A, B> for Box<T>

where T: Foldable<A, B>, A: AstTypes, B: AstTypes,

type Out = Box<<T as Foldable<A, B>>::Out>

fn fold_in<F: Fold<A, B> + ?Sized>( self, folder: &mut F, ) -> Result<Self::Out, F::Error>

fn children<F: Fold<A, B> + ?Sized>( self, folder: &mut F, ) -> Result<Self::Out, F::Error>

impl<T: Foldable<A, B>, A: AstTypes, B: AstTypes> Foldable<A, B> for Option<T>

type Out = Option<<T as Foldable<A, B>>::Out>

fn fold_in<F: Fold<A, B> + ?Sized>( self, folder: &mut F, ) -> Result<Self::Out, F::Error>

fn children<F: Fold<A, B> + ?Sized>( self, folder: &mut F, ) -> Result<Self::Out, F::Error>

impl<T: Foldable<A, B>, A: AstTypes, B: AstTypes> Foldable<A, B> for Vec<T>

type Out = Vec<<T as Foldable<A, B>>::Out>

fn fold_in<F: Fold<A, B> + ?Sized>( self, folder: &mut F, ) -> Result<Self::Out, F::Error>

fn children<F: Fold<A, B> + ?Sized>( self, folder: &mut F, ) -> Result<Self::Out, F::Error>

Implementors

impl<A: AstTypes, B: AstTypes> Foldable<A, B> for At<Expr<A>, A>

type Out = At<Expr<B>, B>

impl<A: AstTypes, B: AstTypes> Foldable<A, B> for At<Pat<A>, A>

type Out = At<Pat<B>, B>

impl<A: AstTypes, B: AstTypes> Foldable<A, B> for Bind<A>

type Out = Bind<B>

impl<A: AstTypes, B: AstTypes> Foldable<A, B> for Expr<A>

type Out = Expr<B>

impl<A: AstTypes, B: AstTypes> Foldable<A, B> for Make<A>

type Out = Make<B>

impl<A: AstTypes, B: AstTypes> Foldable<A, B> for MakeArm<A>

type Out = MakeArm<B>

impl<A: AstTypes, B: AstTypes> Foldable<A, B> for Match<A>

type Out = Match<B>

impl<A: AstTypes, B: AstTypes> Foldable<A, B> for MatchArm<A>

type Out = MatchArm<B>

impl<A: AstTypes, B: AstTypes> Foldable<A, B> for Pat<A>

type Out = Pat<B>

impl<A: AstTypes, B: AstTypes> Foldable<A, B> for Use<A>

type Out = Use<B>