Enum wood::Wood

pub enum Wood {
    Branchv(Branch),
    Leafv(Leaf),
}

Variants

Branchv(Branch)

Leafv(Leaf)

Implementations

impl Wood

pub fn leaf(v: String) -> Wood

pub fn branch(v: Vec<Wood>) -> Wood

pub fn empty() -> Wood

pub fn is_leaf(&self) -> bool

pub fn is_branch(&self) -> bool

pub fn what(&self) -> LB<'_>

pub fn get_leaf(&self) -> Option<&str>

pub fn get_branch(&self) -> Option<&[Wood]>

pub fn line_and_col(&self) -> (isize, isize)

pub fn line(&self) -> isize

pub fn col(&self) -> isize

pub fn initial_str(&self) -> &str

Seeks the earliest string in the tree by looking at the first element of each branch recursively until it hits a leaf. (If it runs into an empty list, returns the empty string. I recommend this whenever you want to use the first string as a discriminator, or whenever you want to get leaf str contents in general. This abstracts over similar structures in a way that I consider generally desirable. I would go as far as to say that the more obvious, less abstract way of getting initial string should be Considered Harmful. A few motivating examples: If you wanted to add a feature to a programming language that allows you to add a special tag to an invocation, you want to put the tag inside the invocation’s ast node but you don’t want it to be confused for a parameter, this pattern enables: ((f tag(special_invoke_inline)) a b) If the syntax of a sexp language had more structure to it than usual: ((if condition) then…) would still get easily picked up as an ‘if’ node. Annotations are a good example, more generally, if you’re refactoring and you decide you want to add an extra field to what was previously a leaf, this pattern enables you to make that change, confident that your code will still read its string content in the same way (list key:value “some prose”) -> (list key:value (“some prose” modifier:italicise))

pub fn to_string(&self) -> String

pub fn strip_comments_escape( &mut self, comment_str: &str, comment_escape_str: &str )

pub fn strip_comments(&mut self, comment_str: &str)

Strips any branches with first element of comment_str. If you need to produce a leaf that is equivalent to comment_str. If you need the wood to contain a leaf that is the comment_str, you can escape it with a backslash. This is actually a highly flawed way of providing commenting, because this will also strip out any serialization of a list of strings where the first element happens to equal the comment_str. That’s a really subtle error, that violates a lot of expectations. You could get around it by escaping your wood so that any strs that resemble comment tags wont read that way, but it’s a bit awkward and sometimes wont really work.

pub fn contents(&self) -> Iter<'_, Self>

if Leaf, returns a slice iter containing just this, else Branch, iterates over branch contents

pub fn head(&self) -> Result<&Wood, Box<WoodError>>

returns the first wood, or if it’s a leaf, itself

pub fn second(&self) -> Result<&Wood, Box<WoodError>>

returns the second wood within this one, if it is a list wood, if there is a second wood

pub fn tail<'b>(&'b self) -> Iter<'b, Self>

if Leaf, returns an empty slice iter, if Branch, returns contents after the first element

pub fn flatter_tail<'a>(&'a self) -> Chain<Iter<'a, Self>, Iter<'a, Self>>

returns the tail of the first element of the wood chained with the rest of the wood. For dealing with a common situation with the termpose syntax where you want to ignore the structure of initial line items

call a b car
  dog
  entropy
  foreign_adversary

in this case, flatter_tail would give you [a, b, car, dog, entropy, foreign_adversary]. (by contrast, tail would only give you [dog, entropy, foreign_adversary])

pub fn seek<'a, 'b>(&'a self, key: &'b str) -> Option<&'a Wood>

self.contents().find(|el| el.initial_str() == key)

pub fn seek_val<'a, 'b>(&'a self, key: &'b str) -> Option<&'a Wood>

pub fn find<'a, 'b>(&'a self, key: &'b str) -> Result<&'a Wood, Box<WoodError>>

returns the first child term with initial_str == key, or if none is found, an error

pub fn find_val<'a, 'b>( &'a self, key: &'b str ) -> Result<&'a Wood, Box<WoodError>>

find(self, key).and_then(|v| v.second())

Trait Implementations

impl Clone for Wood

fn clone(&self) -> Wood

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Wood

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

Formats the value using the given formatter.

impl<'a> From<&'a str> for Wood

fn from(v: &'a str) -> Wood

Converts to this type from the input type.

impl From<String> for Wood

fn from(v: String) -> Wood

Converts to this type from the input type.

impl From<Vec<Wood>> for Wood

fn from(v: Vec<Wood>) -> Wood

Converts to this type from the input type.

impl PartialEq for Wood

Line numbers aren’t checked in equality comparisons

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for Wood