Enum GreenTree 

pub enum GreenTree<'a, L: Language> {
    Node(&'a GreenNode<'a, L>),
    Leaf(GreenLeaf<L>),
}

A green tree element - either a node or a leaf kind.

Green trees represent the immutable structure of kind trees without position information.

Design Note: Lifetimes and References

We use &'a GreenNode<'a, L> instead of an owned GreenNode<'a, L> for two reasons:

1. Recursion: GreenTree is a recursive structure. To avoid infinite size, we must use a pointer. Since green nodes are allocated in an arena, a reference &'a is the most efficient choice.
2. Handles: Holding a reference (8 bytes) is much cheaper than holding the whole GreenNode struct (24+ bytes), making handles like RedNode very lightweight.

Variants

Node(&'a GreenNode<'a, L>)

A green node with child elements

Leaf(GreenLeaf<L>)

A green leaf kind

Implementations

impl<'a, L: Language> GreenTree<'a, L>

pub fn len(&self) -> u32

Returns the total byte length of this green tree element.

For nodes, this is the sum of all children’s lengths. For leaves, this is the length of the token.

pub fn is_node(&self) -> bool

Checks if this green tree element is a node.

pub fn is_leaf(&self) -> bool

Checks if this green tree element is a leaf.

pub fn as_node(&self) -> Option<&'a GreenNode<'a, L>>

Returns the element as a node if it is one.

pub fn as_leaf(&self) -> Option<GreenLeaf<L>>

Returns the element as a leaf if it is one.

Trait Implementations

impl<'a, L: Language> Clone for GreenTree<'a, L>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, L: Language> Debug for GreenTree<'a, L>

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

Formats the value using the given formatter.

impl<'a, L: Language> Hash for GreenTree<'a, L>

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<'a, L: Language> PartialEq for GreenTree<'a, L>

fn eq(&self, other: &Self) -> 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<'a, L: Language> Copy for GreenTree<'a, L>

impl<'a, L: Language> Eq for GreenTree<'a, L>