Allow nested calls to uninterpreted functions (#52)

* Remove old deprecated code.

* Add initial support for nested function calls.

* A new, crazier, but more comprehensive inlining mechanism.

* Resolve solver translation issue.

* New, more reasonable semantics for `BooleanNetwork::infer_valid_graph`.

* Extend the new semantics to `inline_constants` and `inline_inputs`.

* Handle inlining edge case with eliminated parameters.

src/_aeon_parser/_from_string_for_boolean_network.rs

@@ -44,6 +44,9 @@ impl TryFrom<&str> for BooleanNetwork {
             variable_names.insert(reg.regulator.clone());
             variable_names.insert(reg.target.clone());
         }
+        for (name, _) in &update_functions {
+            variable_names.insert(name.clone());
+        }
         let mut variable_names: Vec<String> = variable_names.into_iter().collect();
         variable_names.sort();
 
@@ -113,7 +116,10 @@ mod tests {
             Box::new(FnUpdate::Var(VariableId(0))),
             Box::new(FnUpdate::Binary(
                 Imp,
-                Box::new(FnUpdate::Param(ParameterId(1), vec![VariableId(2)])),
+                Box::new(FnUpdate::Param(
+                    ParameterId(1),
+                    vec![FnUpdate::Var(VariableId(2))],
+                )),
                 Box::new(FnUpdate::Binary(
                     Or,
                     Box::new(FnUpdate::Var(VariableId(2))),
@@ -124,18 +130,21 @@ mod tests {
 
         let f2 = FnUpdate::Binary(
             Iff,
-            Box::new(FnUpdate::Param(ParameterId(1), vec![VariableId(0)])),
+            Box::new(FnUpdate::Param(
+                ParameterId(1),
+                vec![FnUpdate::Var(VariableId(0))],
+            )),
             Box::new(FnUpdate::Param(
                 ParameterId(2),
-                vec![VariableId(0), VariableId(0)],
+                vec![FnUpdate::Var(VariableId(0)), FnUpdate::Var(VariableId(0))],
             )),
         );
 
         let f3 = FnUpdate::Binary(
             Imp,
             Box::new(FnUpdate::Param(
                 ParameterId(2),
-                vec![VariableId(1), VariableId(1)],
+                vec![FnUpdate::Var(VariableId(1)), FnUpdate::Var(VariableId(1))],
             )),
             Box::new(FnUpdate::Not(Box::new(FnUpdate::Binary(
                 Xor,

src/_aeon_parser/_from_string_for_fn_update_temp.rs

@@ -203,29 +203,24 @@ fn terminal(data: &[Token]) -> Result<Box<FnUpdateTemp>, String> {
     }
 }
 
-/// **(internal)** Parse a list of function arguments. All arguments must be names separated
+/// **(internal)** Parse a list of function arguments. All arguments must be expressions separated
 /// by commas.
-fn read_args(data: &[Token]) -> Result<Vec<String>, String> {
+///
+/// Note that commas *have to* separate individual arguments, because any comma which is a part
+/// of a "lower level" function call has to be enclosed in parentheses.
+fn read_args(data: &[Token]) -> Result<Vec<FnUpdateTemp>, String> {
     if data.is_empty() {
         return Ok(Vec::new());
     }
     let mut result = Vec::new();
-    let mut i = 0;
-    while let Token::Name(name) = &data[i] {
-        result.push(name.clone());
-        i += 1;
-        if data.len() == i {
-            return Ok(result);
-        }
-        if data[i] != Token::Comma {
-            return Err(format!("Expected ',', found {:?}.", data[i]));
-        }
-        i += 1;
-        if data.len() == i {
-            return Err("Unexpected ',' at the end of an argument list.".to_string());
+    for arg in data.split(|it| *it == Token::Comma) {
+        if arg.is_empty() {
+            return Err("Found empty function argument.".to_string());
         }
+        let arg = parse_update_function(arg)?;
+        result.push(*arg);
     }
-    Err(format!("Unexpected token {:?} in argument list.", data[i]))
+    Ok(result)
 }
 
 #[cfg(test)]
@@ -245,6 +240,8 @@ mod tests {
             "(a => b)",
             "(a <=> b)",
             "(a <=> !(f(a, b) => (c ^ d)))",
+            "f(a, f(b), c)",
+            "f((a & c))",
         ];
         for str in inputs {
             assert_eq!(str, format!("{}", FnUpdateTemp::try_from(str).unwrap()))
@@ -292,9 +289,7 @@ mod tests {
     fn test_malformed_args() {
         assert!(FnUpdateTemp::try_from("f(a b c)").is_err());
         assert!(FnUpdateTemp::try_from("f(a, b, c,)").is_err());
-        assert!(FnUpdateTemp::try_from("f(a & c)").is_err());
         assert!(FnUpdateTemp::try_from("f(a, & c)").is_err());
-        assert!(FnUpdateTemp::try_from("f(a, f(b), c)").is_err());
     }
 
     #[test]

src/_aeon_parser/_impl_fn_update_temp.rs

@@ -16,7 +16,14 @@ impl FnUpdateTemp {
                 r.unknown_variables_to_parameters(rg),
             ),
             Not(inner) => Not(inner.unknown_variables_to_parameters(rg)),
-            Param(name, args) => Param(name, args),
+            Param(name, args) => {
+                let args: Vec<FnUpdateTemp> = args
+                    .into_iter()
+                    .map(|it| *it.unknown_variables_to_parameters(rg))
+                    .collect();
+
+                Param(name, args)
+            }
             Var(name) => {
                 if rg.find_variable(&name).is_some() {
                     Var(name)
@@ -43,6 +50,10 @@ impl FnUpdateTemp {
             Param(name, args) => {
                 let arity = u32::try_from(args.len()).unwrap();
                 result.insert(Parameter::new(name, arity));
+
+                for arg in args {
+                    arg.dump_parameters(result);
+                }
             }
         }
     }
@@ -61,7 +72,7 @@ impl FnUpdateTemp {
             Const(_) => {}
             Param(_, args) => {
                 for arg in args {
-                    result.insert(arg.clone());
+                    arg.dump_variables(result);
                 }
             }
         }
@@ -82,7 +93,7 @@ impl FnUpdateTemp {
                 Self::check_parameter_arity(&bn[parameter_id], &args)?;
                 let mut arguments = Vec::with_capacity(args.len());
                 for arg in args {
-                    arguments.push(Self::get_variable(bn, &arg)?);
+                    arguments.push(*arg.into_fn_update(bn)?);
                 }
                 FnUpdate::Param(parameter_id, arguments)
             }
@@ -106,7 +117,7 @@ impl FnUpdateTemp {
 
     /// **(internal)** Generate an error message if the given `parameter` does not have
     /// arity matching the given `args` list.
-    fn check_parameter_arity(parameter: &Parameter, args: &[String]) -> Result<(), String> {
+    fn check_parameter_arity(parameter: &Parameter, args: &[FnUpdateTemp]) -> Result<(), String> {
         if parameter.get_arity() != u32::try_from(args.len()).unwrap() {
             Err(format!(
                 "`{}` has arity {}, but is used with {} arguments.",

src/_aeon_parser/mod.rs

@@ -31,7 +31,7 @@ pub(crate) struct RegulationTemp {
 pub(crate) enum FnUpdateTemp {
     Const(bool),
     Var(String),
-    Param(String, Vec<String>),
+    Param(String, Vec<FnUpdateTemp>),
     Not(Box<FnUpdateTemp>),
     Binary(BinaryOp, Box<FnUpdateTemp>, Box<FnUpdateTemp>),
 }