pub mod walkers;

use crate::{
    effect::{Effect, Future},
    protocol::Visitor,
};

/// A type that can be walked.
pub trait Walk<'ctx>: WalkerTypes<'ctx> + Sized {
    /// The walker for the type.
    type Walker<E: Effect<'ctx>>: Walker<'ctx, Error = Self::Error, Output = Self::Output, Effect = E>;

    fn into_walker<E: Effect<'ctx>>(self) -> Self::Walker<E>;
}

pub trait WalkerTypes<'ctx> {
    type Error: Send;

    /// An arbitrary type the walker is left with after walking.
    ///
    /// Its recommended that this is `Self` if the walker is repeatable.
    type Output: Send;
}

/// Walker for a type.
///
/// The `'ctx` lifetime is some lifetime that is longer than `Self`.
/// Data from the value may borrow using `'ctx`.
///
/// The way to use a walker is as follows.
/// - Call [From::from()] with a value to be walked to make a walker.
/// - Call [Self::walk()] to walk the value. Data will be sent to the provided
///     visitor.
pub trait Walker<'ctx>: WalkerTypes<'ctx> + Send {
    type Effect: Effect<'ctx>;

    /// Walk the value.
    ///
    /// The walker should send data to the `visitor` as it walks the value.
    fn walk<'a>(
        self,
        visitor: Visitor<'a, 'ctx>,
    ) -> Future<'a, 'ctx, Result<Self::Output, Self::Error>, Self::Effect>
    where
        Self: 'a;
}