From 66b54990058adaac28305ad455adb421dca9571c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Patrick=20L=C3=BChne?= Date: Tue, 7 Jul 2020 08:15:52 +0200 Subject: [PATCH] Experimental refactoring --- src/ast.rs | 4 +- src/flavor.rs | 32 --------- src/parse.rs | 159 +++++++++++++++++++++++++++++++++++++++++- src/parse/formulas.rs | 67 +++++++++--------- src/parse/terms.rs | 67 +++++++++--------- src/utils.rs | 130 +--------------------------------- 6 files changed, 229 insertions(+), 230 deletions(-) diff --git a/src/ast.rs b/src/ast.rs index e74498f..6867979 100644 --- a/src/ast.rs +++ b/src/ast.rs @@ -199,7 +199,7 @@ where pub fn new(declaration: std::rc::Rc, arguments: Terms) -> Self { assert_eq!(declaration.arity(), arguments.len(), - "function has a different number of arguments then declared"); + "function has a different number of arguments than declared"); Self { @@ -353,7 +353,7 @@ where pub fn new(declaration: std::rc::Rc, arguments: Terms) -> Self { assert_eq!(declaration.arity(), arguments.len(), - "predicate has a different number of arguments then declared"); + "predicate has a different number of arguments than declared"); Self { diff --git a/src/flavor.rs b/src/flavor.rs index 8088dac..f4d4507 100644 --- a/src/flavor.rs +++ b/src/flavor.rs @@ -1,7 +1,5 @@ pub trait FunctionDeclaration { - fn new(name: String, arity: usize) -> Self; - fn display_name(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result; fn arity(&self) -> usize; fn matches_signature(&self, other_name: &str, other_arity: usize) -> bool; @@ -9,15 +7,6 @@ pub trait FunctionDeclaration impl FunctionDeclaration for crate::FunctionDeclaration { - fn new(name: String, arity: usize) -> Self - { - Self - { - name, - arity, - } - } - fn display_name(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result { write!(formatter, "{}", self.name) @@ -36,8 +25,6 @@ impl FunctionDeclaration for crate::FunctionDeclaration pub trait PredicateDeclaration { - fn new(name: String, arity: usize) -> Self; - fn display_name(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result; fn arity(&self) -> usize; fn matches_signature(&self, other_name: &str, other_arity: usize) -> bool; @@ -45,15 +32,6 @@ pub trait PredicateDeclaration impl PredicateDeclaration for crate::PredicateDeclaration { - fn new(name: String, arity: usize) -> Self - { - Self - { - name, - arity, - } - } - fn display_name(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result { write!(formatter, "{}", self.name) @@ -72,22 +50,12 @@ impl PredicateDeclaration for crate::PredicateDeclaration pub trait VariableDeclaration { - fn new(name: String) -> Self; - fn display_name(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result; fn matches_name(&self, other_name: &str) -> bool; } impl VariableDeclaration for crate::VariableDeclaration { - fn new(name: String) -> Self - { - Self - { - name - } - } - fn display_name(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result { write!(formatter, "{}", self.name) diff --git a/src/parse.rs b/src/parse.rs index a05b004..625bb78 100644 --- a/src/parse.rs +++ b/src/parse.rs @@ -4,4 +4,161 @@ pub mod terms; pub mod tokens; pub use error::Error; -pub use formulas::formula; + +use crate::flavor::{FunctionDeclaration as _, PredicateDeclaration as _, VariableDeclaration as _}; + +pub trait Parser: Sized +{ + type Flavor: crate::flavor::Flavor; + + fn new_function_declaration(name: String, arity: usize) + -> ::FunctionDeclaration; + fn new_predicate_declaration(name: String, arity: usize) + -> ::PredicateDeclaration; + fn new_variable_declaration(name: String) + -> ::VariableDeclaration; + + fn find_or_create_function_declaration(&self, name: &str, arity: usize) + -> std::rc::Rc<::FunctionDeclaration>; + fn find_or_create_predicate_declaration(&self, name: &str, arity: usize) + -> std::rc::Rc<::PredicateDeclaration>; + fn find_or_create_variable_declaration( + variable_declaration_stack_layer: &crate::VariableDeclarationStackLayer, + variable_name: &str) + -> std::rc::Rc<::VariableDeclaration> + { + match variable_declaration_stack_layer + { + crate::VariableDeclarationStackLayer::Free(free_variable_declarations) => + { + if let Some(variable_declaration) = free_variable_declarations.borrow().iter() + .find(|x| x.matches_name(variable_name)) + { + return std::rc::Rc::clone(&variable_declaration); + } + + let variable_declaration = Self::new_variable_declaration(variable_name.to_owned()); + let variable_declaration = std::rc::Rc::new(variable_declaration); + + free_variable_declarations.borrow_mut() + .push(std::rc::Rc::clone(&variable_declaration)); + + variable_declaration + }, + crate::VariableDeclarationStackLayer::Bound(bound_variable_declarations) => + { + if let Some(variable_declaration) = bound_variable_declarations + .variable_declarations.iter() + .find(|x| x.matches_name(variable_name)) + { + return std::rc::Rc::clone(&variable_declaration); + } + + Self::find_or_create_variable_declaration(bound_variable_declarations.parent, + variable_name) + }, + } + } + + fn parse_formula(&self, input: &str) + -> Result, crate::parse::Error> + { + formulas::formula(input, self) + } +} + +pub struct DefaultParser +{ + function_declarations: + std::cell::RefCell::Flavor>>, + predicate_declarations: + std::cell::RefCell::Flavor>>, +} + +impl DefaultParser +{ + pub fn new() -> Self + { + Self + { + function_declarations: std::cell::RefCell::new( + crate::FunctionDeclarations::<::Flavor>::new()), + predicate_declarations: std::cell::RefCell::new( + crate::PredicateDeclarations::<::Flavor>::new()), + } + } +} + +impl Parser for DefaultParser +{ + type Flavor = crate::flavor::DefaultFlavor; + + fn new_function_declaration(name: String, arity: usize) + -> ::FunctionDeclaration + { + crate::FunctionDeclaration + { + name, + arity, + } + } + + fn new_predicate_declaration(name: String, arity: usize) + -> ::PredicateDeclaration + { + crate::PredicateDeclaration + { + name, + arity, + } + } + + fn new_variable_declaration(name: String) + -> ::VariableDeclaration + { + crate::VariableDeclaration + { + name, + } + } + + fn find_or_create_function_declaration(&self, name: &str, arity: usize) + -> std::rc::Rc<::FunctionDeclaration> + { + let mut function_declarations = self.function_declarations.borrow_mut(); + + match function_declarations.iter().find(|x| x.matches_signature(name, arity)) + { + Some(declaration) => std::rc::Rc::clone(&declaration), + None => + { + let declaration = Self::new_function_declaration(name.to_string(), arity); + let declaration = std::rc::Rc::new(declaration); + + function_declarations.insert(std::rc::Rc::clone(&declaration)); + + declaration + }, + } + } + + fn find_or_create_predicate_declaration(&self, name: &str, arity: usize) + -> std::rc::Rc<::PredicateDeclaration> + { + let mut predicate_declarations = self.predicate_declarations.borrow_mut(); + + match predicate_declarations.iter().find(|x| x.matches_signature(name, arity)) + { + Some(declaration) => std::rc::Rc::clone(&declaration), + None => + { + let declaration = Self::new_predicate_declaration(name.to_string(), arity); + let declaration = std::rc::Rc::new(declaration); + + predicate_declarations.insert(std::rc::Rc::clone(&declaration)); + + declaration + }, + } + } +} diff --git a/src/parse/formulas.rs b/src/parse/formulas.rs index 7049f6f..f61c206 100644 --- a/src/parse/formulas.rs +++ b/src/parse/formulas.rs @@ -1,15 +1,14 @@ use super::terms::*; use super::tokens::*; -pub fn formula(input: &str, declarations: &D) - -> Result, crate::parse::Error> +pub fn formula

(input: &str, parser: &P) + -> Result, crate::parse::Error> where - F: crate::flavor::Flavor, - D: crate::FindOrCreateFunctionDeclaration + crate::FindOrCreatePredicateDeclaration, + P: super::Parser, { let variable_declaration_stack = crate::VariableDeclarationStackLayer::free(); - let formula_str = FormulaStr::new(input, declarations, &variable_declaration_stack); + let formula_str = FormulaStr::new(input, parser, &variable_declaration_stack); let formula = formula_str.parse(0)?; let free_variable_declarations = match variable_declaration_stack @@ -71,28 +70,27 @@ impl std::fmt::Debug for LogicalConnective } } -struct FormulaStr<'i, 'd, 'p, 'v, F, D> +struct FormulaStr<'i, 'd, 'p, 'v, P> where - F: crate::flavor::Flavor, + P: super::Parser, { input: &'i str, - declarations: &'d D, - variable_declaration_stack: &'v crate::VariableDeclarationStackLayer<'p, F>, + parser: &'d P, + variable_declaration_stack: &'v crate::VariableDeclarationStackLayer<'p, P::Flavor>, } -impl<'i, 'd, 'p, 'v, F, D> FormulaStr<'i, 'd, 'p, 'v, F, D> +impl<'i, 'd, 'p, 'v, P> FormulaStr<'i, 'd, 'p, 'v, P> where - F: crate::flavor::Flavor, - D: crate::FindOrCreateFunctionDeclaration + crate::FindOrCreatePredicateDeclaration, + P: super::Parser, { - pub fn new(input: &'i str, declarations: &'d D, - variable_declaration_stack: &'v crate::VariableDeclarationStackLayer<'p, F>) + pub fn new(input: &'i str, parser: &'d P, + variable_declaration_stack: &'v crate::VariableDeclarationStackLayer<'p, P::Flavor>) -> Self { Self { input, - declarations, + parser, variable_declaration_stack, } } @@ -194,7 +192,7 @@ where Tokens::new_filter_map(self.input, functor) } - pub fn parse(&self, level: usize) -> Result, crate::parse::Error> + pub fn parse(&self, level: usize) -> Result, crate::parse::Error> { let indentation = " ".repeat(level); let input = trim_start(self.input); @@ -221,7 +219,7 @@ where { // TODO: improve error handling if the formulas between the operators are invalid self.split_at_logical_connective(top_level_logical_connective) - .map(|argument| FormulaStr::new(argument?, self.declarations, self.variable_declaration_stack).parse(level + 1)) + .map(|argument| FormulaStr::new(argument?, self.parser, self.variable_declaration_stack).parse(level + 1)) .collect::, _>>() }; @@ -242,12 +240,12 @@ where crate::parse::Error::new_expected_logical_connective_argument( "right-to-left implication".to_string(), crate::parse::error::Location::new(0, Some(0))))?; - let first_argument = FormulaStr::new(first_argument?, self.declarations, self.variable_declaration_stack).parse(level + 1)?; + let first_argument = FormulaStr::new(first_argument?, self.parser, self.variable_declaration_stack).parse(level + 1)?; return argument_iterator.try_fold(first_argument, |accumulator, argument| { - let argument = FormulaStr::new(argument?, self.declarations, self.variable_declaration_stack).parse(level + 1)?; + let argument = FormulaStr::new(argument?, self.parser, self.variable_declaration_stack).parse(level + 1)?; Ok(crate::Formula::implies(crate::ImplicationDirection::RightToLeft, Box::new(argument), Box::new(accumulator))) @@ -266,7 +264,7 @@ where let input = trim_start(input); log::trace!("{} parsing “not” formula body: {}", indentation, input); - let argument = FormulaStr::new(input, self.declarations, self.variable_declaration_stack).parse(level + 1)?; + let argument = FormulaStr::new(input, self.parser, self.variable_declaration_stack).parse(level + 1)?; return Ok(crate::Formula::not(Box::new(argument))); }, @@ -337,10 +335,10 @@ where assert!(comparison_operator_split.next().is_none()); let argument_left = - TermStr::new(input_left, self.declarations, self.variable_declaration_stack) + TermStr::new(input_left, self.parser, self.variable_declaration_stack) .parse(level + 1)?; let argument_right = - TermStr::new(input_right, self.declarations, self.variable_declaration_stack) + TermStr::new(input_right, self.parser, self.variable_declaration_stack) .parse(level + 1)?; return Ok(crate::Formula::compare(comparison_operator, Box::new(argument_left), @@ -361,7 +359,7 @@ where { let functor = |token: &_| *token == Token::Symbol(Symbol::Comma); let arguments = Tokens::new_filter(parenthesized_expression, functor).split() - .map(|argument| TermStr::new(argument?, self.declarations, + .map(|argument| TermStr::new(argument?, self.parser, self.variable_declaration_stack) .parse(level + 1)) .collect::>()?; @@ -377,7 +375,7 @@ where crate::parse::error::Location::new(0, Some(0)))) } - let declaration = self.declarations.find_or_create_predicate_declaration(predicate_name, + let declaration = self.parser.find_or_create_predicate_declaration(predicate_name, arguments.len()); return Ok(crate::Formula::predicate(declaration, arguments)); } @@ -391,7 +389,7 @@ where crate::parse::error::Location::new(0, Some(0)))); } - return FormulaStr::new(parenthesized_expression, self.declarations, self.variable_declaration_stack).parse(level + 1); + return FormulaStr::new(parenthesized_expression, self.parser, self.variable_declaration_stack).parse(level + 1); } Err(crate::parse::Error::new_unexpected_token( @@ -400,7 +398,7 @@ where // TODO: refactor fn implication_left_to_right_inner(&self, mut argument_iterator: T, level: usize) - -> Result>, crate::parse::Error> + -> Result>, crate::parse::Error> where T: std::iter::Iterator> { @@ -409,7 +407,7 @@ where Some(argument) => { // TODO: improve error handling if antecedent cannot be parsed - let argument = FormulaStr::new(argument?, self.declarations, self.variable_declaration_stack).parse(level)?; + let argument = FormulaStr::new(argument?, self.parser, self.variable_declaration_stack).parse(level)?; match self.implication_left_to_right_inner(argument_iterator, level)? { Some(next_argument) => Ok(Some(crate::Formula::implies( @@ -423,7 +421,7 @@ where } fn implication_left_to_right(&self, mut argument_iterator: T, level: usize) - -> Result, crate::parse::Error> + -> Result, crate::parse::Error> where T: std::iter::Iterator> { @@ -432,7 +430,7 @@ where Some(argument) => { // TODO: improve error handling if antecedent cannot be parsed - let argument = FormulaStr::new(argument?, self.declarations, self.variable_declaration_stack).parse(level)?; + let argument = FormulaStr::new(argument?, self.parser, self.variable_declaration_stack).parse(level)?; match self.implication_left_to_right_inner(argument_iterator, level)? { Some(next_argument) => Ok(crate::Formula::implies( @@ -451,9 +449,9 @@ where // TODO: refactor without input argument fn quantified_formula(&self, input: &str, quantifier: Quantifier, level: usize) - -> Result, crate::parse::Error> + -> Result, crate::parse::Error> { - let (parameters, input) = match variable_declarations::(input)? + let (parameters, input) = match variable_declarations::

(input)? { Some(variable_declarations) => variable_declarations, None => return Err(crate::parse::Error::new_expected_variable_declaration( @@ -465,7 +463,7 @@ where self.variable_declaration_stack, std::rc::Rc::clone(¶meters)); let formula_str = - FormulaStr::new(input.trim(), self.declarations, &variable_declaration_stack); + FormulaStr::new(input.trim(), self.parser, &variable_declaration_stack); let formula = Box::new(formula_str.parse(level)?); let formula = match quantifier @@ -505,11 +503,10 @@ mod tests #[test] fn tokenize_formula_logical_connectives() { - let declarations = crate::Declarations::::new(); + let parser = crate::parse::DefaultParser::new(); let variable_declaration_stack = crate::VariableDeclarationStackLayer::free(); - let formula_str = |input| FormulaStr::new(input, &declarations, - &variable_declaration_stack); + let formula_str = |input| FormulaStr::new(input, &parser, &variable_declaration_stack); let f = formula_str("((forall X exists Y (p(X) -> q(Y)) and false) or p) -> false"); assert_eq!(f.top_level_logical_connective().unwrap(), diff --git a/src/parse/terms.rs b/src/parse/terms.rs index c893630..0d54b76 100644 --- a/src/parse/terms.rs +++ b/src/parse/terms.rs @@ -1,4 +1,3 @@ -use crate::flavor::VariableDeclaration as _; use super::tokens::*; pub(crate) fn function_name(input: &str) -> Option<(&str, &str)> @@ -83,23 +82,25 @@ fn is_variable_name(identifier: &str) -> bool false } -pub(crate) fn variable_declaration(input: &str) -> Option<(F::VariableDeclaration, &str)> +pub(crate) fn variable_declaration

(input: &str) + -> Option<(::VariableDeclaration, &str)> where - F: crate::flavor::Flavor, + P: crate::parse::Parser, { variable_name(input) .map(|(variable_name, remaining_input)| - (F::VariableDeclaration::new(variable_name.to_string()), remaining_input)) + (

::new_variable_declaration(variable_name.to_string()), + remaining_input)) } -pub(crate) fn variable_declarations(input: &str) - -> Result, &str)>, crate::parse::Error> +pub(crate) fn variable_declarations

(input: &str) + -> Result, &str)>, crate::parse::Error> where - F: crate::flavor::Flavor, + P: crate::parse::Parser, { let mut variable_declarations = vec![]; - let (first_variable_declaration, mut input) = match variable_declaration::(input) + let (first_variable_declaration, mut input) = match variable_declaration::

(input) { Some(first_variable_declaration) => first_variable_declaration, None => return Ok(None), @@ -120,7 +121,7 @@ where input = trim_start(input); - let (variable_declaration, remaining_input) = match variable_declaration::(input) + let (variable_declaration, remaining_input) = match variable_declaration::

(input) { Some(variable_declaration) => variable_declaration, None => return Err(crate::parse::Error::new_expected_variable_declaration( @@ -167,28 +168,27 @@ impl std::fmt::Debug for ArithmeticOperatorClass } } -pub(crate) struct TermStr<'i, 'd, 'v, 'p, F, D> +pub(crate) struct TermStr<'i, 'd, 'v, 'p, P> where - F: crate::flavor::Flavor, + P: super::Parser, { input: &'i str, - declarations: &'d D, - variable_declaration_stack: &'v crate::VariableDeclarationStackLayer<'p, F>, + parser: &'d P, + variable_declaration_stack: &'v crate::VariableDeclarationStackLayer<'p, P::Flavor>, } -impl<'i, 'd, 'v, 'p, F, D> TermStr<'i, 'd, 'v, 'p, F, D> +impl<'i, 'd, 'v, 'p, P> TermStr<'i, 'd, 'v, 'p, P> where - F: crate::flavor::Flavor, - D: crate::FindOrCreateFunctionDeclaration + crate::FindOrCreatePredicateDeclaration, + P: super::Parser, { - pub fn new(input: &'i str, declarations: &'d D, - variable_declaration_stack: &'v crate::VariableDeclarationStackLayer<'p, F>) + pub fn new(input: &'i str, parser: &'d P, + variable_declaration_stack: &'v crate::VariableDeclarationStackLayer<'p, P::Flavor>) -> Self { Self { input, - declarations, + parser, variable_declaration_stack, } } @@ -307,7 +307,7 @@ where Ok(top_level_arithmetic_operator_class) } - pub fn parse(&self, level: usize) -> Result, crate::parse::Error> + pub fn parse(&self, level: usize) -> Result, crate::parse::Error> { let indentation = " ".repeat(level); log::trace!("{}- parsing term: {}", indentation, self.input); @@ -347,7 +347,7 @@ where crate::parse::Error::new_expected_term( crate::parse::error::Location::new(0, Some(0))))??; let first_argument = - TermStr::new(first_argument, self.declarations, self.variable_declaration_stack) + TermStr::new(first_argument, self.parser, self.variable_declaration_stack) .parse(level + 1)?; // TODO: improve error handling if the terms between the operators are invalid @@ -356,7 +356,7 @@ where |(accumulator, binary_operator), argument| { let (argument, next_binary_operator) = argument?; - let argument = TermStr::new(argument, self.declarations, + let argument = TermStr::new(argument, self.parser, self.variable_declaration_stack) .parse(level + 1)?; let binary_operation = @@ -370,7 +370,7 @@ where // The last item hasn’t been consumed yet, so it’s safe to unwrap it let last_argument = argument_iterator.remaining_input().unwrap(); let last_argument = - TermStr::new(last_argument, self.declarations, self.variable_declaration_stack) + TermStr::new(last_argument, self.parser, self.variable_declaration_stack) .parse(level + 1)?; let last_binary_operation = crate::BinaryOperation::new(last_binary_operator, Box::new(accumulator), @@ -442,7 +442,8 @@ where crate::parse::error::Location::new(0, Some(0)))) } - let declaration = self.variable_declaration_stack.find_or_create(identifier); + let declaration = P::find_or_create_variable_declaration( + self.variable_declaration_stack, identifier); return Ok(crate::Term::variable(declaration)); }, _ if is_function_name(identifier) => @@ -459,7 +460,7 @@ where { let functor = |token: &_| *token == Token::Symbol(Symbol::Comma); let arguments = Tokens::new_filter(parenthesized_expression, functor).split() - .map(|argument| TermStr::new(argument?, self.declarations, + .map(|argument| TermStr::new(argument?, self.parser, self.variable_declaration_stack) .parse(level + 1)) .collect::>()?; @@ -475,7 +476,7 @@ where crate::parse::error::Location::new(0, Some(0)))) } - let declaration = self.declarations.find_or_create_function_declaration( + let declaration = self.parser.find_or_create_function_declaration( function_name, arguments.len()); return Ok(crate::Term::function(declaration, arguments)); }, @@ -494,7 +495,7 @@ where crate::parse::error::Location::new(0, Some(0)))); } - return TermStr::new(parenthesized_expression, self.declarations, + return TermStr::new(parenthesized_expression, self.parser, self.variable_declaration_stack) .parse(level + 1); } @@ -505,7 +506,7 @@ where // TODO: refactor fn exponentiate_inner(&self, mut argument_iterator: T, level: usize) - -> Result>, crate::parse::Error> + -> Result>, crate::parse::Error> where T: std::iter::Iterator> { @@ -515,7 +516,7 @@ where { // TODO: improve error handling if antecedent cannot be parsed let argument = - TermStr::new(argument?, self.declarations, self.variable_declaration_stack) + TermStr::new(argument?, self.parser, self.variable_declaration_stack) .parse(level)?; match self.exponentiate_inner(argument_iterator, level)? { @@ -529,7 +530,7 @@ where } fn exponentiate(&self, mut argument_iterator: T, level: usize) - -> Result, crate::parse::Error> + -> Result, crate::parse::Error> where T: std::iter::Iterator> { @@ -539,7 +540,7 @@ where { // TODO: improve error handling if antecedent cannot be parsed let argument = - TermStr::new(argument?, self.declarations, self.variable_declaration_stack) + TermStr::new(argument?, self.parser, self.variable_declaration_stack) .parse(level)?; match self.exponentiate_inner(argument_iterator, level)? { @@ -581,7 +582,7 @@ mod tests fn parse_variable_declaration() { let variable_declaration = - |x| super::variable_declaration::(x); + |x| super::variable_declaration::(x); let v = variable_declaration("X").unwrap(); assert_eq!((v.0.name.as_str(), v.1), ("X", "")); @@ -613,7 +614,7 @@ mod tests fn parse_variable_declarations() { let variable_declarations = - |x| super::variable_declarations::(x); + |x| super::variable_declarations::(x); let v = variable_declarations("X.").unwrap().unwrap(); assert_eq!(v.0.len(), 1); diff --git a/src/utils.rs b/src/utils.rs index 10297c8..d93da50 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -1,28 +1,11 @@ -use crate::flavor::{FunctionDeclaration as _, PredicateDeclaration as _, VariableDeclaration as _}; - -// Group with implementations -pub trait FindOrCreateFunctionDeclaration -where - F: crate::flavor::Flavor, -{ - fn find_or_create_function_declaration(&self, name: &str, arity: usize) - -> std::rc::Rc; -} - -pub trait FindOrCreatePredicateDeclaration -where - F: crate::flavor::Flavor, -{ - fn find_or_create_predicate_declaration(&self, name: &str, arity: usize) - -> std::rc::Rc; -} +use crate::flavor::VariableDeclaration as _; pub struct BoundVariableDeclarations<'p, F> where F: crate::flavor::Flavor, { - parent: &'p VariableDeclarationStackLayer<'p, F>, - variable_declarations: std::rc::Rc>, + pub parent: &'p VariableDeclarationStackLayer<'p, F>, + pub variable_declarations: std::rc::Rc>, } impl<'p, F> BoundVariableDeclarations<'p, F> @@ -91,40 +74,6 @@ where } } - pub fn find_or_create(&self, variable_name: &str) -> std::rc::Rc - { - match self - { - VariableDeclarationStackLayer::Free(free_variable_declarations) => - { - if let Some(variable_declaration) = free_variable_declarations.borrow().iter() - .find(|x| x.matches_name(variable_name)) - { - return std::rc::Rc::clone(&variable_declaration); - } - - let variable_declaration = F::VariableDeclaration::new(variable_name.to_owned()); - let variable_declaration = std::rc::Rc::new(variable_declaration); - - free_variable_declarations.borrow_mut() - .push(std::rc::Rc::clone(&variable_declaration)); - - variable_declaration - }, - VariableDeclarationStackLayer::Bound(bound_variable_declarations) => - { - if let Some(variable_declaration) = bound_variable_declarations - .variable_declarations.iter() - .find(|x| x.matches_name(variable_name)) - { - return std::rc::Rc::clone(&variable_declaration); - } - - bound_variable_declarations.parent.find_or_create(variable_name) - }, - } - } - pub fn free_variable_declarations_do_mut(&self, f: F1) -> F2 where F1: Fn(&mut crate::VariableDeclarations) -> F2, @@ -151,76 +100,3 @@ where } } } - -pub struct Declarations -where - F: crate::flavor::Flavor, -{ - function_declarations: std::cell::RefCell>, - predicate_declarations: std::cell::RefCell>, -} - -impl Declarations -where - F: crate::flavor::Flavor, -{ - pub fn new() -> Self - { - Self - { - function_declarations: std::cell::RefCell::new(crate::FunctionDeclarations::::new()), - predicate_declarations: - std::cell::RefCell::new(crate::PredicateDeclarations::::new()), - } - } -} - -impl FindOrCreateFunctionDeclaration for Declarations -where - F: crate::flavor::Flavor, -{ - fn find_or_create_function_declaration(&self, name: &str, arity: usize) - -> std::rc::Rc - { - let mut function_declarations = self.function_declarations.borrow_mut(); - - match function_declarations.iter().find(|x| x.matches_signature(name, arity)) - { - Some(declaration) => std::rc::Rc::clone(&declaration), - None => - { - let declaration = F::FunctionDeclaration::new(name.to_string(), arity); - let declaration = std::rc::Rc::new(declaration); - - function_declarations.insert(std::rc::Rc::clone(&declaration)); - - declaration - }, - } - } -} - -impl FindOrCreatePredicateDeclaration for Declarations -where - F: crate::flavor::Flavor, -{ - fn find_or_create_predicate_declaration(&self, name: &str, arity: usize) - -> std::rc::Rc - { - let mut predicate_declarations = self.predicate_declarations.borrow_mut(); - - match predicate_declarations.iter().find(|x| x.matches_signature(name, arity)) - { - Some(declaration) => std::rc::Rc::clone(&declaration), - None => - { - let declaration = F::PredicateDeclaration::new(name.to_string(), arity); - let declaration = std::rc::Rc::new(declaration); - - predicate_declarations.insert(std::rc::Rc::clone(&declaration)); - - declaration - }, - } - } -}