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", so this trait is not object safe.

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 Expr<A>

type Out = Expr<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>

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 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>