Refactoring to support TPTP output

src/output/tptp.rs

@@ -1,53 +1,31 @@
-pub(crate) struct VariableDeclarationDisplay<'a>
+pub(crate) struct DomainDisplay
 {
-	variable_declaration: &'a foliage::VariableDeclaration,
+	domain: crate::translate::common::Domain,
 }
 
-pub(crate) struct TermDisplay<'a>
+pub(crate) fn display_domain(domain: crate::translate::common::Domain) -> DomainDisplay
 {
-	term: &'a foliage::Term,
-}
-
-pub(crate) struct FormulaDisplay<'a>
-{
-	formula: &'a foliage::Formula,
-}
-
-pub(crate) fn display_variable_declaration<'a>(variable_declaration: &'a foliage::VariableDeclaration)
-	-> VariableDeclarationDisplay<'a>
-{
-	VariableDeclarationDisplay
+	DomainDisplay
 	{
-		variable_declaration,
+		domain,
 	}
 }
 
-pub(crate) fn display_term<'a>(term: &'a foliage::Term) -> TermDisplay<'a>
-{
-	TermDisplay
-	{
-		term,
-	}
-}
-
-pub(crate) fn display_formula<'a>(formula: &'a foliage::Formula)
-	-> FormulaDisplay<'a>
-{
-	FormulaDisplay
-	{
-		formula,
-	}
-}
-
-impl<'a> std::fmt::Debug for VariableDeclarationDisplay<'a>
+impl std::fmt::Debug for DomainDisplay
 {
 	fn fmt(&self, format: &mut std::fmt::Formatter) -> std::fmt::Result
 	{
-		write!(format, "{}", &self.variable_declaration.name)
+		let domain_name = match self.domain
+		{
+			crate::translate::common::Domain::Integer => "$int",
+			crate::translate::common::Domain::Program => "object",
+		};
+
+		write!(format, "{}", domain_name)
 	}
 }
 
-impl<'a> std::fmt::Display for VariableDeclarationDisplay<'a>
+impl std::fmt::Display for DomainDisplay
 {
 	fn fmt(&self, format: &mut std::fmt::Formatter) -> std::fmt::Result
 	{
@@ -55,10 +33,107 @@ impl<'a> std::fmt::Display for VariableDeclarationDisplay<'a>
 	}
 }
 
-impl<'a> std::fmt::Debug for TermDisplay<'a>
+pub(crate) struct VariableDeclarationDisplay<'a, 'b, C>
+where
+	C: crate::translate::common::VariableDeclarationDomain
+		+ crate::translate::common::VariableDeclarationID
+{
+	variable_declaration: &'a std::rc::Rc<foliage::VariableDeclaration>,
+	context: &'b C,
+}
+
+pub(crate) fn display_variable_declaration<'a, 'b, C>(
+	variable_declaration: &'a std::rc::Rc<foliage::VariableDeclaration>, context: &'b C)
+	-> VariableDeclarationDisplay<'a, 'b, C>
+where
+	C: crate::translate::common::VariableDeclarationDomain
+		+ crate::translate::common::VariableDeclarationID
+{
+	VariableDeclarationDisplay
+	{
+		variable_declaration,
+		context,
+	}
+}
+
+pub(crate) struct TermDisplay<'a, 'b, C>
+{
+	term: &'a foliage::Term,
+	context: &'b C,
+}
+
+pub(crate) fn display_term<'a, 'b, C>(term: &'a foliage::Term, context: &'b C)
+	-> TermDisplay<'a, 'b, C>
+where
+	C: crate::translate::common::VariableDeclarationDomain
+		+ crate::translate::common::VariableDeclarationID
+{
+	TermDisplay
+	{
+		term,
+		context,
+	}
+}
+
+pub(crate) struct FormulaDisplay<'a, 'b, C>
+{
+	formula: &'a foliage::Formula,
+	context: &'b C,
+}
+
+pub(crate) fn display_formula<'a, 'b, C>(formula: &'a foliage::Formula, context: &'b C)
+	-> FormulaDisplay<'a, 'b, C>
+{
+	FormulaDisplay
+	{
+		formula,
+		context,
+	}
+}
+
+impl<'a, 'b, C> std::fmt::Debug for VariableDeclarationDisplay<'a, 'b, C>
+where
+	C: crate::translate::common::VariableDeclarationDomain
+		+ crate::translate::common::VariableDeclarationID
 {
 	fn fmt(&self, format: &mut std::fmt::Formatter) -> std::fmt::Result
 	{
+		let id = self.context.variable_declaration_id(self.variable_declaration);
+		let domain = self.context.variable_declaration_domain(self.variable_declaration)
+			.expect("unspecified variable domain");
+
+		let prefix = match domain
+		{
+			crate::translate::common::Domain::Integer => "N",
+			crate::translate::common::Domain::Program => "X",
+		};
+
+		write!(format, "{}{}", prefix, id + 1)
+	}
+}
+
+impl<'a, 'b, C> std::fmt::Display for VariableDeclarationDisplay<'a, 'b, C>
+where
+	C: crate::translate::common::VariableDeclarationDomain
+		+ crate::translate::common::VariableDeclarationID
+{
+	fn fmt(&self, format: &mut std::fmt::Formatter) -> std::fmt::Result
+	{
+		write!(format, "{:?}", &self)
+	}
+}
+
+impl<'a, 'b, C> std::fmt::Debug for TermDisplay<'a, 'b, C>
+where
+	C: crate::translate::common::VariableDeclarationDomain
+		+ crate::translate::common::VariableDeclarationID
+{
+	fn fmt(&self, format: &mut std::fmt::Formatter) -> std::fmt::Result
+	{
+		let display_variable_declaration = |variable_declaration|
+			display_variable_declaration(variable_declaration, self.context);
+		let display_term = |term| display_term(term, self.context);
+
 		match &self.term
 		{
 			foliage::Term::Boolean(true) => write!(format, "$true"),
@@ -119,7 +194,10 @@ impl<'a> std::fmt::Debug for TermDisplay<'a>
 	}
 }
 
-impl<'term> std::fmt::Display for TermDisplay<'term>
+impl<'a, 'b, C> std::fmt::Display for TermDisplay<'a, 'b, C>
+where
+	C: crate::translate::common::VariableDeclarationDomain
+		+ crate::translate::common::VariableDeclarationID
 {
 	fn fmt(&self, format: &mut std::fmt::Formatter) -> std::fmt::Result
 	{
@@ -127,10 +205,18 @@ impl<'term> std::fmt::Display for TermDisplay<'term>
 	}
 }
 
-impl<'formula> std::fmt::Debug for FormulaDisplay<'formula>
+impl<'a, 'b, C> std::fmt::Debug for FormulaDisplay<'a, 'b, C>
+where
+	C: crate::translate::common::VariableDeclarationDomain
+		+ crate::translate::common::VariableDeclarationID
 {
 	fn fmt(&self, format: &mut std::fmt::Formatter) -> std::fmt::Result
 	{
+		let display_variable_declaration = |variable_declaration|
+			display_variable_declaration(variable_declaration, self.context);
+		let display_term = |term| display_term(term, self.context);
+		let display_formula = |formula| display_formula(formula, self.context);
+
 		match &self.formula
 		{
 			foliage::Formula::Exists(exists) =>
@@ -141,7 +227,11 @@ impl<'formula> std::fmt::Debug for FormulaDisplay<'formula>
 
 				for parameter in exists.parameters.iter()
 				{
-					write!(format, "{}{:?}", separator, display_variable_declaration(parameter))?;
+					let parameter_domain = self.context.variable_declaration_domain(parameter)
+						.expect("unspecified variable domain");
+
+					write!(format, "{}{:?}: {}", separator, display_variable_declaration(parameter),
+						display_domain(parameter_domain))?;
 
 					separator = ", "
 				}
@@ -156,7 +246,11 @@ impl<'formula> std::fmt::Debug for FormulaDisplay<'formula>
 
 				for parameter in for_all.parameters.iter()
 				{
-					write!(format, "{}{:?}", separator, display_variable_declaration(parameter))?;
+					let parameter_domain = self.context.variable_declaration_domain(parameter)
+						.expect("unspecified variable domain");
+
+					write!(format, "{}{:?}: {}", separator, display_variable_declaration(parameter),
+						display_domain(parameter_domain))?;
 
 					separator = ", "
 				}
@@ -199,7 +293,8 @@ impl<'formula> std::fmt::Debug for FormulaDisplay<'formula>
 				write!(format, ")")?;
 			},
 			foliage::Formula::Implies(foliage::Implies{antecedent, implication})
-				=> write!(format, "({:?} => {:?})", display_formula(antecedent), display_formula(implication))?,
+				=> write!(format, "({:?} => {:?})", display_formula(antecedent),
+					display_formula(implication))?,
 			foliage::Formula::IfAndOnlyIf(foliage::IfAndOnlyIf{left, right})
 				=> write!(format, "({:?} <=> {:?})", display_formula(left), display_formula(right))?,
 			foliage::Formula::Compare(foliage::Compare{operator: foliage::ComparisonOperator::Less, left, right})
@@ -242,7 +337,10 @@ impl<'formula> std::fmt::Debug for FormulaDisplay<'formula>
 	}
 }
 
-impl<'formula> std::fmt::Display for FormulaDisplay<'formula>
+impl<'a, 'b, C> std::fmt::Display for FormulaDisplay<'a, 'b, C>
+where
+	C: crate::translate::common::VariableDeclarationDomain
+		+ crate::translate::common::VariableDeclarationID
 {
 	fn fmt(&self, format: &mut std::fmt::Formatter) -> std::fmt::Result
 	{