scott/rudus
1
0
Fork 0
Code Issues 12 Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: scott:f5a6facb1ce17a175f9f72dd8de7d0d688409147
Branches Tags
scott:main
scott:bytecode
..
compare: scott:dde9ac4bff5fe884440c27f250a16f93d3712e08
Branches Tags
scott:bytecode
scott:main

No commits in common. "f5a6facb1ce17a175f9f72dd8de7d0d688409147" and "dde9ac4bff5fe884440c27f250a16f93d3712e08" have entirely different histories.
f5a6facb1c ... dde9ac4bff

6 changed files with 368 additions and 435 deletions
Show Stats Expand all files Collapse all files

104
src/base.rs
View File

@ -4,7 +4,7 @@ use ran::ran_f64;
use std::rc::Rc; use std::rc::Rc;
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub enum BaseFn<'src> { pub enum Base<'src> {
Nullary(fn() -> Value<'src>), Nullary(fn() -> Value<'src>),
Unary(fn(&Value<'src>) -> Value<'src>), Unary(fn(&Value<'src>) -> Value<'src>),
Binary(fn(&Value<'src>, &Value<'src>) -> Value<'src>), Binary(fn(&Value<'src>, &Value<'src>) -> Value<'src>),
@ -572,59 +572,59 @@ pub fn r#mod<'src>(x: &Value, y: &Value) -> Value<'src> {
pub fn base<'src>() -> Vec<(String, Value<'src>)> { pub fn base<'src>() -> Vec<(String, Value<'src>)> {
let members = vec![ let members = vec![
("add", Value::Base(BaseFn::Binary(add))), ("add", Value::Base(Base::Binary(add))),
("and", Value::Base(BaseFn::Binary(and))), ("and", Value::Base(Base::Binary(and))),
("append", Value::Base(BaseFn::Binary(append))), ("append", Value::Base(Base::Binary(append))),
("assoc", Value::Base(BaseFn::Ternary(assoc))), ("assoc", Value::Base(Base::Ternary(assoc))),
("at", Value::Base(BaseFn::Binary(at))), ("at", Value::Base(Base::Binary(at))),
("atan_2", Value::Base(BaseFn::Binary(atan_2))), ("atan_2", Value::Base(Base::Binary(atan_2))),
("bool", Value::Base(BaseFn::Unary(r#bool))), ("bool", Value::Base(Base::Unary(r#bool))),
("ceil", Value::Base(BaseFn::Unary(ceil))), ("ceil", Value::Base(Base::Unary(ceil))),
("chars", Value::Base(BaseFn::Unary(chars))), ("chars", Value::Base(Base::Unary(chars))),
("concat", Value::Base(BaseFn::Binary(concat))), ("concat", Value::Base(Base::Binary(concat))),
("cos", Value::Base(BaseFn::Unary(cos))), ("cos", Value::Base(Base::Unary(cos))),
("count", Value::Base(BaseFn::Unary(count))), ("count", Value::Base(Base::Unary(count))),
("dec", Value::Base(BaseFn::Unary(dec))), ("dec", Value::Base(Base::Unary(dec))),
("dissoc", Value::Base(BaseFn::Binary(dissoc))), ("dissoc", Value::Base(Base::Binary(dissoc))),
("div", Value::Base(BaseFn::Binary(div))), ("div", Value::Base(Base::Binary(div))),
("doc!", Value::Base(BaseFn::Unary(doc))), ("doc!", Value::Base(Base::Unary(doc))),
("downcase", Value::Base(BaseFn::Unary(downcase))), ("downcase", Value::Base(Base::Unary(downcase))),
("eq?", Value::Base(BaseFn::Binary(eq))), ("eq?", Value::Base(Base::Binary(eq))),
("first", Value::Base(BaseFn::Unary(first))), ("first", Value::Base(Base::Unary(first))),
("floor", Value::Base(BaseFn::Unary(floor))), ("floor", Value::Base(Base::Unary(floor))),
("get", Value::Base(BaseFn::Binary(get))), ("get", Value::Base(Base::Binary(get))),
("gt?", Value::Base(BaseFn::Binary(gt))), ("gt?", Value::Base(Base::Binary(gt))),
("gte?", Value::Base(BaseFn::Binary(gte))), ("gte?", Value::Base(Base::Binary(gte))),
("inc", Value::Base(BaseFn::Unary(inc))), ("inc", Value::Base(Base::Unary(inc))),
("last", Value::Base(BaseFn::Unary(last))), ("last", Value::Base(Base::Unary(last))),
("list", Value::Base(BaseFn::Unary(list))), ("list", Value::Base(Base::Unary(list))),
("lt?", Value::Base(BaseFn::Binary(lt))), ("lt?", Value::Base(Base::Binary(lt))),
("lte?", Value::Base(BaseFn::Binary(lte))), ("lte?", Value::Base(Base::Binary(lte))),
("mod", Value::Base(BaseFn::Binary(r#mod))), ("mod", Value::Base(Base::Binary(r#mod))),
("mult", Value::Base(BaseFn::Binary(mult))), ("mult", Value::Base(Base::Binary(mult))),
("number", Value::Base(BaseFn::Unary(number))), ("number", Value::Base(Base::Unary(number))),
("or", Value::Base(BaseFn::Binary(or))), ("or", Value::Base(Base::Binary(or))),
("pi", Value::Number(std::f64::consts::PI)), ("pi", Value::Number(std::f64::consts::PI)),
("print!", Value::Base(BaseFn::Unary(print))), ("print!", Value::Base(Base::Unary(print))),
("random", Value::Base(BaseFn::Nullary(random))), ("random", Value::Base(Base::Nullary(random))),
("range", Value::Base(BaseFn::Binary(range))), ("range", Value::Base(Base::Binary(range))),
("rest", Value::Base(BaseFn::Unary(rest))), ("rest", Value::Base(Base::Unary(rest))),
("round", Value::Base(BaseFn::Unary(round))), ("round", Value::Base(Base::Unary(round))),
("show", Value::Base(BaseFn::Unary(show))), ("show", Value::Base(Base::Unary(show))),
("sin", Value::Base(BaseFn::Unary(sin))), ("sin", Value::Base(Base::Unary(sin))),
("slice", Value::Base(BaseFn::Ternary(slice))), ("slice", Value::Base(Base::Ternary(slice))),
("split", Value::Base(BaseFn::Binary(split))), ("split", Value::Base(Base::Binary(split))),
("sqrt", Value::Base(BaseFn::Unary(sqrt))), ("sqrt", Value::Base(Base::Unary(sqrt))),
("sqrt_2", Value::Number(std::f64::consts::SQRT_2)), ("sqrt_2", Value::Number(std::f64::consts::SQRT_2)),
("store!", Value::Base(BaseFn::Binary(store))), ("store!", Value::Base(Base::Binary(store))),
("sub", Value::Base(BaseFn::Binary(sub))), ("sub", Value::Base(Base::Binary(sub))),
("tan", Value::Base(BaseFn::Unary(tan))), ("tan", Value::Base(Base::Unary(tan))),
("trim", Value::Base(BaseFn::Unary(trim))), ("trim", Value::Base(Base::Unary(trim))),
("triml", Value::Base(BaseFn::Unary(triml))), ("triml", Value::Base(Base::Unary(triml))),
("trimr", Value::Base(BaseFn::Unary(trimr))), ("trimr", Value::Base(Base::Unary(trimr))),
("type", Value::Base(BaseFn::Unary(r#type))), ("type", Value::Base(Base::Unary(r#type))),
("unbox", Value::Base(BaseFn::Unary(unbox))), ("unbox", Value::Base(Base::Unary(unbox))),
("upcase", Value::Base(BaseFn::Unary(upcase))), ("upcase", Value::Base(Base::Unary(upcase))),
]; ];
let pkg = Value::Dict(HashMap::from(members)); let pkg = Value::Dict(HashMap::from(members));
vec![("base".to_string(), pkg)] vec![("base".to_string(), pkg)]

156
src/context.rs
View File

@ -1,6 +1,5 @@
use crate::base::*; use crate::base::*;
use crate::parser::*; use crate::parser::*;
use crate::spans::*;
use crate::value::{Fn, Value}; use crate::value::{Fn, Value};
use imbl::HashMap; use imbl::HashMap;
use imbl::Vector; use imbl::Vector;
@ -72,17 +71,16 @@ impl<'src> Context<'src> {
} }
} }
pub fn match_pattern(&mut self, patt: &Ast, val: &Value<'src>) -> Option<&Context<'src>> { pub fn match_pattern(&mut self, patt: &Pattern, val: &Value<'src>) -> Option<&Context<'src>> {
use Ast::*;
match (patt, val) { match (patt, val) {
(NilPattern, Value::Nil) => Some(self), (Pattern::Nil, Value::Nil) => Some(self),
(PlaceholderPattern, _) => Some(self), (Pattern::Placeholder, _) => Some(self),
(NumberPattern(x), Value::Number(y)) => self.match_eq(x, y), (Pattern::Number(x), Value::Number(y)) => self.match_eq(x, y),
(BooleanPattern(x), Value::Boolean(y)) => self.match_eq(x, y), (Pattern::Boolean(x), Value::Boolean(y)) => self.match_eq(x, y),
(KeywordPattern(x), Value::Keyword(y)) => self.match_eq(x, y), (Pattern::Keyword(x), Value::Keyword(y)) => self.match_eq(x, y),
(StringPattern(x), Value::InternedString(y)) => self.match_eq(x, y), (Pattern::String(x), Value::InternedString(y)) => self.match_eq(x, y),
(StringPattern(x), Value::AllocatedString(y)) => self.match_eq(&x.to_string(), y), (Pattern::String(x), Value::AllocatedString(y)) => self.match_eq(&x.to_string(), y),
(InterpolatedPattern(_, StringMatcher(matcher)), Value::InternedString(y)) => { (Pattern::Interpolated(_, StringMatcher(matcher)), Value::InternedString(y)) => {
match matcher(y.to_string()) { match matcher(y.to_string()) {
Some(matches) => { Some(matches) => {
let mut matches = matches let mut matches = matches
@ -100,11 +98,11 @@ impl<'src> Context<'src> {
None => None, None => None,
} }
} }
(WordPattern(w), val) => { (Pattern::Word(w), val) => {
self.bind(w.to_string(), &val); self.bind(w.to_string(), &val);
Some(self) Some(self)
} }
(AsPattern(word, type_str), value) => { (Pattern::As(word, type_str), value) => {
let ludus_type = r#type(value); let ludus_type = r#type(value);
let type_kw = Value::Keyword(type_str); let type_kw = Value::Keyword(type_str);
if type_kw == ludus_type { if type_kw == ludus_type {
@ -114,14 +112,16 @@ impl<'src> Context<'src> {
None None
} }
} }
(TuplePattern(x), Value::Tuple(y)) => { (Pattern::Tuple(x), Value::Tuple(y)) => {
let has_splat = x.iter().any(|patt| matches!(patt, (Splattern(_), _))); let has_splat = x
.iter()
.any(|patt| matches!(patt, (Pattern::Splattern(_), _)));
if x.len() > y.len() || (!has_splat && x.len() != y.len()) { if x.len() > y.len() || (!has_splat && x.len() != y.len()) {
return None; return None;
}; };
let to = self.locals.len(); let to = self.locals.len();
for i in 0..x.len() { for i in 0..x.len() {
if let Splattern(patt) = &x[i].0 { if let Pattern::Splattern(patt) = &x[i].0 {
let mut list = Vector::new(); let mut list = Vector::new();
for i in i..y.len() { for i in i..y.len() {
list.push_back(y[i].clone()) list.push_back(y[i].clone())
@ -135,14 +135,16 @@ impl<'src> Context<'src> {
} }
Some(self) Some(self)
} }
(ListPattern(x), Value::List(y)) => { (Pattern::List(x), Value::List(y)) => {
let has_splat = x.iter().any(|patt| matches!(patt, (Splattern(_), _))); let has_splat = x
.iter()
.any(|patt| matches!(patt, (Pattern::Splattern(_), _)));
if x.len() > y.len() || (!has_splat && x.len() != y.len()) { if x.len() > y.len() || (!has_splat && x.len() != y.len()) {
return None; return None;
}; };
let to = self.locals.len(); let to = self.locals.len();
for (i, (patt, _)) in x.iter().enumerate() { for (i, (patt, _)) in x.iter().enumerate() {
if let Splattern(patt) = &patt { if let Pattern::Splattern(patt) = &patt {
let list = Value::List(y.skip(i)); let list = Value::List(y.skip(i));
self.match_pattern(&patt.0, &list); self.match_pattern(&patt.0, &list);
} else if self.match_pattern(patt, y.get(i).unwrap()).is_none() { } else if self.match_pattern(patt, y.get(i).unwrap()).is_none() {
@ -155,8 +157,10 @@ impl<'src> Context<'src> {
// TODO: optimize this on several levels // TODO: optimize this on several levels
// - [ ] opportunistic mutation // - [ ] opportunistic mutation
// - [ ] get rid of all the pointer indirection in word splats // - [ ] get rid of all the pointer indirection in word splats
(DictPattern(x), Value::Dict(y)) => { (Pattern::Dict(x), Value::Dict(y)) => {
let has_splat = x.iter().any(|patt| matches!(patt, (Splattern(_), _))); let has_splat = x
.iter()
.any(|patt| matches!(patt, (Pattern::Splattern(_), _)));
if x.len() > y.len() || (!has_splat && x.len() != y.len()) { if x.len() > y.len() || (!has_splat && x.len() != y.len()) {
return None; return None;
}; };
@ -164,7 +168,7 @@ impl<'src> Context<'src> {
let mut matched = vec![]; let mut matched = vec![];
for (pattern, _) in x { for (pattern, _) in x {
match pattern { match pattern {
PairPattern(key, patt) => { Pattern::Pair(key, patt) => {
if let Some(val) = y.get(key) { if let Some(val) = y.get(key) {
if self.match_pattern(&patt.0, val).is_none() { if self.match_pattern(&patt.0, val).is_none() {
self.pop_to(to); self.pop_to(to);
@ -176,8 +180,8 @@ impl<'src> Context<'src> {
return None; return None;
}; };
} }
Splattern(pattern) => match pattern.0 { Pattern::Splattern(pattern) => match pattern.0 {
WordPattern(w) => { Pattern::Word(w) => {
// TODO: find a way to take ownership // TODO: find a way to take ownership
// this will ALWAYS make structural changes, because of this clone // this will ALWAYS make structural changes, because of this clone
// we want opportunistic mutation if possible // we want opportunistic mutation if possible
@ -187,7 +191,7 @@ impl<'src> Context<'src> {
} }
self.bind(w.to_string(), &Value::Dict(unmatched)); self.bind(w.to_string(), &Value::Dict(unmatched));
} }
PlaceholderPattern => (), Pattern::Placeholder => (),
_ => unreachable!(), _ => unreachable!(),
}, },
_ => unreachable!(), _ => unreachable!(),
@ -202,15 +206,14 @@ impl<'src> Context<'src> {
pub fn match_clauses( pub fn match_clauses(
&mut self, &mut self,
value: &Value<'src>, value: &Value<'src>,
clauses: &'src [Spanned<Ast>], clauses: &'src [MatchClause],
) -> LResult<'src> { ) -> LResult<'src> {
{ {
let parent = self.ast; let parent = self.ast;
let to = self.locals.len(); let to = self.locals.len();
let mut clauses = clauses.iter(); for MatchClause { patt, body, guard } in clauses.iter() {
while let Some((Ast::MatchClause(patt, guard, body), _)) = clauses.next() {
if let Some(_) = self.match_pattern(&patt.0, value) { if let Some(_) = self.match_pattern(&patt.0, value) {
let pass_guard = match guard.as_ref() { let pass_guard = match guard {
None => true, None => true,
Some((ast, _)) => { Some((ast, _)) => {
self.ast = ast; self.ast = ast;
@ -237,31 +240,30 @@ impl<'src> Context<'src> {
} }
pub fn apply(&mut self, callee: Value<'src>, caller: Value<'src>) -> LResult<'src> { pub fn apply(&mut self, callee: Value<'src>, caller: Value<'src>) -> LResult<'src> {
use Value::*;
match (callee, caller) { match (callee, caller) {
(Keyword(kw), Dict(dict)) => { (Value::Keyword(kw), Value::Dict(dict)) => {
if let Some(val) = dict.get(kw) { if let Some(val) = dict.get(kw) {
Ok(val.clone()) Ok(val.clone())
} else { } else {
Ok(Nil) Ok(Value::Nil)
} }
} }
(Dict(dict), Keyword(kw)) => { (Value::Dict(dict), Value::Keyword(kw)) => {
if let Some(val) = dict.get(kw) { if let Some(val) = dict.get(kw) {
Ok(val.clone()) Ok(val.clone())
} else { } else {
Ok(Nil) Ok(Value::Nil)
} }
} }
(Fn(f), Tuple(args)) => { (Value::Fn(f), Value::Tuple(args)) => {
let args = Tuple(args); let args = Value::Tuple(args);
self.match_clauses(&args, f.body) self.match_clauses(&args, f.body)
} }
(Fn(_f), Args(_args)) => todo!(), (Value::Fn(_f), Value::Args(_args)) => todo!(),
(_, Keyword(_)) => Ok(Nil), (_, Value::Keyword(_)) => Ok(Value::Nil),
(_, Args(_)) => Err(LErr::new(format!("you may only call a function"))), (_, Value::Args(_)) => Err(LErr::new(format!("you may only call a function"))),
(Base(f), Tuple(args)) => match f { (Value::Base(f), Value::Tuple(args)) => match f {
BaseFn::Nullary(f) => { Base::Nullary(f) => {
let num_args = args.len(); let num_args = args.len();
if num_args != 0 { if num_args != 0 {
Err(LErr::new(format!( Err(LErr::new(format!(
@ -271,7 +273,7 @@ impl<'src> Context<'src> {
Ok(f()) Ok(f())
} }
} }
BaseFn::Unary(f) => { Base::Unary(f) => {
let num_args = args.len(); let num_args = args.len();
if num_args != 1 { if num_args != 1 {
Err(LErr::new(format!( Err(LErr::new(format!(
@ -281,7 +283,7 @@ impl<'src> Context<'src> {
Ok(f(&args[0])) Ok(f(&args[0]))
} }
} }
BaseFn::Binary(r#fn) => { Base::Binary(r#fn) => {
let num_args = args.len(); let num_args = args.len();
if num_args != 2 { if num_args != 2 {
Err(LErr::new(format!( Err(LErr::new(format!(
@ -291,7 +293,7 @@ impl<'src> Context<'src> {
Ok(r#fn(&args[0], &args[1])) Ok(r#fn(&args[0], &args[1]))
} }
} }
BaseFn::Ternary(f) => { Base::Ternary(f) => {
let num_args = args.len(); let num_args = args.len();
if num_args != 3 { if num_args != 3 {
Err(LErr::new(format!( Err(LErr::new(format!(
@ -307,16 +309,15 @@ impl<'src> Context<'src> {
} }
pub fn eval(&mut self) -> LResult<'src> { pub fn eval(&mut self) -> LResult<'src> {
use Ast::*;
let root = self.ast; let root = self.ast;
let result = match self.ast { let result = match self.ast {
Nil => Ok(Value::Nil), Ast::Nil => Ok(Value::Nil),
Boolean(b) => Ok(Value::Boolean(*b)), Ast::Boolean(b) => Ok(Value::Boolean(*b)),
Number(n) => Ok(Value::Number(*n)), Ast::Number(n) => Ok(Value::Number(*n)),
Keyword(k) => Ok(Value::Keyword(k)), Ast::Keyword(k) => Ok(Value::Keyword(k)),
String(s) => Ok(Value::InternedString(s)), Ast::String(s) => Ok(Value::InternedString(s)),
Interpolated(parts) => { Ast::Interpolated(parts) => {
let mut interpolated = std::string::String::new(); let mut interpolated = String::new();
for part in parts { for part in parts {
match &part.0 { match &part.0 {
StringPart::Data(s) => interpolated.push_str(s.as_str()), StringPart::Data(s) => interpolated.push_str(s.as_str()),
@ -329,7 +330,7 @@ impl<'src> Context<'src> {
} }
Ok(Value::AllocatedString(Rc::new(interpolated))) Ok(Value::AllocatedString(Rc::new(interpolated)))
} }
Block(exprs) => { Ast::Block(exprs) => {
let parent = self.ast; let parent = self.ast;
let to = self.locals.len(); let to = self.locals.len();
let mut result = Value::Nil; let mut result = Value::Nil;
@ -341,7 +342,7 @@ impl<'src> Context<'src> {
self.ast = parent; self.ast = parent;
Ok(result) Ok(result)
} }
If(cond, if_true, if_false) => { Ast::If(cond, if_true, if_false) => {
let parent = self.ast; let parent = self.ast;
self.ast = &cond.0; self.ast = &cond.0;
let truthy = self.eval()?.bool(); let truthy = self.eval()?.bool();
@ -350,7 +351,7 @@ impl<'src> Context<'src> {
self.ast = parent; self.ast = parent;
result result
} }
List(members) => { Ast::List(members) => {
let parent = self.ast; let parent = self.ast;
let mut vect = Vector::new(); let mut vect = Vector::new();
for member in members { for member in members {
@ -372,7 +373,7 @@ impl<'src> Context<'src> {
self.ast = parent; self.ast = parent;
Ok(Value::List(vect)) Ok(Value::List(vect))
} }
Tuple(members) => { Ast::Tuple(members) => {
let parent = self.ast; let parent = self.ast;
let mut vect = Vec::new(); let mut vect = Vec::new();
for member in members { for member in members {
@ -382,11 +383,11 @@ impl<'src> Context<'src> {
self.ast = parent; self.ast = parent;
Ok(Value::Tuple(Rc::new(vect))) Ok(Value::Tuple(Rc::new(vect)))
} }
Word(w) | Ast::Splat(w) => { Ast::Word(w) | Ast::Splat(w) => {
let val = self.resolve(&w.to_string())?; let val = self.resolve(&w.to_string())?;
Ok(val) Ok(val)
} }
Let(patt, expr) => { Ast::Let(patt, expr) => {
let parent = self.ast; let parent = self.ast;
self.ast = &expr.0; self.ast = &expr.0;
let val = self.eval()?; let val = self.eval()?;
@ -397,8 +398,9 @@ impl<'src> Context<'src> {
self.ast = parent; self.ast = parent;
result result
} }
Placeholder => Ok(Value::Placeholder), Ast::Placeholder => Ok(Value::Placeholder),
Arguments(a) => { Ast::Error => unreachable!(),
Ast::Arguments(a) => {
let parent = self.ast; let parent = self.ast;
let mut args = vec![]; let mut args = vec![];
for (arg, _) in a.iter() { for (arg, _) in a.iter() {
@ -414,7 +416,7 @@ impl<'src> Context<'src> {
self.ast = parent; self.ast = parent;
result result
} }
Dict(terms) => { Ast::Dict(terms) => {
let parent = self.ast; let parent = self.ast;
let mut dict = HashMap::new(); let mut dict = HashMap::new();
for term in terms { for term in terms {
@ -439,7 +441,7 @@ impl<'src> Context<'src> {
self.ast = parent; self.ast = parent;
Ok(Value::Dict(dict)) Ok(Value::Dict(dict))
} }
LBox(name, expr) => { Ast::Box(name, expr) => {
let parent = self.ast; let parent = self.ast;
self.ast = &expr.0; self.ast = &expr.0;
let val = self.eval()?; let val = self.eval()?;
@ -448,7 +450,7 @@ impl<'src> Context<'src> {
self.ast = parent; self.ast = parent;
Ok(boxed) Ok(boxed)
} }
Synthetic(root, first, rest) => { Ast::Synthetic(root, first, rest) => {
let parent = self.ast; let parent = self.ast;
self.ast = &root.0; self.ast = &root.0;
let root = self.eval()?; let root = self.eval()?;
@ -463,12 +465,10 @@ impl<'src> Context<'src> {
self.ast = parent; self.ast = parent;
Ok(curr) Ok(curr)
} }
When(clauses) => { Ast::When(clauses) => {
let parent = self.ast; let parent = self.ast;
for clause in clauses.iter() { for clause in clauses.iter() {
let WhenClause(cond, body) = &clause.0 else { let WhenClause { cond, body } = &clause.0;
unreachable!()
};
self.ast = &cond.0; self.ast = &cond.0;
if self.eval()?.bool() { if self.eval()?.bool() {
self.ast = &body.0; self.ast = &body.0;
@ -479,7 +479,7 @@ impl<'src> Context<'src> {
} }
Err(LErr::new(format!("no match"))) Err(LErr::new(format!("no match")))
} }
Match(value, clauses) => { Ast::Match(value, clauses) => {
let parent = self.ast; let parent = self.ast;
self.ast = &value.0; self.ast = &value.0;
let value = self.eval()?; let value = self.eval()?;
@ -487,9 +487,9 @@ impl<'src> Context<'src> {
self.ast = parent; self.ast = parent;
result result
} }
Fn(name, clauses, doc) => { Ast::Fn(name, clauses, doc) => {
let doc = doc.map(|s| s.to_string()); let doc = doc.map(|s| s.to_string());
let the_fn = Value::Fn::<'src>(Rc::new(crate::value::Fn::<'src> { let the_fn = Value::Fn::<'src>(Rc::new(Fn::<'src> {
name: name.to_string(), name: name.to_string(),
body: clauses, body: clauses,
doc, doc,
@ -497,13 +497,13 @@ impl<'src> Context<'src> {
self.bind(name.to_string(), &the_fn); self.bind(name.to_string(), &the_fn);
Ok(the_fn) Ok(the_fn)
} }
FnDeclaration(_name) => Ok(Value::Nil), Ast::FnDeclaration(_name) => Ok(Value::Nil),
Panic(msg) => { Ast::Panic(msg) => {
self.ast = &msg.0; self.ast = &msg.0;
let msg = self.eval()?; let msg = self.eval()?;
Err(LErr::new(format!("{msg}"))) Err(LErr::new(format!("{msg}")))
} }
Repeat(times, body) => { Ast::Repeat(times, body) => {
let parent = self.ast; let parent = self.ast;
self.ast = &times.0; self.ast = &times.0;
let times_num = match self.eval() { let times_num = match self.eval() {
@ -517,7 +517,7 @@ impl<'src> Context<'src> {
self.ast = parent; self.ast = parent;
Ok(Value::Nil) Ok(Value::Nil)
} }
Do(terms) => { Ast::Do(terms) => {
let parent = self.ast; let parent = self.ast;
self.ast = &terms[0].0; self.ast = &terms[0].0;
let mut result = self.eval()?; let mut result = self.eval()?;
@ -530,7 +530,10 @@ impl<'src> Context<'src> {
self.ast = parent; self.ast = parent;
Ok(result) Ok(result)
} }
Loop(init, clauses) => { Ast::Pair(..) => {
unreachable!()
}
Ast::Loop(init, clauses) => {
let parent = self.ast; let parent = self.ast;
self.ast = &init.0; self.ast = &init.0;
let mut args = self.eval()?; let mut args = self.eval()?;
@ -544,7 +547,7 @@ impl<'src> Context<'src> {
} }
} }
} }
Recur(args) => { Ast::Recur(args) => {
let parent = self.ast; let parent = self.ast;
let mut vect = Vec::new(); let mut vect = Vec::new();
for arg in args { for arg in args {
@ -554,7 +557,6 @@ impl<'src> Context<'src> {
self.ast = parent; self.ast = parent;
Ok(Value::Recur(vect)) Ok(Value::Recur(vect))
} }
_ => unreachable!(),
}; };
self.ast = root; self.ast = root;
result result

23
src/main.rs
View File

@ -150,25 +150,26 @@ pub fn run(src: &'static str) {
let mut valxor = validator::Validator::new(&ast, span, &dummy_prelude); let mut valxor = validator::Validator::new(&ast, span, &dummy_prelude);
// valxor.validate(); valxor.validate();
// dbg!(valxor); dbg!(valxor);
let mut ctx = prelude(); // let mut ctx = prelude();
ctx.ast = &ast; // ctx.ast = &ast;
let result = ctx.eval(); // let result = ctx.eval();
match result { // match result {
Ok(result) => println!("{}", result), // Ok(result) => println!("{}", result),
Err(LErr { msg, .. }) => println!("Errors!\n{}", msg), // Err(LErr { msg, .. }) => println!("Errors!\n{}", msg),
} // }
} }
pub fn main() { pub fn main() {
let src = " let src = "
let #{:a (x, y), :b [1, 2, (a, b)]} = #{:a (1, 2), :b [1, 2, (7, 8)]} loop () with {
(x, y, a, b) () -> :baz
}
"; ";
run(src); run(src);
// struct_scalpel::print_dissection_info::<value::Value>() // struct_scalpel::print_dissection_info::<value::Value>()

512
src/parser.rs
View File

@ -4,34 +4,34 @@ use chumsky::{input::ValueInput, prelude::*, recursive::Recursive};
use std::fmt; use std::fmt;
use struct_scalpel::Dissectible; use struct_scalpel::Dissectible;
// #[derive(Clone, Debug, PartialEq)] #[derive(Clone, Debug, PartialEq)]
// pub struct WhenClause { pub struct WhenClause {
// pub cond: Spanned<Ast>, pub cond: Spanned<Ast>,
// pub body: Spanned<Ast>, pub body: Spanned<Ast>,
// } }
// impl fmt::Display for WhenClause { impl fmt::Display for WhenClause {
// fn fmt(self: &WhenClause, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(self: &WhenClause, f: &mut fmt::Formatter) -> fmt::Result {
// write!(f, "cond: {}, body: {}", self.cond.0, self.body.0) write!(f, "cond: {}, body: {}", self.cond.0, self.body.0)
// } }
// } }
// #[derive(Clone, Debug, PartialEq)] #[derive(Clone, Debug, PartialEq)]
// pub struct MatchClause { pub struct MatchClause {
// pub patt: Spanned<Pattern>, pub patt: Spanned<Pattern>,
// pub guard: Option<Spanned<Ast>>, pub guard: Option<Spanned<Ast>>,
// pub body: Spanned<Ast>, pub body: Spanned<Ast>,
// } }
// impl fmt::Display for MatchClause { impl fmt::Display for MatchClause {
// fn fmt(self: &MatchClause, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(self: &MatchClause, f: &mut fmt::Formatter) -> fmt::Result {
// write!( write!(
// f, f,
// "pattern: {}, guard: {:?} body: {}", "pattern: {}, guard: {:?} body: {}",
// self.patt.0, self.guard, self.body.0 self.patt.0, self.guard, self.body.0
// ) )
// } }
// } }
#[derive(Clone, Debug, PartialEq, Eq)] #[derive(Clone, Debug, PartialEq, Eq)]
pub enum StringPart { pub enum StringPart {
@ -53,11 +53,7 @@ impl fmt::Display for StringPart {
#[derive(Clone, Debug, PartialEq, Dissectible)] #[derive(Clone, Debug, PartialEq, Dissectible)]
pub enum Ast { pub enum Ast {
// a special Error node
// may come in handy?
Error, Error,
// expression nodes
Placeholder, Placeholder,
Nil, Nil,
Boolean(bool), Boolean(bool),
@ -72,52 +68,29 @@ pub enum Ast {
Arguments(Vec<Spanned<Self>>), Arguments(Vec<Spanned<Self>>),
List(Vec<Spanned<Self>>), List(Vec<Spanned<Self>>),
Dict(Vec<Spanned<Self>>), Dict(Vec<Spanned<Self>>),
Let(Box<Spanned<Self>>, Box<Spanned<Self>>), Let(Box<Spanned<Pattern>>, Box<Spanned<Self>>),
LBox(&'static str, Box<Spanned<Self>>), Box(&'static str, Box<Spanned<Self>>),
Synthetic(Box<Spanned<Self>>, Box<Spanned<Self>>, Vec<Spanned<Self>>), Synthetic(Box<Spanned<Self>>, Box<Spanned<Self>>, Vec<Spanned<Self>>),
When(Vec<Spanned<Self>>), When(Vec<Spanned<WhenClause>>),
WhenClause(Box<Spanned<Self>>, Box<Spanned<Self>>), Match(Box<Spanned<Self>>, Vec<MatchClause>),
Match(Box<Spanned<Self>>, Vec<Spanned<Self>>), Fn(&'static str, Vec<MatchClause>, Option<&'static str>),
MatchClause(
Box<Spanned<Self>>,
Box<Option<Spanned<Self>>>,
Box<Spanned<Self>>,
),
Fn(&'static str, Vec<Spanned<Self>>, Option<&'static str>),
FnDeclaration(&'static str), FnDeclaration(&'static str),
Panic(Box<Spanned<Self>>), Panic(Box<Spanned<Self>>),
Do(Vec<Spanned<Self>>), Do(Vec<Spanned<Self>>),
Repeat(Box<Spanned<Self>>, Box<Spanned<Self>>), Repeat(Box<Spanned<Self>>, Box<Spanned<Self>>),
Splat(&'static str), Splat(&'static str),
Pair(&'static str, Box<Spanned<Self>>), Pair(&'static str, Box<Spanned<Self>>),
Loop(Box<Spanned<Self>>, Vec<Spanned<Self>>), Loop(Box<Spanned<Self>>, Vec<MatchClause>),
Recur(Vec<Spanned<Self>>), Recur(Vec<Spanned<Self>>),
// pattern nodes
NilPattern,
BooleanPattern(bool),
NumberPattern(f64),
StringPattern(&'static str),
InterpolatedPattern(Vec<Spanned<StringPart>>, StringMatcher),
KeywordPattern(&'static str),
WordPattern(&'static str),
AsPattern(&'static str, &'static str),
Splattern(Box<Spanned<Self>>),
PlaceholderPattern,
TuplePattern(Vec<Spanned<Self>>),
ListPattern(Vec<Spanned<Self>>),
PairPattern(&'static str, Box<Spanned<Self>>),
DictPattern(Vec<Spanned<Self>>),
} }
impl fmt::Display for Ast { impl fmt::Display for Ast {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
use Ast::*;
match self { match self {
Error => write!(f, "Error"), Ast::Error => write!(f, "Error"),
Nil => write!(f, "nil"), Ast::Nil => write!(f, "nil"),
String(s) => write!(f, "String: \"{}\"", s), Ast::String(s) => write!(f, "String: \"{}\"", s),
Interpolated(strs) => { Ast::Interpolated(strs) => {
write!( write!(
f, f,
"Interpolated: \"{}\"", "Interpolated: \"{}\"",
@ -127,11 +100,11 @@ impl fmt::Display for Ast {
.join("") .join("")
) )
} }
Boolean(b) => write!(f, "Boolean: {}", b), Ast::Boolean(b) => write!(f, "Boolean: {}", b),
Number(n) => write!(f, "Number: {}", n), Ast::Number(n) => write!(f, "Number: {}", n),
Keyword(k) => write!(f, "Keyword: :{}", k), Ast::Keyword(k) => write!(f, "Keyword: :{}", k),
Word(w) => write!(f, "Word: {}", w), Ast::Word(w) => write!(f, "Word: {}", w),
Block(b) => write!( Ast::Block(b) => write!(
f, f,
"Block: <{}>", "Block: <{}>",
b.iter() b.iter()
@ -139,15 +112,15 @@ impl fmt::Display for Ast {
.collect::<Vec<_>>() .collect::<Vec<_>>()
.join("\n") .join("\n")
), ),
If(cond, then_branch, else_branch) => write!( Ast::If(cond, then_branch, else_branch) => write!(
f, f,
"If: {} Then: {} Else: {}", "If: {} Then: {} Else: {}",
cond.0, then_branch.0, else_branch.0 cond.0, then_branch.0, else_branch.0
), ),
Let(pattern, expression) => { Ast::Let(pattern, expression) => {
write!(f, "Let: {} = {}", pattern.0, expression.0) write!(f, "Let: {} = {}", pattern.0, expression.0)
} }
Dict(entries) => write!( Ast::Dict(entries) => write!(
f, f,
"#{{{}}}", "#{{{}}}",
entries entries
@ -156,7 +129,7 @@ impl fmt::Display for Ast {
.collect::<Vec<_>>() .collect::<Vec<_>>()
.join(", ") .join(", ")
), ),
List(l) => write!( Ast::List(l) => write!(
f, f,
"List: [{}]", "List: [{}]",
l.iter() l.iter()
@ -164,7 +137,7 @@ impl fmt::Display for Ast {
.collect::<Vec<_>>() .collect::<Vec<_>>()
.join("\n") .join("\n")
), ),
Tuple(t) | Ast::Arguments(t) => write!( Ast::Tuple(t) | Ast::Arguments(t) => write!(
f, f,
"Tuple: ({})", "Tuple: ({})",
t.iter() t.iter()
@ -172,7 +145,7 @@ impl fmt::Display for Ast {
.collect::<Vec<_>>() .collect::<Vec<_>>()
.join("\n") .join("\n")
), ),
Synthetic(root, first, rest) => write!( Ast::Synthetic(root, first, rest) => write!(
f, f,
"Synth: [{}, {}, {}]", "Synth: [{}, {}, {}]",
root.0, root.0,
@ -182,7 +155,7 @@ impl fmt::Display for Ast {
.collect::<Vec<_>>() .collect::<Vec<_>>()
.join("\n") .join("\n")
), ),
When(clauses) => write!( Ast::When(clauses) => write!(
f, f,
"When: [{}]", "When: [{}]",
clauses clauses
@ -191,35 +164,35 @@ impl fmt::Display for Ast {
.collect::<Vec<_>>() .collect::<Vec<_>>()
.join("\n") .join("\n")
), ),
Placeholder => todo!(), Ast::Placeholder => todo!(),
LBox(_name, _rhs) => todo!(), Ast::Box(_name, _rhs) => todo!(),
Match(value, clauses) => { Ast::Match(value, clauses) => {
write!( write!(
f, f,
"match: {} with {}", "match: {} with {}",
&value.0.to_string(), &value.0.to_string(),
clauses clauses
.iter() .iter()
.map(|clause| clause.0.to_string()) .map(|clause| clause.to_string())
.collect::<Vec<_>>() .collect::<Vec<_>>()
.join("\n") .join("\n")
) )
} }
Fn(name, clauses, _) => { Ast::Fn(name, clauses, _) => {
write!( write!(
f, f,
"fn: {}\n{}", "fn: {}\n{}",
name, name,
clauses clauses
.iter() .iter()
.map(|clause| clause.0.to_string()) .map(|clause| clause.to_string())
.collect::<Vec<_>>() .collect::<Vec<_>>()
.join("\n") .join("\n")
) )
} }
FnDeclaration(_name) => todo!(), Ast::FnDeclaration(_name) => todo!(),
Panic(_expr) => todo!(), Ast::Panic(_expr) => todo!(),
Do(terms) => { Ast::Do(terms) => {
write!( write!(
f, f,
"do: {}", "do: {}",
@ -230,25 +203,25 @@ impl fmt::Display for Ast {
.join(" > ") .join(" > ")
) )
} }
Repeat(_times, _body) => todo!(), Ast::Repeat(_times, _body) => todo!(),
Splat(word) => { Ast::Splat(word) => {
write!(f, "splat: {}", word) write!(f, "splat: {}", word)
} }
Pair(k, v) => { Ast::Pair(k, v) => {
write!(f, "pair: {} {}", k, v.0) write!(f, "pair: {} {}", k, v.0)
} }
Loop(init, body) => { Ast::Loop(init, body) => {
write!( write!(
f, f,
"loop: {} with {}", "loop: {} with {}",
init.0, init.0,
body.iter() body.iter()
.map(|clause| clause.0.to_string()) .map(|clause| clause.to_string())
.collect::<Vec<_>>() .collect::<Vec<_>>()
.join("\n") .join("\n")
) )
} }
Recur(args) => { Ast::Recur(args) => {
write!( write!(
f, f,
"recur: {}", "recur: {}",
@ -258,65 +231,22 @@ impl fmt::Display for Ast {
.join(", ") .join(", ")
) )
} }
MatchClause(pattern, guard, body) => {
write!(
f,
"match clause: {} if {:?} -> {}",
pattern.0, guard, body.0
)
}
WhenClause(cond, body) => {
write!(f, "when clause: {} -> {}", cond.0, body.0)
}
NilPattern => write!(f, "nil"),
BooleanPattern(b) => write!(f, "{}", b),
NumberPattern(n) => write!(f, "{}", n),
StringPattern(s) => write!(f, "{}", s),
KeywordPattern(k) => write!(f, ":{}", k),
WordPattern(w) => write!(f, "{}", w),
AsPattern(w, t) => write!(f, "{} as {}", w, t),
Splattern(p) => write!(f, "...{}", p.0),
PlaceholderPattern => write!(f, "_"),
TuplePattern(t) => write!(
f,
"({})",
t.iter()
.map(|x| x.0.to_string())
.collect::<Vec<_>>()
.join(", ")
),
ListPattern(l) => write!(
f,
"({})",
l.iter()
.map(|x| x.0.to_string())
.collect::<Vec<_>>()
.join(", ")
),
DictPattern(entries) => write!(
f,
"#{{{}}}",
entries
.iter()
.map(|(pair, _)| pair.to_string())
.collect::<Vec<_>>()
.join(", ")
),
PairPattern(key, value) => write!(f, ":{} {}", key, value.0),
InterpolatedPattern(strprts, _) => write!(
f,
"interpolated: \"{}\"",
strprts
.iter()
.map(|part| part.0.to_string())
.collect::<Vec<_>>()
.join("")
),
} }
} }
} }
#[derive(Clone, Debug, PartialEq)]
pub struct PairPattern {
pub key: &'static str,
pub patt: Spanned<Pattern>,
}
impl fmt::Display for PairPattern {
fn fmt(self: &PairPattern, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "pair pattern: {}: {}", self.key, self.patt.0)
}
}
pub struct StringMatcher(pub Box<dyn Fn(String) -> Option<Vec<(String, String)>>>); pub struct StringMatcher(pub Box<dyn Fn(String) -> Option<Vec<(String, String)>>>);
impl PartialEq for StringMatcher { impl PartialEq for StringMatcher {
@ -343,74 +273,74 @@ impl fmt::Debug for StringMatcher {
} }
} }
// #[derive(Clone, Debug, PartialEq)] #[derive(Clone, Debug, PartialEq)]
// pub enum Pattern { pub enum Pattern {
// Nil, Nil,
// Boolean(bool), Boolean(bool),
// Number(f64), Number(f64),
// String(&'static str), String(&'static str),
// Interpolated(Vec<Spanned<StringPart>>, StringMatcher), Interpolated(Vec<Spanned<StringPart>>, StringMatcher),
// Keyword(&'static str), Keyword(&'static str),
// Word(&'static str), Word(&'static str),
// As(&'static str, &'static str), As(&'static str, &'static str),
// Splattern(Box<Spanned<Self>>), Splattern(Box<Spanned<Self>>),
// Placeholder, Placeholder,
// Tuple(Vec<Spanned<Self>>), Tuple(Vec<Spanned<Self>>),
// List(Vec<Spanned<Self>>), List(Vec<Spanned<Self>>),
// Pair(&'static str, Box<Spanned<Self>>), Pair(&'static str, Box<Spanned<Self>>),
// Dict(Vec<Spanned<Self>>), Dict(Vec<Spanned<Self>>),
// } }
// impl fmt::Display for Pattern { impl fmt::Display for Pattern {
// fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
// match self { match self {
// Pattern::Nil => write!(f, "nil"), Pattern::Nil => write!(f, "nil"),
// Pattern::Boolean(b) => write!(f, "{}", b), Pattern::Boolean(b) => write!(f, "{}", b),
// Pattern::Number(n) => write!(f, "{}", n), Pattern::Number(n) => write!(f, "{}", n),
// Pattern::String(s) => write!(f, "{}", s), Pattern::String(s) => write!(f, "{}", s),
// Pattern::Keyword(k) => write!(f, ":{}", k), Pattern::Keyword(k) => write!(f, ":{}", k),
// Pattern::Word(w) => write!(f, "{}", w), Pattern::Word(w) => write!(f, "{}", w),
// Pattern::As(w, t) => write!(f, "{} as {}", w, t), Pattern::As(w, t) => write!(f, "{} as {}", w, t),
// Pattern::Splattern(p) => write!(f, "...{}", p.0), Pattern::Splattern(p) => write!(f, "...{}", p.0),
// Pattern::Placeholder => write!(f, "_"), Pattern::Placeholder => write!(f, "_"),
// Pattern::Tuple(t) => write!( Pattern::Tuple(t) => write!(
// f, f,
// "({})", "({})",
// t.iter() t.iter()
// .map(|x| x.0.to_string()) .map(|x| x.0.to_string())
// .collect::<Vec<_>>() .collect::<Vec<_>>()
// .join(", ") .join(", ")
// ), ),
// Pattern::List(l) => write!( Pattern::List(l) => write!(
// f, f,
// "({})", "({})",
// l.iter() l.iter()
// .map(|x| x.0.to_string()) .map(|x| x.0.to_string())
// .collect::<Vec<_>>() .collect::<Vec<_>>()
// .join(", ") .join(", ")
// ), ),
// Pattern::Dict(entries) => write!( Pattern::Dict(entries) => write!(
// f, f,
// "#{{{}}}", "#{{{}}}",
// entries entries
// .iter() .iter()
// .map(|(pair, _)| pair.to_string()) .map(|(pair, _)| pair.to_string())
// .collect::<Vec<_>>() .collect::<Vec<_>>()
// .join(", ") .join(", ")
// ), ),
// Pattern::Pair(key, value) => write!(f, ":{} {}", key, value.0), Pattern::Pair(key, value) => write!(f, ":{} {}", key, value.0),
// Pattern::Interpolated(strprts, _) => write!( Pattern::Interpolated(strprts, _) => write!(
// f, f,
// "interpolated: \"{}\"", "interpolated: \"{}\"",
// strprts strprts
// .iter() .iter()
// .map(|part| part.0.to_string()) .map(|part| part.0.to_string())
// .collect::<Vec<_>>() .collect::<Vec<_>>()
// .join("") .join("")
// ), ),
// } }
// } }
// } }
fn is_word_char(c: char) -> bool { fn is_word_char(c: char) -> bool {
if c.is_ascii_alphanumeric() { if c.is_ascii_alphanumeric() {
@ -546,8 +476,6 @@ pub fn parser<I>(
where where
I: ValueInput<'static, Token = Token, Span = Span>, I: ValueInput<'static, Token = Token, Span = Span>,
{ {
use Ast::*;
let mut expr = Recursive::declare(); let mut expr = Recursive::declare();
let mut pattern = Recursive::declare(); let mut pattern = Recursive::declare();
@ -569,15 +497,16 @@ where
}); });
let placeholder_pattern = let placeholder_pattern =
select! {Token::Punctuation("_") => PlaceholderPattern}.map_with(|p, e| (p, e.span())); select! {Token::Punctuation("_") => Pattern::Placeholder}.map_with(|p, e| (p, e.span()));
let word_pattern = select! { Token::Word(w) => WordPattern(w) }.map_with(|w, e| (w, e.span())); let word_pattern =
select! { Token::Word(w) => Pattern::Word(w) }.map_with(|w, e| (w, e.span()));
let atom_pattern = select! { let atom_pattern = select! {
Token::Nil => NilPattern, Token::Nil => Pattern::Nil,
Token::Boolean(b) => BooleanPattern(b), Token::Boolean(b) => Pattern::Boolean(b),
Token::Number(n) => NumberPattern(n), Token::Number(n) => Pattern::Number(n),
Token::Keyword(k) => KeywordPattern(k), Token::Keyword(k) => Pattern::Keyword(k),
} }
.map_with(|a, e| (a, e.span())); .map_with(|a, e| (a, e.span()));
@ -585,9 +514,9 @@ where
let parsed = parse_string(s, e.span()); let parsed = parse_string(s, e.span());
match parsed { match parsed {
Ok(parts) => match parts[0] { Ok(parts) => match parts[0] {
(StringPart::Inline(_), _) => Ok((StringPattern(s), e.span())), (StringPart::Inline(_), _) => Ok((Pattern::String(s), e.span())),
_ => Ok(( _ => Ok((
InterpolatedPattern(parts.clone(), compile_string_pattern(parts)), Pattern::Interpolated(parts.clone(), compile_string_pattern(parts)),
e.span(), e.span(),
)), )),
}, },
@ -597,7 +526,7 @@ where
let bare_splat = just(Token::Punctuation("...")).map_with(|_, e| { let bare_splat = just(Token::Punctuation("...")).map_with(|_, e| {
( (
Splattern(Box::new((PlaceholderPattern, e.span()))), Pattern::Splattern(Box::new((Pattern::Placeholder, e.span()))),
e.span(), e.span(),
) )
}); });
@ -606,7 +535,7 @@ where
let patt_splat = just(Token::Punctuation("...")) let patt_splat = just(Token::Punctuation("..."))
.ignore_then(splattable) .ignore_then(splattable)
.map_with(|x, e| (Splattern(Box::new(x)), e.span())); .map_with(|x, e| (Pattern::Splattern(Box::new(x)), e.span()));
let splattern = patt_splat.or(bare_splat); let splattern = patt_splat.or(bare_splat);
@ -618,7 +547,7 @@ where
.allow_trailing() .allow_trailing()
.collect() .collect()
.delimited_by(just(Token::Punctuation("(")), just(Token::Punctuation(")"))) .delimited_by(just(Token::Punctuation("(")), just(Token::Punctuation(")")))
.map_with(|tuple, e| (TuplePattern(tuple), e.span())) .map_with(|tuple, e| (Pattern::Tuple(tuple), e.span()))
.labelled("tuple pattern"); .labelled("tuple pattern");
let list_pattern = pattern let list_pattern = pattern
@ -629,15 +558,15 @@ where
.allow_trailing() .allow_trailing()
.collect() .collect()
.delimited_by(just(Token::Punctuation("[")), just(Token::Punctuation("]"))) .delimited_by(just(Token::Punctuation("[")), just(Token::Punctuation("]")))
.map_with(|list, e| (ListPattern(list), e.span())); .map_with(|list, e| (Pattern::List(list), e.span()));
let pair_pattern = select! {Token::Keyword(k) => k} let pair_pattern = select! {Token::Keyword(k) => k}
.then(pattern.clone()) .then(pattern.clone())
.map_with(|(key, patt), e| (PairPattern(key, Box::new(patt)), e.span())); .map_with(|(key, patt), e| (Pattern::Pair(key, Box::new(patt)), e.span()));
let shorthand_pattern = select! {Token::Word(w) => w}.map_with(|w, e| { let shorthand_pattern = select! {Token::Word(w) => w}.map_with(|w, e| {
( (
PairPattern(w, Box::new((WordPattern(w), e.span()))), Pattern::Pair(w, Box::new((Pattern::Word(w), e.span()))),
e.span(), e.span(),
) )
}); });
@ -653,14 +582,14 @@ where
just(Token::Punctuation("#{")), just(Token::Punctuation("#{")),
just(Token::Punctuation("}")), just(Token::Punctuation("}")),
) )
.map_with(|dict, e| (DictPattern(dict), e.span())); .map_with(|dict, e| (Pattern::Dict(dict), e.span()));
let keyword = select! {Token::Keyword(k) => Keyword(k),}.map_with(|k, e| (k, e.span())); let keyword = select! {Token::Keyword(k) => Ast::Keyword(k),}.map_with(|k, e| (k, e.span()));
let as_pattern = select! {Token::Word(w) => w} let as_pattern = select! {Token::Word(w) => w}
.then_ignore(just(Token::Reserved("as"))) .then_ignore(just(Token::Reserved("as")))
.then(select! {Token::Keyword(k) => k}) .then(select! {Token::Keyword(k) => k})
.map_with(|(w, t), e| (AsPattern(w, t), e.span())); .map_with(|(w, t), e| (Pattern::As(w, t), e.span()));
pattern.define( pattern.define(
atom_pattern atom_pattern
@ -675,16 +604,16 @@ where
); );
let placeholder = let placeholder =
select! {Token::Punctuation("_") => Placeholder}.map_with(|p, e| (p, e.span())); select! {Token::Punctuation("_") => Ast::Placeholder}.map_with(|p, e| (p, e.span()));
let word = select! { Token::Word(w) => Word(w) } let word = select! { Token::Word(w) => Ast::Word(w) }
.map_with(|w, e| (w, e.span())) .map_with(|w, e| (w, e.span()))
.labelled("word"); .labelled("word");
let value = select! { let value = select! {
Token::Nil => Nil, Token::Nil => Ast::Nil,
Token::Boolean(b) => Boolean(b), Token::Boolean(b) => Ast::Boolean(b),
Token::Number(n) => Number(n), Token::Number(n) => Ast::Number(n),
} }
.map_with(|v, e| (v, e.span())); .map_with(|v, e| (v, e.span()));
@ -692,8 +621,8 @@ where
let parsed = parse_string(s, e.span()); let parsed = parse_string(s, e.span());
match parsed { match parsed {
Ok(parts) => match parts[0] { Ok(parts) => match parts[0] {
(StringPart::Inline(_), _) => Ok((String(s), e.span())), (StringPart::Inline(_), _) => Ok((Ast::String(s), e.span())),
_ => Ok((Interpolated(parts), e.span())), _ => Ok((Ast::Interpolated(parts), e.span())),
}, },
Err(msg) => Err(Rich::custom(e.span(), msg)), Err(msg) => Err(Rich::custom(e.span(), msg)),
} }
@ -706,7 +635,7 @@ where
.allow_trailing() .allow_trailing()
.collect() .collect()
.delimited_by(just(Token::Punctuation("(")), just(Token::Punctuation(")"))) .delimited_by(just(Token::Punctuation("(")), just(Token::Punctuation(")")))
.map_with(|tuple, e| (Tuple(tuple), e.span())); .map_with(|tuple, e| (Ast::Tuple(tuple), e.span()));
let args = simple let args = simple
.clone() .clone()
@ -716,7 +645,7 @@ where
.allow_trailing() .allow_trailing()
.collect() .collect()
.delimited_by(just(Token::Punctuation("(")), just(Token::Punctuation(")"))) .delimited_by(just(Token::Punctuation("(")), just(Token::Punctuation(")")))
.map_with(|args, e| (Arguments(args), e.span())); .map_with(|args, e| (Ast::Arguments(args), e.span()));
let synth_root = word.or(keyword); let synth_root = word.or(keyword);
@ -726,14 +655,21 @@ where
.then(synth_term.clone()) .then(synth_term.clone())
.then(synth_term.clone().repeated().collect()) .then(synth_term.clone().repeated().collect())
.map_with(|((root, first), rest), e| { .map_with(|((root, first), rest), e| {
(Synthetic(Box::new(root), Box::new(first), rest), e.span()) (
Ast::Synthetic(Box::new(root), Box::new(first), rest),
e.span(),
)
}); });
let splat = just(Token::Punctuation("...")) let splat = just(Token::Punctuation("..."))
.ignore_then(word) .ignore_then(word)
.map_with(|(w, _), e| { .map_with(|(w, _), e| {
( (
Splat(if let Word(w) = w { w } else { unreachable!() }), Ast::Splat(if let Ast::Word(w) = w {
w
} else {
unreachable!()
}),
e.span(), e.span(),
) )
}); });
@ -746,14 +682,14 @@ where
.allow_trailing() .allow_trailing()
.collect() .collect()
.delimited_by(just(Token::Punctuation("[")), just(Token::Punctuation("]"))) .delimited_by(just(Token::Punctuation("[")), just(Token::Punctuation("]")))
.map_with(|list, e| (List(list), e.span())); .map_with(|list, e| (Ast::List(list), e.span()));
let pair = select! {Token::Keyword(k) => k} let pair = select! {Token::Keyword(k) => k}
.then(simple.clone()) .then(simple.clone())
.map_with(|(key, value), e| (Pair(key, Box::new(value)), e.span())); .map_with(|(key, value), e| (Ast::Pair(key, Box::new(value)), e.span()));
let shorthand = select! {Token::Word(w) => w} let shorthand = select! {Token::Word(w) => w}
.map_with(|w, e| (Pair(w, Box::new((Word(w), e.span()))), e.span())); .map_with(|w, e| (Ast::Pair(w, Box::new((Ast::Word(w), e.span()))), e.span()));
let dict = pair let dict = pair
.or(shorthand) .or(shorthand)
@ -766,15 +702,15 @@ where
just(Token::Punctuation("#{")), just(Token::Punctuation("#{")),
just(Token::Punctuation("}")), just(Token::Punctuation("}")),
) )
.map_with(|dict, e| (Dict(dict), e.span())); .map_with(|dict, e| (Ast::Dict(dict), e.span()));
let recur = just(Token::Reserved("recur")) let recur = just(Token::Reserved("recur"))
.ignore_then(tuple.clone()) .ignore_then(tuple.clone())
.map_with(|args, e| { .map_with(|args, e| {
let (Tuple(args), _) = args else { let (Ast::Tuple(args), _) = args else {
unreachable!() unreachable!()
}; };
(Recur(args), e.span()) (Ast::Recur(args), e.span())
}); });
let block = expr let block = expr
@ -784,7 +720,7 @@ where
.allow_trailing() .allow_trailing()
.collect() .collect()
.delimited_by(just(Token::Punctuation("{")), just(Token::Punctuation("}"))) .delimited_by(just(Token::Punctuation("{")), just(Token::Punctuation("}")))
.map_with(|block, e| (Block(block), e.span())) .map_with(|block, e| (Ast::Block(block), e.span()))
.recover_with(via_parser(nested_delimiters( .recover_with(via_parser(nested_delimiters(
Token::Punctuation("{"), Token::Punctuation("{"),
Token::Punctuation("}"), Token::Punctuation("}"),
@ -792,7 +728,7 @@ where
(Token::Punctuation("("), Token::Punctuation(")")), (Token::Punctuation("("), Token::Punctuation(")")),
(Token::Punctuation("["), Token::Punctuation("]")), (Token::Punctuation("["), Token::Punctuation("]")),
], ],
|span| (Error, span), |span| (Ast::Error, span),
))); )));
let if_ = just(Token::Reserved("if")) let if_ = just(Token::Reserved("if"))
@ -805,7 +741,7 @@ where
.then(expr.clone()) .then(expr.clone())
.map_with(|((condition, then_branch), else_branch), e| { .map_with(|((condition, then_branch), else_branch), e| {
( (
If( Ast::If(
Box::new(condition), Box::new(condition),
Box::new(then_branch), Box::new(then_branch),
Box::new(else_branch), Box::new(else_branch),
@ -818,7 +754,7 @@ where
.clone() .clone()
.then_ignore(just(Token::Punctuation("->"))) .then_ignore(just(Token::Punctuation("->")))
.then(expr.clone()) .then(expr.clone())
.map_with(|(cond, body), e| (WhenClause(Box::new(cond), Box::new(body)), e.span())); .map_with(|(cond, body), e| (WhenClause { cond, body }, e.span()));
let when = just(Token::Reserved("when")) let when = just(Token::Reserved("when"))
.ignore_then( .ignore_then(
@ -829,7 +765,7 @@ where
.collect() .collect()
.delimited_by(just(Token::Punctuation("{")), just(Token::Punctuation("}"))), .delimited_by(just(Token::Punctuation("{")), just(Token::Punctuation("}"))),
) )
.map_with(|clauses, e| (When(clauses), e.span())); .map_with(|clauses, e| (Ast::When(clauses), e.span()));
let guarded_clause = pattern let guarded_clause = pattern
.clone() .clone()
@ -837,25 +773,23 @@ where
.then(simple.clone()) .then(simple.clone())
.then_ignore(just(Token::Punctuation("->"))) .then_ignore(just(Token::Punctuation("->")))
.then(expr.clone()) .then(expr.clone())
.map_with(|((patt, guard), body), e| { .map_with(|((patt, guard), body), _| MatchClause {
( patt,
MatchClause(Box::new(patt), Box::new(Some(guard)), Box::new(body)), guard: Some(guard),
e.span(), body,
)
}); });
let match_clause = pattern let match_clause = pattern
.clone() .clone()
.then_ignore(just(Token::Punctuation("->"))) .then_ignore(just(Token::Punctuation("->")))
.then(expr.clone()) .then(expr.clone())
.map_with(|(patt, body), e| { .map_with(|(patt, body), _| MatchClause {
( patt,
MatchClause(Box::new(patt), Box::new(None), Box::new(body)), guard: None,
e.span(), body,
)
}); });
let r#match = just(Token::Reserved("match")) let match_ = just(Token::Reserved("match"))
.ignore_then(simple.clone()) .ignore_then(simple.clone())
.then_ignore(just(Token::Reserved("with"))) .then_ignore(just(Token::Reserved("with")))
.then( .then(
@ -868,13 +802,13 @@ where
.collect() .collect()
.delimited_by(just(Token::Punctuation("{")), just(Token::Punctuation("}"))), .delimited_by(just(Token::Punctuation("{")), just(Token::Punctuation("}"))),
) )
.map_with(|(expr, clauses), e| (Match(Box::new(expr), clauses), e.span())); .map_with(|(expr, clauses), e| (Ast::Match(Box::new(expr), clauses), e.span()));
let conditional = when.or(if_).or(r#match); let conditional = when.or(if_).or(match_);
let panic = just(Token::Reserved("panic!")) let panic = just(Token::Reserved("panic!"))
.ignore_then(nonbinding.clone()) .ignore_then(nonbinding.clone())
.map_with(|expr, e| (Panic(Box::new(expr)), e.span())); .map_with(|expr, e| (Ast::Panic(Box::new(expr)), e.span()));
let do_ = just(Token::Reserved("do")) let do_ = just(Token::Reserved("do"))
.ignore_then( .ignore_then(
@ -885,12 +819,12 @@ where
) )
.collect(), .collect(),
) )
.map_with(|exprs, e| (Do(exprs), e.span())); .map_with(|exprs, e| (Ast::Do(exprs), e.span()));
let repeat = just(Token::Reserved("repeat")) let repeat = just(Token::Reserved("repeat"))
.ignore_then(simple.clone()) .ignore_then(simple.clone())
.then(block.clone()) .then(block.clone())
.map_with(|(count, body), e| (Repeat(Box::new(count), Box::new(body)), e.span())); .map_with(|(count, body), e| (Ast::Repeat(Box::new(count), Box::new(body)), e.span()));
let fn_guarded = tuple_pattern let fn_guarded = tuple_pattern
.clone() .clone()
@ -898,11 +832,10 @@ where
.then(simple.clone()) .then(simple.clone())
.then_ignore(just(Token::Punctuation("->"))) .then_ignore(just(Token::Punctuation("->")))
.then(nonbinding.clone()) .then(nonbinding.clone())
.map_with(|((patt, guard), body), e| { .map_with(|((patt, guard), body), _| MatchClause {
( patt,
MatchClause(Box::new(patt), Box::new(Some(guard)), Box::new(body)), body,
e.span(), guard: Some(guard),
)
}) })
.labelled("function clause"); .labelled("function clause");
@ -910,11 +843,10 @@ where
.clone() .clone()
.then_ignore(just(Token::Punctuation("->"))) .then_ignore(just(Token::Punctuation("->")))
.then(nonbinding.clone()) .then(nonbinding.clone())
.map_with(|(patt, body), e| { .map_with(|(patt, body), _| MatchClause {
( patt,
MatchClause(Box::new(patt), Box::new(None), Box::new(body)), body,
e.span(), guard: None,
)
}) })
.labelled("function clause"); .labelled("function clause");
@ -922,7 +854,7 @@ where
let lambda = just(Token::Reserved("fn")) let lambda = just(Token::Reserved("fn"))
.ignore_then(fn_unguarded.clone()) .ignore_then(fn_unguarded.clone())
.map_with(|clause, e| (Fn("anonymous", vec![clause], None), e.span())); .map_with(|clause, e| (Ast::Fn("anonymous", vec![clause], None), e.span()));
let fn_clauses = fn_clause let fn_clauses = fn_clause
.clone() .clone()
@ -941,7 +873,7 @@ where
.ignore_then(tuple.clone()) .ignore_then(tuple.clone())
.then_ignore(just(Token::Reserved("with"))) .then_ignore(just(Token::Reserved("with")))
.then(loop_multiclause.clone().or(fn_single_clause.clone())) .then(loop_multiclause.clone().or(fn_single_clause.clone()))
.map_with(|(init, body), e| (Loop(Box::new(init), body), e.span())); .map_with(|(init, body), e| (Ast::Loop(Box::new(init), body), e.span()));
simple.define( simple.define(
synthetic synthetic
@ -974,7 +906,7 @@ where
.then_ignore(just(Token::Punctuation("="))) .then_ignore(just(Token::Punctuation("=")))
.then(nonbinding.clone()) .then(nonbinding.clone())
.map_with(|(pattern, expression), e| { .map_with(|(pattern, expression), e| {
(Let(Box::new(pattern), Box::new(expression)), e.span()) (Ast::Let(Box::new(pattern), Box::new(expression)), e.span())
}); });
let box_ = just(Token::Reserved("box")) let box_ = just(Token::Reserved("box"))
@ -982,35 +914,35 @@ where
.then_ignore(just(Token::Punctuation("="))) .then_ignore(just(Token::Punctuation("=")))
.then(nonbinding.clone()) .then(nonbinding.clone())
.map_with(|(word, expr), e| { .map_with(|(word, expr), e| {
let name = if let Word(w) = word.0 { let name = if let Ast::Word(w) = word.0 {
w w
} else { } else {
unreachable!() unreachable!()
}; };
(LBox(name, Box::new(expr)), e.span()) (Ast::Box(name, Box::new(expr)), e.span())
}); });
let fn_decl = just(Token::Reserved("fn")) let fn_decl = just(Token::Reserved("fn"))
.ignore_then(word) .ignore_then(word)
.map_with(|(word, _), e| { .map_with(|(word, _), e| {
let name = if let Word(w) = word { let name = if let Ast::Word(w) = word {
w w
} else { } else {
unreachable!() unreachable!()
}; };
(FnDeclaration(name), e.span()) (Ast::FnDeclaration(name), e.span())
}); });
let fn_named = just(Token::Reserved("fn")) let fn_named = just(Token::Reserved("fn"))
.ignore_then(word) .ignore_then(word)
.then(fn_unguarded.clone()) .then(fn_unguarded.clone())
.map_with(|(word, clause), e| { .map_with(|(word, clause), e| {
let name = if let Word(word) = word.0 { let name = if let Ast::Word(word) = word.0 {
word word
} else { } else {
unreachable!() unreachable!()
}; };
(Fn(name, vec![clause], None), e.span()) (Ast::Fn(name, vec![clause], None), e.span())
}); });
let docstr = select! {Token::String(s) => s}; let docstr = select! {Token::String(s) => s};
@ -1027,12 +959,12 @@ where
.ignore_then(word) .ignore_then(word)
.then(fn_multiclause) .then(fn_multiclause)
.map_with(|(word, (docstr, clauses, _)), e| { .map_with(|(word, (docstr, clauses, _)), e| {
let name = if let Word(word) = word.0 { let name = if let Ast::Word(word) = word.0 {
word word
} else { } else {
unreachable!() unreachable!()
}; };
(Fn(name, clauses, docstr), e.span()) (Ast::Fn(name, clauses, docstr), e.span())
}); });
let fn_ = fn_named.or(fn_compound).or(fn_decl); let fn_ = fn_named.or(fn_compound).or(fn_decl);
@ -1046,7 +978,7 @@ where
.allow_trailing() .allow_trailing()
.allow_leading() .allow_leading()
.collect() .collect()
.map_with(|exprs, e| (Block(exprs), e.span())); .map_with(|exprs, e| (Ast::Block(exprs), e.span()));
script script
} }

3
src/validator.rs
View File

@ -315,7 +315,7 @@ impl<'a> Validator<'a> {
// binding forms // binding forms
// TODO: set up errors to include original binding // TODO: set up errors to include original binding
Ast::LBox(name, boxed) => { Ast::Box(name, boxed) => {
if self.bound(name).is_some() { if self.bound(name).is_some() {
self.err(format!("box name `{name}` is already bound")); self.err(format!("box name `{name}` is already bound"));
} else { } else {
@ -470,7 +470,6 @@ impl<'a> Validator<'a> {
} }
// terminals can never be invalid // terminals can never be invalid
Ast::Nil | Ast::Boolean(_) | Ast::Number(_) | Ast::Keyword(_) | Ast::String(_) => (), Ast::Nil | Ast::Boolean(_) | Ast::Number(_) | Ast::Keyword(_) | Ast::String(_) => (),
_ => todo!(),
}; };
self.ast = root; self.ast = root;
} }

5
src/value.rs
View File

@ -1,6 +1,5 @@
use crate::base::*; use crate::base::*;
use crate::parser::*; use crate::parser::*;
use crate::spans::*;
use imbl::*; use imbl::*;
use std::cell::RefCell; use std::cell::RefCell;
use std::fmt; use std::fmt;
@ -10,7 +9,7 @@ use struct_scalpel::Dissectible;
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub struct Fn<'src> { pub struct Fn<'src> {
pub name: String, pub name: String,
pub body: &'src Vec<Spanned<Ast>>, pub body: &'src Vec<MatchClause>,
pub doc: Option<String>, pub doc: Option<String>,
} }
@ -30,7 +29,7 @@ pub enum Value<'src> {
Dict(HashMap<&'static str, Self>), Dict(HashMap<&'static str, Self>),
Box(&'static str, Rc<RefCell<Self>>), Box(&'static str, Rc<RefCell<Self>>),
Fn(Rc<Fn<'src>>), Fn(Rc<Fn<'src>>),
Base(BaseFn<'src>), Base(Base<'src>),
Recur(Vec<Self>), Recur(Vec<Self>),
// Set(HashSet<Self>), // Set(HashSet<Self>),
// Sets are hard // Sets are hard