roland/xo-reader
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

xo-reader xo-expression: nested lambdas working properly + docs

Browse source
This commit is contained in:
Roland Conybeare 2025-07-06 14:13:44 -05:00
commit d46c3a2082
26 changed files with 534 additions and 94 deletions
Download patch file Download diff file Expand all files Collapse all files

3
src/reader/CMakeLists.txt
View file

@ -19,8 +19,7 @@ set(SELF_SRCS
expect_type_xs.cpp
lambda_xs.cpp
let1_xs.cpp
envframestack.cpp
envframe.cpp)
envframestack.cpp)
xo_add_shared_library4(${SELF_LIB} ${PROJECT_NAME}Targets ${PROJECT_VERSION} 1 ${SELF_SRCS})
xo_dependency(${SELF_LIB} xo_expression)

34
src/reader/define_xs.cpp
View file

@ -93,6 +93,11 @@ namespace xo {
define_xs::on_expr_with_semicolon(bp<Expression> expr,
parserstatemachine * p_psm)
{
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag));
log && log(xtag("defxs_type", defxs_type_));
this->on_expr(expr, p_psm);
/* semicolon is allowed to terminate def expr */
this->on_semicolon_token(token_type::semicolon(), p_psm);
@ -190,10 +195,31 @@ namespace xo {
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
/* remember variable binding in lexical context,
* so we can refer to it later
*/
p_psm->upsert_var(def_expr->lhs_variable());
// if this is a genuine top-level define (i.e. nesting level = 0),
// then we need to upsert so we can refer to rhs later.
//
// In other contexts (e.g. body-of-lambda) will be rewriting
// {
// def y = foo(x,x);
// bar(y,y);
// }
// into something like
// {
// (lambda (y123) bar(y123,y123))(foo(x,x));
// }
//
// This works in the body of lambda, because we don't evaluate anything
// until lambda definition is complete.
//
// For interactive top-level defs we want to evaluate as we go,
// so need incremental bindings.
if (p_psm->env_stack_size() == 1) {
/* remember variable binding in lexical context,
* so we can refer to it later
*/
p_psm->upsert_var(def_expr->lhs_variable());
}
p_psm->top_exprstate().on_expr(def_expr, p_psm);
} else {

31
src/reader/envframe.cpp
View file

@ -10,37 +10,30 @@ namespace xo {
using xo::ast::Variable;
namespace scm {
rp<Variable>
envframe::lookup(const std::string & x) const {
for (const auto & var : argl_) {
if (x == var->name())
return var;
}
#ifdef OBSOLETE
envframe::envframe(const std::vector<rp<Variable>> & argl,
const rp<Environment>& parent_env)
{
this->env_ = LocalEnv::make(argl, parent_env);
}
return nullptr;
bp<Variable>
envframe::lookup(const std::string & target) const {
return env_->lookup_local(target);
}
void
envframe::upsert(bp<Variable> target) {
for (auto & var : this->argl_) {
if (var->name() == target->name()) {
/* replace existing variable -- may change type */
var = target.promote();
return;
}
}
/* here: target not already present in this frame, append it */
this->argl_.push_back(target.promote());
env_->upsert_local(target);
}
void
envframe::print(std::ostream & os) const {
os << "<envframe"
<< xtag("argl", argl_)
<< xtag("argv", env_->argv())
<< ">";
}
#endif
} /*namespace scm */
} /*namespace xo*/

26
src/reader/envframestack.cpp
View file

@ -6,10 +6,11 @@
#include "envframestack.hpp"
namespace xo {
using xo::ast::LocalEnv;
using xo::ast::Variable;
namespace scm {
envframe &
bp<LocalEnv>
envframestack::top_envframe() {
std::size_t z = stack_.size();
@ -18,11 +19,12 @@ namespace xo {
("parser::top_exprstate: unexpected empty stack");
}
return stack_[z-1];
return stack_[z-1].get();
}
void
envframestack::push_envframe(envframe frame) {
envframestack::push_envframe(const rp<LocalEnv> & frame)
{
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag),
xtag("frame", frame));
@ -31,10 +33,10 @@ namespace xo {
stack_.resize(z+1);
stack_[z] = std::move(frame);
stack_[z] = frame;
}
void
rp<LocalEnv>
envframestack::pop_envframe() {
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag));
@ -44,26 +46,28 @@ namespace xo {
if (z > 0) {
//std::unique_ptr<exprstate> top = std::move(stack_[z-1]);
rp<LocalEnv> retval = stack_.at(z-1);
stack_.resize(z-1);
//return top;
return retval;
} else {
//return nullptr;
return nullptr;
}
}
rp<Variable>
bp<Variable>
envframestack::lookup(const std::string & x) const {
for (std::size_t i = 0, z = this->size(); i < z; ++i) {
const auto & frame = (*this)[i];
auto retval = frame.lookup(x);
auto retval = frame->lookup_local(x);
if (retval)
return retval;
}
return nullptr;
return bp<Variable>::from_native(nullptr);
}
void
@ -71,7 +75,7 @@ namespace xo {
/* upsert should always happen in the innermost lexical context.
* We are providing new variable binding (perhaps shadowing an existing binding)
*/
this->top_envframe().upsert(x);
this->top_envframe()->upsert_local(x);
}
void

4
src/reader/expect_expr_xs.cpp
View file

@ -139,7 +139,7 @@ namespace xo {
* and {(2), (3)} (symbol is function call)
*/
rp<Variable> var = p_psm->lookup_var(tk.text());
bp<Variable> var = p_psm->lookup_var(tk.text());
if (!var) {
throw std::runtime_error
@ -157,7 +157,7 @@ namespace xo {
* def y = foo(pi2);
* ^
*/
progress_xs::start(var, p_psm);
progress_xs::start(var.promote(), p_psm);
#ifdef NOT_YET
p_stack->push_exprstate(exprstate(exprstatetype::expr_progress,

4
src/reader/expect_symbol_xs.cpp
View file

@ -33,10 +33,12 @@ namespace xo {
log && log(xtag("tk", tk));
assert(&p_psm->top_exprstate() == this);
/* have to do pop first, before sending symbol to
* the o.g. symbol-requester
*/
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
std::unique_ptr<exprstate> self{p_psm->pop_exprstate()};
p_psm->on_symbol(tk.text());
}

4
src/reader/exprseq_xs.cpp
View file

@ -63,10 +63,10 @@ namespace xo {
* a + b; // rhs expression
* Variable must have been defined!
*/
rp<Variable> var = p_psm->lookup_var(tk.text());
bp<Variable> var = p_psm->lookup_var(tk.text());
if (var.get()) {
progress_xs::start(var, p_psm);
progress_xs::start(var.promote(), p_psm);
} else {
this->unknown_variable_error(c_self_name, tk);
}

1
src/reader/exprstate.cpp
View file

@ -289,6 +289,7 @@ namespace xo {
log && log(xtag("tk", tk));
log && log(xtag("state", *this));
log && log(xtag("psm", *p_psm));
log && log(xtag("proofoflogging", true));
switch (tk.tk_type()) {

13
src/reader/lambda_xs.cpp
View file

@ -9,6 +9,7 @@
namespace xo {
using xo::ast::Lambda;
using xo::ast::LocalEnv;
namespace scm {
const char *
@ -60,9 +61,10 @@ namespace xo {
{
if (lmxs_type_ == lambdastatetype::lm_1) {
this->lmxs_type_ = lambdastatetype::lm_2;
this->argl_ = argl;
this->parent_env_ = p_psm->top_envframe().promote();
this->local_env_ = LocalEnv::make(argl, parent_env_);
p_psm->push_envframe(envframe(argl));
p_psm->push_envframe(local_env_);
expect_expr_xs::start(p_psm);
} else {
@ -99,12 +101,13 @@ namespace xo {
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
std::string name = "fixmename";
rp<Lambda> lm = Lambda::make(name, argl_, body_);
std::string name = Variable::gensym("lambda");
/* top env frame recorded arguments to this lambda */
p_psm->pop_envframe();
rp<Lambda> lm = Lambda::make_from_env(name, local_env_, body_);
p_psm->top_exprstate().on_expr(lm, p_psm);
p_psm->top_exprstate().on_semicolon_token(tk, p_psm);

70
src/reader/let1_xs.cpp
View file

@ -17,20 +17,18 @@ namespace xo {
using Apply = xo::ast::Apply;
using Lambda = xo::ast::Lambda;
using LambdaAccess = xo::ast::LambdaAccess;
using Environment = xo::ast::Environment;
using LocalEnv = xo::ast::LocalEnv;
using Variable = xo::ast::Variable;
namespace {
std::string gensym() {
return "genanotherxx";
}
}
namespace scm {
std::unique_ptr<let1_xs>
let1_xs::make(std::string lhs_name,
rp<LocalEnv> local_env,
rp<Expression> rhs)
{
return std::make_unique<let1_xs>(let1_xs(std::move(lhs_name),
std::move(local_env),
std::move(rhs)));
}
@ -39,7 +37,16 @@ namespace xo {
const rp<Expression> & rhs,
parserstatemachine * p_psm)
{
p_psm->push_exprstate(let1_xs::make(lhs_name, rhs));
rp<Environment> parent_env = p_psm->top_envframe().promote();
rp<Variable> var1 = Variable::make(lhs_name, rhs->valuetype());
rp<LocalEnv> let_env = LocalEnv::make1(var1, parent_env);
p_psm->push_envframe(let_env);
// TODO: stash let_env in let1_xs, then pick up directly in .on_rightbrace_token()
// still have to push here so vars can find it
//
p_psm->push_exprstate(let1_xs::make(lhs_name, let_env, rhs));
expect_expr_xs::start(true /*allow_defs*/,
true /*cxl_on_rightbrace*/,
@ -47,9 +54,11 @@ namespace xo {
}
let1_xs::let1_xs(std::string lhs_name,
rp<LocalEnv> local_env,
rp<Expression> rhs)
: exprstate(),
: exprstate(exprstatetype::let1expr),
lhs_name_{std::move(lhs_name)},
local_env_{std::move(local_env)},
rhs_{std::move(rhs)}
{}
@ -63,7 +72,8 @@ namespace xo {
bp<DefineExpr> def_expr = DefineExpr::from(expr);
if (def_expr) {
/** nested_start: control returns via
/** starting a nested let here:
* control returns via
* .on_expr(x)
* with x something like:
* Apply(Lambda(gensym(),
@ -85,6 +95,32 @@ namespace xo {
}
}
void
let1_xs::on_expr_with_semicolon(bp<Expression> expr,
parserstatemachine * p_psm)
{
/* same as on_expr(), since we only use let1_xs inside a block { .. }
* This means final ';' is unnecessary
*/
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag));
bp<DefineExpr> def_expr = DefineExpr::from(expr);
if (def_expr) {
let1_xs::start(def_expr->lhs_name(),
def_expr->rhs(),
p_psm);
} else {
this->expr_v_.push_back(expr.promote());
expect_expr_xs::start(true /*allow_defs*/,
true /*cxl_on_rightbvrace*/,
p_psm);
}
}
void
let1_xs::on_rightbrace_token(const token_type & tk,
parserstatemachine * p_psm)
@ -93,13 +129,19 @@ namespace xo {
auto expr = Sequence::make(this->expr_v_);
std::string argname = gensym();
/* top env frame was established by let1_xs::start();
* now unwind it
*/
p_psm->pop_envframe();
std::string lambda_name = Variable::gensym("let1");
rp<Environment> parent_env = p_psm->top_envframe().promote();
rp<Expression> lambda
= Lambda::make(this->lhs_name_,
{Variable::make(argname,
this->rhs_->valuetype())},
expr);
= Lambda::make_from_env(lambda_name,
local_env_,
expr);
rp<Expression> result
= Apply::make(lambda, {this->rhs_});

11
src/reader/parser.cpp
View file

@ -10,11 +10,15 @@
#include "xo/expression/DefineExpr.hpp"
#include "xo/expression/Constant.hpp"
#include "xo/expression/ConvertExpr.hpp"
//#include "xo/expression/GlobalEnv.hpp"
#include "xo/expression/LocalEnv.hpp"
//#include <regex>
#include <stdexcept>
namespace xo {
using xo::ast::Expression;
//using xo::ast::GlobalEnv;
using xo::ast::LocalEnv;
//using xo::ast::DefineExpr;
//using xo::ast::ConvertExpr;
//using xo::ast::Constant;
@ -28,14 +32,15 @@ namespace xo {
: xs_stack_{}, env_stack_{}
{
/* top-level environment. initially empty */
envframe toplevel_env;
rp<LocalEnv> toplevel_env = LocalEnv::make_empty();
this->env_stack_.push_envframe(toplevel_env);
}
bool
parser::has_incomplete_expr() const {
return !xs_stack_.empty();
/* (don't count toplevel exprseq) */
return xs_stack_.size() > 1;
}
void
@ -73,6 +78,8 @@ namespace xo {
/* stack_ is non-empty */
log && log(xtag("top", xs_stack_.top_exprstate()));
rp<Expression> retval;
parserstatemachine psm(&xs_stack_, &env_stack_, &retval);

18
src/reader/parserstatemachine.cpp
View file

@ -7,10 +7,11 @@
#include "exprstatestack.hpp"
namespace xo {
using xo::ast::LocalEnv;
using xo::ast::Variable;
namespace scm {
rp<Variable>
bp<Variable>
parserstatemachine::lookup_var(const std::string & x) const {
return p_env_stack_->lookup(x);
}
@ -35,22 +36,27 @@ namespace xo {
p_stack_->push_exprstate(std::move(x));
}
bp<LocalEnv>
parserstatemachine::top_envframe() const {
return p_env_stack_->top_envframe();
}
void
parserstatemachine::push_envframe(envframe x) {
parserstatemachine::push_envframe(const rp<LocalEnv> & x) {
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag));
log && log(xtag("frame", x));
p_env_stack_->push_envframe(std::move(x));
p_env_stack_->push_envframe(x);
}
void
rp<LocalEnv>
parserstatemachine::pop_envframe() {
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag));
p_env_stack_->pop_envframe();
return p_env_stack_->pop_envframe();
}
void
@ -75,6 +81,8 @@ namespace xo {
log && log(xtag("x", x),
xtag("psm", *this));
assert(!this->p_stack_->empty());
this->p_stack_
->top_exprstate().on_expr_with_semicolon(x, this);
}

31
src/reader/progress_xs.cpp
View file

@ -187,6 +187,35 @@ namespace xo {
this->rhs_ = expr.promote();
}
void
progress_xs::on_expr_with_semicolon(bp<Expression> expr,
parserstatemachine * p_psm)
{
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag));
log && log(xtag("lhs", lhs_), xtag("op", op_type_), xtag("expr", expr));
constexpr const char * c_self_name = "progress_xs::on_expr_with_semicolon";
if (op_type_ == optype::invalid) {
throw std::runtime_error(tostr(c_self_name,
": consecutive unseparated exprs not legal"));
}
this->rhs_ = expr.promote();
// FORBIDDEN, because .on_semicolon_token() destroys *this before returning
// this->on_semicolon_token(token_type::semicolon(), p_psm);
// INSTEAD, spell out the body
rp<Expression> expr2 = this->assemble_expr();
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
p_psm->on_expr_with_semicolon(expr2);
}
void
progress_xs::on_symbol_token(const token_type & /*tk*/,
parserstatemachine * /*p_psm*/)
@ -225,6 +254,8 @@ namespace xo {
rp<Expression> expr = this->assemble_expr();
log && log(xtag("assembled-expr", expr));
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
p_psm->on_expr_with_semicolon(expr);