Struct libunseemly::form::Form

pub struct Form {
    pub name: Name,
    pub grammar: Rc<FormPat>,
    pub type_compare: BiDiWR<Canonicalize, Subtype>,
    pub synth_type: BiDiWR<SynthTy, UnpackTy>,
    pub eval: BiDiWR<Eval, Destructure>,
    pub quasiquote: BiDiWR<QQuote, QQuoteDestr>,
}

Unseemly language form. This is what tells us what a particular Node actually does.

Fields

name: Name

The name of the form. Mainly for internal use.

grammar: Rc<FormPat>

The grammar the programmer should use to invoke this form. This contains information about bindings and syntax extension:

type_compare: BiDiWR<Canonicalize, Subtype>

(Meaningful for types only) Subtype.

synth_type: BiDiWR<SynthTy, UnpackTy>

From a type environment, construct the type of this term.

eval: BiDiWR<Eval, Destructure>

(Meaningful for exprs and pats only) From a value environment, evaluate this term. Or, (HACK) macro expansion, for macro invocations (just so we don’t need another field)

quasiquote: BiDiWR<QQuote, QQuoteDestr>

At runtime, pick up code to use it as a value

Trait Implementations

impl Debug for Form

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

Formats the value using the given formatter.

impl PartialEq<Form> for Form

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

pointer equality on the underlying structure!

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

This method tests for !=.

impl<'t> Reifiable for Form

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.