Enum libunseemly::grammar::FormPat

pub enum FormPat {
    Anyways(Ast),
    Impossible,
    Scan(Scanner, Option<String>),
    Common(Rc<FormPat>),
    Reserved(Rc<FormPat>, Vec<Name>),
    Literal(Rc<FormPat>, Name),
    VarRef(Rc<FormPat>),
    Seq(Vec<Rc<FormPat>>),
    Star(Rc<FormPat>),
    Plus(Rc<FormPat>),
    Alt(Vec<Rc<FormPat>>),
    Biased(Rc<FormPat>, Rc<FormPat>),
    Call(Name),
    SynImport(Rc<FormPat>, Rc<FormPat>, SyntaxExtension),
    Scope(Rc<Form>, ExportBeta),
    Named(Name, Rc<FormPat>),
    Pick(Rc<FormPat>, Name),
    NameImport(Rc<FormPat>, Beta),
    NameImportPhaseless(Rc<FormPat>, Beta),
    QuoteDeepen(Rc<FormPat>, bool),
    QuoteEscape(Rc<FormPat>, u8),
}

FormPat defines a pattern in a grammar. Think EBNF, but more extended. Most kinds of grammar nodes produce an Ast of either Shape or Env, but Named and Scope are special: everything outside of a Named (up to a Scope, if any) is discarded, and Scope produces a Node, which maps names to what they got.

Variants

Anyways(Ast)

Tuple Fields

0: Ast

Matches 0 tokens, produces the Ast

Impossible

Never matches

Scan(Scanner, Option<String>)

Tuple Fields

0: Scanner

1: Option<String>

Matches actual text! The regex must have a single capturing group. The optional string is a TextMate syntax category.

Common(Rc<FormPat>)

Tuple Fields

0: Rc<FormPat>

Marks this rule as too commonly-used to be informative; prevents display of this rule in parse errors,

Reserved(Rc<FormPat>, Vec<Name>)

Tuple Fields

0: Rc<FormPat>

1: Vec<Name>

Matches an atom or varref, but not if it’s on the list of reserved words

Literal(Rc<FormPat>, Name)

Tuple Fields

0: Rc<FormPat>

1: Name

Matches if the sub-pattern equals the given name

VarRef(Rc<FormPat>)

Tuple Fields

0: Rc<FormPat>

Matches an atom, turns it into a VariableReference

Seq(Vec<Rc<FormPat>>)

Tuple Fields

0: Vec<Rc<FormPat>>

Matches an ordered sequence of patterns.

Star(Rc<FormPat>)

Tuple Fields

0: Rc<FormPat>

Matches zero or more occurrences of a pattern.

Plus(Rc<FormPat>)

Tuple Fields

0: Rc<FormPat>

Matches one or more occurrences of a pattern.

Alt(Vec<Rc<FormPat>>)

Tuple Fields

0: Vec<Rc<FormPat>>

Matches any of the sub-pattersn.

Biased(Rc<FormPat>, Rc<FormPat>)

Tuple Fields

0: Rc<FormPat>

1: Rc<FormPat>

Matches the LHS pattern, or, failing that, the RHS pattern.

Call(Name)

Tuple Fields

0: Name

Lookup a nonterminal in the current syntactic environment.

SynImport(Rc<FormPat>, Rc<FormPat>, SyntaxExtension)

Tuple Fields

0: Rc<FormPat>

1: Rc<FormPat>

2: SyntaxExtension

This is where syntax gets extensible. Parses its body in the syntax environment computed from the LHS and the current syntax environment.

Scope(Rc<Form>, ExportBeta)

Tuple Fields

0: Rc<Form>

1: ExportBeta

Makes a node and limits the region where names are meaningful. Beta defines export.

Named(Name, Rc<FormPat>)

Tuple Fields

0: Name

1: Rc<FormPat>

Matches a pattern and gives it a name (inside the current Scope)

Pick(Rc<FormPat>, Name)

Tuple Fields

0: Rc<FormPat>

1: Name

Like a Scope, but just returns whatever has the given name

NameImport(Rc<FormPat>, Beta)

Tuple Fields

0: Rc<FormPat>

1: Beta

FOOTGUN: NameImport(Named(…), …) is almost always wrong. (write Named(NameImport(…, …)) instead) TODO: make this better

NameImportPhaseless(Rc<FormPat>, Beta)

Tuple Fields

0: Rc<FormPat>

1: Beta

Like NameImport, but affects all phases.

QuoteDeepen(Rc<FormPat>, bool)

Tuple Fields

0: Rc<FormPat>

1: bool

Quote syntax (the boolean indicates whether it’s positive or negative)

QuoteEscape(Rc<FormPat>, u8)

Tuple Fields

0: Rc<FormPat>

1: u8

Escape syntax quotation (by some number of levels)

Implementations

impl FormPat

pub fn mark_up(&self, pos: Option<usize>) -> String

pub fn binders(&self) -> Vec<(Name, u8)>

pub fn find_named_call(&self, n: Name) -> Option<Name>

pub fn textmate_categories(&self) -> Vec<(String, String)>

Map regular expressions (as strings) to their TextMate categories. This is a loose approximation of the impossible task of syntax-highlighting a FormPat.

Trait Implementations

impl Clone for FormPat

fn clone(&self) -> FormPat

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for FormPat

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

Formats the value using the given formatter.

impl Display for FormPat

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

Formats the value using the given formatter.

impl PartialEq<FormPat> for FormPat

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

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

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

This method tests for !=.

impl<'t> Reifiable for FormPat

fn ty() -> Ast

The Unseemly type that corresponds to to the Reifiable type. This leaves abstract the type parameters of Self; invoke like Self::<Irr,Irr>::ty(). e.g. ∀ A. Pair<A int> TODO: rename to generic_ty

fn ty_name() -> Name

A name for that type, so that recursive types are okay. Ignore the type parameters of Self; invoke like Self::<Irr,Irr>::ty_name(). e.g. WithInteger

fn concrete_arguments() -> Option<Vec<Ast>>

fn reify(&self) -> Value

The Unseemly value that corresponds to a value.

fn reflect(v: &Value) -> Self

Get a value from an Unseemly value

fn ty_invocation() -> Ast

How to refer to this type, given an environment in which ty_name() is defined to be ty(). Parameters will be concrete. e.g. WithInteger<Float> (Types using this type will use this, rather than ty) Don’t override this.

impl StructuralPartialEq for FormPat