Enum rosary::RoseTree

pub enum RoseTree<V> {
    Leaf(V),
    Branch(V, Vec<RoseTree<V>>),
}

Variants

Leaf(V)

A simple (and almost certainly terribly inefficient) Rose Tree implementation. A dead end node, single value.

Branch(V, Vec<RoseTree<V>>)

A branch has a head value, and then all its child values.

Implementations

impl<V> RoseTree<V>

pub fn leaf(val: V) -> Self

Constructors, because I don’t know how to make From do this for me.

pub fn branch<I: Iterator<Item = V>>(val: V, children: I) -> Self

pub fn ref_tree(&self) -> RoseTree<&V>

Creates a tree of the same structure as self where every node is a reference to the corresponding node in the owning tree.

pub fn is_leaf(&self) -> bool

These three check if a RoseTree is of a given variant.

pub fn is_branch(&self) -> bool

pub fn size(&self) -> usize

Calculates the number of nodes in the tree.

pub fn head(&self) -> Option<&V>

Retrieves a reference to the head of the tree.

pub fn head_mut(&mut self) -> Option<&mut V>

pub fn children(&self) -> Option<&Vec<RoseTree<V>>>

Gets the children of a branch directly, if it is a branch.

pub fn children_mut(&mut self) -> Option<&mut Vec<RoseTree<V>>>

pub fn swap_head(self, new_head: V) -> Self

Swaps out the head-most value of the tree with the provided one.

pub fn add_child(self, child: V) -> Self

Adds a child to specifically a Branch node.

pub fn map_head(self, head_fn: fn(_: V) -> V) -> Self

pub fn map_leaves(self, child_fn: fn(_: V) -> V) -> Self

Map over only the leaves of the tree.

pub fn map<U>(&self, func: fn(_: &V) -> U) -> RoseTree<U>

Map over the whole tree.

pub fn map_into<U>(self, func: fn(_: V) -> U) -> RoseTree<U>

pub fn depth_map<A: Clone, U>(
    &self,
    initial: A,
    func: fn(_: A, _: &V) -> (A, U)
) -> RoseTree<U>

Maps over the tree, where each child of the same parent receives the same accumulator value as a function argument. Add more variants of this for different argument mutabilities maybe?

pub fn filter<F: Fn(&V) -> bool>(self, func: F) -> Option<Self>

Removes all values from the tree which don’t satisfy the predicate. In the case of branches, if the head of the branch does not satisfy the predicate, both it and all its children are removed.

pub fn preorder_iter<'a>(&'a self) -> PreorderRoseIter<'_, V>

Trait Implementations

impl<V: Clone> Clone for RoseTree<V>

fn clone(&self) -> RoseTree<V>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<V: Debug> Debug for RoseTree<V>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<V: Display> Display for RoseTree<V>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<V: Eq> Eq for RoseTree<V>

impl<V, I: IntoIterator<Item = V>> From<(V, I)> for RoseTree<V>

fn from((head, child_collection): (V, I)) -> RoseTree<V>

Convenience to make wrapping anything in a Branch nicer(I know, shocking).

impl<V> From<V> for RoseTree<V>

fn from(val: V) -> Self

Convenience function to make wrapping anything in a leaf nicer.

impl<V: PartialEq> PartialEq<RoseTree<V>> for RoseTree<V>

fn eq(&self, other: &Self) -> bool

It’d be really nice to be able to check equality of variants independently of the values within the variants, but I have no idea how or if that’s possible.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<V> StructuralEq for RoseTree<V>

impl<T: Display> TreeFormat for RoseTree<T>

If you’re a RoseTree, you get TreeFormat for free so long as T can be printed. If printing T involves printing newlines, don’t. It’ll get weird.

fn treeify(&self) -> RoseTree<String>

The only thing you need to define is the conversion from your type to a RoseTree.

fn indent(&self) -> RoseTree<String>

Indent adds the decorations to the strings of the tree with the default formatter.

fn fmt_tree(&self) -> String

Actually converts the tree into a single string for printing.