Kindelia/Kind2
1
1
Fork 0
mirror of https://github.com/Kindelia/Kind2.git synced 2024-08-16 02:30:40 +03:00
Code Issues Projects Releases Wiki Activity

feat: Update basic function names for Kindex update

Browse Source
This commit is contained in:
Nicolas Abril 2023-05-09 23:19:47 +02:00
parent b09fadd441
commit e7c0371373
15 changed files with 193 additions and 193 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
crates/kind-checker/src/compiler/mod.rs
View File

@ -44,7 +44,7 @@ fn lift_spine(spine: Vec<Box<Term>>) -> Vec<Box<Term>> {
if spine.len() > 16 { if spine.len() > 16 {
let mut start = spine[..2].to_vec(); let mut start = spine[..2].to_vec();
start.push(Box::new(Term::Ctr { start.push(Box::new(Term::Ctr {
name: format!("Kind.Term.args{}", spine.len() - 2), name: format!("Apps.Kind.Term.args{}", spine.len() - 2),
args: spine[2..].to_vec(), args: spine[2..].to_vec(),
})); }));
start start
@ -101,7 +101,7 @@ fn range_to_num(lhs: bool, range: Range) -> Box<Term> {
fn set_origin(ident: &Ident) -> Box<Term> { fn set_origin(ident: &Ident) -> Box<Term> {
mk_lifted_ctr( mk_lifted_ctr(
"Kind.Term.set_origin".to_owned(), "Apps.Kind.Term.set_origin".to_owned(),
vec![range_to_num(false, ident.range), mk_var(ident.to_str())], vec![range_to_num(false, ident.range), mk_var(ident.to_str())],
) )
} }
@ -114,8 +114,8 @@ fn lam(name: &Ident, body: Box<Term>) -> Box<Term> {
} }
fn desugar_str(input: &str, range: Range) -> Box<desugared::Expr> { fn desugar_str(input: &str, range: Range) -> Box<desugared::Expr> {
let nil = QualifiedIdent::new_static("String.nil", None, range); let nil = QualifiedIdent::new_static("Data.String.nil", None, range);
let cons = QualifiedIdent::new_static("String.cons", None, range); let cons = QualifiedIdent::new_static("Data.String.cons", None, range);
input input
.chars() .chars()
.rfold(desugared::Expr::ctr(range, nil, vec![]), |right, chr| { .rfold(desugared::Expr::ctr(range, nil, vec![]), |right, chr| {
@ -132,12 +132,12 @@ fn desugar_str(input: &str, range: Range) -> Box<desugared::Expr> {
fn codegen_str(input: &str) -> Box<Term> { fn codegen_str(input: &str) -> Box<Term> {
input.chars().rfold( input.chars().rfold(
Box::new(Term::Ctr { Box::new(Term::Ctr {
name: "String.nil".to_string(), name: "Data.String.nil".to_string(),
args: vec![], args: vec![],
}), }),
|right, chr| { |right, chr| {
Box::new(Term::Ctr { Box::new(Term::Ctr {
name: "String.cons".to_string(), name: "Data.String.cons".to_string(),
args: vec![mk_u60(chr as u64), right], args: vec![mk_u60(chr as u64), right],
}) })
}, },
@ -339,8 +339,8 @@ fn codegen_vec<T>(exprs: T) -> Box<Term>
where where
T: DoubleEndedIterator<Item = Box<Term>>, T: DoubleEndedIterator<Item = Box<Term>>,
{ {
exprs.rfold(mk_ctr("List.nil".to_string(), vec![]), |left, right| { exprs.rfold(mk_ctr("Data.List.nil".to_string(), vec![]), |left, right| {
mk_ctr("List.cons".to_string(), vec![right, left]) mk_ctr("Data.List.cons".to_string(), vec![right, left])
}) })
} }
@ -406,7 +406,7 @@ fn codegen_rule(file: &mut lang::File, rule: &desugared::Rule) {
rhs: codegen_expr(true, &rule.body), rhs: codegen_expr(true, &rule.body),
}); });
if rule.name.to_string().as_str() == "HVM.log" { if rule.name.to_string().as_str() == "Apps.HVM.log" {
file.rules.push(lang::Rule { file.rules.push(lang::Rule {
lhs: mk_ctr( lhs: mk_ctr(
TermTag::HoasF(rule.name.to_string()).to_string(), TermTag::HoasF(rule.name.to_string()).to_string(),
@ -419,9 +419,9 @@ fn codegen_rule(file: &mut lang::File, rule: &desugared::Rule) {
], ],
), ),
rhs: mk_ctr( rhs: mk_ctr(
"HVM.print".to_owned(), "Apps.HVM.print".to_owned(),
vec![ vec![
mk_ctr("Kind.Term.show".to_owned(), vec![mk_var("log")]), mk_ctr("Apps.Kind.Term.show".to_owned(), vec![mk_var("log")]),
mk_var("ret"), mk_var("ret"),
], ],
), ),
@ -449,7 +449,7 @@ fn codegen_entry_rules(
) -> Box<Term> { ) -> Box<Term> {
if pats.is_empty() { if pats.is_empty() {
mk_ctr( mk_ctr(
"Kind.Rule.rhs".to_owned(), "Apps.Kind.Rule.rhs".to_owned(),
vec![mk_ctr( vec![mk_ctr(
format!("QT{}", index), format!("QT{}", index),
vec_preppend![ vec_preppend![
@ -464,7 +464,7 @@ fn codegen_entry_rules(
let expr = codegen_all_expr(true, false, count, false, pat); let expr = codegen_all_expr(true, false, count, false, pat);
args.push(expr.clone()); args.push(expr.clone());
mk_ctr( mk_ctr(
"Kind.Rule.lhs".to_owned(), "Apps.Kind.Rule.lhs".to_owned(),
vec![ vec![
expr, expr,
codegen_entry_rules(count, index + 1, args, entry, &pats[1..]), codegen_entry_rules(count, index + 1, args, entry, &pats[1..]),
@ -476,7 +476,7 @@ fn codegen_entry_rules(
fn codegen_entry(file: &mut lang::File, entry: &desugared::Entry) { fn codegen_entry(file: &mut lang::File, entry: &desugared::Entry) {
file.rules.push(lang::Rule { file.rules.push(lang::Rule {
lhs: mk_ctr( lhs: mk_ctr(
"Kind.Axiom.NameOf".to_owned(), "Apps.Kind.Axiom.NameOf".to_owned(),
vec![mk_ctr_name(&entry.name)], vec![mk_ctr_name(&entry.name)],
), ),
rhs: codegen_str(entry.name.to_string().as_str()), rhs: codegen_str(entry.name.to_string().as_str()),
@ -484,7 +484,7 @@ fn codegen_entry(file: &mut lang::File, entry: &desugared::Entry) {
file.rules.push(lang::Rule { file.rules.push(lang::Rule {
lhs: mk_ctr( lhs: mk_ctr(
"Kind.Axiom.OrigOf".to_owned(), "Apps.Kind.Axiom.OrigOf".to_owned(),
vec![mk_ctr_name(&entry.name)], vec![mk_ctr_name(&entry.name)],
), ),
rhs: range_to_num(false, entry.name.range), rhs: range_to_num(false, entry.name.range),
@ -492,7 +492,7 @@ fn codegen_entry(file: &mut lang::File, entry: &desugared::Entry) {
file.rules.push(lang::Rule { file.rules.push(lang::Rule {
lhs: mk_ctr( lhs: mk_ctr(
"Kind.Axiom.HashOf".to_owned(), "Apps.Kind.Axiom.HashOf".to_owned(),
vec![mk_ctr_name(&entry.name)], vec![mk_ctr_name(&entry.name)],
), ),
rhs: mk_u60(fxhash::hash64(entry.name.to_string().as_str())), rhs: mk_u60(fxhash::hash64(entry.name.to_string().as_str())),
@ -500,7 +500,7 @@ fn codegen_entry(file: &mut lang::File, entry: &desugared::Entry) {
file.rules.push(lang::Rule { file.rules.push(lang::Rule {
lhs: mk_ctr( lhs: mk_ctr(
"Kind.Axiom.TypeOf".to_owned(), "Apps.Kind.Axiom.TypeOf".to_owned(),
vec![mk_ctr_name(&entry.name)], vec![mk_ctr_name(&entry.name)],
), ),
rhs: codegen_type(&entry.args, &entry.typ), rhs: codegen_type(&entry.args, &entry.typ),
@ -512,7 +512,7 @@ fn codegen_entry(file: &mut lang::File, entry: &desugared::Entry) {
file.rules.push(lang::Rule { file.rules.push(lang::Rule {
lhs: mk_lifted_ctr( lhs: mk_lifted_ctr(
format!("Kind.Term.FN{}", entry.args.len()), format!("Apps.Kind.Term.FN{}", entry.args.len()),
vec_preppend![ vec_preppend![
mk_ctr_name(&entry.name), mk_ctr_name(&entry.name),
mk_var("orig"); mk_var("orig");
@ -561,7 +561,7 @@ fn codegen_entry(file: &mut lang::File, entry: &desugared::Entry) {
file.rules.push(lang::Rule { file.rules.push(lang::Rule {
lhs: mk_ctr( lhs: mk_ctr(
"Kind.Axiom.RuleOf".to_owned(), "Apps.Kind.Axiom.RuleOf".to_owned(),
vec![mk_ctr_name(&entry.name)], vec![mk_ctr_name(&entry.name)],
), ),
rhs: codegen_vec(rules), rhs: codegen_vec(rules),
@ -573,10 +573,10 @@ pub fn codegen_coverage(file: &mut lang::File, book: &Book) {
if !entry.rules.is_empty() && !entry.rules[0].pats.is_empty() && !entry.attrs.partial && !entry.attrs.axiom { if !entry.rules.is_empty() && !entry.rules[0].pats.is_empty() && !entry.attrs.partial && !entry.attrs.axiom {
file.rules.push(lang::Rule { file.rules.push(lang::Rule {
lhs: mk_ctr( lhs: mk_ctr(
"Kind.Axiom.CoverCheck".to_owned(), "Apps.Kind.Axiom.CoverCheck".to_owned(),
vec![mk_ctr_name(&entry.name)], vec![mk_ctr_name(&entry.name)],
), ),
rhs: mk_single_ctr("Bool.true".to_string()), rhs: mk_single_ctr("Data.Bool.true".to_string()),
}); });
} }
} }
@ -584,15 +584,15 @@ pub fn codegen_coverage(file: &mut lang::File, book: &Book) {
for family in book.families.values() { for family in book.families.values() {
file.rules.push(lang::Rule { file.rules.push(lang::Rule {
lhs: mk_ctr( lhs: mk_ctr(
"Kind.Axiom.Family.Constructors".to_owned(), "Apps.Kind.Axiom.Family.Constructors".to_owned(),
vec![mk_ctr_name(&family.name)], vec![mk_ctr_name(&family.name)],
), ),
rhs: mk_ctr("Maybe.some".to_string(), vec![codegen_vec(family.constructors.iter().map(mk_ctr_name))]), rhs: mk_ctr("Data.Maybe.some".to_string(), vec![codegen_vec(family.constructors.iter().map(mk_ctr_name))]),
}); });
file.rules.push(lang::Rule { file.rules.push(lang::Rule {
lhs: mk_ctr( lhs: mk_ctr(
"Kind.Axiom.Family.Params".to_owned(), "Apps.Kind.Axiom.Family.Params".to_owned(),
vec![mk_ctr_name(&family.name)], vec![mk_ctr_name(&family.name)],
), ),
rhs: mk_u60(family.parameters.len() as u64), rhs: mk_u60(family.parameters.len() as u64),
@ -613,7 +613,7 @@ pub fn codegen_coverage(file: &mut lang::File, book: &Book) {
let entry = book.entrs.get(constructor.to_str()).unwrap(); let entry = book.entrs.get(constructor.to_str()).unwrap();
let mut maker = mk_ctr( let mut maker = mk_ctr(
"Kind.Coverage.Maker.End".to_string(), "Apps.Kind.Coverage.Maker.End".to_string(),
vec![codegen_expr( vec![codegen_expr(
false, false,
&kind_tree::desugared::Expr::ctr( &kind_tree::desugared::Expr::ctr(
@ -630,7 +630,7 @@ pub fn codegen_coverage(file: &mut lang::File, book: &Book) {
for arg in entry.args[family.parameters.len()..].iter().rev() { for arg in entry.args[family.parameters.len()..].iter().rev() {
maker = mk_ctr( maker = mk_ctr(
"Kind.Coverage.Maker.Cons".to_string(), "Apps.Kind.Coverage.Maker.Cons".to_string(),
vec![ vec![
range_to_num(false, arg.range), range_to_num(false, arg.range),
codegen_all_expr(false, false, &mut 0, false, &arg.typ), codegen_all_expr(false, false, &mut 0, false, &arg.typ),
@ -641,7 +641,7 @@ pub fn codegen_coverage(file: &mut lang::File, book: &Book) {
file.rules.push(lang::Rule { file.rules.push(lang::Rule {
lhs: mk_ctr( lhs: mk_ctr(
"Kind.Coverage.Maker.Mk".to_owned(), "Apps.Kind.Coverage.Maker.Mk".to_owned(),
vec![ vec![
mk_ctr_name(constructor), mk_ctr_name(constructor),
mk_var("orig"), mk_var("orig"),
@ -655,20 +655,20 @@ pub fn codegen_coverage(file: &mut lang::File, book: &Book) {
), ),
], ],
), ),
rhs: mk_ctr("Maybe.some".to_string(), vec![maker]), rhs: mk_ctr("Data.Maybe.some".to_string(), vec![maker]),
}); });
file.rules.push(lang::Rule { file.rules.push(lang::Rule {
lhs: mk_ctr( lhs: mk_ctr(
"Kind.Axiom.Compare".to_owned(), "Apps.Kind.Axiom.Compare".to_owned(),
vec![mk_ctr_name(constructor), mk_ctr_name(constructor)], vec![mk_ctr_name(constructor), mk_ctr_name(constructor)],
), ),
rhs: mk_single_ctr("Bool.true".to_string()), rhs: mk_single_ctr("Data.Bool.true".to_string()),
}); });
file.rules.push(lang::Rule { file.rules.push(lang::Rule {
lhs: mk_ctr( lhs: mk_ctr(
"Kind.Axiom.ArgsCount".to_owned(), "Apps.Kind.Axiom.ArgsCount".to_owned(),
vec![mk_ctr_name(constructor)], vec![mk_ctr_name(constructor)],
), ),
rhs: mk_u60(entry.args.len() as u64), rhs: mk_u60(entry.args.len() as u64),
@ -676,10 +676,10 @@ pub fn codegen_coverage(file: &mut lang::File, book: &Book) {
file.rules.push(lang::Rule { file.rules.push(lang::Rule {
lhs: mk_ctr( lhs: mk_ctr(
"Kind.Axiom.Compare".to_owned(), "Apps.Kind.Axiom.Compare".to_owned(),
vec![mk_ctr_name(constructor), mk_ctr_name(constructor)], vec![mk_ctr_name(constructor), mk_ctr_name(constructor)],
), ),
rhs: mk_single_ctr("Bool.true".to_string()), rhs: mk_single_ctr("Data.Bool.true".to_string()),
}); });
} }
} }
@ -694,7 +694,7 @@ pub fn codegen_book(book: &Book, check_coverage: bool, functions_to_check: Vec<S
}; };
let functions_entry = lang::Rule { let functions_entry = lang::Rule {
lhs: mk_ctr("Kind.Axiom.Functions".to_owned(), vec![]), lhs: mk_ctr("Apps.Kind.Axiom.Functions".to_owned(), vec![]),
rhs: codegen_vec(functions_to_check.iter().map(|x| mk_ctr_name_from_str(x))), rhs: codegen_vec(functions_to_check.iter().map(|x| mk_ctr_name_from_str(x))),
}; };
@ -723,30 +723,30 @@ pub fn codegen_book(book: &Book, check_coverage: bool, functions_to_check: Vec<S
} }
file.rules.push(lang::Rule { file.rules.push(lang::Rule {
lhs: mk_ctr("Kind.Axiom.CoverCheck".to_owned(), vec![mk_var("_")]), lhs: mk_ctr("Apps.Kind.Axiom.CoverCheck".to_owned(), vec![mk_var("_")]),
rhs: mk_single_ctr("Bool.false".to_string()), rhs: mk_single_ctr("Data.Bool.false".to_string()),
}); });
if check_coverage { if check_coverage {
file.rules.push(lang::Rule { file.rules.push(lang::Rule {
lhs: mk_ctr( lhs: mk_ctr(
"Kind.Axiom.Compare".to_owned(), "Apps.Kind.Axiom.Compare".to_owned(),
vec![mk_var("a"), mk_var("b")], vec![mk_var("a"), mk_var("b")],
), ),
rhs: mk_single_ctr("Bool.false".to_string()), rhs: mk_single_ctr("Data.Bool.false".to_string()),
}); });
file.rules.push(lang::Rule { file.rules.push(lang::Rule {
lhs: mk_ctr( lhs: mk_ctr(
"Kind.Coverage.Maker.Mk".to_owned(), "Apps.Kind.Coverage.Maker.Mk".to_owned(),
vec![mk_var("cons"), mk_var("a"), mk_var("b")], vec![mk_var("cons"), mk_var("a"), mk_var("b")],
), ),
rhs: mk_single_ctr("Maybe.none".to_string()), rhs: mk_single_ctr("Data.Maybe.none".to_string()),
}); });
file.rules.push(lang::Rule { file.rules.push(lang::Rule {
lhs: mk_ctr("Kind.Axiom.Family.Constructors".to_owned(), vec![mk_var("_")]), lhs: mk_ctr("Apps.Kind.Axiom.Family.Constructors".to_owned(), vec![mk_var("_")]),
rhs: mk_single_ctr("Maybe.none".to_string()), rhs: mk_single_ctr("Data.Maybe.none".to_string()),
}); });
} }

72
crates/kind-checker/src/compiler/tags.rs
View File

@ -46,21 +46,21 @@ pub enum EvalTag {
impl fmt::Display for TermTag { impl fmt::Display for TermTag {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self { match self {
TermTag::Var => write!(f, "Kind.Term.var"), TermTag::Var => write!(f, "Apps.Kind.Term.var"),
TermTag::All => write!(f, "Kind.Term.all"), TermTag::All => write!(f, "Apps.Kind.Term.all"),
TermTag::Lambda => write!(f, "Kind.Term.lam"), TermTag::Lambda => write!(f, "Apps.Kind.Term.lam"),
TermTag::App => write!(f, "Kind.Term.app"), TermTag::App => write!(f, "Apps.Kind.Term.app"),
TermTag::Fun(n) => write!(f, "Kind.Term.fn{}", n), TermTag::Fun(n) => write!(f, "Apps.Kind.Term.fn{}", n),
TermTag::Ctr(n) => write!(f, "Kind.Term.ct{}", n), TermTag::Ctr(n) => write!(f, "Apps.Kind.Term.ct{}", n),
TermTag::Let => write!(f, "Kind.Term.let"), TermTag::Let => write!(f, "Apps.Kind.Term.let"),
TermTag::Ann => write!(f, "Kind.Term.ann"), TermTag::Ann => write!(f, "Apps.Kind.Term.ann"),
TermTag::Sub => write!(f, "Kind.Term.sub"), TermTag::Sub => write!(f, "Apps.Kind.Term.sub"),
TermTag::Typ => write!(f, "Kind.Term.typ"), TermTag::Typ => write!(f, "Apps.Kind.Term.typ"),
TermTag::U60 => write!(f, "Kind.Term.U60"), TermTag::U60 => write!(f, "Apps.Kind.Term.U60"),
TermTag::NUMU60 => write!(f, "Kind.Term.u60"), TermTag::NUMU60 => write!(f, "Apps.Kind.Term.u60"),
TermTag::Binary => write!(f, "Kind.Term.op2"), TermTag::Binary => write!(f, "Apps.Kind.Term.op2"),
TermTag::Hole => write!(f, "Kind.Term.hol"), TermTag::Hole => write!(f, "Apps.Kind.Term.hol"),
TermTag::Hlp => write!(f, "Kind.Term.hlp"), TermTag::Hlp => write!(f, "Apps.Kind.Term.hlp"),
TermTag::HoasF(name) => write!(f, "F${}", name), TermTag::HoasF(name) => write!(f, "F${}", name),
TermTag::HoasQ(name) => write!(f, "Q${}", name), TermTag::HoasQ(name) => write!(f, "Q${}", name),
} }
@ -70,11 +70,11 @@ impl fmt::Display for TermTag {
impl fmt::Display for EvalTag { impl fmt::Display for EvalTag {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self { match self {
EvalTag::Op => write!(f, "Kind.Term.eval_op"), EvalTag::Op => write!(f, "Apps.Kind.Term.eval_op"),
EvalTag::App => write!(f, "Kind.Term.eval_app"), EvalTag::App => write!(f, "Apps.Kind.Term.eval_app"),
EvalTag::Let => write!(f, "Kind.Term.eval_let"), EvalTag::Let => write!(f, "Apps.Kind.Term.eval_let"),
EvalTag::Ann => write!(f, "Kind.Term.eval_ann"), EvalTag::Ann => write!(f, "Apps.Kind.Term.eval_ann"),
EvalTag::Sub => write!(f, "Kind.Term.eval_sub"), EvalTag::Sub => write!(f, "Apps.Kind.Term.eval_sub"),
} }
} }
} }
@ -83,21 +83,21 @@ impl fmt::Display for EvalTag {
/// by the checker. /// by the checker.
pub fn operator_to_constructor<'a>(operator: Operator) -> &'a str { pub fn operator_to_constructor<'a>(operator: Operator) -> &'a str {
match operator { match operator {
Operator::Add => "Kind.Operator.add", Operator::Add => "Apps.Kind.Operator.add",
Operator::Sub => "Kind.Operator.sub", Operator::Sub => "Apps.Kind.Operator.sub",
Operator::Mul => "Kind.Operator.mul", Operator::Mul => "Apps.Kind.Operator.mul",
Operator::Div => "Kind.Operator.div", Operator::Div => "Apps.Kind.Operator.div",
Operator::Mod => "Kind.Operator.mod", Operator::Mod => "Apps.Kind.Operator.mod",
Operator::And => "Kind.Operator.and", Operator::And => "Apps.Kind.Operator.and",
Operator::Xor => "Kind.Operator.xor", Operator::Xor => "Apps.Kind.Operator.xor",
Operator::Shl => "Kind.Operator.shl", Operator::Shl => "Apps.Kind.Operator.shl",
Operator::Shr => "Kind.Operator.shr", Operator::Shr => "Apps.Kind.Operator.shr",
Operator::Ltn => "Kind.Operator.ltn", Operator::Ltn => "Apps.Kind.Operator.ltn",
Operator::Lte => "Kind.Operator.lte", Operator::Lte => "Apps.Kind.Operator.lte",
Operator::Eql => "Kind.Operator.eql", Operator::Eql => "Apps.Kind.Operator.eql",
Operator::Gte => "Kind.Operator.gte", Operator::Gte => "Apps.Kind.Operator.gte",
Operator::Gtn => "Kind.Operator.gtn", Operator::Gtn => "Apps.Kind.Operator.gtn",
Operator::Neq => "Kind.Operator.neq", Operator::Neq => "Apps.Kind.Operator.neq",
Operator::Or => "Kind.Operator.or", Operator::Or => "Apps.Kind.Operator.or",
} }
} }

2
crates/kind-checker/src/lib.rs
View File

@ -110,7 +110,7 @@ pub fn eval_api(book: &Book) -> (String, u64) {
runtime::link( runtime::link(
&heap, &heap,
0, 0,
runtime::Fun(*book.name_to_id.get("Kind.API.eval_main").unwrap(), 0), runtime::Fun(*book.name_to_id.get("Apps.Kind.API.eval_main").unwrap(), 0),
); );
let host = 0; let host = 0;

88
crates/kind-checker/src/report.rs
View File

@ -35,22 +35,22 @@ fn parse_num(term: &Term) -> Result<u64, String> {
fn parse_op(term: &Term) -> Result<Operator, String> { fn parse_op(term: &Term) -> Result<Operator, String> {
match term { match term {
Term::Ctr { name, args: _ } => match name.as_str() { Term::Ctr { name, args: _ } => match name.as_str() {
"Kind.Operator.add" => Ok(Operator::Add), "Apps.Kind.Operator.add" => Ok(Operator::Add),
"Kind.Operator.sub" => Ok(Operator::Sub), "Apps.Kind.Operator.sub" => Ok(Operator::Sub),
"Kind.Operator.mul" => Ok(Operator::Mul), "Apps.Kind.Operator.mul" => Ok(Operator::Mul),
"Kind.Operator.div" => Ok(Operator::Div), "Apps.Kind.Operator.div" => Ok(Operator::Div),
"Kind.Operator.mod" => Ok(Operator::Mod), "Apps.Kind.Operator.mod" => Ok(Operator::Mod),
"Kind.Operator.and" => Ok(Operator::And), "Apps.Kind.Operator.and" => Ok(Operator::And),
"Kind.Operator.or" => Ok(Operator::Or), "Apps.Kind.Operator.or" => Ok(Operator::Or),
"Kind.Operator.xor" => Ok(Operator::Xor), "Apps.Kind.Operator.xor" => Ok(Operator::Xor),
"Kind.Operator.shl" => Ok(Operator::Shl), "Apps.Kind.Operator.shl" => Ok(Operator::Shl),
"Kind.Operator.shr" => Ok(Operator::Shr), "Apps.Kind.Operator.shr" => Ok(Operator::Shr),
"Kind.Operator.ltn" => Ok(Operator::Ltn), "Apps.Kind.Operator.ltn" => Ok(Operator::Ltn),
"Kind.Operator.lte" => Ok(Operator::Lte), "Apps.Kind.Operator.lte" => Ok(Operator::Lte),
"Kind.Operator.eql" => Ok(Operator::Eql), "Apps.Kind.Operator.eql" => Ok(Operator::Eql),
"Kind.Operator.gte" => Ok(Operator::Gte), "Apps.Kind.Operator.gte" => Ok(Operator::Gte),
"Kind.Operator.gtn" => Ok(Operator::Gtn), "Apps.Kind.Operator.gtn" => Ok(Operator::Gtn),
"Kind.Operator.neq" => Ok(Operator::Neq), "Apps.Kind.Operator.neq" => Ok(Operator::Neq),
_ => Err("Cannot recognized operator".to_string()), _ => Err("Cannot recognized operator".to_string()),
}, },
_ => Err("Error parsing operator".to_string()), _ => Err("Error parsing operator".to_string()),
@ -91,44 +91,44 @@ fn parse_all_expr(
) -> Result<Box<desugared::Expr>, String> { ) -> Result<Box<desugared::Expr>, String> {
match term { match term {
Term::Ctr { name, args } => match name.as_str() { Term::Ctr { name, args } => match name.as_str() {
"Kind.Term.Quoted.all" => Ok(Expr::all( "Apps.Kind.Term.Quoted.all" => Ok(Expr::all(
parse_orig(&args[0])?, parse_orig(&args[0])?,
Ident::generate(&parse_name(&args[1])?), Ident::generate(&parse_name(&args[1])?),
parse_all_expr(names.clone(), &args[2])?, parse_all_expr(names.clone(), &args[2])?,
parse_all_expr(names, &args[3])?, parse_all_expr(names, &args[3])?,
false, // TODO: Fix false, // TODO: Fix
)), )),
"Kind.Term.Quoted.lam" => Ok(Expr::lambda( "Apps.Kind.Term.Quoted.lam" => Ok(Expr::lambda(
parse_orig(&args[0])?, parse_orig(&args[0])?,
Ident::generate(&parse_name(&args[1])?), Ident::generate(&parse_name(&args[1])?),
parse_all_expr(names, &args[2])?, parse_all_expr(names, &args[2])?,
false, // TODO: Fix false, // TODO: Fix
)), )),
"Kind.Term.Quoted.let" => Ok(Expr::let_( "Apps.Kind.Term.Quoted.let" => Ok(Expr::let_(
parse_orig(&args[0])?, parse_orig(&args[0])?,
Ident::generate(&parse_name(&args[1])?), Ident::generate(&parse_name(&args[1])?),
parse_all_expr(names.clone(), &args[2])?, parse_all_expr(names.clone(), &args[2])?,
parse_all_expr(names, &args[3])?, parse_all_expr(names, &args[3])?,
)), )),
"Kind.Term.Quoted.typ" => Ok(Expr::typ(parse_orig(&args[0])?)), "Apps.Kind.Term.Quoted.typ" => Ok(Expr::typ(parse_orig(&args[0])?)),
"Kind.Term.Quoted.var" => Ok(Expr::var(Ident::new( "Apps.Kind.Term.Quoted.var" => Ok(Expr::var(Ident::new(
parse_name(&args[1])?, parse_name(&args[1])?,
parse_orig(&args[0])?, parse_orig(&args[0])?,
))), ))),
"Kind.Term.Quoted.hol" => Ok(Expr::hole(parse_orig(&args[0])?, parse_num(&args[1])?)), "Apps.Kind.Term.Quoted.hol" => Ok(Expr::hole(parse_orig(&args[0])?, parse_num(&args[1])?)),
"Kind.Term.Quoted.ann" => Ok(Expr::ann( "Apps.Kind.Term.Quoted.ann" => Ok(Expr::ann(
parse_orig(&args[0])?, parse_orig(&args[0])?,
parse_all_expr(names.clone(), &args[1])?, parse_all_expr(names.clone(), &args[1])?,
parse_all_expr(names, &args[2])?, parse_all_expr(names, &args[2])?,
)), )),
"Kind.Term.Quoted.sub" => Ok(Expr::sub( "Apps.Kind.Term.Quoted.sub" => Ok(Expr::sub(
parse_orig(&args[0])?, parse_orig(&args[0])?,
Ident::generate(&parse_name(&args[1])?), Ident::generate(&parse_name(&args[1])?),
parse_num(&args[2])? as usize, parse_num(&args[2])? as usize,
parse_num(&args[3])? as usize, parse_num(&args[3])? as usize,
parse_all_expr(names, &args[4])?, parse_all_expr(names, &args[4])?,
)), )),
"Kind.Term.Quoted.app" => Ok(Expr::app( "Apps.Kind.Term.Quoted.app" => Ok(Expr::app(
parse_orig(&args[0])?, parse_orig(&args[0])?,
parse_all_expr(names.clone(), &args[1])?, parse_all_expr(names.clone(), &args[1])?,
vec![desugared::AppBinding { vec![desugared::AppBinding {
@ -136,7 +136,7 @@ fn parse_all_expr(
erased: false, erased: false,
}], }],
)), )),
"Kind.Term.Quoted.ctr" => { "Apps.Kind.Term.Quoted.ctr" => {
let name = parse_qualified(&args[0])?; let name = parse_qualified(&args[0])?;
let orig = parse_orig(&args[1])?; let orig = parse_orig(&args[1])?;
let mut res = Vec::new(); let mut res = Vec::new();
@ -145,7 +145,7 @@ fn parse_all_expr(
} }
Ok(Expr::ctr(orig, name, res)) Ok(Expr::ctr(orig, name, res))
} }
"Kind.Term.Quoted.fun" => Ok(Expr::fun( "Apps.Kind.Term.Quoted.fun" => Ok(Expr::fun(
parse_orig(&args[1])?, parse_orig(&args[1])?,
parse_qualified(&args[0])?, parse_qualified(&args[0])?,
{ {
@ -156,11 +156,11 @@ fn parse_all_expr(
res res
}, },
)), )),
"Kind.Term.Quoted.hlp" => Ok(Expr::hlp(parse_orig(&args[0])?, Ident::generate("?"))), "Apps.Kind.Term.Quoted.hlp" => Ok(Expr::hlp(parse_orig(&args[0])?, Ident::generate("?"))),
"Kind.Term.Quoted.u60" => Ok(Expr::type_u60(parse_orig(&args[0])?)), "Apps.Kind.Term.Quoted.u60" => Ok(Expr::type_u60(parse_orig(&args[0])?)),
"Kind.Term.Quoted.num" => Ok(Expr::num_u60(parse_orig(&args[0])?, parse_num(&args[1])?)), "Apps.Kind.Term.Quoted.num" => Ok(Expr::num_u60(parse_orig(&args[0])?, parse_num(&args[1])?)),
// TODO: Change quoting to support floats // TODO: Change quoting to support floats
"Kind.Term.Quoted.op2" => Ok(Expr::binary( "Apps.Kind.Term.Quoted.op2" => Ok(Expr::binary(
parse_orig(&args[0])?, parse_orig(&args[0])?,
parse_op(&args[1])?, parse_op(&args[1])?,
parse_all_expr(names.clone(), &args[2])?, parse_all_expr(names.clone(), &args[2])?,
@ -181,9 +181,9 @@ fn parse_list(term: &Term) -> Result<Vec<Box<Term>>, String> {
loop { loop {
match cur { match cur {
Term::Ctr { name, args } => { Term::Ctr { name, args } => {
if name == "List.nil" { if name == "Data.List.nil" {
break; break;
} else if name == "List.cons" { } else if name == "Data.List.cons" {
vec.push(args[0].clone()); vec.push(args[0].clone());
cur = &args[1]; cur = &args[1];
} else { } else {
@ -199,10 +199,10 @@ fn parse_list(term: &Term) -> Result<Vec<Box<Term>>, String> {
/// Transforms a HVM quoted entry into a easy to manipulate structure. /// Transforms a HVM quoted entry into a easy to manipulate structure.
pub fn transform_entry(term: &Term) -> Result<Entry, String> { pub fn transform_entry(term: &Term) -> Result<Entry, String> {
match term { match term {
Term::Ctr { name, args } if name == "Pair.new" => { Term::Ctr { name, args } if name == "Data.Pair.new" => {
let fst = parse_name(&args[0])?; let fst = parse_name(&args[0])?;
match &*args[1] { match &*args[1] {
Term::Ctr { name, args } if name == "Pair.new" => { Term::Ctr { name, args } if name == "Data.Pair.new" => {
let snd = parse_expr(&args[0])?; let snd = parse_expr(&args[0])?;
let trd = parse_list(&args[1])?; let trd = parse_list(&args[1])?;
let trd = trd.iter().flat_map(|x| parse_expr(x)).collect(); let trd = trd.iter().flat_map(|x| parse_expr(x)).collect();
@ -226,7 +226,7 @@ fn parse_type_error(expr: &Term) -> Result<TypeDiagnostic, String> {
let ctx = Context(entries.collect()); let ctx = Context(entries.collect());
let orig = match_opt!(*args[1], Term::U6O { numb } => EncodedRange(numb).to_range())?; let orig = match_opt!(*args[1], Term::U6O { numb } => EncodedRange(numb).to_range())?;
match name.as_str() { match name.as_str() {
"Kind.Error.Quoted.uncovered_pattern" => Ok(TypeDiagnostic::UncoveredPattern(ctx, orig, { "Apps.Kind.Error.Quoted.uncovered_pattern" => Ok(TypeDiagnostic::UncoveredPattern(ctx, orig, {
let args = parse_list(&args[2])?; let args = parse_list(&args[2])?;
let mut new_args = Vec::with_capacity(args.len()); let mut new_args = Vec::with_capacity(args.len());
for arg in &args { for arg in &args {
@ -234,25 +234,25 @@ fn parse_type_error(expr: &Term) -> Result<TypeDiagnostic, String> {
} }
new_args new_args
})), })),
"Kind.Error.Quoted.unbound_variable" => Ok(TypeDiagnostic::UnboundVariable(ctx, orig)), "Apps.Kind.Error.Quoted.unbound_variable" => Ok(TypeDiagnostic::UnboundVariable(ctx, orig)),
"Kind.Error.Quoted.cant_infer_hole" => Ok(TypeDiagnostic::CantInferHole(ctx, orig)), "Apps.Kind.Error.Quoted.cant_infer_hole" => Ok(TypeDiagnostic::CantInferHole(ctx, orig)),
"Kind.Error.Quoted.cant_infer_lambda" => Ok(TypeDiagnostic::CantInferLambda(ctx, orig)), "Apps.Kind.Error.Quoted.cant_infer_lambda" => Ok(TypeDiagnostic::CantInferLambda(ctx, orig)),
"Kind.Error.Quoted.invalid_call" => Ok(TypeDiagnostic::InvalidCall(ctx, orig)), "Apps.Kind.Error.Quoted.invalid_call" => Ok(TypeDiagnostic::InvalidCall(ctx, orig)),
"Kind.Error.Quoted.impossible_case" => Ok(TypeDiagnostic::ImpossibleCase( "Apps.Kind.Error.Quoted.impossible_case" => Ok(TypeDiagnostic::ImpossibleCase(
ctx, ctx,
orig, orig,
parse_all_expr(im_rc::HashMap::new(), &args[2])?, parse_all_expr(im_rc::HashMap::new(), &args[2])?,
parse_all_expr(im_rc::HashMap::new(), &args[3])?, parse_all_expr(im_rc::HashMap::new(), &args[3])?,
)), )),
"Kind.Error.Quoted.inspection" => Ok(TypeDiagnostic::Inspection( "Apps.Kind.Error.Quoted.inspection" => Ok(TypeDiagnostic::Inspection(
ctx, ctx,
orig, orig,
parse_all_expr(im_rc::HashMap::new(), &args[2])?, parse_all_expr(im_rc::HashMap::new(), &args[2])?,
)), )),
"Kind.Error.Quoted.too_many_arguments" => { "Apps.Kind.Error.Quoted.too_many_arguments" => {
Ok(TypeDiagnostic::TooManyArguments(ctx, orig)) Ok(TypeDiagnostic::TooManyArguments(ctx, orig))
} }
"Kind.Error.Quoted.type_mismatch" => Ok(TypeDiagnostic::TypeMismatch( "Apps.Kind.Error.Quoted.type_mismatch" => Ok(TypeDiagnostic::TypeMismatch(
ctx, ctx,
orig, orig,
parse_all_expr(im_rc::HashMap::new(), &args[2])?, parse_all_expr(im_rc::HashMap::new(), &args[2])?,

12
crates/kind-derive/src/subst.rs
View File

@ -214,7 +214,7 @@ impl<'a> Visitor for Subst<'a> {
snd, snd,
} => { } => {
self.visit_qualified_ident(&mut QualifiedIdent::new_static( self.visit_qualified_ident(&mut QualifiedIdent::new_static(
"Sigma", None, expr.range, "Data.Sigma", None, expr.range,
)); ));
self.visit_expr(fst); self.visit_expr(fst);
self.visit_expr(snd); self.visit_expr(snd);
@ -225,7 +225,7 @@ impl<'a> Visitor for Subst<'a> {
snd, snd,
} => { } => {
self.visit_qualified_ident(&mut QualifiedIdent::new_static( self.visit_qualified_ident(&mut QualifiedIdent::new_static(
"Sigma", None, expr.range, "Data.Sigma", None, expr.range,
)); ));
self.visit_expr(fst); self.visit_expr(fst);
self.context_vars.push((ident.range, ident.to_string())); self.context_vars.push((ident.range, ident.to_string()));
@ -257,7 +257,7 @@ impl<'a> Visitor for Subst<'a> {
} }
ExprKind::If { cond, then_, else_ } => { ExprKind::If { cond, then_, else_ } => {
self.visit_qualified_ident(&mut QualifiedIdent::new_sugared( self.visit_qualified_ident(&mut QualifiedIdent::new_sugared(
"Bool", "if", expr.range, "Data.Bool", "if", expr.range,
)); ));
self.visit_expr(cond); self.visit_expr(cond);
self.visit_expr(then_); self.visit_expr(then_);
@ -265,17 +265,17 @@ impl<'a> Visitor for Subst<'a> {
} }
ExprKind::Pair { fst, snd } => { ExprKind::Pair { fst, snd } => {
self.visit_qualified_ident(&mut QualifiedIdent::new_sugared( self.visit_qualified_ident(&mut QualifiedIdent::new_sugared(
"Pair", "new", expr.range, "Data.Pair", "new", expr.range,
)); ));
self.visit_expr(fst); self.visit_expr(fst);
self.visit_expr(snd); self.visit_expr(snd);
} }
ExprKind::List { args } => { ExprKind::List { args } => {
self.visit_qualified_ident(&mut QualifiedIdent::new_sugared( self.visit_qualified_ident(&mut QualifiedIdent::new_sugared(
"List", "nil", expr.range, "Data.List", "nil", expr.range,
)); ));
self.visit_qualified_ident(&mut QualifiedIdent::new_sugared( self.visit_qualified_ident(&mut QualifiedIdent::new_sugared(
"List", "cons", expr.range, "Data.List", "cons", expr.range,
)); ));
visit_vec!(args.iter_mut(), arg => self.visit_expr(arg)); visit_vec!(args.iter_mut(), arg => self.visit_expr(arg));
} }

8
crates/kind-parser/src/expr.rs
View File

@ -241,10 +241,10 @@ impl<'a> Parser<'a> {
let id = self.parse_upper_id()?; let id = self.parse_upper_id()?;
let data = match id.to_string().as_str() { let data = match id.to_string().as_str() {
"Type" => ExprKind::Lit { lit: Literal::Type }, "Type" => ExprKind::Lit { lit: Literal::Type },
"U60" => ExprKind::Lit { "Data.U60" => ExprKind::Lit {
lit: Literal::NumTypeU60, lit: Literal::NumTypeU60,
}, },
"F60" => ExprKind::Lit { "Data.F60" => ExprKind::Lit {
lit: Literal::NumTypeF60, lit: Literal::NumTypeF60,
}, },
_ => ExprKind::Constr { _ => ExprKind::Constr {
@ -263,10 +263,10 @@ impl<'a> Parser<'a> {
let mut range = id.range; let mut range = id.range;
let data = match id.to_string().as_str() { let data = match id.to_string().as_str() {
"Type" => ExprKind::Lit { lit: Literal::Type }, "Type" => ExprKind::Lit { lit: Literal::Type },
"U60" => ExprKind::Lit { "Data.U60" => ExprKind::Lit {
lit: Literal::NumTypeU60, lit: Literal::NumTypeU60,
}, },
"F60" => ExprKind::Lit { "Data.F60" => ExprKind::Lit {
lit: Literal::NumTypeF60, lit: Literal::NumTypeF60,
}, },
_ => { _ => {

16
crates/kind-pass/src/desugar/expr.rs
View File

@ -24,8 +24,8 @@ impl<'a> DesugarState<'a> {
) -> Box<desugared::Expr> { ) -> Box<desugared::Expr> {
match literal { match literal {
Literal::String(string) => { Literal::String(string) => {
if !self.check_implementation("String.cons", range, Sugar::String) if !self.check_implementation("Data.String.cons", range, Sugar::String)
|| !self.check_implementation("String.nil", range, Sugar::String) || !self.check_implementation("Data.String.nil", range, Sugar::String)
{ {
return desugared::Expr::err(range); return desugared::Expr::err(range);
} }
@ -37,7 +37,7 @@ impl<'a> DesugarState<'a> {
Literal::NumTypeF60 => desugared::Expr::type_f60(range), Literal::NumTypeF60 => desugared::Expr::type_f60(range),
Literal::NumU60(num) => desugared::Expr::num_u60(range, *num), Literal::NumU60(num) => desugared::Expr::num_u60(range, *num),
Literal::Nat(num) => { Literal::Nat(num) => {
let list_ident = QualifiedIdent::new_static("Nat", None, range); let list_ident = QualifiedIdent::new_static("Data.Nat", None, range);
let cons_ident = list_ident.add_segment("succ"); let cons_ident = list_ident.add_segment("succ");
let nil_ident = list_ident.add_segment("zero"); let nil_ident = list_ident.add_segment("zero");
@ -50,7 +50,7 @@ impl<'a> DesugarState<'a> {
res res
} }
Literal::NumU120(num) => { Literal::NumU120(num) => {
if !self.check_implementation("U120.new", range, Sugar::U120) { if !self.check_implementation("Data.U120.new", range, Sugar::U120) {
return desugared::Expr::err(range); return desugared::Expr::err(range);
} }
desugared::Expr::num_u120(range, *num) desugared::Expr::num_u120(range, *num)
@ -292,7 +292,7 @@ impl<'a> DesugarState<'a> {
typ: &expr::Expr, typ: &expr::Expr,
body: &expr::Expr, body: &expr::Expr,
) -> Box<desugared::Expr> { ) -> Box<desugared::Expr> {
let sigma = QualifiedIdent::new_static("Sigma", None, range); let sigma = QualifiedIdent::new_static("Data.Sigma", None, range);
if !self.check_implementation(sigma.to_str(), range, Sugar::Sigma) { if !self.check_implementation(sigma.to_str(), range, Sugar::Sigma) {
return desugared::Expr::err(range); return desugared::Expr::err(range);
@ -316,7 +316,7 @@ impl<'a> DesugarState<'a> {
range: Range, range: Range,
expr: &[expr::Expr], expr: &[expr::Expr],
) -> Box<desugared::Expr> { ) -> Box<desugared::Expr> {
let list_ident = QualifiedIdent::new_static("List", None, range); let list_ident = QualifiedIdent::new_static("Data.List", None, range);
let cons_ident = list_ident.add_segment("cons"); let cons_ident = list_ident.add_segment("cons");
let nil_ident = list_ident.add_segment("nil"); let nil_ident = list_ident.add_segment("nil");
@ -345,7 +345,7 @@ impl<'a> DesugarState<'a> {
if_: &expr::Expr, if_: &expr::Expr,
else_: &expr::Expr, else_: &expr::Expr,
) -> Box<desugared::Expr> { ) -> Box<desugared::Expr> {
let boolean = QualifiedIdent::new_static("Bool", None, range); let boolean = QualifiedIdent::new_static("Data.Bool", None, range);
let bool_if_ident = boolean.add_segment("if"); let bool_if_ident = boolean.add_segment("if");
let bool_if = self.old_book.names.get(bool_if_ident.to_str()); let bool_if = self.old_book.names.get(bool_if_ident.to_str());
@ -419,7 +419,7 @@ impl<'a> DesugarState<'a> {
fst: &expr::Expr, fst: &expr::Expr,
snd: &expr::Expr, snd: &expr::Expr,
) -> Box<desugared::Expr> { ) -> Box<desugared::Expr> {
let sigma_new = QualifiedIdent::new_sugared("Sigma", "new", range); let sigma_new = QualifiedIdent::new_sugared("Data.Sigma", "new", range);
if !self.check_implementation(sigma_new.to_str(), range, Sugar::Pair) { if !self.check_implementation(sigma_new.to_str(), range, Sugar::Pair) {
return desugared::Expr::err(range); return desugared::Expr::err(range);

4
crates/kind-pass/src/desugar/top_level.rs
View File

@ -223,7 +223,7 @@ impl<'a> DesugarState<'a> {
fst: &concrete::pat::Pat, fst: &concrete::pat::Pat,
snd: &concrete::pat::Pat, snd: &concrete::pat::Pat,
) -> Box<desugared::Expr> { ) -> Box<desugared::Expr> {
let sigma_new = QualifiedIdent::new_static("Sigma", Some("new".to_string()), range); let sigma_new = QualifiedIdent::new_static("Data.Sigma", Some("new".to_string()), range);
let entry = self.old_book.entries.get(sigma_new.to_string().as_str()); let entry = self.old_book.entries.get(sigma_new.to_string().as_str());
if entry.is_none() { if entry.is_none() {
@ -241,7 +241,7 @@ impl<'a> DesugarState<'a> {
range: Range, range: Range,
expr: &[concrete::pat::Pat], expr: &[concrete::pat::Pat],
) -> Box<desugared::Expr> { ) -> Box<desugared::Expr> {
let list_ident = QualifiedIdent::new_static("List", None, range); let list_ident = QualifiedIdent::new_static("Data.List", None, range);
let cons_ident = list_ident.add_segment("cons"); let cons_ident = list_ident.add_segment("cons");
let nil_ident = list_ident.add_segment("nil"); let nil_ident = list_ident.add_segment("nil");

12
crates/kind-pass/src/diagnostic.rs
View File

@ -218,12 +218,12 @@ impl Diagnostic for PassDiagnostic {
subtitles: vec![], subtitles: vec![],
hints: vec![match sugar { hints: vec![match sugar {
Sugar::DoNotation => "You must implement 'bind' and 'pure' for this type in order to use the do notation.".to_string(), Sugar::DoNotation => "You must implement 'bind' and 'pure' for this type in order to use the do notation.".to_string(),
Sugar::List => "You must implement 'List', 'List.cons' and 'List.nil' for this type in order to use the list notation.".to_string(), Sugar::List => "You must implement 'Data.List', 'Data.List.cons' and 'Data.List.nil' for this type in order to use the list notation.".to_string(),
Sugar::Sigma => "You must implement 'Sigma' in order to use the sigma notation.".to_string(), Sugar::Sigma => "You must implement 'Data.Sigma' in order to use the sigma notation.".to_string(),
Sugar::Pair => "You must implement 'Sigma' and 'Sigma.new' in order to use the sigma notation.".to_string(), Sugar::Pair => "You must implement 'Data.Sigma' and 'Data.Sigma.new' in order to use the sigma notation.".to_string(),
Sugar::BoolIf => "You must implement 'Bool.if' in order to use the if notation.".to_string(), Sugar::BoolIf => "You must implement 'Data.Bool.if' in order to use the if notation.".to_string(),
Sugar::String => "You must implement 'String.cons' in order to use the string notation.".to_string(), Sugar::String => "You must implement 'Data.String.cons' in order to use the string notation.".to_string(),
Sugar::U120 => "You must implement 'U120.new' in order to use the u120 notation.".to_string(), Sugar::U120 => "You must implement 'Data.U120.new' in order to use the u120 notation.".to_string(),
Sugar::Match(_) => "You must implement 'match' in order to use the match notation (or derive match with #derive[match]).".to_string(), Sugar::Match(_) => "You must implement 'match' in order to use the match notation (or derive match with #derive[match]).".to_string(),
Sugar::Mutter(typ) => format!("You must derive 'mutters' for '{}' in order to use this syntax", typ), Sugar::Mutter(typ) => format!("You must derive 'mutters' for '{}' in order to use this syntax", typ),
Sugar::Getter(typ) => format!("You must derive 'getters' for '{}' in order to use this syntax", typ) Sugar::Getter(typ) => format!("You must derive 'getters' for '{}' in order to use this syntax", typ)

8
crates/kind-pass/src/erasure/mod.rs
View File

@ -348,8 +348,8 @@ impl<'a> ErasureState<'a> {
NumU60 { numb } => untyped::Expr::u60(expr.range, *numb), NumU60 { numb } => untyped::Expr::u60(expr.range, *numb),
NumF60 { numb } => untyped::Expr::f60(expr.range, *numb), NumF60 { numb } => untyped::Expr::f60(expr.range, *numb),
Str { val } => { Str { val } => {
let nil = QualifiedIdent::new_static("String.nil", None, expr.range); let nil = QualifiedIdent::new_static("Data.String.nil", None, expr.range);
let cons = QualifiedIdent::new_static("String.cons", None, expr.range); let cons = QualifiedIdent::new_static("Data.String.cons", None, expr.range);
self.connect_with(edge, &nil, relevance); self.connect_with(edge, &nil, relevance);
self.connect_with(edge, &cons, relevance); self.connect_with(edge, &cons, relevance);
@ -491,8 +491,8 @@ impl<'a> ErasureState<'a> {
NumU60 { numb } => untyped::Expr::u60(expr.range, *numb), NumU60 { numb } => untyped::Expr::u60(expr.range, *numb),
NumF60 { numb } => untyped::Expr::f60(expr.range, *numb), NumF60 { numb } => untyped::Expr::f60(expr.range, *numb),
Str { val } => { Str { val } => {
let nil = QualifiedIdent::new_static("String.nil", None, expr.range); let nil = QualifiedIdent::new_static("Data.String.nil", None, expr.range);
let cons = QualifiedIdent::new_static("String.cons", None, expr.range); let cons = QualifiedIdent::new_static("Data.String.cons", None, expr.range);
self.connect_with(edge, &nil, ambient); self.connect_with(edge, &nil, ambient);
self.connect_with(edge, &cons, ambient); self.connect_with(edge, &cons, ambient);

14
crates/kind-pass/src/unbound/mod.rs
View File

@ -376,7 +376,7 @@ impl Visitor for UnboundCollector {
match &mut pat.data { match &mut pat.data {
PatKind::Var(ident) => self.visit_pat_ident(ident), PatKind::Var(ident) => self.visit_pat_ident(ident),
PatKind::Str(_) => { PatKind::Str(_) => {
let string = &mut QualifiedIdent::new_static("String", None, pat.range); let string = &mut QualifiedIdent::new_static("Data.String", None, pat.range);
self.visit_qualified_ident(&mut string.add_segment("cons").to_generated()); self.visit_qualified_ident(&mut string.add_segment("cons").to_generated());
self.visit_qualified_ident(&mut string.add_segment("nil").to_generated()); self.visit_qualified_ident(&mut string.add_segment("nil").to_generated());
} }
@ -475,7 +475,7 @@ impl Visitor for UnboundCollector {
use kind_tree::concrete::Literal::*; use kind_tree::concrete::Literal::*;
if let String(_) = lit { if let String(_) = lit {
let string = &mut QualifiedIdent::new_static("String", None, range); let string = &mut QualifiedIdent::new_static("Data.String", None, range);
self.visit_qualified_ident(&mut string.add_segment("cons").to_generated()); self.visit_qualified_ident(&mut string.add_segment("cons").to_generated());
self.visit_qualified_ident(&mut string.add_segment("nil").to_generated()); self.visit_qualified_ident(&mut string.add_segment("nil").to_generated());
} }
@ -545,7 +545,7 @@ impl Visitor for UnboundCollector {
snd, snd,
} => { } => {
self.visit_qualified_ident( self.visit_qualified_ident(
&mut QualifiedIdent::new_static("Sigma", None, expr.range).to_generated(), &mut QualifiedIdent::new_static("Data.Sigma", None, expr.range).to_generated(),
); );
self.visit_expr(fst); self.visit_expr(fst);
self.visit_expr(snd); self.visit_expr(snd);
@ -556,7 +556,7 @@ impl Visitor for UnboundCollector {
snd, snd,
} => { } => {
self.visit_qualified_ident( self.visit_qualified_ident(
&mut QualifiedIdent::new_static("Sigma", None, expr.range).to_generated(), &mut QualifiedIdent::new_static("Data.Sigma", None, expr.range).to_generated(),
); );
self.visit_expr(fst); self.visit_expr(fst);
self.context_vars.push((ident.range, ident.to_string())); self.context_vars.push((ident.range, ident.to_string()));
@ -587,20 +587,20 @@ impl Visitor for UnboundCollector {
self.visit_sttm(sttm) self.visit_sttm(sttm)
} }
ExprKind::If { cond, then_, else_ } => { ExprKind::If { cond, then_, else_ } => {
let typ = QualifiedIdent::new_static("Bool", None, expr.range); let typ = QualifiedIdent::new_static("Data.Bool", None, expr.range);
self.visit_qualified_ident(&mut typ.add_segment("if").to_generated()); self.visit_qualified_ident(&mut typ.add_segment("if").to_generated());
self.visit_expr(cond); self.visit_expr(cond);
self.visit_expr(then_); self.visit_expr(then_);
self.visit_expr(else_); self.visit_expr(else_);
} }
ExprKind::Pair { fst, snd } => { ExprKind::Pair { fst, snd } => {
let typ = QualifiedIdent::new_static("Pair", None, expr.range); let typ = QualifiedIdent::new_static("Data.Pair", None, expr.range);
self.visit_qualified_ident(&mut typ.add_segment("new").to_generated()); self.visit_qualified_ident(&mut typ.add_segment("new").to_generated());
self.visit_expr(fst); self.visit_expr(fst);
self.visit_expr(snd); self.visit_expr(snd);
} }
ExprKind::List { args } => { ExprKind::List { args } => {
let mut typ = QualifiedIdent::new_static("List", None, expr.range); let mut typ = QualifiedIdent::new_static("Data.List", None, expr.range);
self.visit_qualified_ident(&mut typ); self.visit_qualified_ident(&mut typ);
self.visit_qualified_ident(&mut typ.add_segment("nil").to_generated()); self.visit_qualified_ident(&mut typ.add_segment("nil").to_generated());

6
crates/kind-target-hvm/src/lib.rs
View File

@ -17,13 +17,13 @@ pub fn compile_book(book: untyped::Book, trace: bool) -> File {
pub fn compile_str(val: &str) -> Box<Term> { pub fn compile_str(val: &str) -> Box<Term> {
let nil = Box::new(Term::Ctr { let nil = Box::new(Term::Ctr {
name: String::from("String.nil"), name: String::from("Data.String.nil"),
args: vec![], args: vec![],
}); });
let cons = |numb, next| { let cons = |numb, next| {
Box::new(Term::Ctr { Box::new(Term::Ctr {
name: String::from("String.cons"), name: String::from("Data.String.cons"),
args: vec![Box::new(Term::U6O { numb }), next], args: vec![Box::new(Term::U6O { numb }), next],
}) })
}; };
@ -105,7 +105,7 @@ fn compile_entry(file: &mut File, entry: Box<untyped::Entry>, trace: bool) {
args: args.clone(), args: args.clone(),
}), }),
rhs: Box::new(Term::Ctr { rhs: Box::new(Term::Ctr {
name: "HVM.log".to_string(), name: "Apps.HVM.log".to_string(),
args: vec![ args: vec![
compile_str(entry.name.to_str()), compile_str(entry.name.to_str()),
Box::new(Term::Ctr { Box::new(Term::Ctr {

46
crates/kind-target-kdl/src/compile.rs
View File

@ -326,7 +326,7 @@ pub fn compile_expr(ctx: &mut CompileCtx, expr: &untyped::Expr) -> kdl::Term {
From::Ctr { name, args } => { From::Ctr { name, args } => {
// Convert U120 numbers into the native kindelia representation // Convert U120 numbers into the native kindelia representation
// Only possible if both U60s are U60 terms // Only possible if both U60s are U60 terms
if name.to_str() == "U120.new" { if name.to_str() == "Data.U120.new" {
if let (From::U60 { numb: hi }, From::U60 { numb: lo }) = if let (From::U60 { numb: hi }, From::U60 { numb: lo }) =
(&args[0].data, &args[1].data) (&args[0].data, &args[1].data)
{ {
@ -344,97 +344,97 @@ pub fn compile_expr(ctx: &mut CompileCtx, expr: &untyped::Expr) -> kdl::Term {
// some numeric function applications // some numeric function applications
// Add with no boundary check is just a normal add // Add with no boundary check is just a normal add
"U60.add_unsafe" => To::Op2 { "Data.U60.add_unsafe" => To::Op2 {
oper: kdl::Oper::Add, oper: kdl::Oper::Add,
val0: Box::new(compile_expr(ctx, &args[0])), val0: Box::new(compile_expr(ctx, &args[0])),
val1: Box::new(compile_expr(ctx, &args[1])), val1: Box::new(compile_expr(ctx, &args[1])),
}, },
// U60s are already stored in 120 bits // U60s are already stored in 120 bits
"U60.to_u120" => compile_expr(ctx, &args[0]), "Data.U60.to_u120" => compile_expr(ctx, &args[0]),
// Truncate to 60 bits // Truncate to 60 bits
"U120.to_u60" => To::Op2 { "Data.U120.to_u60" => To::Op2 {
oper: kdl::Oper::And, oper: kdl::Oper::And,
val0: Box::new(compile_expr(ctx, &args[0])), val0: Box::new(compile_expr(ctx, &args[0])),
val1: Box::new(To::Num { numb: U60_MAX }), val1: Box::new(To::Num { numb: U60_MAX }),
}, },
// Compilation for U120 numeric operations // Compilation for U120 numeric operations
"U120.add" => To::Op2 { "Data.U120.add" => To::Op2 {
oper: kdl::Oper::Add, oper: kdl::Oper::Add,
val0: Box::new(compile_expr(ctx, &args[0])), val0: Box::new(compile_expr(ctx, &args[0])),
val1: Box::new(compile_expr(ctx, &args[1])), val1: Box::new(compile_expr(ctx, &args[1])),
}, },
"U120.sub" => To::Op2 { "Data.U120.sub" => To::Op2 {
oper: kdl::Oper::Add, oper: kdl::Oper::Add,
val0: Box::new(compile_expr(ctx, &args[0])), val0: Box::new(compile_expr(ctx, &args[0])),
val1: Box::new(compile_expr(ctx, &args[1])), val1: Box::new(compile_expr(ctx, &args[1])),
}, },
"U120.mul" => To::Op2 { "Data.U120.mul" => To::Op2 {
oper: kdl::Oper::Mul, oper: kdl::Oper::Mul,
val0: Box::new(compile_expr(ctx, &args[0])), val0: Box::new(compile_expr(ctx, &args[0])),
val1: Box::new(compile_expr(ctx, &args[1])), val1: Box::new(compile_expr(ctx, &args[1])),
}, },
"U120.div" => To::Op2 { "Data.U120.div" => To::Op2 {
oper: kdl::Oper::Div, oper: kdl::Oper::Div,
val0: Box::new(compile_expr(ctx, &args[0])), val0: Box::new(compile_expr(ctx, &args[0])),
val1: Box::new(compile_expr(ctx, &args[1])), val1: Box::new(compile_expr(ctx, &args[1])),
}, },
"U120.mod" => To::Op2 { "Data.U120.mod" => To::Op2 {
oper: kdl::Oper::Mod, oper: kdl::Oper::Mod,
val0: Box::new(compile_expr(ctx, &args[0])), val0: Box::new(compile_expr(ctx, &args[0])),
val1: Box::new(compile_expr(ctx, &args[1])), val1: Box::new(compile_expr(ctx, &args[1])),
}, },
"U120.num_equal" => To::Op2 { "Data.U120.num_equal" => To::Op2 {
oper: kdl::Oper::Eql, oper: kdl::Oper::Eql,
val0: Box::new(compile_expr(ctx, &args[0])), val0: Box::new(compile_expr(ctx, &args[0])),
val1: Box::new(compile_expr(ctx, &args[1])), val1: Box::new(compile_expr(ctx, &args[1])),
}, },
"U120.num_not_equal" => To::Op2 { "Data.U120.num_not_equal" => To::Op2 {
oper: kdl::Oper::Neq, oper: kdl::Oper::Neq,
val0: Box::new(compile_expr(ctx, &args[0])), val0: Box::new(compile_expr(ctx, &args[0])),
val1: Box::new(compile_expr(ctx, &args[1])), val1: Box::new(compile_expr(ctx, &args[1])),
}, },
"U120.shift_left" => To::Op2 { "Data.U120.shift_left" => To::Op2 {
oper: kdl::Oper::Shl, oper: kdl::Oper::Shl,
val0: Box::new(compile_expr(ctx, &args[0])), val0: Box::new(compile_expr(ctx, &args[0])),
val1: Box::new(compile_expr(ctx, &args[1])), val1: Box::new(compile_expr(ctx, &args[1])),
}, },
"U120.shift_right" => To::Op2 { "Data.U120.shift_right" => To::Op2 {
oper: kdl::Oper::Shr, oper: kdl::Oper::Shr,
val0: Box::new(compile_expr(ctx, &args[0])), val0: Box::new(compile_expr(ctx, &args[0])),
val1: Box::new(compile_expr(ctx, &args[1])), val1: Box::new(compile_expr(ctx, &args[1])),
}, },
"U120.num_less_than" => To::Op2 { "Data.U120.num_less_than" => To::Op2 {
oper: kdl::Oper::Ltn, oper: kdl::Oper::Ltn,
val0: Box::new(compile_expr(ctx, &args[0])), val0: Box::new(compile_expr(ctx, &args[0])),
val1: Box::new(compile_expr(ctx, &args[1])), val1: Box::new(compile_expr(ctx, &args[1])),
}, },
"U120.num_less_equal" => To::Op2 { "Data.U120.num_less_equal" => To::Op2 {
oper: kdl::Oper::Lte, oper: kdl::Oper::Lte,
val0: Box::new(compile_expr(ctx, &args[0])), val0: Box::new(compile_expr(ctx, &args[0])),
val1: Box::new(compile_expr(ctx, &args[1])), val1: Box::new(compile_expr(ctx, &args[1])),
}, },
"U120.num_greater_than" => To::Op2 { "Data.U120.num_greater_than" => To::Op2 {
oper: kdl::Oper::Gtn, oper: kdl::Oper::Gtn,
val0: Box::new(compile_expr(ctx, &args[0])), val0: Box::new(compile_expr(ctx, &args[0])),
val1: Box::new(compile_expr(ctx, &args[1])), val1: Box::new(compile_expr(ctx, &args[1])),
}, },
"U120.num_greater_equal" => To::Op2 { "Data.U120.num_greater_equal" => To::Op2 {
oper: kdl::Oper::Gte, oper: kdl::Oper::Gte,
val0: Box::new(compile_expr(ctx, &args[0])), val0: Box::new(compile_expr(ctx, &args[0])),
val1: Box::new(compile_expr(ctx, &args[1])), val1: Box::new(compile_expr(ctx, &args[1])),
}, },
"U120.bitwise_and" => To::Op2 { "Data.U120.bitwise_and" => To::Op2 {
oper: kdl::Oper::And, oper: kdl::Oper::And,
val0: Box::new(compile_expr(ctx, &args[0])), val0: Box::new(compile_expr(ctx, &args[0])),
val1: Box::new(compile_expr(ctx, &args[1])), val1: Box::new(compile_expr(ctx, &args[1])),
}, },
"U120.bitwise_or" => To::Op2 { "Data.U120.bitwise_or" => To::Op2 {
oper: kdl::Oper::Or, oper: kdl::Oper::Or,
val0: Box::new(compile_expr(ctx, &args[0])), val0: Box::new(compile_expr(ctx, &args[0])),
val1: Box::new(compile_expr(ctx, &args[1])), val1: Box::new(compile_expr(ctx, &args[1])),
}, },
"U120.bitwise_xor" => To::Op2 { "Data.U120.bitwise_xor" => To::Op2 {
oper: kdl::Oper::Xor, oper: kdl::Oper::Xor,
val0: Box::new(compile_expr(ctx, &args[0])), val0: Box::new(compile_expr(ctx, &args[0])),
val1: Box::new(compile_expr(ctx, &args[1])), val1: Box::new(compile_expr(ctx, &args[1])),
@ -455,11 +455,11 @@ pub fn compile_expr(ctx: &mut CompileCtx, expr: &untyped::Expr) -> kdl::Term {
} }
From::Str { val } => { From::Str { val } => {
let nil = kdl::Term::Ctr { let nil = kdl::Term::Ctr {
name: *ctx.kdl_names.get("String.nil").unwrap(), name: *ctx.kdl_names.get("Data.String.nil").unwrap(),
args: vec![], args: vec![],
}; };
let cons_name = *ctx.kdl_names.get("String.cons").unwrap(); let cons_name = *ctx.kdl_names.get("Data.String.cons").unwrap();
let cons = |numb: u128, next| kdl::Term::Ctr { let cons = |numb: u128, next| kdl::Term::Ctr {
name: cons_name, name: cons_name,
@ -494,7 +494,7 @@ pub fn compile_entry(ctx: &mut CompileCtx, entry: &untyped::Entry) {
} }
} else { } else {
match entry.name.to_str() { match entry.name.to_str() {
"U120.new" => compile_u120_new(ctx, entry), "Data.U120.new" => compile_u120_new(ctx, entry),
_ => compile_common_function(ctx, entry), _ => compile_common_function(ctx, entry),
} }
} }

4
crates/kind-tree/src/concrete/expr.rs
View File

@ -397,8 +397,8 @@ impl Display for Literal {
match self { match self {
Literal::Help(s) => write!(f, "?{}", s), Literal::Help(s) => write!(f, "?{}", s),
Literal::Type => write!(f, "Type"), Literal::Type => write!(f, "Type"),
Literal::NumTypeU60 => write!(f, "U60"), Literal::NumTypeU60 => write!(f, "Data.U60"),
Literal::NumTypeF60 => write!(f, "F60"), Literal::NumTypeF60 => write!(f, "Data.F60"),
Literal::Char(c) => write!(f, "'{}'", c), Literal::Char(c) => write!(f, "'{}'", c),
Literal::NumU60(numb) => write!(f, "{}", numb), Literal::NumU60(numb) => write!(f, "{}", numb),
Literal::Nat(numb) => write!(f, "{}numb", numb), Literal::Nat(numb) => write!(f, "{}numb", numb),

10
crates/kind-tree/src/desugared/mod.rs
View File

@ -249,7 +249,7 @@ impl Expr {
} }
pub fn num_u120(range: Range, numb: u128) -> Box<Expr> { pub fn num_u120(range: Range, numb: u128) -> Box<Expr> {
let name = QualifiedIdent::new_static("U120.new", None, range); let name = QualifiedIdent::new_static("Data.U120.new", None, range);
let lo = Expr::num_u60(range, (numb & 0xFFFFFFFFFFFFFFF) as u64); let lo = Expr::num_u60(range, (numb & 0xFFFFFFFFFFFFFFF) as u64);
let hi = Expr::num_u60(range, (numb >> 60) as u64); let hi = Expr::num_u60(range, (numb >> 60) as u64);
Box::new(Expr { Box::new(Expr {
@ -402,8 +402,8 @@ impl Display for AppBinding {
pub fn try_desugar_to_nat(name: &QualifiedIdent, spine: &[Box<Expr>], acc: u128) -> Option<u128> { pub fn try_desugar_to_nat(name: &QualifiedIdent, spine: &[Box<Expr>], acc: u128) -> Option<u128> {
match (name.to_str(), spine) { match (name.to_str(), spine) {
("Nat.zero", []) => Some(acc), ("Data.Nat.zero", []) => Some(acc),
("Nat.succ", [spine]) => match &spine.data { ("Data.Nat.succ", [spine]) => match &spine.data {
ExprKind::Ctr { name, args } => try_desugar_to_nat(name, args, acc + 1), ExprKind::Ctr { name, args } => try_desugar_to_nat(name, args, acc + 1),
_ => None, _ => None,
}, },
@ -416,8 +416,8 @@ impl Display for Expr {
use ExprKind::*; use ExprKind::*;
match &self.data { match &self.data {
Typ => write!(f, "Type"), Typ => write!(f, "Type"),
NumTypeU60 => write!(f, "U60"), NumTypeU60 => write!(f, "Data.U60"),
NumTypeF60 => write!(f, "F60"), NumTypeF60 => write!(f, "Data.F60"),
Str { val } => write!(f, "\"{}\"", val), Str { val } => write!(f, "\"{}\"", val),
NumU60 { numb } => write!(f, "{}", numb), NumU60 { numb } => write!(f, "{}", numb),
NumF60 { numb: _ } => todo!(), NumF60 { numb: _ } => todo!(),