Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
23 changes: 19 additions & 4 deletions src/evaluator/mod.rs
Original file line number Diff line number Diff line change
@@ -1,4 +1,5 @@
pub mod beta;
pub mod nbe;
pub mod strategy;
pub mod substitute;

Expand Down Expand Up @@ -51,7 +52,13 @@ impl<'a> Evaluator<'a> {
let start = Instant::now();

if !self.trace && self.strategy.options.kind == strategy::StrategyKind::Normal {
let result = self.normalize(term);
// Weak-head (`lazy`) stays on the spine normalizer, which stops under
// binders; every other normal-order run normalizes through NbE.
let result = if self.strategy.options.lazy {
self.normalize_spine(term)
} else {
self.normalize_nbe(term)
};
self.stats.duration = start.elapsed();
self.stats.created_terms = self.ctx.terms.total_terms().saturating_sub(initial_terms);
return result;
Expand Down Expand Up @@ -98,7 +105,15 @@ impl<'a> Evaluator<'a> {
}
}

fn normalize(&mut self, mut term: TermId) -> result::Result<TermId> {
fn normalize_nbe(&mut self, term: TermId) -> result::Result<TermId> {
let limit = self.strategy.options.limit;
let (result, reductions) = nbe::normalize(self.ctx, term, limit)?;
self.stats.steps = reductions;
self.stats.reductions = reductions;
Ok(result)
}

fn normalize_spine(&mut self, mut term: TermId) -> result::Result<TermId> {
let spine_base = self.spine.len();

loop {
Expand Down Expand Up @@ -167,7 +182,7 @@ impl<'a> Evaluator<'a> {
return Ok(term);
}
let lambda = *self.ctx.terms.lambdas.get(lambda_id);
let normalized_body = self.normalize(lambda.body)?;
let normalized_body = self.normalize_spine(lambda.body)?;
if normalized_body == lambda.body {
return Ok(term);
}
Expand All @@ -186,7 +201,7 @@ impl<'a> Evaluator<'a> {
let Some(argument) = self.spine.pop() else {
break;
};
let normalized_argument = self.normalize(argument)?;
let normalized_argument = self.normalize_spine(argument)?;
let new_apply = Apply { function: term, argument: normalized_argument };
term = self.ctx.terms.add_apply(new_apply);
}
Expand Down
90 changes: 90 additions & 0 deletions src/evaluator/nbe/domain.rs
Original file line number Diff line number Diff line change
@@ -0,0 +1,90 @@
use crate::{
core::{
TermId, TypeId,
arena::{Arena, Id},
},
symbol::SymbolId,
};

/// Binder levels at or above this encode free variables by position, so readback
/// can restore the `depth + position` index the parser assigns to them.
pub const FREE_BASE: u32 = 1 << 30;

pub type ValueId = Id<Value>;
pub type EnvId = Id<Binding>;
pub type Env = Option<EnvId>;

#[derive(Clone, Copy)]
pub struct Closure {
pub body: TermId,
pub parameter: Option<SymbolId>,
pub annotation: Option<TypeId>,
pub env: Env,
}

#[derive(Clone, Copy)]
pub enum Value {
Closure(Closure),
Neutral(Neutral),
Suspended { term: TermId, env: Env },
}

#[derive(Clone, Copy)]
pub enum Neutral {
Var(u32),
App(ValueId, ValueId),
}

pub struct Binding {
pub value: ValueId,
pub next: Env,
pub depth: u32,
}

pub struct Domain {
values: Arena<Value>,
envs: Arena<Binding>,
}

impl Default for Domain {
fn default() -> Self {
Domain { values: Arena::with_capacity(64), envs: Arena::with_capacity(64) }
}
}

impl Domain {
pub fn value(&self, id: ValueId) -> Value {
*self.values.get(id)
}

pub fn add(&mut self, value: Value) -> ValueId {
self.values.add(value)
}

pub fn depth(&self, env: Env) -> u32 {
match env {
Some(id) => self.envs.get(id).depth,
None => 0,
}
}

pub fn cons(&mut self, value: ValueId, env: Env) -> Env {
let binding = Binding { value, next: env, depth: self.depth(env) + 1 };
Some(self.envs.add(binding))
}

/// Resolves `index` against `env`. The caller guarantees `index < depth(env)`.
pub fn lookup(&self, env: Env, mut index: u32) -> ValueId {
let mut current = env;
while index > 0 {
current = self.binding(current).next;
index -= 1;
}
self.binding(current).value
}

fn binding(&self, env: Env) -> &Binding {
let id = env.expect("binding within the environment depth");
self.envs.get(id)
}
}
64 changes: 64 additions & 0 deletions src/evaluator/nbe/eval.rs
Original file line number Diff line number Diff line change
@@ -0,0 +1,64 @@
use crate::{
core::{TermId, TermKind},
result,
};

use super::{
Machine,
domain::{Closure, Env, FREE_BASE, Neutral, Value, ValueId},
};

impl<'a> Machine<'a> {
pub(super) fn eval(&mut self, term: TermId, env: Env) -> result::Result<ValueId> {
match term.kind() {
TermKind::Variable(id) => {
let index = self.ctx.terms.variables.get(id).index;
let depth = self.store.depth(env);
if index < depth {
Ok(self.store.lookup(env, index))
} else {
let level = FREE_BASE + index - depth;
Ok(self.store.add(Value::Neutral(Neutral::Var(level))))
}
},
TermKind::Lambda(id) => Ok(self.store.add(Value::Closure(Closure {
body: self.ctx.terms.lambdas.get(id).body,
parameter: self.ctx.terms.parameter(id),
annotation: self.ctx.terms.annotation(id),
env,
}))),
TermKind::Apply(id) => {
let apply = *self.ctx.terms.applies.get(id);
let function = self.eval(apply.function, env)?;
let suspended = Value::Suspended { term: apply.argument, env };
let argument = self.store.add(suspended);
self.apply(function, argument)
},
}
}

pub(super) fn force(&mut self, value: ValueId) -> result::Result<ValueId> {
let mut current = value;
loop {
match self.store.value(current) {
Value::Suspended { term, env } => current = self.eval(term, env)?,
_ => return Ok(current),
}
}
}

fn apply(&mut self, function: ValueId, argument: ValueId) -> result::Result<ValueId> {
let forced = self.force(function)?;
match self.store.value(forced) {
Value::Closure(closure) => {
self.fuel.tick()?;
let extended = self.store.cons(argument, closure.env);
self.eval(closure.body, extended)
},
_ => {
let neutral = Value::Neutral(Neutral::App(forced, argument));
Ok(self.store.add(neutral))
},
}
}
}
68 changes: 68 additions & 0 deletions src/evaluator/nbe/mod.rs
Original file line number Diff line number Diff line change
@@ -0,0 +1,68 @@
mod domain;
mod eval;
mod readback;

use crate::{
context::Context,
core::TermId,
error,
result::{self, Failed},
};

use domain::{Domain, ValueId};

/// Normalizes `term` by evaluation: evaluate into a semantic value and read it
/// back once, instead of rebuilding the term at every beta step. Returns the
/// normal form and the number of beta steps.
pub fn normalize(ctx: &mut Context, term: TermId, limit: usize) -> result::Result<(TermId, usize)> {
let mut machine = Machine::new(ctx, limit);

let value = match machine.eval(term, None) {
Ok(value) => value,
Err(_) => return Err(machine.report_limit()),
};

match machine.quote(value, 0) {
Ok(term) => Ok((term, machine.fuel.used)),
Err(_) => Err(machine.report_limit()),
}
}

struct Machine<'a> {
ctx: &'a mut Context,
store: Domain,
fuel: Fuel,
arguments: Vec<ValueId>,
}

impl<'a> Machine<'a> {
fn new(ctx: &'a mut Context, limit: usize) -> Self {
Machine { ctx, store: Domain::default(), fuel: Fuel::new(limit), arguments: Vec::new() }
}

fn report_limit(&mut self) -> Failed {
let steps = self.fuel.used;
let text = format!("eval limit reached\n\nsteps: {steps}\nreductions: {steps}");
self.ctx.messages.add(error!("{text}"));
Failed::Abort
}
}

struct Fuel {
used: usize,
limit: usize,
}

impl Fuel {
fn new(limit: usize) -> Self {
Fuel { used: 0, limit }
}

fn tick(&mut self) -> result::Result<()> {
if self.used >= self.limit {
return Err(Failed::Abort);
}
self.used += 1;
Ok(())
}
}
72 changes: 72 additions & 0 deletions src/evaluator/nbe/readback.rs
Original file line number Diff line number Diff line change
@@ -0,0 +1,72 @@
use crate::{
core::{Apply, Lambda, TermId, Variable},
result,
};

use super::{
Machine,
domain::{FREE_BASE, Neutral, Value, ValueId},
};

impl<'a> Machine<'a> {
/// `level` is the number of binders read back so far.
pub(super) fn quote(&mut self, value: ValueId, level: u32) -> result::Result<TermId> {
let value = self.force(value)?;
match self.store.value(value) {
Value::Closure(closure) => {
let fresh = self.store.add(Value::Neutral(Neutral::Var(level)));
let extended = self.store.cons(fresh, closure.env);
let body = self.eval(closure.body, extended)?;
let body = self.quote(body, level + 1)?;
let lambda = Lambda { body };
let parameter = closure.parameter;
let annotation = closure.annotation;
let new_id = self.ctx.terms.add_annotated(lambda, parameter, annotation);
Ok(new_id)
},
Value::Neutral(Neutral::Var(variable)) => Ok(self.quote_variable(variable, level)),
Value::Neutral(Neutral::App(..)) => self.quote_spine(value, level),
Value::Suspended { .. } => unreachable!("force returns an evaluated value"),
}
}

fn quote_spine(&mut self, value: ValueId, level: u32) -> result::Result<TermId> {
let base = self.arguments.len();

let mut current = value;
let head = loop {
match self.store.value(current) {
Value::Neutral(Neutral::App(head, argument)) => {
self.arguments.push(argument);
current = head;
},
Value::Neutral(Neutral::Var(variable)) => break variable,
Value::Suspended { .. } => current = self.force(current)?,
Value::Closure(_) => unreachable!("a neutral spine is headed by a variable"),
}
};

let mut term = self.quote_variable(head, level);
while self.arguments.len() > base {
let Some(argument) = self.arguments.pop() else {
break;
};
let normalized = self.quote(argument, level)?;
let apply = Apply { function: term, argument: normalized };
term = self.ctx.terms.add_apply(apply);
}
Ok(term)
}

fn quote_variable(&mut self, neutral: u32, level: u32) -> TermId {
let index = if neutral >= FREE_BASE {
level + (neutral - FREE_BASE)
} else {
let Some(index) = level.checked_sub(neutral + 1) else {
unreachable!("variable level is within the readback")
};
index
};
self.ctx.terms.add_variable(Variable { index })
}
}
2 changes: 1 addition & 1 deletion tests/snapshots/01_simple__apply.snap
Original file line number Diff line number Diff line change
Expand Up @@ -12,5 +12,5 @@ term
eval
steps: 3
reduces: 3
allocs: 2
allocs: 0
time: [time]
Original file line number Diff line number Diff line change
Expand Up @@ -12,5 +12,5 @@ term
eval
steps: 1
reduces: 1
allocs: 1
allocs: 2
time: [time]
2 changes: 1 addition & 1 deletion tests/snapshots/02_booleans__and_true_false.snap
Original file line number Diff line number Diff line change
Expand Up @@ -12,5 +12,5 @@ term
eval
steps: 7
reduces: 7
allocs: 14
allocs: 2
time: [time]
2 changes: 1 addition & 1 deletion tests/snapshots/02_booleans__not_true.snap
Original file line number Diff line number Diff line change
Expand Up @@ -12,5 +12,5 @@ term
eval
steps: 6
reduces: 6
allocs: 11
allocs: 2
time: [time]
2 changes: 1 addition & 1 deletion tests/snapshots/02_booleans__or_false_true.snap
Original file line number Diff line number Diff line change
Expand Up @@ -12,5 +12,5 @@ term
eval
steps: 7
reduces: 7
allocs: 12
allocs: 2
time: [time]
2 changes: 1 addition & 1 deletion tests/snapshots/02_booleans__xor.snap
Original file line number Diff line number Diff line change
Expand Up @@ -12,5 +12,5 @@ term
eval
steps: 9
reduces: 9
allocs: 16
allocs: 2
time: [time]
Loading
Loading