mirror of
https://github.com/HigherOrderCO/Bend.git
synced 2024-10-26 14:05:36 +03:00
Rename more types
This commit is contained in:
parent
5ca1d87115
commit
527d3ce8ca
@ -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!(),
|
||||
}
|
||||
}
|
||||
|
@ -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,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;
|
||||
|
@ -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: <ree, 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!(),
|
||||
},
|
||||
|
@ -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),
|
||||
|
@ -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)?),
|
||||
|
@ -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)),
|
||||
},
|
||||
|
Loading…
Reference in New Issue
Block a user