866 lines
29 KiB
Rust
866 lines
29 KiB
Rust
// an implementation of Ludus
|
|
|
|
// curently left undone (and not adding for a while yet):
|
|
// * sets
|
|
// * interpolated strings & string patterns
|
|
// * pkgs, namespaces, imports, `use` forms
|
|
// * with forms
|
|
// * test forms
|
|
// * ignored words
|
|
|
|
// todo:
|
|
// * [ ] rewrite fn parser to use chumsky::Recursive::declare/define
|
|
// - [ ] do this to extract/simplify/DRY things like tuple patterns, fn clauses, etc.
|
|
// * [ ] Work around chumsky::Stream::from_iter().spanned disappearing in most recent version
|
|
// * [x] investigate using labels (which is behind a compiler flag, somehow)
|
|
// * [ ] wire up Ariadne parsing errors
|
|
// * [ ] validation
|
|
// * [ ] break this out into multiple files
|
|
// * [ ] write a tree-walk VM
|
|
// - [ ] learn how to deal with lifetimes
|
|
// - [ ] with stack mechanics and refcounting
|
|
// - [ ] with tail-call optimization
|
|
// * [ ] write `base` in Rust
|
|
// * [ ] turn this into a library function
|
|
// * [ ] compile this into WASM
|
|
// * [ ] perf testing
|
|
|
|
use chumsky::{
|
|
input::{Stream, ValueInput},
|
|
prelude::*,
|
|
};
|
|
use imbl::{HashMap, Vector};
|
|
use std::fmt;
|
|
|
|
pub type Span = SimpleSpan<usize>;
|
|
pub type Spanned<T> = (T, Span);
|
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub enum Token<'src> {
|
|
Nil,
|
|
Number(f64),
|
|
Word(&'src str),
|
|
Boolean(bool),
|
|
Keyword(&'src str),
|
|
String(&'src str),
|
|
// todo: hard code these types
|
|
Reserved(&'src str),
|
|
Punctuation(&'src str),
|
|
}
|
|
|
|
impl<'src> fmt::Display for Token<'src> {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
match self {
|
|
Token::Number(n) => write!(f, "[Number {}]", n),
|
|
Token::Word(w) => write!(f, "[Word {}]", w),
|
|
Token::Boolean(b) => write!(f, "[Boolean {}]", b),
|
|
Token::Keyword(k) => write!(f, "[Keyword :{}]", k),
|
|
Token::String(s) => write!(f, "[String {}]", s),
|
|
Token::Reserved(r) => write!(f, "[Reserved {}]", r),
|
|
Token::Nil => write!(f, "[nil]"),
|
|
Token::Punctuation(p) => write!(f, "[Punctuation {}]", p),
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn lexer<'src>(
|
|
) -> impl Parser<'src, &'src str, Vec<(Token<'src>, Span)>, extra::Err<Rich<'src, char, Span>>> {
|
|
let number = just('-')
|
|
.or_not()
|
|
.then(text::int(10).then(just('.').then(text::digits(10)).or_not()))
|
|
.to_slice()
|
|
.from_str()
|
|
.unwrapped()
|
|
.map(Token::Number);
|
|
|
|
let word = any()
|
|
.filter(char::is_ascii_lowercase)
|
|
.then(
|
|
any()
|
|
.filter(char::is_ascii_alphanumeric)
|
|
.or(one_of("*/?!_"))
|
|
.repeated(),
|
|
)
|
|
.to_slice();
|
|
|
|
let reserved_or_word = word.map(|word: &str| match word {
|
|
"true" => Token::Boolean(true),
|
|
"false" => Token::Boolean(false),
|
|
"nil" => Token::Nil,
|
|
// todo: hard code these as type constructors
|
|
"as" | "box" | "do" | "else" | "fn" | "if" | "let" | "loop" | "match" | "panic!"
|
|
| "recur" | "repeat" | "then" | "when" | "with" => Token::Reserved(word),
|
|
_ => Token::Word(word),
|
|
});
|
|
|
|
let keyword = just(':').ignore_then(word.clone()).map(Token::Keyword);
|
|
|
|
let string = just('"')
|
|
.ignore_then(none_of("\"").repeated().to_slice())
|
|
.then_ignore(just('"'))
|
|
.map(Token::String);
|
|
|
|
// todo: hard code these as type constructors
|
|
let punctuation = one_of(",=[]{}()>;\n_")
|
|
.to_slice()
|
|
.or(just("->"))
|
|
.or(just("..."))
|
|
.or(just("#{"))
|
|
.or(just("${"))
|
|
.map(Token::Punctuation);
|
|
|
|
let token = number
|
|
.or(reserved_or_word)
|
|
.or(keyword)
|
|
.or(string)
|
|
.or(punctuation);
|
|
|
|
let comment = just('&')
|
|
.ignore_then(any().and_is(just('\n').not()).repeated())
|
|
.repeated();
|
|
|
|
let ludus_ws = just(' ').or(just('\t')).repeated();
|
|
|
|
token
|
|
.map_with(|tok, e| (tok, e.span()))
|
|
.padded_by(ludus_ws)
|
|
.padded_by(comment)
|
|
.recover_with(skip_then_retry_until(any().ignored(), end()))
|
|
.repeated()
|
|
.collect()
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
struct Clause<'src> {
|
|
patt: Pattern<'src>,
|
|
span: Span,
|
|
body: Ast<'src>,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
struct Fn<'src> {
|
|
name: &'src str,
|
|
span: Span,
|
|
body: Vec<Clause<'src>>,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
enum Value<'src> {
|
|
Nil,
|
|
Boolean(bool),
|
|
Number(f64),
|
|
Keyword(&'src str),
|
|
String(&'src str),
|
|
Tuple(Vec<Self>), // on the heap for now
|
|
List(Vector<Self>), // ref-counted, immutable, persistent
|
|
Dict(HashMap<&'src str, Self>), // ref-counted, immutable, persistent
|
|
Fn(&'src Fn<'src>),
|
|
// Set(HashSet<Self>),
|
|
// Sets are hard
|
|
// Sets require Eq
|
|
// Eq is not implemented on f64, because NaNs
|
|
// We could use ordered_float::NotNan
|
|
// Let's defer that
|
|
// We're not really using sets in Ludus
|
|
|
|
// Other things we're not implementing yet:
|
|
// pkgs, nses, tests
|
|
}
|
|
|
|
impl<'src> fmt::Display for Value<'src> {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
match self {
|
|
Value::Nil => write!(f, "nil"),
|
|
Value::Boolean(b) => write!(f, "{}", b),
|
|
Value::Number(n) => write!(f, "{}", n),
|
|
Value::Keyword(k) => write!(f, ":{}", k),
|
|
Value::String(s) => write!(f, "\"{}\"", s),
|
|
Value::Fn(fun) => write!(f, "fn {}", fun.name),
|
|
Value::Tuple(t) => write!(
|
|
f,
|
|
"({})",
|
|
t.iter()
|
|
.map(|x| x.to_string())
|
|
.collect::<Vec<_>>()
|
|
.join(", ")
|
|
),
|
|
Value::List(l) => write!(
|
|
f,
|
|
"[{}]",
|
|
l.iter()
|
|
.map(|x| x.to_string())
|
|
.collect::<Vec<_>>()
|
|
.join(", ")
|
|
),
|
|
Value::Dict(d) => write!(f, "#{{{:?}}}", d),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
enum Ast<'src> {
|
|
Error,
|
|
Placeholder,
|
|
Value(Value<'src>),
|
|
Word(&'src str),
|
|
Block(Vec<Spanned<Self>>),
|
|
If(Box<Spanned<Self>>, Box<Spanned<Self>>, Box<Spanned<Self>>),
|
|
Tuple(Vec<Spanned<Self>>),
|
|
Arguments(Vec<Spanned<Self>>),
|
|
List(Vec<Spanned<Self>>),
|
|
Pair(Value<'src>, Box<Spanned<Self>>),
|
|
Dict(Vec<Spanned<Self>>),
|
|
Let(Box<Spanned<Pattern<'src>>>, Box<Spanned<Self>>),
|
|
Box(&'src str, Box<Spanned<Self>>),
|
|
Synthetic(Box<Spanned<Self>>, Box<Spanned<Self>>, Vec<Spanned<Self>>),
|
|
WhenClause(Box<Spanned<Self>>, Box<Spanned<Self>>),
|
|
When(Vec<Spanned<Self>>),
|
|
MatchClause(Box<Spanned<Pattern<'src>>>, Box<Spanned<Self>>),
|
|
Match(Box<Spanned<Self>>, Vec<Spanned<Self>>),
|
|
FnClause(Box<Spanned<Pattern<'src>>>, Box<Spanned<Self>>),
|
|
Fn(&'src str, Vec<Spanned<Self>>),
|
|
FnDeclaration(&'src str),
|
|
Panic(Box<Spanned<Self>>),
|
|
Do(Vec<Spanned<Self>>),
|
|
Repeat(Box<Spanned<Self>>, Box<Spanned<Self>>),
|
|
Loop(Box<Spanned<Self>>, Vec<Spanned<Self>>),
|
|
Recur(Vec<Spanned<Self>>),
|
|
}
|
|
|
|
impl<'src> fmt::Display for Ast<'src> {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
match self {
|
|
Ast::Error => write!(f, "Error"),
|
|
Ast::Value(v) => write!(f, "Value: {}", v),
|
|
Ast::Word(w) => write!(f, "Word: {}", w),
|
|
Ast::Block(b) => write!(
|
|
f,
|
|
"Block: <{}>",
|
|
b.iter()
|
|
.map(|(line, _)| line.to_string())
|
|
.collect::<Vec<_>>()
|
|
.join("\n")
|
|
),
|
|
Ast::If(cond, then_branch, else_branch) => write!(
|
|
f,
|
|
"If: {} Then: {} Else: {}",
|
|
cond.0, then_branch.0, else_branch.0
|
|
),
|
|
Ast::Let(pattern, expression) => {
|
|
write!(f, "Let: {} = {}", pattern.0, expression.0)
|
|
}
|
|
Ast::Pair(kw, expr) => write!(f, "{} {}", kw, expr.0),
|
|
Ast::Dict(entries) => write!(
|
|
f,
|
|
"#{{{}}}",
|
|
entries
|
|
.iter()
|
|
.map(|(pair, _)| pair.to_string())
|
|
.collect::<Vec<_>>()
|
|
.join(", ")
|
|
),
|
|
Ast::List(l) => write!(
|
|
f,
|
|
"List: [{}]",
|
|
l.iter()
|
|
.map(|(line, _)| line.to_string())
|
|
.collect::<Vec<_>>()
|
|
.join("\n")
|
|
),
|
|
Ast::Tuple(t) | Ast::Arguments(t) => write!(
|
|
f,
|
|
"Tuple: ({})",
|
|
t.iter()
|
|
.map(|(line, _)| line.to_string())
|
|
.collect::<Vec<_>>()
|
|
.join("\n")
|
|
),
|
|
Ast::Synthetic(root, first, rest) => write!(
|
|
f,
|
|
"Synth: [{}, {}, {}]",
|
|
root.0,
|
|
first.0,
|
|
rest.iter()
|
|
.map(|(term, _)| term.to_string())
|
|
.collect::<Vec<_>>()
|
|
.join("\n")
|
|
),
|
|
_ => unimplemented!(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
enum Pattern<'src> {
|
|
Atom(Value<'src>),
|
|
Word(&'src str),
|
|
Placeholder,
|
|
Tuple(Vec<Spanned<Self>>),
|
|
List(Vec<Spanned<Self>>),
|
|
// is this the right representation for Dicts?
|
|
// Could/should this also be a Vec?
|
|
Pair(Value<'src>, Box<Spanned<Self>>),
|
|
Dict(Vec<Spanned<Self>>),
|
|
}
|
|
|
|
impl<'src> fmt::Display for Pattern<'src> {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
match self {
|
|
Pattern::Atom(a) => write!(f, "{}", a),
|
|
Pattern::Word(w) => write!(f, "{}", w),
|
|
Pattern::Placeholder => write!(f, "_"),
|
|
Pattern::Tuple(t) => write!(
|
|
f,
|
|
"({})",
|
|
t.iter()
|
|
.map(|x| x.0.to_string())
|
|
.collect::<Vec<_>>()
|
|
.join(", ")
|
|
),
|
|
Pattern::List(l) => write!(
|
|
f,
|
|
"({})",
|
|
l.iter()
|
|
.map(|x| x.0.to_string())
|
|
.collect::<Vec<_>>()
|
|
.join(", ")
|
|
),
|
|
Pattern::Pair(kw, expr) => write!(f, "{} {}", kw, expr.0),
|
|
Pattern::Dict(entries) => write!(
|
|
f,
|
|
"#{{{}}}",
|
|
entries
|
|
.iter()
|
|
.map(|(pair, _)| pair.to_string())
|
|
.collect::<Vec<_>>()
|
|
.join(", ")
|
|
),
|
|
}
|
|
}
|
|
}
|
|
|
|
fn parser<'src, I>(
|
|
) -> impl Parser<'src, I, Spanned<Ast<'src>>, extra::Err<Rich<'src, Token<'src>, Span>>> + Clone
|
|
where
|
|
I: ValueInput<'src, Token = Token<'src>, Span = Span>,
|
|
{
|
|
recursive(|expr| {
|
|
let separators = recursive(|separators| {
|
|
just(Token::Punctuation(","))
|
|
.or(just(Token::Punctuation("\n")))
|
|
.then(separators.clone().repeated())
|
|
});
|
|
|
|
let pattern = recursive(|pattern| {
|
|
let placeholder = select! {Token::Punctuation("_") => Pattern::Placeholder}
|
|
.map_with(|p, e| (p, e.span()));
|
|
|
|
let word =
|
|
select! { Token::Word(w) => Pattern::Word(w) }.map_with(|w, e| (w, e.span()));
|
|
|
|
let atom = select! {
|
|
Token::Nil => Pattern::Atom(Value::Nil),
|
|
Token::Boolean(b) => Pattern::Atom(Value::Boolean(b)),
|
|
Token::Number(n) => Pattern::Atom(Value::Number(n)),
|
|
Token::Keyword(k) => Pattern::Atom(Value::Keyword(k)),
|
|
}
|
|
.map_with(|a, e| (a, e.span()));
|
|
|
|
let tuple = pattern
|
|
.clone()
|
|
.separated_by(separators.clone())
|
|
.allow_leading()
|
|
.allow_trailing()
|
|
.collect()
|
|
.delimited_by(just(Token::Punctuation("(")), just(Token::Punctuation(")")))
|
|
.map_with(|tuple, e| (Pattern::Tuple(tuple), e.span()));
|
|
|
|
let list = pattern
|
|
.clone()
|
|
.separated_by(separators.clone())
|
|
.allow_leading()
|
|
.allow_trailing()
|
|
.collect()
|
|
.delimited_by(just(Token::Punctuation("[")), just(Token::Punctuation("]")))
|
|
.map_with(|list, e| (Pattern::List(list), e.span()));
|
|
|
|
let pair = select! {Token::Keyword(k) => Value::Keyword(k)}
|
|
.then(pattern.clone())
|
|
.map_with(|(kw, patt), e| (Pattern::Pair(kw, Box::new(patt)), e.span()));
|
|
|
|
let shorthand = select! {Token::Word(w) => w}.map_with(|w, e| {
|
|
(
|
|
Pattern::Pair(Value::Keyword(w), Box::new((Pattern::Word(w), e.span()))),
|
|
e.span(),
|
|
)
|
|
});
|
|
|
|
let dict = pair
|
|
.or(shorthand)
|
|
.separated_by(separators.clone())
|
|
.allow_leading()
|
|
.allow_trailing()
|
|
.collect()
|
|
.delimited_by(
|
|
just(Token::Punctuation("#{")),
|
|
just(Token::Punctuation("}")),
|
|
)
|
|
.map_with(|dict, e| (Pattern::Dict(dict), e.span()));
|
|
|
|
atom.or(word)
|
|
.or(placeholder)
|
|
.or(tuple)
|
|
.or(list)
|
|
.or(dict)
|
|
.labelled("pattern")
|
|
});
|
|
|
|
let placeholder =
|
|
select! {Token::Punctuation("_") => Ast::Placeholder}.map_with(|p, e| (p, e.span()));
|
|
|
|
let word = select! { Token::Word(w) => Ast::Word(w) }
|
|
.map_with(|w, e| (w, e.span()))
|
|
.labelled("word");
|
|
|
|
let simple = recursive(|simple| {
|
|
let value = select! {
|
|
Token::Nil => Ast::Value(Value::Nil),
|
|
Token::Boolean(b) => Ast::Value(Value::Boolean(b)),
|
|
Token::Number(n) => Ast::Value(Value::Number(n)),
|
|
Token::String(s) => Ast::Value(Value::String(s)),
|
|
}
|
|
.map_with(|v, e| (v, e.span()));
|
|
|
|
let keyword = select! {Token::Keyword(k) => Ast::Value(Value::Keyword(k)),}
|
|
.map_with(|k, e| (k, e.span()));
|
|
|
|
// let word = select! {Token::Word(w) => Ast::Word(w)}.map_with(|w, e| (w, e.span()));
|
|
|
|
let tuple = simple
|
|
.clone()
|
|
.separated_by(separators.clone())
|
|
.allow_leading()
|
|
.allow_trailing()
|
|
.collect()
|
|
.delimited_by(just(Token::Punctuation("(")), just(Token::Punctuation(")")))
|
|
.map_with(|tuple, e| (Ast::Tuple(tuple), e.span()));
|
|
|
|
// let placeholder = select! {Token::Punctuation("_") => Ast::Placeholder}
|
|
// .map_with(|p, e| (p, e.span()));
|
|
|
|
let args = simple
|
|
.clone()
|
|
.or(placeholder)
|
|
.separated_by(separators.clone())
|
|
.allow_leading()
|
|
.allow_trailing()
|
|
.collect()
|
|
.delimited_by(just(Token::Punctuation("(")), just(Token::Punctuation(")")))
|
|
.map_with(|args, e| (Ast::Arguments(args), e.span()));
|
|
|
|
let synth_root = word.clone().or(keyword.clone());
|
|
|
|
let synth_term = keyword.clone().or(args);
|
|
|
|
let synthetic = synth_root
|
|
.then(synth_term.clone())
|
|
.then(synth_term.clone().repeated().collect())
|
|
.map_with(|((root, first), rest), e| {
|
|
(
|
|
Ast::Synthetic(Box::new(root), Box::new(first), rest),
|
|
e.span(),
|
|
)
|
|
});
|
|
|
|
let list = simple
|
|
.clone()
|
|
.separated_by(separators.clone())
|
|
.allow_leading()
|
|
.allow_trailing()
|
|
.collect()
|
|
.delimited_by(just(Token::Punctuation("[")), just(Token::Punctuation("]")))
|
|
.map_with(|list, e| (Ast::List(list), e.span()));
|
|
|
|
let pair = select! {Token::Keyword(k) => Value::Keyword(k)}
|
|
.then(simple.clone())
|
|
.map_with(|(kw, expr), e| (Ast::Pair(kw, Box::new(expr)), e.span()));
|
|
|
|
let shorthand = select! {Token::Word(w) => w}.map_with(|w, e| {
|
|
(
|
|
Ast::Pair(Value::Keyword(w), Box::new((Ast::Word(w), e.span()))),
|
|
e.span(),
|
|
)
|
|
});
|
|
|
|
let dict = pair
|
|
.or(shorthand)
|
|
.separated_by(separators.clone())
|
|
.allow_leading()
|
|
.allow_trailing()
|
|
.collect()
|
|
.delimited_by(
|
|
just(Token::Punctuation("#{")),
|
|
just(Token::Punctuation("}")),
|
|
)
|
|
.map_with(|dict, e| (Ast::Dict(dict), e.span()));
|
|
|
|
synthetic
|
|
.or(word)
|
|
.or(keyword)
|
|
.or(value)
|
|
.or(tuple)
|
|
.or(list)
|
|
.or(dict)
|
|
.labelled("simple expression")
|
|
});
|
|
|
|
let terminators = recursive(|terminators| {
|
|
just(Token::Punctuation("\n"))
|
|
.or(just(Token::Punctuation(";")))
|
|
.then(terminators.clone().repeated())
|
|
.labelled("terminator")
|
|
});
|
|
|
|
let nonbinding = recursive(|nonbinding| {
|
|
let block = expr
|
|
.clone()
|
|
.separated_by(terminators.clone())
|
|
.allow_leading()
|
|
.allow_trailing()
|
|
.collect()
|
|
.delimited_by(just(Token::Punctuation("{")), just(Token::Punctuation("}")))
|
|
.map_with(|block, e| (Ast::Block(block), e.span()))
|
|
.recover_with(via_parser(nested_delimiters(
|
|
Token::Punctuation("{"),
|
|
Token::Punctuation("}"),
|
|
[
|
|
(Token::Punctuation("("), Token::Punctuation(")")),
|
|
(Token::Punctuation("["), Token::Punctuation("]")),
|
|
],
|
|
|span| (Ast::Error, span),
|
|
)));
|
|
|
|
let if_ = just(Token::Reserved("if"))
|
|
.ignore_then(simple.clone())
|
|
.then_ignore(just(Token::Reserved("then")))
|
|
.then(expr.clone())
|
|
.then_ignore(just(Token::Reserved("else")))
|
|
.then(expr.clone())
|
|
.map_with(|((condition, then_branch), else_branch), e| {
|
|
(
|
|
Ast::If(
|
|
Box::new(condition),
|
|
Box::new(then_branch),
|
|
Box::new(else_branch),
|
|
),
|
|
e.span(),
|
|
)
|
|
});
|
|
|
|
let when_clause = simple
|
|
.clone()
|
|
.then_ignore(just(Token::Punctuation("->")))
|
|
.then(expr.clone())
|
|
.map_with(|(cond, body), e| {
|
|
(Ast::WhenClause(Box::new(cond), Box::new(body)), e.span())
|
|
});
|
|
|
|
let when = just(Token::Reserved("when"))
|
|
.ignore_then(
|
|
when_clause
|
|
.separated_by(terminators.clone())
|
|
.allow_trailing()
|
|
.allow_leading()
|
|
.collect()
|
|
.delimited_by(just(Token::Punctuation("{")), just(Token::Punctuation("}"))),
|
|
)
|
|
.map_with(|clauses, e| (Ast::When(clauses), e.span()));
|
|
|
|
let match_clause = pattern
|
|
.clone()
|
|
.then_ignore(just(Token::Punctuation("->")))
|
|
.then(expr.clone())
|
|
.map_with(|(patt, body), e| {
|
|
(Ast::MatchClause(Box::new(patt), Box::new(body)), e.span())
|
|
});
|
|
|
|
let match_ = just(Token::Reserved("match"))
|
|
.ignore_then(simple.clone())
|
|
.then_ignore(just(Token::Reserved("with")))
|
|
.then(
|
|
match_clause
|
|
.clone()
|
|
.separated_by(terminators.clone())
|
|
.allow_leading()
|
|
.allow_trailing()
|
|
.collect()
|
|
.delimited_by(just(Token::Punctuation("{")), just(Token::Punctuation("}"))),
|
|
)
|
|
.map_with(|(expr, clauses), e| (Ast::Match(Box::new(expr), clauses), e.span()));
|
|
|
|
let conditional = when.or(if_).or(match_);
|
|
|
|
//todo:
|
|
// * [x] do
|
|
// * [ ] loop
|
|
// * [ ] repeat
|
|
// * [x] panic!
|
|
|
|
let panic = just(Token::Reserved("panic!"))
|
|
.ignore_then(nonbinding.clone())
|
|
.map_with(|expr, e| (Ast::Panic(Box::new(expr)), e.span()));
|
|
|
|
let do_ = just(Token::Reserved("do"))
|
|
.ignore_then(
|
|
nonbinding
|
|
.clone()
|
|
.separated_by(
|
|
just(Token::Punctuation(">"))
|
|
.then(just(Token::Punctuation("\n")).repeated()),
|
|
)
|
|
.collect(),
|
|
)
|
|
.map_with(|exprs, e| (Ast::Do(exprs), e.span()));
|
|
|
|
let repeat = just(Token::Reserved("repeat"))
|
|
.ignore_then(simple.clone())
|
|
.then(block.clone())
|
|
.map_with(|(count, body), e| {
|
|
(Ast::Repeat(Box::new(count), Box::new(body)), e.span())
|
|
});
|
|
|
|
let tuple_pattern = pattern
|
|
.clone()
|
|
.separated_by(separators.clone())
|
|
.allow_leading()
|
|
.allow_trailing()
|
|
.collect()
|
|
.delimited_by(just(Token::Punctuation("(")), just(Token::Punctuation(")")))
|
|
.map_with(|tuple, e| (Pattern::Tuple(tuple), e.span()))
|
|
.labelled("tuple pattern");
|
|
|
|
let fn_clause = tuple_pattern
|
|
.then_ignore(just(Token::Punctuation("->")))
|
|
.then(nonbinding.clone())
|
|
.map_with(|(pattern, body), e| {
|
|
(Ast::FnClause(Box::new(pattern), Box::new(body)), e.span())
|
|
})
|
|
.labelled("function clause");
|
|
|
|
let lambda = just(Token::Reserved("fn"))
|
|
.ignore_then(fn_clause)
|
|
.map_with(|clause, e| (Ast::Fn("anonymous", vec![clause]), e.span()));
|
|
|
|
let loop_ = just(Token::Reserved("loop"));
|
|
|
|
simple
|
|
.clone()
|
|
.or(conditional)
|
|
.or(block)
|
|
.or(lambda)
|
|
.or(panic)
|
|
.or(do_)
|
|
.labelled("nonbinding expression")
|
|
});
|
|
|
|
let let_ = just(Token::Reserved("let"))
|
|
.ignore_then(pattern.clone())
|
|
.then_ignore(just(Token::Punctuation("=")))
|
|
.then(nonbinding.clone())
|
|
.map_with(|(pattern, expression), e| {
|
|
(Ast::Let(Box::new(pattern), Box::new(expression)), e.span())
|
|
});
|
|
|
|
let box_ = just(Token::Reserved("box"))
|
|
.ignore_then(word.clone())
|
|
.then_ignore(just(Token::Punctuation("=")))
|
|
.then(nonbinding.clone())
|
|
.map_with(|(word, expr), e| {
|
|
let name = if let Ast::Word(w) = word.0 {
|
|
w
|
|
} else {
|
|
unreachable!()
|
|
};
|
|
(Ast::Box(name, Box::new(expr)), e.span())
|
|
});
|
|
|
|
let fn_decl = just(Token::Reserved("fn"))
|
|
.ignore_then(word.clone())
|
|
.map_with(|(word, _), e| {
|
|
let name = if let Ast::Word(w) = word {
|
|
w
|
|
} else {
|
|
unreachable!()
|
|
};
|
|
(Ast::FnDeclaration(name), e.span())
|
|
});
|
|
|
|
let tuple_pattern = pattern
|
|
.clone()
|
|
.separated_by(separators.clone())
|
|
.allow_leading()
|
|
.allow_trailing()
|
|
.collect()
|
|
.delimited_by(just(Token::Punctuation("(")), just(Token::Punctuation(")")))
|
|
.map_with(|tuple, e| (Pattern::Tuple(tuple), e.span()));
|
|
|
|
let fn_clause = tuple_pattern
|
|
.then_ignore(just(Token::Punctuation("->")))
|
|
.then(nonbinding.clone())
|
|
.map_with(|(pattern, body), e| {
|
|
(Ast::FnClause(Box::new(pattern), Box::new(body)), e.span())
|
|
});
|
|
|
|
let fn_named = just(Token::Reserved("fn"))
|
|
.ignore_then(word.clone())
|
|
.then(fn_clause.clone())
|
|
.map_with(|(word, clause), e| {
|
|
let name = if let Ast::Word(word) = word.0 {
|
|
word
|
|
} else {
|
|
unreachable!()
|
|
};
|
|
(Ast::Fn(name, vec![clause]), e.span())
|
|
});
|
|
|
|
let fn_compound = just(Token::Reserved("fn"))
|
|
.ignore_then(word.clone())
|
|
.then(
|
|
fn_clause
|
|
.clone()
|
|
.separated_by(terminators)
|
|
.allow_leading()
|
|
.allow_trailing()
|
|
.collect()
|
|
.delimited_by(just(Token::Punctuation("{")), just(Token::Punctuation("}"))),
|
|
)
|
|
.map_with(|(word, clauses), e| {
|
|
let name = if let Ast::Word(word) = word.0 {
|
|
word
|
|
} else {
|
|
unreachable!()
|
|
};
|
|
(Ast::Fn(name, clauses), e.span())
|
|
});
|
|
|
|
let fn_ = fn_named.or(fn_compound).or(fn_decl);
|
|
|
|
let binding = let_.or(box_).or(fn_);
|
|
|
|
nonbinding.or(binding)
|
|
})
|
|
}
|
|
|
|
pub fn main() {
|
|
let src = "let #{a, :b b} = foo";
|
|
let (tokens, lex_errs) = lexer().parse(src).into_output_errors();
|
|
if lex_errs.len() > 0 {
|
|
println!("{:?}", lex_errs);
|
|
return ();
|
|
}
|
|
let tokens = tokens.unwrap();
|
|
let to_parse = tokens.clone();
|
|
for (token, _) in tokens {
|
|
println!("{}", token)
|
|
}
|
|
let (ast, _) = parser()
|
|
.parse(Stream::from_iter(to_parse).spanned(SimpleSpan::new(0, src.len())))
|
|
.unwrap();
|
|
println!("{}", ast);
|
|
}
|
|
|
|
// #[cfg(test)]
|
|
// mod tests {
|
|
// use crate::lexer;
|
|
// use crate::Token;
|
|
// use chumsky::prelude::*;
|
|
|
|
// #[test]
|
|
// fn it_lexes_positive_ints() {
|
|
// let (mytoken, _) = lexer().parse("42").unwrap()[0].clone();
|
|
// assert_eq!(mytoken, Token::Number(42.0))
|
|
// }
|
|
|
|
// #[test]
|
|
// fn it_lexes_negative_ints() {
|
|
// let (mytoken, _) = lexer().parse("-42").unwrap()[0].clone();
|
|
// assert_eq!(mytoken, Token::Number(-42.0))
|
|
// }
|
|
|
|
// #[test]
|
|
// fn it_lexes_positive_floats() {
|
|
// let (mytoken, _) = lexer().parse("42.032").unwrap()[0].clone();
|
|
// assert_eq!(mytoken, Token::Number(42.032))
|
|
// }
|
|
|
|
// #[test]
|
|
// fn it_lexes_positive_decimals() {
|
|
// let (mytoken, _) = lexer().parse("0.123").unwrap()[0].clone();
|
|
// assert_eq!(mytoken, Token::Number(0.123))
|
|
// }
|
|
|
|
// #[test]
|
|
// fn it_lexes_negative_floats() {
|
|
// let mytoken = lexer().parse("-42.123").unwrap()[0].clone().0;
|
|
// assert_eq!(mytoken, Token::Number(-42.123))
|
|
// }
|
|
|
|
// #[test]
|
|
// fn it_lexes_negative_decimals() {
|
|
// let mytoken = lexer().parse("-0.123").unwrap()[0].clone().0;
|
|
// assert_eq!(mytoken, Token::Number(-0.123))
|
|
// }
|
|
|
|
// #[test]
|
|
// fn it_lexes_bools() {
|
|
// let tt = lexer().parse("true").unwrap()[0].clone().0;
|
|
// assert_eq!(tt, Token::Boolean(true));
|
|
// let ff = lexer().parse("false").unwrap()[0].clone().0;
|
|
// assert_eq!(ff, Token::Boolean(false))
|
|
// }
|
|
|
|
// #[test]
|
|
// fn it_lexes_words() {
|
|
// let mytoken = lexer().parse("foo").unwrap()[0].clone().0;
|
|
// assert_eq!(mytoken, Token::Word("foo"))
|
|
// }
|
|
|
|
// #[test]
|
|
// fn it_lexes_keywords() {
|
|
// let kw = lexer().parse(":foo").unwrap()[0].clone().0;
|
|
// assert_eq!(kw, Token::Keyword("foo"))
|
|
// }
|
|
|
|
// #[test]
|
|
// fn it_lexes_strings() {
|
|
// let s = lexer().parse("\"foo bar baz\"").unwrap()[0].clone().0;
|
|
// assert_eq!(s, Token::String("foo bar baz"))
|
|
// }
|
|
|
|
// #[test]
|
|
// fn it_ignores_comments() {
|
|
// let e = lexer().parse("foo &bar\nbaz").unwrap();
|
|
// assert_eq!(e[0].0, Token::Word("foo"));
|
|
// assert_eq!(e[1].0, Token::Punctuation("\n"));
|
|
// assert_eq!(e[2].0, Token::Word("baz"))
|
|
// }
|
|
|
|
// #[test]
|
|
// fn it_lexes_multiple_tokens() {
|
|
// let toks = lexer().parse("foo;bar\nbaz").unwrap();
|
|
// assert_eq!(toks[0].0, Token::Word("foo"));
|
|
// assert_eq!(toks[2].0, Token::Word("bar"));
|
|
// assert_eq!(toks[4].0, Token::Word("baz"))
|
|
// }
|
|
|
|
// #[test]
|
|
// fn it_lexes_collections() {
|
|
// let toks = lexer().parse("(1, 2)").unwrap();
|
|
// assert_eq!(toks[0].0, Token::Punctuation("("));
|
|
// assert_eq!(toks[1].0, Token::Number(1.0));
|
|
// assert_eq!(toks[2].0, Token::Punctuation(","));
|
|
// assert_eq!(toks[3].0, Token::Number(2.0));
|
|
// assert_eq!(toks[4].0, Token::Punctuation(")"))
|
|
// }
|
|
// }
|