Trait Traversable

pub trait Traversable<Inspector, Adjuster> {
    type InspectError: Into<AnyError>;
    type AdjustError: Into<AnyError>;

    // Required methods
    fn inspect(&self, visitor: &mut Inspector) -> Result<(), Self::InspectError>;
    fn adjust(
        &mut self,
        visitor: &mut Adjuster,
    ) -> Result<(), Self::AdjustError>;
}

Required Associated Types

type InspectError: Into<AnyError>

type AdjustError: Into<AnyError>

Required Methods

fn inspect(&self, visitor: &mut Inspector) -> Result<(), Self::InspectError>

fn adjust(&mut self, visitor: &mut Adjuster) -> Result<(), Self::AdjustError>

Implementations on Foreign Types

impl<I, A> Traversable<I, A> for bool

type InspectError = Infallible

type AdjustError = Infallible

fn inspect(&self, _visitor: &mut I) -> Result<(), Self::InspectError>

fn adjust(&mut self, _visitor: &mut A) -> Result<(), Self::AdjustError>

impl<I, A> Traversable<I, A> for char

type InspectError = Infallible

type AdjustError = Infallible

fn inspect(&self, _visitor: &mut I) -> Result<(), Self::InspectError>

fn adjust(&mut self, _visitor: &mut A) -> Result<(), Self::AdjustError>

impl<I, A> Traversable<I, A> for f32

type InspectError = Infallible

type AdjustError = Infallible

fn inspect(&self, _visitor: &mut I) -> Result<(), Self::InspectError>

fn adjust(&mut self, _visitor: &mut A) -> Result<(), Self::AdjustError>

impl<I, A> Traversable<I, A> for f64

type InspectError = Infallible

type AdjustError = Infallible

fn inspect(&self, _visitor: &mut I) -> Result<(), Self::InspectError>

fn adjust(&mut self, _visitor: &mut A) -> Result<(), Self::AdjustError>

impl<I, A> Traversable<I, A> for i8

type InspectError = Infallible

type AdjustError = Infallible

fn inspect(&self, _visitor: &mut I) -> Result<(), Self::InspectError>

fn adjust(&mut self, _visitor: &mut A) -> Result<(), Self::AdjustError>

impl<I, A> Traversable<I, A> for i16

type InspectError = Infallible

type AdjustError = Infallible

fn inspect(&self, _visitor: &mut I) -> Result<(), Self::InspectError>

fn adjust(&mut self, _visitor: &mut A) -> Result<(), Self::AdjustError>

impl<I, A> Traversable<I, A> for i32

type InspectError = Infallible

type AdjustError = Infallible

fn inspect(&self, _visitor: &mut I) -> Result<(), Self::InspectError>

fn adjust(&mut self, _visitor: &mut A) -> Result<(), Self::AdjustError>

impl<I, A> Traversable<I, A> for i64

type InspectError = Infallible

type AdjustError = Infallible

fn inspect(&self, _visitor: &mut I) -> Result<(), Self::InspectError>

fn adjust(&mut self, _visitor: &mut A) -> Result<(), Self::AdjustError>

impl<I, A> Traversable<I, A> for i128

type InspectError = Infallible

type AdjustError = Infallible

fn inspect(&self, _visitor: &mut I) -> Result<(), Self::InspectError>

fn adjust(&mut self, _visitor: &mut A) -> Result<(), Self::AdjustError>

impl<I, A> Traversable<I, A> for isize

type InspectError = Infallible

type AdjustError = Infallible

fn inspect(&self, _visitor: &mut I) -> Result<(), Self::InspectError>

fn adjust(&mut self, _visitor: &mut A) -> Result<(), Self::AdjustError>

impl<I, A> Traversable<I, A> for u8

type InspectError = Infallible

type AdjustError = Infallible

fn inspect(&self, _visitor: &mut I) -> Result<(), Self::InspectError>

fn adjust(&mut self, _visitor: &mut A) -> Result<(), Self::AdjustError>

impl<I, A> Traversable<I, A> for u16

type InspectError = Infallible

type AdjustError = Infallible

fn inspect(&self, _visitor: &mut I) -> Result<(), Self::InspectError>

fn adjust(&mut self, _visitor: &mut A) -> Result<(), Self::AdjustError>

impl<I, A> Traversable<I, A> for u32

type InspectError = Infallible

type AdjustError = Infallible

fn inspect(&self, _visitor: &mut I) -> Result<(), Self::InspectError>

fn adjust(&mut self, _visitor: &mut A) -> Result<(), Self::AdjustError>

impl<I, A> Traversable<I, A> for u64

type InspectError = Infallible

type AdjustError = Infallible

fn inspect(&self, _visitor: &mut I) -> Result<(), Self::InspectError>

fn adjust(&mut self, _visitor: &mut A) -> Result<(), Self::AdjustError>

impl<I, A> Traversable<I, A> for u128

type InspectError = Infallible

type AdjustError = Infallible

fn inspect(&self, _visitor: &mut I) -> Result<(), Self::InspectError>

fn adjust(&mut self, _visitor: &mut A) -> Result<(), Self::AdjustError>

impl<I, A> Traversable<I, A> for ()

type InspectError = Infallible

type AdjustError = Infallible

fn inspect(&self, _visitor: &mut I) -> Result<(), Self::InspectError>

fn adjust(&mut self, _visitor: &mut A) -> Result<(), Self::AdjustError>

impl<I, A> Traversable<I, A> for usize

type InspectError = Infallible

type AdjustError = Infallible

fn inspect(&self, _visitor: &mut I) -> Result<(), Self::InspectError>

fn adjust(&mut self, _visitor: &mut A) -> Result<(), Self::AdjustError>

impl<L, R, I, A> Traversable<I, A> for Either<L, R>

where L: Traversable<I, A>, R: Traversable<I, A>,

type AdjustError = Box<dyn Error + Sync + Send>

type InspectError = Box<dyn Error + Sync + Send>

fn inspect(&self, visitor: &mut I) -> Result<(), Self::InspectError>

fn adjust(&mut self, visitor: &mut A) -> Result<(), Self::AdjustError>

impl<T, E, I, A> Traversable<I, A> for Result<T, E>

where T: Traversable<I, A>, E: Traversable<I, A>,

type AdjustError = Box<dyn Error + Sync + Send>

type InspectError = Box<dyn Error + Sync + Send>

fn inspect(&self, visitor: &mut I) -> Result<(), Self::InspectError>

fn adjust(&mut self, visitor: &mut A) -> Result<(), Self::AdjustError>

impl<T, I, A> Traversable<I, A> for Option<T>

where T: Traversable<I, A>,

type AdjustError = <T as Traversable<I, A>>::AdjustError

type InspectError = <T as Traversable<I, A>>::InspectError

fn inspect(&self, visitor: &mut I) -> Result<(), Self::InspectError>

fn adjust(&mut self, visitor: &mut A) -> Result<(), Self::AdjustError>

impl<T, I, A> Traversable<I, A> for Vec<T>

where T: Traversable<I, A>,

type AdjustError = <T as Traversable<I, A>>::AdjustError

type InspectError = <T as Traversable<I, A>>::InspectError

fn inspect(&self, visitor: &mut I) -> Result<(), Self::InspectError>

fn adjust(&mut self, visitor: &mut A) -> Result<(), Self::AdjustError>

impl<T, const S: usize, I, A> Traversable<I, A> for [T; S]

where T: Traversable<I, A>,

type AdjustError = <T as Traversable<I, A>>::AdjustError

type InspectError = <T as Traversable<I, A>>::InspectError

fn inspect(&self, visitor: &mut I) -> Result<(), Self::InspectError>

fn adjust(&mut self, visitor: &mut A) -> Result<(), Self::AdjustError>

Implementors