Struct RazTree 

pub struct RazTree<E: 'static + Debug + Clone + Eq + Hash, M: RazMeta<E> + 'static> { /* private fields */ }

Tree form of a RAZ

used between refocusing, and for running global algorithms

Implementations

impl<E: Debug + Clone + Eq + Hash + 'static, M: RazMeta<E>> RazTree<E, M>

pub fn meta(&self) -> &M

get the meta data

pub fn is_empty(&self) -> bool

pub fn empty() -> Self

create a new RazTree with no data

pub fn join( ltree: Self, level: u32, name: Option<Name>, rtree: Self, ) -> Option<Self>

Combine two trees left to right

returns None if either tree is empty.

pub fn from_vec(vec: Vec<E>) -> Option<Self>

Make a RazTree from a Vec

This tree will contain no levels or names Returns None if the Vec is empty

pub fn fold_up<I, R, B>(self, init: Rc<I>, bin: Rc<B>) -> Option<R>

where R: 'static + Eq + Clone + Hash + Debug, I: 'static + Fn(&E) -> R, B: 'static + Fn(R, R) -> R,

Runs an incremental binary function over the sequence data

This is calculated from data in leaves of a tree structure, so the operation must be associative. Returns None if there are no elements.

pub fn fold_up_nl<I, R, B, N>( self, init: Rc<I>, bin: Rc<B>, binnl: Rc<N>, ) -> Option<R>

where R: 'static + Eq + Clone + Hash + Debug, I: 'static + Fn(&E) -> R, B: 'static + Fn(R, R) -> R, N: 'static + Fn(R, u32, Option<Name>, R) -> R,

Runs an incremental binary function over the sequence data, levels, and names

This is calculated from data in leaves of a tree structure, so the operation must be associative. Returns None if there are no elements.

pub fn fold_up_gauged<I, R, B>(self, init: Rc<I>, bin: Rc<B>) -> Option<R>

where R: 'static + Eq + Clone + Hash + Debug, I: 'static + Fn(&Vec<E>) -> R, B: 'static + Fn(R, u32, Option<Name>, R) -> R,

Runs an incremental binary function over subsequences, levels, and names

Subsequences allow potential for optimization. The binary function still operates on the results from the subsequence conputation.

pub fn fold_lr<A, B>(self, init: A, bin: Rc<B>) -> A

where A: 'static + Eq + Clone + Hash + Debug, B: 'static + Fn(A, &E) -> A,

Runs an incremental fold over the sequence, left to right

pub fn fold_lr_meta<A, B, N>(self, init: A, bin: Rc<B>, meta: Rc<N>) -> A

where A: 'static + Eq + Clone + Hash + Debug, B: 'static + Fn(A, &E) -> A, N: 'static + Fn(A, (u32, Option<Name>)) -> A,

left-to-right memoized fold with levels and names

pub fn fold_lr_archive<A, B, F, N>( self, init: A, bin: Rc<B>, finbin: Rc<F>, meta: Rc<N>, ) -> A

where A: 'static + Eq + Clone + Hash + Debug, B: 'static + Fn(A, &E) -> A, F: 'static + Fn(A, Option<Name>) -> A, N: 'static + Fn(A, u32) -> A,

left-to-right incremental fold with levels and names, with a name provided at the leaf

pub fn map<R, F, N: RazMeta<R>>(self, f: Rc<F>) -> RazTree<R, N>

where R: 'static + Eq + Clone + Hash + Debug, F: 'static + Fn(&E) -> R,

An incremental mapping of the tree, returning a new tree

pub fn focus<I: Into<M::Index>>(self, index: I) -> Option<Raz<E, M>>

focus on a location in the sequence to begin editing.

pub fn focus_left(self) -> Raz<E, M>

focus on the first element in the sequence

Trait Implementations

impl<E: Clone + 'static + Debug + Clone + Eq + Hash, M: Clone + RazMeta<E> + 'static> Clone for RazTree<E, M>

fn clone(&self) -> RazTree<E, M>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: Debug + 'static + Debug + Clone + Eq + Hash, M: Debug + RazMeta<E> + 'static> Debug for RazTree<E, M>

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

Formats the value using the given formatter.

impl<E: Hash + 'static + Debug + Clone + Eq + Hash, M: Hash + RazMeta<E> + 'static> Hash for RazTree<E, M>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<E: Debug + Clone + Eq + Hash + 'static, M: RazMeta<E>> MemoFrom<AtHead<E, u32>> for RazTree<E, M>

fn memo_from(headstack: &AtHead<E, u32>) -> Self

impl<E: Debug + Clone + Eq + Hash + 'static, M: RazMeta<E>> MemoFrom<AtTail<E, u32>> for RazTree<E, M>

fn memo_from(tailstack: &AtTail<E, u32>) -> Self

impl<E: PartialEq + 'static + Debug + Clone + Eq + Hash, M: PartialEq + RazMeta<E> + 'static> PartialEq for RazTree<E, M>

fn eq(&self, other: &RazTree<E, M>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<E: Eq + 'static + Debug + Clone + Eq + Hash, M: Eq + RazMeta<E> + 'static> Eq for RazTree<E, M>

impl<E: 'static + Debug + Clone + Eq + Hash, M: RazMeta<E> + 'static> StructuralPartialEq for RazTree<E, M>