Enum Expression 

pub enum Expression {
    Named {
        name: Name,
        sub: Tree,
    },
    Format {
        style: CompleteStyle,
        sub: Tree,
    },
    Group {
        d: Delimiter,
        sub: Tree,
    },
    Literal(String),
    Separator(Separator),
}

The types of possible expressions which form an expression tree

The gist format has three types of valid expressions:

1. Named expressions
2. Group Expressions
3. Literal Expressions

The interpreter transforms these expressions to their final output after they have been parsed from the input string.

Named expressions take one of two forms: the plain form with no arguments, or with arguments

• name plain form
• name(exp1exp2...exp3) any number of expressions

Group expressions are set of expressions, which are not comma seperated. There are a few base group types:

• \() parentheses - wrap with parens
• \{} curly braces - wrap with curly braces
• \[] square brackets - wrap contents with square brackets
• \<> angle brackets - wrap contenst with angle brackets

By nesting groups of expressions, we can create an implicit tree.

A literal expression is any valid utf8 characters between single quites, except for single quotes and backslashes.

'hello''we''are''literal''expressions''I am one including whitespace'

Variants

Named

An expression with a name and optional arguments which represents git repository stats

Fields

name: Name

Name of the expression

sub: Tree

Arguments to the expression, zero or more

Format

An expression which represents terminal text formatting

Fields

style: CompleteStyle

sub: Tree

Group

A group of sub-expressions which forms an expression tree

Fields

d: Delimiter

Group delimiter type, [], <>, {}, or ()

sub: Tree

A tree of sub expressions

Literal(String)

Literal characters including whitespace, surrounded by single quotes

Separator(Separator)

Separator between elements in a tree

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl Display for Expression

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

Formats the value using the given formatter.

impl Eq for Expression

impl PartialEq for Expression

fn eq(&self, other: &Expression) -> 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 StructuralPartialEq for Expression