From bb5adba4efa25226c6ba57dd1cae9a03e34eabfb Mon Sep 17 00:00:00 2001 From: bakaq Date: Sat, 12 Oct 2024 16:48:13 -0300 Subject: [PATCH] Rename PrologTerm to Term --- src/machine/lib_machine.rs | 155 ++++++++++++++++++------------------- 1 file changed, 75 insertions(+), 80 deletions(-) diff --git a/src/machine/lib_machine.rs b/src/machine/lib_machine.rs index ba1be14c..e05ed2a6 100644 --- a/src/machine/lib_machine.rs +++ b/src/machine/lib_machine.rs @@ -27,17 +27,17 @@ pub enum LeafAnswer { /// This means that there are no more answers for the query. False, /// An exception leaf answer. - Exception(PrologTerm), + Exception(Term), /// A leaf answer with bindings and residual goals. LeafAnswer { /// The bindings of variables in the query. /// /// Can be empty. - bindings: BTreeMap, + bindings: BTreeMap, /// Residual goals. /// /// Can be empty. - residual_goals: Vec, + residual_goals: Vec, }, } @@ -61,7 +61,7 @@ impl LeafAnswer { /// Represents a Prolog term. #[non_exhaustive] #[derive(Debug, Clone, PartialEq)] -pub enum PrologTerm { +pub enum Term { /// An arbitrary precision integer. Integer(Integer), /// An arbitrary precision rational. @@ -75,100 +75,95 @@ pub enum PrologTerm { /// In particular, this represents Prolog lists of characters. String(String), /// A Prolog list. - List(Vec), + List(Vec), /// A Prolog compound term. - Compound(String, Vec), + Compound(String, Vec), /// A Prolog variable. Var(String), } -impl PrologTerm { +impl Term { /// Creates an integer term. pub fn integer(value: impl Into) -> Self { - PrologTerm::Integer(value.into()) + Term::Integer(value.into()) } /// Creates a rational term. pub fn rational(value: impl Into) -> Self { - PrologTerm::Rational(value.into()) + Term::Rational(value.into()) } /// Creates a float term. pub fn float(value: impl Into) -> Self { - PrologTerm::Float(value.into()) + Term::Float(value.into()) } /// Creates an atom term. pub fn atom(value: impl Into) -> Self { - PrologTerm::Atom(value.into()) + Term::Atom(value.into()) } /// Creates a string term. /// /// In specific, this represents a list of chars in Prolog. pub fn string(value: impl Into) -> Self { - PrologTerm::String(value.into()) + Term::String(value.into()) } /// Creates a list term. - pub fn list(value: impl IntoIterator) -> Self { - PrologTerm::List(value.into_iter().collect()) + pub fn list(value: impl IntoIterator) -> Self { + Term::List(value.into_iter().collect()) } /// Creates a compound term. - pub fn compound( - functor: impl Into, - args: impl IntoIterator, - ) -> Self { - PrologTerm::Compound(functor.into(), args.into_iter().collect()) + pub fn compound(functor: impl Into, args: impl IntoIterator) -> Self { + Term::Compound(functor.into(), args.into_iter().collect()) } /// Creates a variable. pub fn variable(value: impl Into) -> Self { - PrologTerm::Var(value.into()) + Term::Var(value.into()) } /// Creates a conjunction, giving the atom `true` if empty. - pub fn conjunction(value: impl IntoIterator) -> Self { - PrologTerm::try_conjunction(value).unwrap_or(PrologTerm::atom("true")) + pub fn conjunction(value: impl IntoIterator) -> Self { + Term::try_conjunction(value).unwrap_or(Term::atom("true")) } /// Creates a conjunction, giving `None` if empty. - pub fn try_conjunction(value: impl IntoIterator) -> Option { + pub fn try_conjunction(value: impl IntoIterator) -> Option { let mut iter = value.into_iter(); iter.next().map(|first| { - PrologTerm::try_conjunction(iter) - .map(|rest| PrologTerm::compound(",", [first.clone(), rest])) + Term::try_conjunction(iter) + .map(|rest| Term::compound(",", [first.clone(), rest])) .unwrap_or(first) }) } /// Creates a disjunction, giving the atom `false` if empty. - pub fn disjunction(value: impl IntoIterator) -> Self { - PrologTerm::try_disjunction(value).unwrap_or(PrologTerm::atom("false")) + pub fn disjunction(value: impl IntoIterator) -> Self { + Term::try_disjunction(value).unwrap_or(Term::atom("false")) } /// Creates a disjunction, giving `None` if empty. - pub fn try_disjunction(value: impl IntoIterator) -> Option { + pub fn try_disjunction(value: impl IntoIterator) -> Option { let mut iter = value.into_iter(); iter.next().map(|first| { - PrologTerm::try_disjunction(iter) - .map(|rest| PrologTerm::compound(";", [first.clone(), rest])) + Term::try_disjunction(iter) + .map(|rest| Term::compound(";", [first.clone(), rest])) .unwrap_or(first) }) } } -impl From for PrologTerm { +impl From for Term { fn from(value: LeafAnswer) -> Self { match value { - LeafAnswer::True => PrologTerm::atom("true"), - LeafAnswer::False => PrologTerm::atom("false"), + LeafAnswer::True => Term::atom("true"), + LeafAnswer::False => Term::atom("false"), LeafAnswer::Exception(inner) => match inner.clone() { - PrologTerm::Compound(functor, args) if functor == "error" && args.len() == 2 => { - inner - } - _ => PrologTerm::compound("throw", [inner]), + Term::Compound(functor, args) if functor == "error" && args.len() == 2 => inner, + _ => Term::compound("throw", [inner]), }, LeafAnswer::LeafAnswer { bindings: _, @@ -198,7 +193,7 @@ fn count_to_letter_code(mut count: usize) -> String { letters.into_iter().chain("_".chars()).rev().collect() } -impl PrologTerm { +impl Term { pub(crate) fn from_heapcell( machine: &mut Machine, heap_cell: HeapCellValue, @@ -233,41 +228,41 @@ impl PrologTerm { let head = term_stack.pop().unwrap(); let list = match tail { - PrologTerm::Atom(atom) if atom == "[]" => match head { - PrologTerm::Atom(ref a) if a.chars().collect::>().len() == 1 => { + Term::Atom(atom) if atom == "[]" => match head { + Term::Atom(ref a) if a.chars().collect::>().len() == 1 => { // Handle lists of char as strings - PrologTerm::String(a.to_string()) + Term::String(a.to_string()) } - _ => PrologTerm::List(vec![head]), + _ => Term::List(vec![head]), }, - PrologTerm::List(elems) if elems.is_empty() => match head { - PrologTerm::Atom(ref a) if a.chars().collect::>().len() == 1 => { + Term::List(elems) if elems.is_empty() => match head { + Term::Atom(ref a) if a.chars().collect::>().len() == 1 => { // Handle lists of char as strings - PrologTerm::String(a.to_string()) + Term::String(a.to_string()) }, - _ => PrologTerm::List(vec![head]), + _ => Term::List(vec![head]), }, - PrologTerm::List(mut elems) => { + Term::List(mut elems) => { elems.insert(0, head); - PrologTerm::List(elems) + Term::List(elems) }, - PrologTerm::String(mut elems) => match head { - PrologTerm::Atom(ref a) if a.chars().collect::>().len() == 1 => { + Term::String(mut elems) => match head { + Term::Atom(ref a) if a.chars().collect::>().len() == 1 => { // Handle lists of char as strings elems.insert(0, a.chars().next().unwrap()); - PrologTerm::String(elems) + Term::String(elems) }, _ => { - let mut elems: Vec = elems + let mut elems: Vec = elems .chars() - .map(|x| PrologTerm::Atom(x.into())) + .map(|x| Term::Atom(x.into())) .collect(); elems.insert(0, head); - PrologTerm::List(elems) + Term::List(elems) } }, _ => { - PrologTerm::Compound(".".into(), vec![head, tail]) + Term::Compound(".".into(), vec![head, tail]) } }; term_stack.push(list); @@ -275,7 +270,7 @@ impl PrologTerm { (HeapCellValueTag::Var | HeapCellValueTag::AttrVar | HeapCellValueTag::StackVar) => { let var = var_names.get(&addr).map(|x| x.borrow().clone()); match var { - Some(Var::Named(name)) => term_stack.push(PrologTerm::Var(name)), + Some(Var::Named(name)) => term_stack.push(Term::Var(name)), _ => { let anon_name = loop { // Generate a name for the anonymous variable @@ -300,28 +295,28 @@ impl PrologTerm { }, } }; - term_stack.push(PrologTerm::Var(anon_name)); + term_stack.push(Term::Var(anon_name)); }, } } (HeapCellValueTag::F64, f) => { - term_stack.push(PrologTerm::Float((*f).into())); + term_stack.push(Term::Float((*f).into())); } (HeapCellValueTag::Char, c) => { - term_stack.push(PrologTerm::Atom(c.into())); + term_stack.push(Term::Atom(c.into())); } (HeapCellValueTag::Fixnum, n) => { - term_stack.push(PrologTerm::Integer(n.into())); + term_stack.push(Term::Integer(n.into())); } (HeapCellValueTag::Cons) => { match Number::try_from(addr) { - Ok(Number::Integer(i)) => term_stack.push(PrologTerm::Integer((*i).clone())), - Ok(Number::Rational(r)) => term_stack.push(PrologTerm::Rational((*r).clone())), + Ok(Number::Integer(i)) => term_stack.push(Term::Integer((*i).clone())), + Ok(Number::Rational(r)) => term_stack.push(Term::Rational((*r).clone())), _ => {} } } (HeapCellValueTag::CStr, s) => { - term_stack.push(PrologTerm::String(s.as_str().to_string())); + term_stack.push(Term::String(s.as_str().to_string())); } (HeapCellValueTag::Atom, (name, arity)) => { //let h = iter.focus().value() as usize; @@ -352,46 +347,46 @@ impl PrologTerm { if arity == 0 { let atom_name = name.as_str().to_string(); if atom_name == "[]" { - term_stack.push(PrologTerm::List(vec![])); + term_stack.push(Term::List(vec![])); } else { - term_stack.push(PrologTerm::Atom(atom_name)); + term_stack.push(Term::Atom(atom_name)); } } else { let subterms = term_stack .drain(term_stack.len() - arity ..) .collect(); - term_stack.push(PrologTerm::Compound(name.as_str().to_string(), subterms)); + term_stack.push(Term::Compound(name.as_str().to_string(), subterms)); } } (HeapCellValueTag::PStr, atom) => { let tail = term_stack.pop().unwrap(); match tail { - PrologTerm::Atom(atom) => { + Term::Atom(atom) => { if atom == "[]" { - term_stack.push(PrologTerm::String(atom.as_str().to_string())); + term_stack.push(Term::String(atom.as_str().to_string())); } }, - PrologTerm::List(l) => { - let mut list: Vec = atom + Term::List(l) => { + let mut list: Vec = atom .as_str() .to_string() .chars() - .map(|x| PrologTerm::Atom(x.to_string())) + .map(|x| Term::Atom(x.to_string())) .collect(); list.extend(l.into_iter()); - term_stack.push(PrologTerm::List(list)); + term_stack.push(Term::List(list)); }, _ => { - let mut list: Vec = atom + let mut list: Vec = atom .as_str() .to_string() .chars() - .map(|x| PrologTerm::Atom(x.to_string())) + .map(|x| Term::Atom(x.to_string())) .collect(); - let mut partial_list = PrologTerm::Compound( + let mut partial_list = Term::Compound( ".".into(), vec![ list.pop().unwrap(), @@ -400,7 +395,7 @@ impl PrologTerm { ); while let Some(last) = list.pop() { - partial_list = PrologTerm::Compound( + partial_list = Term::Compound( ".".into(), vec![ last, @@ -511,7 +506,7 @@ impl Iterator for QueryState<'_> { return Some(Ok(LeafAnswer::False)); } - let mut bindings: BTreeMap = BTreeMap::new(); + let mut bindings: BTreeMap = BTreeMap::new(); let var_dict = &term_write_result.var_dict; @@ -528,9 +523,9 @@ impl Iterator for QueryState<'_> { } let mut term = - PrologTerm::from_heapcell(machine, *term_to_be_printed, &mut var_names.clone()); + Term::from_heapcell(machine, *term_to_be_printed, &mut var_names.clone()); - if let PrologTerm::Var(ref term_str) = term { + if let Term::Var(ref term_str) = term { if *term_str == var_name { continue; } @@ -544,7 +539,7 @@ impl Iterator for QueryState<'_> { var_dict.get_index_of(&VarKey::VarPtr(Var::Named(term_str.clone()).into())); if let Some(idx) = term_idx { if idx < var_name_idx { - let new_term = PrologTerm::Var(var_name); + let new_term = Term::Var(var_name); let new_var_name = term_str.into(); term = new_term; var_name = new_var_name; -- 2.54.0