Struct TraverseMut 

pub struct TraverseMut<'a, T, S> { /* private fields */ }

Implements the traverse algorithms for a mutable reference of a Node.

Implementations

impl<'a, T> TraverseMut<'a, T, Asynchronous>

pub fn into_sync(self) -> TraverseMut<'a, T, Synchronous>

Converts the asynchronous traverse into a synchronous one.

impl<'a, T: Sync + Send + 'a> TraverseMut<'a, T, Asynchronous>

pub async fn for_each<F>(self, f: F)

where F: Fn(&mut Node<T>) + Sync + Send,

Calls the given closure for each node in the tree rooted by self.

pub async fn map<F, R>(self, f: F) -> TraverseOwned<R, Asynchronous>

where F: Fn(&mut Node<T>) -> R + Sync + Send, R: Sized + Sync + Send,

Builds a new tree by calling the given closure along the tree rooted by self following the pre-order traversal.

pub async fn reduce<F, R>(self, f: F) -> R

where F: Fn(&mut Node<T>, Vec<R>) -> R + Sync + Send, R: Sized + Sync + Send,

Calls the given closure along the tree rooted by self, reducing it into a single value.

pub async fn cascade<F, R>(self, base: R, f: F)

where F: Fn(&mut Node<T>, &R) -> R + Sync + Send, R: Sized + Sync + Send,

Calls the given closure along the tree rooted by self, providing the parent’s data to its children.

impl<'a, T> TraverseMut<'a, T, Synchronous>

where T: Sync + Send,

pub fn into_async(self) -> TraverseMut<'a, T, Asynchronous>

impl<'a, T> TraverseMut<'a, T, Synchronous>

pub fn for_each<F>(self, f: F) -> Self

where F: FnMut(&mut Node<T>),

Traverses the tree rooted by self in post-order, calling the given closure along the way.

pub fn map<F, R>(self, f: F) -> TraverseOwned<R, Synchronous>

where F: FnMut(&mut Node<T>) -> R,

Traverses the tree rooted by self in pre-order, building a new tree by calling the given closure along the way.

pub fn reduce<F, R>(self, f: F) -> R

where F: FnMut(&mut Node<T>, Vec<R>) -> R, R: Sized,

Traverses the tree rooted by self in post-order, calling the given closure along the way and providing its results from children to parent.

pub fn cascade<F, R>(self, base: R, f: F) -> Self

where F: FnMut(&mut Node<T>, &R) -> R, R: Sized,

Traverses the tree rooted by self in pre-order, calling the given closure along the way and providing its result from parent to children.

impl<'a, T, S> TraverseMut<'a, T, S>

pub fn node(&self) -> &Node<T>

pub fn node_mut(&mut self) -> &mut Node<T>

pub fn pre(self) -> InPreMut<'a, T, S>

Returns the pre-order traversal entity for the tree.

pub fn post(self) -> InPostMut<'a, T, S>

Returns the post-order traversal entity for the tree.

Trait Implementations

impl<'a, T, S> From<&'a mut Node<T>> for TraverseMut<'a, T, S>

fn from(node: &'a mut Node<T>) -> Self

Converts to this type from the input type.

impl<'a, T> From<TraverseMut<'a, T, Asynchronous>> for TraverseMut<'a, T, Synchronous>

fn from(value: TraverseMut<'a, T, Asynchronous>) -> Self

Converts to this type from the input type.

impl<'a, T> From<TraverseMut<'a, T, Synchronous>> for TraverseMut<'a, T, Asynchronous>

where T: Sync + Send,

fn from(value: TraverseMut<'a, T, Synchronous>) -> Self

Converts to this type from the input type.