Refactores solver, removes dead binary code

planner/src/bin/weekly.rs

@@ -1,44 +1,2 @@
 //! The weekly menu planner
 //!
-
-use cookbook::{Meal, fetch_meals};
-use planner::solver::{Variables, Domain, solve_all};
-
-
-fn generate_weekly_menu() -> String {
-    let assignments: Variables<Meal> = [
-        ("LundiMidi".to_string(), None), ("LundiSoir".to_string(), None),
-        ("MardiMidi".to_string(), None), ("MardiSoir".to_string(), None),
-        ("MercrediMidi".to_string(), None), ("MercrediSoir".to_string(), None),
-    ].iter().cloned().collect();
-    let meals: Domain<Meal> = Domain::new(fetch_meals());
-    let validator = |vars: &Variables<Meal>| {
-        let mut result = true;
-        for day in ["Lundi", "Mardi", "Mercredi"].into_iter() {
-            let all_day = vars.keys().filter(|k| k.starts_with(day));
-            let mut nutri_value = 0;
-            for key in all_day {
-                nutri_value += vars.get(key)
-                    .expect("no value here !")
-                    .expect("no meal there !")
-                    .nutritional_value()
-            }
-            println!("{} -> {}", day, nutri_value);
-            if nutri_value != 1200 { result = false; };
-        }
-        println!("Validator returns {}", result);
-        result
-    };
-
-    let solutions = solve_all(assignments, &meals, validator);
-    format!("{:#?}", solutions)
-}
-
-fn main() {
-    println!("{}", generate_weekly_menu());
-}
-
-#[cfg(test)]
-mod tests {
-
-}

planner/src/solver.rs

@@ -32,65 +32,115 @@ impl<V: fmt::Debug> fmt::Debug for Domain<V> {
     }
 }
 
+type Constraint<'a,V> = fn(&Variables<'a,V>) -> bool;
 
-/// Returns all possible Updates for next assignements, prepended with
+pub struct Problem<'a, V> {
-/// a Clear to ensure the variable is unset before when leaving the branch.
+    /// The initial assignements map
-fn assign_next<'a,'b, V>(assign: &'b Variables<'a, V>, domain: &'a Domain<V>) 
+    variables: Variables<'a, V>,
-    -> Option<Vec<Assignment<'a, V>>> 
+    /// Each variable has its associated domain
-    where V: fmt::Debug 
+    domains: HashMap<String, &'a Domain<V>>,
-{
+    /// Set of constraints to validate
-    // Panics on empty domain
+    constraints: Vec<Constraint<'a,V>>,
-    // If domain values are filtered, then the branch is a dead end
+}
-    if domain.values.is_empty() { panic!("No values in domain : {:?}", domain); };
 
-    // TODO: should be able to inject a choosing strategy
+impl<'a,V> Problem<'a, V> {
-    if let Some((key,_)) = assign.iter().find(|(_, val)| val.is_none()) {
+
-        let mut updates = vec![Assignment::Clear(key.clone())];
+    pub fn build() -> ProblemBuilder<'a,V> {
-        // TODO: should be able to filter domain values (inference, pertinence)
+        ProblemBuilder::new()
-        for value in domain.values.iter() {
+    }
-            updates.push(Assignment::Update(key.clone(), value));
+
+    /// Returns all possible Updates for next assignements, prepended with
+    /// a Clear to ensure the variable is unset before when leaving the branch.
+    fn _assign_next(&self) -> Option<Vec<Assignment<'a,V>>> {
+        // TODO: should be able to inject a choosing strategy
+        if let Some((key,_)) = self.variables.iter().find(|(_, val)| val.is_none()) {
+            let domain = self.domains.get(key).expect("No domain for variable !");
+            let mut updates = vec![Assignment::Clear(key.clone())];
+
+            if domain.values.is_empty() { panic!("No value in domain !"); }
+            // TODO: should be able to filter domain values (inference, pertinence)
+            for value in domain.values.iter() {
+                updates.push(Assignment::Update(key.clone(), value));
+            }
+            Some(updates)
+        } else { // End of assignements
+            None
         }
-        Some(updates)
+    }
-    } else { // End of assignements    
+
-        None
+    /// Checks that the current assignments doesn't violate any constraint
+    fn _is_valid(&self) -> bool {
+        for validator in self.constraints.iter() {
+            if validator(&self.variables) == false { return false; }
+        }
+        return true;
+    }
+
+    /// Visit all possible solutions, using a stack.
+    pub fn solve_all(&mut self) -> Vec<Variables<'a,V>>
+        where V: Clone + fmt::Debug
+    {
+        let mut solutions: Vec<Variables<V>> = vec![];
+        let mut stack: Vec<Assignment<'a, V>> = vec![];
+        stack.append(&mut self._assign_next().unwrap());
+        loop {
+            let node = stack.pop();
+            if node.is_none() { break; };
+            match node.unwrap() {
+                Assignment::Update(key, val) => {
+                    // Assign the variable and open new branches, if any.
+                    *self.variables.get_mut(&key).unwrap() = Some(val);
+                    // TODO: handle case of empty domain.values
+                    if let Some(mut nodes) = self._assign_next() {
+                        stack.append(&mut nodes);
+                    } else {
+                        // Assignements are completed
+                        if self._is_valid() {
+                            solutions.push(self.variables.clone());
+                        };
+                    };
+                },
+                Assignment::Clear(key) => {
+                    // We are closing this branch, unset the variable
+                    *self.variables.get_mut(&key).unwrap() = None;
+                },
+            };
+        };
+        solutions
     }
 }
 
-/// Visit all possible solutions, using a stack.
+pub struct ProblemBuilder<'a, V>(Problem<'a, V>);
-pub fn solve_all<'a, V>(
+
-    mut assign: Variables<'a, V>, 
+impl<'a, V> ProblemBuilder<'a, V> {
-    domain: &'a Domain<V>, 
+    fn new() -> ProblemBuilder<'a, V> {
-    is_valid: fn(&Variables<'a,V>) -> bool
+        ProblemBuilder(
-    ) -> Vec<Variables<'a, V>> 
+            Problem{
-    where V: Clone + fmt::Debug
+                variables: Variables::new(),
-{
+                domains: HashMap::new(),
-    let mut solutions: Vec<Variables<V>> = vec![];
+                constraints: Vec::new(),
-    let mut stack: Vec<Assignment<'a, V>> = vec![];
+            })
-    stack.append(&mut assign_next(&assign,domain).unwrap());
+    }
-    loop {
+
-        let node = stack.pop();
+    pub fn add_variable(
-        if node.is_none() { break; };
+        mut self,
-        match node.unwrap() {
+        name: String,
-            Assignment::Update(key, val) => {
+        domain: &'a Domain<V>,
-                // Assign the variable and open new branches, if any.
+        value: Option<&'a V>,
-                *assign.get_mut(&key).unwrap() = Some(val);
+    ) -> Self {
-                // TODO: handle case of empty domain.values
+        self.0.variables.insert(name.clone(), value);
-                if let Some(mut nodes) = assign_next(&assign, domain) {
+        self.0.domains.insert(name, domain);
-                    stack.append(&mut nodes);
+        self
-                } else {
+    }
-                    // Assignements are completed
+
-                    if is_valid(&assign) {
+    pub fn add_constraint(mut self, cons: Constraint<'a,V>) -> Self {
-                        solutions.push(assign.clone());
+        self.0.constraints.push(cons);
-                    };
+        self
-                };
+    }
-            },
+
-            Assignment::Clear(key) => {
+    pub fn finish(self) -> Problem<'a, V> {
-                // We are closing this branch, unset the variable
+        self.0
-                *assign.get_mut(&key).unwrap() = None;
+    }
-            },
-        };
-    };
-    solutions
 }
 
 
@@ -99,41 +149,41 @@ mod tests {
     #[test]
     fn test_solver_find_pairs() {
         use super::*;
-        // Find all pairs of two differents
-        let assign: Variables<i32> = [
-            ("Left".to_string(), None), 
-            ("Right".to_string(), None),
-            ].iter().cloned().collect();
         let domain = Domain::new(vec![1,2,3]);
-        let constraint = |assign: &Variables<i32>| {
+        let mut problem: Problem<_> = Problem::build()
-            assign.get("Left").unwrap() == assign.get("Right").unwrap()
+            .add_variable(String::from("Left"), &domain, None)
-        };
+            .add_variable(String::from("Right"), &domain, None)
+            .add_constraint(
+            |assign: &Variables<i32>| {
+                assign.get("Left").unwrap() == assign.get("Right").unwrap()
+            })
+            .finish();
+
         let solutions: Vec<Variables<i32>> = vec![
             [("Left".to_string(), Some(&3)), ("Right".to_string(), Some(&3)),].iter().cloned().collect(),
             [("Left".to_string(), Some(&2)), ("Right".to_string(), Some(&2)),].iter().cloned().collect(),
             [("Left".to_string(), Some(&1)), ("Right".to_string(), Some(&1)),].iter().cloned().collect(),
         ];
 
-        assert_eq!(solve_all(assign, &domain, constraint), solutions);
+        assert_eq!(problem.solve_all(), solutions);
     }
 
     #[test]
     fn test_solver_find_pairs_with_initial() {
         use super::*;
-        // Find all pairs of two differents
-        let assign: Variables<i32> = [
-            ("Left".to_string(), None), 
-            ("Right".to_string(), Some(&2)),
-            ].iter().cloned().collect();
         let domain = Domain::new(vec![1,2,3]);
-        let constraint = |assign: &Variables<i32>| {
+        let mut problem: Problem<_> = Problem::build()
-            assign.get("Left").unwrap() == assign.get("Right").unwrap()
+            .add_variable("Left".to_string(), &domain, None)
-        };
+            .add_variable("Right".to_string(), &domain, Some(&2))
+            .add_constraint( |assign: &Variables<i32>| {
+                assign.get("Left").unwrap() == assign.get("Right").unwrap()
+            })
+            .finish();
+
         let solutions: Vec<Variables<i32>> = vec![
             [("Left".to_string(), Some(&2)), ("Right".to_string(), Some(&2)),].iter().cloned().collect(),
         ];
 
-        assert_eq!(solve_all(assign, &domain, constraint), solutions);
+        assert_eq!(problem.solve_all(), solutions);
      }
 }
-