HigherOrderCO/Bend
1
1
Fork 0
mirror of https://github.com/HigherOrderCO/Bend.git synced 2024-10-26 14:05:36 +03:00
Code Issues Packages Projects Releases Wiki Activity

Rename more types

Browse Source
This commit is contained in:
Nicolas Abril 2023-09-22 21:01:12 +02:00
parent 5ca1d87115
commit 527d3ce8ca
7 changed files with 79 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
src/ast/compat.rs
View File

@ -1,9 +1,8 @@
// TODO: Refactor to not use this intermediate form
use super::Opr;
use hvm_core::Val;
use super::NumOper;
#[derive(Clone, Debug)]
/// Net representation used only as an intermediate for converting to hvm-core format
pub struct INet {
@ -74,19 +73,19 @@ pub fn link(inet: &mut INet, ptr_a: Port, ptr_b: Port) {
inet.nodes[ptr_b as usize] = ptr_a;
}
impl From<NodeKind> for NumOper {
impl From<NodeKind> for Opr {
fn from(value: NodeKind) -> Self {
match value {
0 => NumOper::Add,
0 => Opr::Add,
_ => todo!(),
}
}
}
impl From<NumOper> for NodeKind {
fn from(value: NumOper) -> Self {
impl From<Opr> for NodeKind {
fn from(value: Opr) -> Self {
match value {
NumOper::Add => 0,
Opr::Add => 0,
_ => todo!(),
}
}

73
src/ast/hvm_lang.rs
View File

@ -46,7 +46,7 @@ pub enum Term {
nam: Name,
bod: Box<Term>,
},
/// The use of a Channel variable
/// The use of a Channel variable.
Lnk {
nam: Name,
},
@ -70,8 +70,9 @@ pub enum Term {
I32 {
val: i32,
},
Opr {
op: NumOper,
/// A numeric operation between built-in numbers.
Opx {
op: Opr,
fst: Box<Term>,
snd: Box<Term>,
},
@ -82,8 +83,9 @@ pub enum Term {
Era,
}
/// A numeric operator, for built-in machine numbers
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
pub enum NumOper {
pub enum Opr {
Add,
Sub,
Mul,
@ -102,29 +104,40 @@ pub enum NumOper {
Neq,
}
impl From<NumOper> for hvm_core::OP {
fn from(value: NumOper) -> Self {
impl From<Opr> for hvm_core::OP {
fn from(value: Opr) -> Self {
match value {
NumOper::Add => hvm_core::OP::ADD,
Opr::Add => hvm_core::OP::ADD,
_ => todo!(),
}
}
}
impl From<hvm_core::OP> for NumOper {
impl From<hvm_core::OP> for Opr {
fn from(value: hvm_core::OP) -> Self {
match value {
hvm_core::OP::ADD => NumOper::Add,
hvm_core::OP::ADD => Opr::Add,
_ => todo!(),
}
}
}
impl From<&hvm_core::OP> for NumOper {
impl From<&hvm_core::OP> for Opr {
fn from(value: &hvm_core::OP) -> Self {
match value {
hvm_core::OP::ADD => NumOper::Add,
_ => todo!(),
hvm_core::OP::ADD => Opr::Add,
hvm_core::OP::SUB => Opr::Sub,
hvm_core::OP::MUL => Opr::Mul,
hvm_core::OP::DIV => Opr::Div,
hvm_core::OP::MOD => Opr::Mod,
hvm_core::OP::EQ => Opr::Eql,
hvm_core::OP::NEQ => Opr::Neq,
hvm_core::OP::LT => Opr::Ltn,
hvm_core::OP::GT => Opr::Gtn,
hvm_core::OP::LTE => Opr::Lte,
hvm_core::OP::GTE => Opr::Gte,
hvm_core::OP::AND => Opr::And,
hvm_core::OP::OR => Opr::Or,
}
}
}
@ -135,25 +148,25 @@ impl DefinitionBook {
}
}
impl fmt::Display for NumOper {
impl fmt::Display for Opr {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
NumOper::Add => write!(f, "+"),
NumOper::Sub => write!(f, "-"),
NumOper::Mul => write!(f, "*"),
NumOper::Div => write!(f, "/"),
NumOper::Mod => write!(f, "%"),
NumOper::And => write!(f, "&"),
NumOper::Or => write!(f, "|"),
NumOper::Xor => write!(f, "^"),
NumOper::Shl => write!(f, "<<"),
NumOper::Shr => write!(f, ">>"),
NumOper::Ltn => write!(f, "<"),
NumOper::Lte => write!(f, "<="),
NumOper::Gtn => write!(f, ">"),
NumOper::Gte => write!(f, ">="),
NumOper::Eql => write!(f, "=="),
NumOper::Neq => write!(f, "!="),
Opr::Add => write!(f, "+"),
Opr::Sub => write!(f, "-"),
Opr::Mul => write!(f, "*"),
Opr::Div => write!(f, "/"),
Opr::Mod => write!(f, "%"),
Opr::And => write!(f, "&"),
Opr::Or => write!(f, "|"),
Opr::Xor => write!(f, "^"),
Opr::Shl => write!(f, "<<"),
Opr::Shr => write!(f, ">>"),
Opr::Ltn => write!(f, "<"),
Opr::Lte => write!(f, "<="),
Opr::Gtn => write!(f, ">"),
Opr::Gte => write!(f, ">="),
Opr::Eql => write!(f, "=="),
Opr::Neq => write!(f, "!="),
}
}
}
@ -181,7 +194,7 @@ impl Term {
),
Term::U32 { val } => format!("{val}"),
Term::I32 { val } => format!("{val:+}"),
Term::Opr { op, fst, snd } => {
Term::Opx { op, fst, snd } => {
format!("({} {} {})", op, fst.to_string(def_names), snd.to_string(def_names))
}
Term::Sup { fst, snd } => format!("{{{} {}}}", fst.to_string(def_names), snd.to_string(def_names)),

2
src/ast/mod.rs
View File

@ -2,7 +2,7 @@ pub mod compat;
pub mod core;
pub mod hvm_lang;
pub use hvm_lang::{Definition, DefinitionBook, NumOper, Rule, Term};
pub use hvm_lang::{Definition, DefinitionBook, Opr, Rule, Term};
use derive_more::{Display, From, Into};
use hvm_core::Val;

8
src/from_core/mod.rs
View File

@ -3,7 +3,7 @@ use crate::ast::{
addr, enter, kind, link, new_inet, new_node, port, slot, INet, INode, INodes, NodeId, NodeKind, Port,
SlotId, CON, DUP, ERA, LABEL_MASK, NUMOP, NUM_I32, NUM_U32, REF, ROOT, TAG_MASK,
},
var_id_to_name, DefId, Name, NumOper, Term,
var_id_to_name, DefId, Name, Opr, Term,
};
use hvm_core::{LNet, LTree, Val};
use std::collections::{HashMap, HashSet};
@ -99,7 +99,7 @@ fn tree_to_inodes(tree: &LTree, tree_root: String, net_root: &str, n_vars: &mut
inodes.push(INode { kind, ports: [subtree_root, var.clone(), var] });
}
LTree::OpX { opx, lft, rgt } => {
let kind = NUMOP | NodeKind::from(NumOper::from(opx));
let kind = NUMOP | NodeKind::from(Opr::from(opx));
let lft = process_node_subtree(lft, net_root, &mut subtrees, n_vars);
let rgt = process_node_subtree(rgt, net_root, &mut subtrees, n_vars);
inodes.push(INode { kind, ports: [subtree_root, lft, rgt] })
@ -237,13 +237,13 @@ fn readback_compat(net: &INet) -> (Term, bool) {
2 => {
seen.insert(port(node, 0));
seen.insert(port(node, 1));
let op = NumOper::from(label);
let op = Opr::from(label);
let fst = enter(net, port(node, 0));
let (fst, fst_valid) = reader(net, fst, var_port_to_name, dups_vec, dups_set, seen);
let snd = enter(net, port(node, 1));
let (snd, snd_valid) = reader(net, snd, var_port_to_name, dups_vec, dups_set, seen);
let valid = fst_valid && snd_valid;
(Term::Opr { op, fst: Box::new(fst), snd: Box::new(snd) }, valid)
(Term::Opx { op, fst: Box::new(fst), snd: Box::new(snd) }, valid)
}
_ => unreachable!(),
},

42
src/parser/parser.rs
View File

@ -1,6 +1,6 @@
use super::lexer::LexingError;
use crate::{
ast::{hvm_lang::Pattern, DefId, Definition, DefinitionBook, Name, NumOper, Rule, Term},
ast::{hvm_lang::Pattern, DefId, Definition, DefinitionBook, Name, Opr, Rule, Term},
parser::lexer::Token,
};
use chumsky::{
@ -44,7 +44,7 @@ pub fn parse_definition_book(code: &str) -> Result<DefinitionBook, Vec<Rich<Toke
pub fn parse_term(code: &str) -> Result<Term, Vec<Rich<Token>>> {
let inline_app =
term().foldl(term().repeated(), |fun, arg| Term::App { fun: Box::new(fun), arg: Box::new(arg) });
let inline_num_oper = num_oper().then(term()).then(term()).map(|((op, fst), snd)| Term::Opr {
let inline_num_oper = num_oper().then(term()).then(term()).map(|((op, fst), snd)| Term::Opx {
op,
fst: Box::new(fst),
snd: Box::new(snd),
@ -91,27 +91,27 @@ where
choice((select!(Token::Asterisk => None), name().map(Some)))
}
fn num_oper<'a, I>() -> impl Parser<'a, I, NumOper, extra::Err<Rich<'a, Token>>>
fn num_oper<'a, I>() -> impl Parser<'a, I, Opr, extra::Err<Rich<'a, Token>>>
where
I: ValueInput<'a, Token = Token, Span = SimpleSpan>,
{
select! {
Token::Add => NumOper::Add,
Token::Sub => NumOper::Sub,
Token::Asterisk => NumOper::Mul,
Token::Div => NumOper::Div,
Token::Mod => NumOper::Mod,
Token::And => NumOper::And,
Token::Or => NumOper::Or,
Token::Xor => NumOper::Xor,
Token::Shl => NumOper::Shl,
Token::Shr => NumOper::Shr,
Token::Lte => NumOper::Lte,
Token::Ltn => NumOper::Ltn,
Token::Gte => NumOper::Gte,
Token::Gtn => NumOper::Gtn,
Token::EqualsEquals => NumOper::Eql,
Token::NotEquals => NumOper::Neq,
Token::Add => Opr::Add,
Token::Sub => Opr::Sub,
Token::Asterisk => Opr::Mul,
Token::Div => Opr::Div,
Token::Mod => Opr::Mod,
Token::And => Opr::And,
Token::Or => Opr::Or,
Token::Xor => Opr::Xor,
Token::Shl => Opr::Shl,
Token::Shr => Opr::Shr,
Token::Lte => Opr::Lte,
Token::Ltn => Opr::Ltn,
Token::Gte => Opr::Gte,
Token::Gtn => Opr::Gtn,
Token::EqualsEquals => Opr::Eql,
Token::NotEquals => Opr::Neq,
}
}
@ -199,7 +199,7 @@ where
.then(term.clone())
.delimited_by(new_line(), new_line())
.delimited_by(just(Token::LParen), just(Token::RParen))
.map(|((op, fst), snd)| Term::Opr { op, fst: Box::new(fst), snd: Box::new(snd) })
.map(|((op, fst), snd)| Term::Opx { op, fst: Box::new(fst), snd: Box::new(snd) })
.boxed();
choice((global_var, var, unsigned, signed, global_lam, lam, dup, let_, num_op, app))
@ -229,7 +229,7 @@ where
{
let inline_app =
term().foldl(term().repeated(), |fun, arg| Term::App { fun: Box::new(fun), arg: Box::new(arg) });
let inline_num_oper = num_oper().then(term()).then(term()).map(|((op, fst), snd)| Term::Opr {
let inline_num_oper = num_oper().then(term()).then(term()).map(|((op, fst), snd)| Term::Opx {
op,
fst: Box::new(fst),
snd: Box::new(snd),

2
src/semantic/affine.rs
View File

@ -125,7 +125,7 @@ fn term_to_affine(
let (fst, nxt) = pop_scope(fst, nxt, scope, def_names);
Term::Dup { fst, snd, val, nxt }
}
Term::Opr { op, fst, snd } => Term::Opr {
Term::Opx { op, fst, snd } => Term::Opx {
op: *op,
fst: Box::new(term_to_affine(fst, scope, globals, def_names)?),
snd: Box::new(term_to_affine(snd, scope, globals, def_names)?),

7
src/to_core/compat_net.rs
View File

@ -3,7 +3,7 @@ use crate::ast::{
addr, enter, kind, link, new_inet, new_node, port, slot, INet, NodeId, NodeKind, Port, CON, DUP, ERA,
LABEL_MASK, NUMOP, NUM_I32, NUM_U32, REF, ROOT, TAG_MASK,
},
var_id_to_name, DefId, Name, NumOper, Term,
var_id_to_name, DefId, Name, Opr, Term,
};
use hvm_core::{LNet, LTree, Tag};
use std::collections::{HashMap, HashSet};
@ -128,7 +128,7 @@ fn encode_term(
inet.nodes[port(node, 2) as usize] = port(node, 1);
Ok(Some(port(node, 0)))
}
Term::Opr { op, fst, snd } => {
Term::Opx { op, fst, snd } => {
let node = new_node(inet, NUMOP | NodeKind::from(*op));
let fst = encode_term(inet, fst, port(node, 0), scope, vars, global_vars, dups)?;
link_local(inet, port(node, 0), fst);
@ -138,7 +138,6 @@ fn encode_term(
}
Term::Sup { .. } => unreachable!(),
Term::Era => unreachable!(),
_ => todo!(),
}
}
@ -294,7 +293,7 @@ fn compat_tree_to_hvm_tree(inet: &INet, root: NodeId, port_to_var_id: &mut HashM
NUM_U32 => LTree::U32 { val: label as u32 },
NUM_I32 => LTree::I32 { val: label as u32 as i32 },
NUMOP => LTree::OpX {
opx: hvm_core::OP::from(NumOper::from(label)),
opx: hvm_core::OP::from(Opr::from(label)),
lft: Box::new(var_or_subtree(inet, port(root, 1), port_to_var_id)),
rgt: Box::new(var_or_subtree(inet, port(root, 2), port_to_var_id)),
},