Struct libunseemly::ast_walk::LazyWalkReses

pub struct LazyWalkReses<Mode: WalkMode> {
    pub parts: EnvMBE<Rc<LazilyWalkedTerm<Mode>>>,
    pub env: ResEnv<Mode::Elt>,
    pub prelude_env: ResEnv<Mode::Elt>,
    pub more_quoted_env: Vec<ResEnv<Mode::Elt>>,
    pub less_quoted_env: Vec<ResEnv<Mode::Elt>>,
    pub less_quoted_out_env: Vec<Option<OutEnvHandle<Mode>>>,
    pub this_ast: Ast,
    pub extra_info: Mode::ExtraInfo,
}

Package containing enough information to walk the subforms of some form on-demand.

It is safe to have unwalkable subforms, as long as nothing ever refers to them.

Contents probably shouldn’t be pub…

Fields

parts: EnvMBE<Rc<LazilyWalkedTerm<Mode>>>

Things that we have walked and that we might walk

env: ResEnv<Mode::Elt>

The environment of the overall walk.

prelude_env: ResEnv<Mode::Elt>

The environment to use when entering a new phase. It’s like a prelude, except that it’s affected by syntax extensions.

more_quoted_env: Vec<ResEnv<Mode::Elt>>

The environment for syntax quotation (deeper on the front, shallower on the back)

less_quoted_env: Vec<ResEnv<Mode::Elt>>

The environment for interpolation (further out on the front, nearer on the back)

less_quoted_out_env: Vec<Option<OutEnvHandle<Mode>>>

For all the less-quoted walks ongoing whose direction is negative, we need to smuggle out results. This is a stack of (optional, because not all walks are negative) mutable handles to the environments being accumulated.

this_ast: Ast

extra_info: Mode::ExtraInfo

Implementations

impl<Mode: WalkMode> LazyWalkReses<Mode>

pub fn new(
    env: ResEnv<Mode::Elt>,
    prelude_env: ResEnv<Mode::Elt>,
    this_ast: Ast
) -> LazyWalkReses<Mode>

pub fn new_wrapper(env: ResEnv<Mode::Elt>) -> LazyWalkReses<Mode>

Slight hack: this is just to get a recursion started with some environment. Only use this in tests or at the top level; this discards any non-phase-0-environments!

pub fn new_mq_wrapper(
    env: ResEnv<Mode::Elt>,
    mqe: Vec<ResEnv<Mode::Elt>>
) -> LazyWalkReses<Mode>

pub fn new_empty() -> LazyWalkReses<Mode>

pub fn switch_ast(
    self,
    parts: &EnvMBE<Ast>,
    this_ast: Ast
) -> LazyWalkReses<Mode>

pub fn this_form(&self) -> Rc<Form>

pub fn get_res(
    &self,
    part_name: Name
) -> Result<<Mode::D as Dir>::Out, Mode::Err>

The result of walking the subform named part_name. This is memoized.

pub fn has(&self, part_name: Name) -> bool

Will get_res or get_term panic? Rarely used, because a form typically knows which named subterms it has based on parsing.

pub fn get_rep_res(
    &self,
    part_name: Name
) -> Result<Vec<<Mode::D as Dir>::Out>, Mode::Err>

Like get_res, but for subforms that are repeated at depth 1. Sort of a hack.

pub fn flatten_res_at_depth(
    &self,
    part_name: Name,
    depth: u8,
    map: &dyn Fn(<Mode::D as Dir>::Out) -> <Mode::D as Dir>::Out,
    flatten: &dyn Fn(Vec<<Mode::D as Dir>::Out>) -> <Mode::D as Dir>::Out
) -> Result<<Mode::D as Dir>::Out, Mode::Err>

Like get_res, but with depth levels of repetition, and calling f to flatten the result

pub fn flatten_generate_at_depth(
    &self,
    part_name: Name,
    depth: u8,
    generate: &dyn Fn() -> <Mode::D as Dir>::Out,
    flatten: &dyn Fn(Vec<<Mode::D as Dir>::Out>) -> <Mode::D as Dir>::Out
) -> <Mode::D as Dir>::Out

Like flatten_res_at_depth, but uses leaf instead of doing get_res TODO: this is used in only one place, and feels really awkward.

pub fn map_flatten_term_at_depth<S>(
    &self,
    part_name: Name,
    depth: u8,
    m: &dyn Fn(&Ast) -> S,
    f: &dyn Fn(Vec<S>) -> S
) -> S

Like get_term, but with depth levels of repetition, and calling m to map and f to flatten the result

pub fn get_term(&self, part_name: Name) -> Ast

The subform named part_name, without any processing.

pub fn maybe_get_term(&self, part_name: Name) -> Option<Ast>

Only needed if, for some reason, a form could occur with or without a particular term. (a hack involving “mu_type” and “opacity_for_different_phase” does this)

pub fn get_term_ref(&self, part_name: Name) -> &Ast

pub fn get_rep_term(&self, part_name: Name) -> Vec<Ast>

pub fn context_elt(&self) -> &Mode::Elt

Only sensible for negative walks

pub fn maybe__context_elt(&self) -> Option<Mode::Elt>

pub fn with_context(&self, e: Mode::Elt) -> LazyWalkReses<Mode>

Change the context (by editing the environment). Only sensible for negative walks. Don’t do .with_context(…).with_environment(…); it’s the same as .with_environment(…).

pub fn with_environment(&self, env: ResEnv<Mode::Elt>) -> LazyWalkReses<Mode>

Change the whole environment

pub fn with_prelude_environment(
    &self,
    prelude_env: ResEnv<Mode::Elt>
) -> LazyWalkReses<Mode>

Change the prelude environment

pub fn clear_memo(&self)

Clear the memo table; important if you’re re-evaluating the same term, but have changed the environment

pub fn switch_mode<NewMode: WalkMode<Elt = Mode::Elt, ExtraInfo = Mode::ExtraInfo>>(
    &self
) -> LazyWalkReses<NewMode>

Switch to a different mode with the same Elt type.

pub fn switch_to_positive(
    &self
) -> LazyWalkReses<<Mode as WalkMode>::AsPositive>

If Mode is positive, returns self. If Mode is negative, switch_modes it to be positive

pub fn switch_to_negative(
    &self
) -> LazyWalkReses<<Mode as WalkMode>::AsNegative>

If Mode is negative, returns self. If Mode is positive, switch_modes it to be negative

pub fn quote_more(self, oeh: Option<OutEnvHandle<Mode>>) -> LazyWalkReses<Mode>

pub fn quote_less(self) -> (Option<OutEnvHandle<Mode>>, LazyWalkReses<Mode>)

Shift to a less-quoted level. If the OEH is non-None, you need to call squirrel_away.

pub fn march_parts(&self, driving_names: &[Name]) -> Vec<LazyWalkReses<Mode>>

March by example, turning a repeated set of part names into one LWR per repetition. Keeps the same environment.

pub fn march_all(&self, driving_names: &[Name]) -> Vec<LazyWalkReses<Mode>>

HACK: The mbe_one_name! macro expects a type with march_all (it can accept both LazyWalkReses and EnvMBE). But, for LazyWalkReses, prefer march_parts, so don’t use this ) :

pub fn march_parts_with(
    &self,
    driving_names: &[Name],
    new_contexts: Vec<Mode::Elt>
) -> Option<Vec<LazyWalkReses<Mode>>>

Combines march_parts and with_context. new_contexts should have the same length as the repetition marched.

pub fn map_terms<F, E: Clone>(self, f: &mut F) -> Result<LazyWalkReses<Mode>, E> where
    F: FnMut(Name, &Ast) -> Result<Ast, E>, 

pub fn get_rep_res_with(
    &self,
    n: Name,
    new_contexts: Vec<Mode::Elt>
) -> Result<Vec<<Mode::D as Dir>::Out>, Mode::Err>

Like get_rep_res, but with a different context for each repetition

Trait Implementations

impl<Mode: Clone + WalkMode> Clone for LazyWalkReses<Mode> where
    Mode::Elt: Clone,
    Mode::Elt: Clone,
    Mode::Elt: Clone,
    Mode::Elt: Clone,
    Mode::ExtraInfo: Clone, 

fn clone(&self) -> LazyWalkReses<Mode>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Mode: Debug + WalkMode> Debug for LazyWalkReses<Mode> where
    Mode::Elt: Debug,
    Mode::Elt: Debug,
    Mode::Elt: Debug,
    Mode::Elt: Debug,
    Mode::ExtraInfo: Debug, 

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

Formats the value using the given formatter.

impl<Mode: WalkMode> Reifiable for LazyWalkReses<Mode>

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() -> 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_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.