some more thinking...

cookbook/src/lib.rs

@@ -38,6 +38,14 @@ pub mod recipes {
             .execute(conn)
             .is_ok()
     }
+
+    pub fn get(conn: &SqliteConnection, recipe_id: i32) -> Option<Recipe> {
+        use self::schema::recipes::dsl::*;
+
+        recipes.filter(id.eq(recipe_id))
+            .first(conn)
+            .ok()
+    }
 }
 
 pub mod ingredients {
@@ -49,6 +57,7 @@ pub mod ingredients {
     use super::{SqliteConnection, schema};
     use super::diesel::prelude::*;
 
+    /// A wrapper of [`IngredientList`] with DB connection capacity.
     pub struct IngredientListManager<'a>(&'a SqliteConnection, IngredientList);
 
     impl<'a> IngredientListManager<'a> {
@@ -90,12 +99,9 @@ pub mod ingredients {
     fn find(conn: &SqliteConnection, name: &str) -> Option<Ingredient> {
         use self::schema::ingredients::dsl::*;
 
-        match ingredients.filter(alias.like(name))
+        ingredients.filter(alias.like(name))
                    .first(conn)
-        {
-            Ok(ingdt) => Some(ingdt),
-            Err(_) => None,
-        }
+                   .ok()
     }
 
     fn create(conn: &SqliteConnection, name: &str) -> Result<i32,String> {

cookbook/src/models.rs

@@ -144,6 +144,12 @@ pub struct Recipe {
     pub preparation: String,
 }
 
+impl PartialEq for Recipe {
+    fn eq(&self, other: &Recipe) -> bool {
+        self.id == other.id
+    }
+}
+
 #[derive(Insertable, Debug)]
 #[table_name="recipes"]
 pub struct NewRecipe<'a> {

planner/src/bin/weekly.rs

@@ -3,21 +3,21 @@
 extern crate planner;
 extern crate cookbook;
 
+use std::time;
 use std::fmt::Debug;
-use std::fmt::Display;
 use std::hash::Hash;
 use cookbook::*;
 use planner::{
     *, Value,
     solver::{
-        Variables,
+        Solution,
         Domain,
         Problem
     }
 };
 
 
-fn pretty_output<K: Eq + Hash + Debug>(res: &Variables<Value, K>) -> String {
+fn pretty_output<K: Eq + Hash + Debug>(res: &Solution<Value, K>) -> String {
     let mut repr = String::new();
     for (var,value) in res {
         let value = match value {
@@ -30,6 +30,7 @@ fn pretty_output<K: Eq + Hash + Debug>(res: &Variables<Value, K>) -> String {
 }
 
 fn main() {
+    let start_time = time::Instant::now();
     let conn = establish_connection();
     let possible_values = recipes::load_all(&conn);
     let domain = Domain::new(possible_values);
@@ -39,5 +40,6 @@ fn main() {
     }
     let mut problem = problem.finish();
     let results = problem.solve_all();
-    println!("{:?}", pretty_output(results.first().unwrap()));
+    println!("Took {:?}", start_time.elapsed());
+    println!("{}", pretty_output(results.first().unwrap()));
 }

planner/src/constraint.rs

@@ -0,0 +1,135 @@
+//! Constraints building
+//!
+//! # Ideas
+//!
+//! Each constraints will be updated on every assignment,
+//! thus their status is always inspectable.
+//! A constraint applies to a set of variables, identified
+//! by a key of type `K`.
+//! A constraint owns references to actual values assigned,
+//! used to perform checks.
+//!
+//!
+//! The problem is to clarify the way Constraints operate.
+//! Do they compute their status from some data on demand ?
+//! Do they keep their status updated by watching the Variables
+//! they act on ?
+//! Worse, do they have superpowers ?
+//! Could they filter on a variable domain, according to some other variable
+//! state ? This would mean that constraints won't judge a result, but guide
+//! the solving process to avoid erroring paths, like a constraint-driven
+//! solving. This would be powerfull but maybe far too complex...
+//!
+//! On the other hand, we can implement a simple Observer pattern, with strong
+//! coupling to [`Problem`](crate::solver::Problem).
+//! Because of this, we can safely play with private fields of Problem, and in
+//! return, provide a public api to build specific constraints.
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum Status {
+    Validated,// Solution is valid
+    Unknown,  // Constraint cannot resolve yet (unbound variables)
+    Violated, // Solution is invalid
+}
+
+use std::collections::HashMap;
+
+// *Like this
+enum ValueChecker {
+    AllDifferent,
+    AllSame,
+}
+
+pub struct Constraint<'c, V, K> {
+    status: Status,
+    variables: HashMap<&'c K, Option<&'c V>>,
+    // TODO: add a ValueChecker Trait object,
+    // or just a simple Enum.*
+    // to provide the check_status procedure, given
+    // a vector to variables values.
+}
+
+impl<'c, V, K> Constraint<'c, V, K>
+    where K: Eq + std::hash::Hash,
+          V: PartialEq,
+{
+
+    pub fn new(vars: Vec<&'c K>) -> Self {
+        let len = vars.len();
+        Self {
+            status: Status::Unknown,
+            variables: vars.into_iter()
+                           .zip(vec![None; len])
+                           .collect(),
+        }
+    }
+
+    pub fn status(&self) -> &Status {
+        &self.status
+    }
+
+    fn check_status(vars: Vec<&Option<&V>>) -> Status {
+        /// LEts do an hacky NotEqualConstraint
+        let vars_len = vars.len();
+        let set_vars: Vec<&Option<&V>> = vars.into_iter().filter(|v| v.is_some()).collect();
+        let is_complete = vars_len == set_vars.len();
+        for (idx, value) in set_vars.iter().enumerate() {
+            let violated = set_vars.iter()
+                .enumerate()
+                .filter(|(i,_)| *i != idx)
+                .fold(false, |res, (_,v)| {
+                    res || v == value
+                });
+            if violated { return Status::Violated; }
+        }
+        match is_complete {
+            true => Status::Validated,
+            false => Status::Unknown,
+        }
+    }
+
+    fn update_status(&mut self) {
+        self.status = Self::check_status(self.variables.values().collect());
+    }
+
+    pub fn update(&mut self, key: &K, new_value: Option<&'c V>) {
+        if let Some(value) = self.variables.get_mut(key) {
+            // Actually update values
+            dbg!(*value = new_value);
+            self.update_status();
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_all_different_problem() {
+        use crate::solver::{Domain, Problem};
+        use super::Constraint;
+
+        let domain = Domain::new(vec![1, 2, 3]);
+        let problem = Problem::build()
+            .add_variable("Left", domain.all(), None)
+            .add_variable("Right", domain.all(), None)
+            .add_constraint(Constraint::new(vec![&"Left", &"Right"]))
+            .finish();
+
+        let solutions = vec![
+            (("Left", Some(&1)), ("Right", Some(&2))),
+            (("Left", Some(&1)), ("Right", Some(&3))),
+            (("Left", Some(&2)), ("Right", Some(&1))),
+            (("Left", Some(&2)), ("Right", Some(&3))),
+            (("Left", Some(&3)), ("Right", Some(&1))),
+            (("Left", Some(&3)), ("Right", Some(&2))),
+        ];
+        let results = problem.solve_all();
+        println!("{:#?}", results);
+        assert!(results.len() == solutions.len());
+        results.into_iter().for_each(|res| {
+            let res = (("Left", *res.get("Left").unwrap()),
+                       ("Right", *res.get("Right").unwrap())) ;
+            assert!(solutions.contains(&res));
+        });
+    }
+}

planner/src/lib.rs

@@ -3,7 +3,7 @@ use cookbook::recipes::Recipe;
 
 pub mod solver;
 pub mod template;
-
+pub mod constraint;
 
 pub use solver::{Domain, DomainValues};
 /// We mainly use Recipe as the domain value type

planner/src/rules.rs

@@ -1,16 +1,56 @@
 //! Rules used by the `planner`
 //! A rule is a constraint on valid solutions, but also provides insights
 //! and eventually inferences to optimize the solving process.
+//!
+//! * Basic repartition
+//!    * All different meals
+//!    * Map recipes categories to each meals
+//!    * (Eating a dish over two days (leftovers))
+//! * Nutritional values
+//!    * Per day : according to user profile (man: 2000kcal, woman: 1800kcal)
+//!    * Per meal : some meals should have higher nutrional values than others
+//!
+//! * Ingredients
+//!    * Per week : should use most of a limited set of ingredients (excluding
+//!                 condiments, ...)
+//!    * To consume : must use a small set of ingredients (leftovers)
+//!
+//!
+//! Price
+//! - Per week : should restrict ingredients cost to a given amount
 
-// Nutritional values
-// - Per day : according to user profile (man: 2000kcal, woman: 1800kcal)
-// - Per meal : some meals should have higher nutrional values than others
+enum Status {
+    Ok,
+    Violated,
+}
 
-// Ingredients
-// - Per week : should use most of a limited set of ingredients (excluding
-// condiments, ...)
-// - To consume : must use a small set of ingredients (leftovers)
-//
+trait Rule {
+    type Key;
+    type Value;
 
-// Price
-// - Per week : should restrict ingredients cost to a given amount
+    fn status(&self, state: (Vec<&Self::Key>, Vec<&Self::Value>));
+    fn update(&self, idx: usize, value: Option<Self::Value>) -> Option<Filter>;
+};
+
+struct AllDifferentMeals;
+
+impl Rule for AllDifferentMeals {
+    type State = Vec<Recipe>;
+
+    fn status(&self, _: Self::State) -> Status {
+        Status::Ok // Always enforced by update rule
+    }
+
+    fn update(&self, _: Self::State) -> Option<Filter> {
+        // Returns a filter excluding this value from domain.
+        // so that it is impossible to select the same meal twice.
+        None
+    }
+}
+struct FilterRecipeByMeals; // Essentially work on domain
+
+struct NutritionalByDayAverageReq;
+struct NutritionalByMealAverageValues;
+
+struct IngredientsInFridge;
+struct IngredientsMustUse;

planner/src/solver.rs

@@ -6,17 +6,26 @@ use std::hash::Hash;
 use std::clone::Clone;
 use std::collections::HashMap;
 
-/// An assignments map of variables
-pub type Variables<'a, V, K> = HashMap<K, Option<&'a V>>;
+use crate::constraint::{Status, Constraint};
 
-enum Assignment<'a, V, K> {
-    Update(K, &'a V),
-    Clear(K)
+/// A solution returned by [`Solver`]
+pub type Solution<'a, V, K> = HashMap<K, Option<&'a V>>;
+
+
+/// An assignments map of variables
+type Variables<'a, V> = Vec<Option<&'a V>>;
+
+/// Orders used by solver to update variables
+enum Assignment<'a, V> {
+    Update(usize, &'a V),
+    Clear(usize)
 }
 
-
+/// Collection of references to values owned by a domain.
 pub type DomainValues<'a, V> = Vec<&'a V>;
-/// The domain of values that can be assigned to variables
+
+/// The domain of values that can be assigned to a variable.
+/// The values are owned by the instance.
 #[derive(Clone)]
 pub struct Domain<V> {
     values: Vec<V>
@@ -27,11 +36,21 @@ impl<V> Domain<V> {
         Domain { values }
     }
 
-    /// Returns all values of a Domain instance
+    /// Returns references to all values of this instance
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # extern crate planner;
+    /// # use planner::solver::Domain;
+    /// let domain = Domain::new(vec!["a", "b", "c"]);
+    /// assert_eq!(domain.all(), vec![&"a", &"b", &"c"]);
+    /// ```
     pub fn all(&self) -> DomainValues<V> {
         self.values.iter().collect()
     }
-    /// Returns a Filter filter applied to inner values
+    /// Returns a collection of references to a filtered
+    /// subset of this domain.
     ///
     /// # Examples
     ///
@@ -45,12 +64,39 @@ impl<V> Domain<V> {
     /// assert_eq!(domain.filter(even), vec![&2]);
     /// assert_eq!(domain.filter(|i: &i32| i % 2 == 1), vec![&1,&3]);
     /// ```
-    pub fn filter(&self, filter_func: fn(&V) -> bool) -> DomainValues<V> {
+    pub fn filter<F>(&self, filter_func: F) -> DomainValues<V>
+        where F: Fn(&V) -> bool
+    {
         self.values
             .iter()
             .filter(|v: &&V| filter_func(*v))
             .collect()
     }
+
+    /// Wrapper for `find`, returns a optionnal reference
+    /// to the first found value of this domain.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # extern crate planner;
+    /// # use planner::solver::Domain;
+    /// let domain = Domain::new(vec![1,2,3]);
+    /// fn even(i: &i32) -> bool {
+    ///     *i == 2
+    /// };
+    /// assert_eq!(domain.find(even), Some(&2));
+    /// assert_eq!(domain.find(|i: &i32| i % 2 == 1), Some(&1));
+    /// assert_eq!(domain.find(|i| *i == 4), None);
+    /// ```
+    pub fn find<F>(&self, getter_func: F) -> Option<&V>
+        where F: Fn(&V) -> bool
+    {
+        self.values
+            .iter()
+            .find(|v: &&V| getter_func(*v))
+    }
+
 }
 
 impl<V: fmt::Debug> fmt::Debug for Domain<V> {
@@ -59,117 +105,231 @@ impl<V: fmt::Debug> fmt::Debug for Domain<V> {
     }
 }
 
-
-pub type Constraint<'a,V, K> = fn(&Variables<'a,V, K>) -> bool;
-
-pub struct Problem<'a, V, K> {
-    /// The initial assignements map
-    variables: Variables<'a, V, K>,
-    /// Each variable has its associated domain
-    domains: HashMap<K, DomainValues<'a,V>>,
-    /// Set of constraints to validate
-    constraints: Vec<Constraint<'a,V,K>>,
+/// Or we can have a much more complex version of Domain.
+/// We want to retrieve a filtered domain for each variable.
+/// Filters will be static (filter by category,...) or dynamic
+/// (inserted by rules updates).
+///
+/// For every variable, we can retrieve its filtered values (values,
+/// filtered by all globals, filtered by one local).
+/// Plus, set a dynamic filter that will apply to all other variables.
+/// Of course, it also affects this variable, but considering that dynamic
+/// filters are cleared and repopulated on every assign, this side-effect
+/// can never occur.
+struct SDomain<V, Filter> {
+    values: Vec<V>,
+    global_filters: Vec<Filter>, // Globals are dynamic Filters
+    local_filters: Vec<Filter>, // Locals are static Filters
 }
 
-impl<'a,V, K: Eq + Hash + Clone> Problem<'a, V, K> {
+impl<V, F> SDomain<V, F> {
+    fn new(values: Vec<V>) -> Self {
+        Self {
+            values,
+            global_filters: Vec::new(),
+            local_filters: Vec::new(),
+        }
+    }
 
-    pub fn build() -> ProblemBuilder<'a,V, K> {
+    /// Returns the current domain values for a variable by index
+    fn get(&self, idx: usize) -> DomainValues<V> {
+        self.values
+            .iter()
+            .collect()
+    }
+
+    /// Adds a dynamic filter to globals, identified by its setter's id
+    /// /!\ Previously set filters are overriden, hence dynamic
+    fn set_global(&mut self, setter: usize, filter: F) {
+        self.global_filters[setter] = filter;
+    }
+}
+
+
+//pub type Constraint<'a,V> = fn(&Variables<'a,V>) -> bool;
+
+
+/// Could be more efficient to just use fixed array of options as variables,
+/// using a helper to bind Keys to Index in this array.
+/// Domains could be a similar array of DomainValues.
+/// It makes sense with an array where indexing is O(1)
+
+pub struct Problem<'p, V, K> {
+    keys: Vec<K>,
+    /// The initial assignements
+    variables: Variables<'p, V>,
+    /// Each variable has its associated domain
+    domains: Vec<DomainValues<'p,V>>,
+    /// Set of constraints to validate
+    constraints: Vec<Constraint<'p,V,K>>,
+}
+
+impl<'p, V: PartialEq, K: Eq + Hash + Clone> Problem<'p, V, K> {
+
+    pub fn build() -> ProblemBuilder<'p,V, K> {
         ProblemBuilder::new()
     }
 
-    pub fn from_template(_template: i32) -> Problem<'a, V, K> {
-        Self::build()
-            .finish()
+    pub fn from_template() -> Problem<'p, V, K> {
+        let builder = Self::build();
+
+        builder.finish()
     }
 
     /// Returns all possible Updates for next assignements, prepended with
     /// a Clear to ensure the variable is unset before when leaving the branch.
-    fn _push_updates(&self) -> Option<Vec<Assignment<'a,V, K>>> {
-        // TODO: should be able to inject a choosing strategy
-        if let Some((key,_)) = self.variables.iter().find(|(_, val)| val.is_none()) {
-            let domain_values = self.domains.get(key).expect("No domain for variable !");
+    fn _push_updates(&self) -> Option<Vec<Assignment<'p,V>>> {
+        if let Some(idx) = self._next_assign() {
+            // TODO: Domain will filter possible values for us
+            // let values = self.domain.get(idx);
+            let domain_values = self.domains
+                                    .get(idx)
+                                    .expect("No domain for variable !");
+            // TODO: handle case of empty domain.values
+            assert!(!domain_values.is_empty());
             // Push a clear assignment first, just before going up the stack.
-            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.into_iter() {
-                updates.push(Assignment::Update(key.clone(), *value));
-            }
+            let mut updates = vec![Assignment::Clear(idx.clone())];
+            domain_values.iter().for_each(|value| {
+                updates.push(
+                    Assignment::Update(idx, *value)
+                );
+            });
             Some(updates)
         } else { // End of assignements
             None
         }
     }
 
+    fn _next_assign(&self) -> Option<usize> {
+        // TODO: should be able to inject a choosing strategy
+        self.variables.iter()
+            .enumerate()
+            .find_map(|(idx, val)| {
+                    if val.is_none() { Some(idx) }
+                    else { 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; }
+        for status in self.constraints.iter().map(|c| c.status()) {
+            if status == &Status::Violated { return false; }
         }
         return true;
     }
 
-    /// Returns all complete solutions, after visiting all possible outcomes using a stack (DFS).
-    pub fn solve_all(&mut self) -> Vec<Variables<'a,V,K>>
-        where V: Clone + fmt::Debug,
-              K: Clone + fmt::Debug,
-    {
-        let mut solutions: Vec<Variables<V, K>> = vec![];
-        let mut stack: Vec<Assignment<'a, V, K>> = vec![];
-        stack.append(&mut self._push_updates().unwrap());
+    fn _get_key(&self, idx: usize) -> &K {
+        &self.keys[idx]
+    }
+
+    fn _get_solution(&self) -> Solution<'p, V, K> {
+        // Returns the current state wrapped in a Solution type.
+        self.keys.iter().cloned()
+            .zip(self.variables.iter().cloned())
+            .collect()
+    }
+
+    /// Assigns a new value to the given index, then calls update
+    /// on every constraints.
+    fn _assign(&mut self, idx: usize, value: Option<&'p V>) {
+        self.variables[idx] = value;
+        let var_key = &self.keys[idx];
+        // TODO: manage dynamic filters on Domain
+        // let filters: Filter::Chain = self.constraints.iter_mut().map([...]).collect();
+        // self.domain.set_global(idx, filters);
+        self.constraints.iter_mut()
+                        .for_each(|c| {
+                            c.update(&var_key, value);
+                        });
+
+    }
+
+    fn _solve(&mut self, limit: Option<usize>) -> Vec<Solution<'p, V, K>> {
+        let mut solutions: Vec<Solution<V, K>> = vec![];
+        let mut stack: Vec<Assignment<'p, V>> = vec![];
+        if let Some(mut init_updates) = self._push_updates() {
+            stack.append(&mut init_updates);
+        } else {
+            // Solution is complete
+            panic!("Could not initialize !");
+        }
+
         loop {
             let node = stack.pop();
+            // There is no more combination to try out
             if node.is_none() { break; };
+            // Exit early if we have enough solutions
+            if limit.is_some()
+               && solutions.len() == limit.unwrap()
+            {
+                break;
+            };
+
             match node.unwrap() {
-                Assignment::Update(key, val) => {
+                Assignment::Update(idx, 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
+                    self._assign(idx, Some(val));
                     if let Some(mut nodes) = self._push_updates() {
                         stack.append(&mut nodes);
                     } else {
                         // Assignements are completed
                         if self._is_valid() {
-                            solutions.push(self.variables.clone());
+                            solutions.push(self._get_solution());
                         };
                     };
                 },
-                Assignment::Clear(key) => {
+                Assignment::Clear(idx) => {
                     // We are closing this branch, unset the variable
-                    *self.variables.get_mut(&key).unwrap() = None;
+                    self._assign(idx, None);
                 },
             };
         };
         solutions
+
+    }
+    /// Returns all complete solutions, after visiting all possible outcomes using a stack (DFS).
+    pub fn solve_all(mut self) -> Vec<Solution<'p,V,K>>
+        where V: fmt::Debug,
+              K: fmt::Debug,
+    {
+        self._solve(None) // No limit
+    }
+
+    pub fn solve_one(mut self) -> Option<Solution<'p,V,K>>
+        where V: fmt::Debug,
+              K: fmt::Debug,
+    {
+        self._solve(Some(1)).pop()
     }
 }
 
-pub struct ProblemBuilder<'a, V, K>(Problem<'a, V, K>);
+pub struct ProblemBuilder<'p, V, K>(Problem<'p, V, K>);
 
-impl<'a, V, K: Eq + Hash + Clone> ProblemBuilder<'a, V, K> {
-    fn new() -> ProblemBuilder<'a, V, K> {
+impl<'p, V, K: Eq + Hash + Clone> ProblemBuilder<'p, V, K> {
+    fn new() -> ProblemBuilder<'p, V, K> {
         ProblemBuilder(
             Problem{
+                keys: Vec::new(),
                 variables: Variables::new(),
-                domains: HashMap::new(),
+                domains: Vec::new(),
                 constraints: Vec::new(),
             })
     }
 
-    pub fn add_variable(mut self, name: K, domain: Vec<&'a V>, value: Option<&'a V>) -> Self
+    pub fn add_variable(mut self, name: K, static_filter: Vec<&'p V>, initial: Option<&'p V>) -> Self
     {
-        self.0.variables.insert(name.clone(), value);
-        self.0.domains.insert(name, domain);
+        self.0.keys.push(name);
+        self.0.variables.push(initial);
+        self.0.domains.push(static_filter);
         self
     }
 
-    pub fn add_constraint(mut self, cons: Constraint<'a,V, K>) -> Self {
+    pub fn add_constraint(mut self, cons: Constraint<'p,V,K>) -> Self {
         self.0.constraints.push(cons);
         self
     }
 
-    pub fn finish(self) -> Problem<'a, V, K> {
+    pub fn finish(self) -> Problem<'p,V, K> {
         self.0
     }
 }
@@ -181,18 +341,15 @@ mod tests {
     fn test_solver_find_pairs() {
         use super::*;
         let domain = Domain::new(vec![1,2,3]);
-        let mut problem: Problem<_, _> = Problem::build()
+        let problem: Problem<_, _> = Problem::build()
             .add_variable(String::from("Left"), domain.all(), None)
             .add_variable(String::from("Right"), domain.all(), 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(),
+        let solutions: Vec<Solution<i32, _>> = vec![
+            [(String::from("Left"), Some(&3)), (String::from("Right"), Some(&3))].iter().cloned().collect(),
+            [(String::from("Left"), Some(&2)), (String::from("Right"), Some(&2))].iter().cloned().collect(),
+            [(String::from("Left"), Some(&1)), (String::from("Right"), Some(&1))].iter().cloned().collect(),
         ];
 
         assert_eq!(problem.solve_all(), solutions);
@@ -202,16 +359,13 @@ mod tests {
     fn test_solver_find_pairs_with_initial() {
         use super::*;
         let domain = Domain::new(vec![1,2,3]);
-        let mut problem: Problem<_, _> = Problem::build()
+        let problem: Problem<_, _> = Problem::build()
             .add_variable("Left".to_string(), domain.all(), None)
             .add_variable("Right".to_string(), domain.all(), 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(),
+        let solutions: Vec<Solution<i32, String>> = vec![
+            [(String::from("Left"), Some(&2)), (String::from("Right"), Some(&2))].iter().cloned().collect(),
         ];
 
         assert_eq!(problem.solve_all(), solutions);

planner/src/template.rs

@@ -6,7 +6,6 @@ const DAYS: &[&str] = &[
     "Dimanche"];
 
 /// An enum to discriminate every meals
-#[allow(dead_code)]
 #[derive(Debug, PartialEq, Eq, Clone, Hash)]
 pub enum Meal {
     Breakfast,
@@ -16,7 +15,6 @@ pub enum Meal {
 
 type Key<'a> = (&'a str, &'a Meal);
 
-
 /// Options set on a meal
 #[derive(Debug, Default)]
 struct MealOpts<V> {
@@ -50,11 +48,17 @@ impl<'a> Template {
         -> Vec<(Key, DomainValues<Value>, Option<&Value>)>
     {
         use cookbook::recipes::RecipeCategory;
-        let mut vars_opts = Vec::new();
-        for key in Self::keys().into_iter() {
+        Self::keys()
+            .into_iter()
+            .filter(|key| {
+                match *key {
+                    ("Samedi", _) | ("Dimanche", _) => true,
+                    (_, Meal::Breakfast) => false,
+                    (_,_) => true,
+                }
+            })
+            .map(|key| {
                 //TODO: is key used ? MealOpts.is_used
-
-            //TODO: Initial values
                 let category_filter: fn(&Value) -> bool = match key {
                     (_, Meal::Breakfast) => |r: &Value| {
                         r.category == RecipeCategory::Breakfast // Breakfast
@@ -66,12 +70,10 @@ impl<'a> Template {
                         r.category == RecipeCategory::Starter // Starter
                     }
                 };
-
                 // TODO: has initial ?
-            //let key_name = format!("{}_{:?}", key.0, key.1);
                 let initial = None;
-            vars_opts.push((key, domain.filter(category_filter), initial));
-        }
-        vars_opts
+                (key, domain.filter(category_filter), initial)
+            })
+            .collect()
     }
 }

web/src/main.rs

@@ -37,7 +37,7 @@ mod api {
     pub struct CookbookDbConn(diesel::SqliteConnection);
 
     /// A serializable wrapper for [`cookbook::recipes::Recipe`]
-    #[derive(Serialize)]
+    #[derive(Serialize, Deserialize, Debug)]
     pub struct RecipeObject {
         id: i32,
         title: String,
@@ -76,13 +76,13 @@ mod api {
         Json( recipes::delete(&conn, id) )
     }
 
-    #[derive(Serialize)]
+    #[derive(Serialize, Deserialize, Debug)]
     pub struct TemplateItems {
         key: (String, String),
         value: Option<RecipeObject>,
     }
 
-    #[derive(Serialize)]
+    #[derive(Serialize, Deserialize)]
     pub struct TemplateObject {
         items: Vec<TemplateItems>
     }
@@ -100,12 +100,9 @@ mod api {
         for (var, dom, ini) in template::Template::generate_variables(&domain) {
             problem = problem.add_variable(var, dom, ini);
         }
-        let mut problem = problem
-            .add_constraint(|_| true)
-            .finish();
-        let results = problem.solve_all();
-        let one_result = results.first().unwrap();
+        let problem = problem.finish();
         
+        if let Some(one_result) = problem.solve_one() {
             Json(TemplateObject {
                 items: one_result
                         .into_iter()
@@ -116,6 +113,66 @@ mod api {
                         }})
                         .collect(),
             })
+        } else {
+            panic!("No solution at all !");
+        }
+    }
+
+
+    #[post("/solver/complete", data="<partial>")]
+    pub fn complete_problem(conn: CookbookDbConn, partial: Json<Vec<TemplateItems>>) -> Json<TemplateObject> {
+        use planner::{
+            template,
+            solver::{Domain, Problem}
+        };
+
+        let possible_values = recipes::load_all(&conn);
+        let domain = Domain::new(possible_values);
+        let mut problem = Problem::build();
+        for (var, dom, ini) in template::Template::generate_variables(&domain) {
+            // Let's hack for now
+            // BUGGY because template does not generate every variables, needs refactoring
+            // Find variable in partial
+            let initial_id = partial.iter()
+                    .filter(|slot| slot.value.is_some())
+                    .find_map(|slot| {
+                        //println!("{:?} vs {:?}", slot, var);
+                        if  slot.key.0 == var.0
+                            && slot.key.1 == format!("{:?}",var.1)
+                        {
+                            let id = slot.value.as_ref().unwrap().id;
+                            //println!("found initial : recipe with id {}", id);
+                            Some(id)
+                        } else {
+                            None
+                        }
+                    });
+            let ini = if let Some(id) = initial_id {
+                let new_ini = domain.find(|r| {r.id == id});
+                //println!("Overrided {:?}", new_ini);
+                new_ini
+            } else {
+                ini
+            };
+            // If found, override initial value
+            problem = problem.add_variable(var, dom, ini);
+        };
+        let problem = problem.finish();
+
+        if let Some(one_result) = problem.solve_one() {
+            Json(TemplateObject {
+                items: one_result
+                        .into_iter()
+                        .map(|(k,v)| {
+                            TemplateItems {
+                                key: (format!("{}", k.0), format!("{:?}", k.1)),
+                                value: v.map(|r| RecipeObject::from(&conn, r.clone())),
+                        }})
+                        .collect(),
+            })
+        } else {
+            panic!("No solution at all !");
+        }
     }
 }
 
@@ -136,7 +193,12 @@ fn main() -> Result<(), Error> {
     rocket::ignite()
         .attach(api::CookbookDbConn::fairing())
         .mount("/", routes![index, files])
-        .mount("/api", routes![api::recipes_list, api::delete_recipe, api::one_solution])
+        .mount("/api", routes![
+            api::recipes_list,
+            api::delete_recipe,
+            api::one_solution,
+            api::complete_problem,
+        ])
         .attach(cors)
         .launch();
     Ok(())

web/vue/package.json

@@ -8,6 +8,7 @@
     "lint": "vue-cli-service lint"
   },
   "dependencies": {
+    "@mdi/font": "^3.4.93",
     "bulma": "^0.7.2",
     "vue": "^2.5.22"
   },

web/vue/src/App.vue

@@ -2,14 +2,14 @@
   <div id="app">
     <Heading msg="Cook-Assistant"/>
     <section class="section" id="recipes-view">
-      <p v-if="status.loading">Loading...</p>
+      <div v-if="status.loading" class="notification is-info">Loading...</div>
       <div v-if="status.error" class="notification is-danger">Error: {{ status.error_msg }}</div>
-      <h2 v-else class="subtitle">Livre de recettes</h2>
       <div class="container">
         <keep-alive>
         <RecipeDetails v-if="active_view > -1"
           v-bind:item="items[active_view]"
-          v-on:close="closeActiveView" />
+          v-on:close="closeActiveView"
+          v-on:add="addToPlanning" />
         <RecipeList v-else
           v-bind:items="items"
           v-on:open-details="setActiveView" />
@@ -18,19 +18,19 @@
     </section>
     <section class="section has-background-grey-lighter" id="planner-view">
       <h2 class="subtitle">Planning</h2>
-      <Planner />
+      <Planner ref="weekPlanning" />
     </section>
   </div>
 </template>
 
 <script>
 import 'bulma/css/bulma.css'
+import '@mdi/font/css/materialdesignicons.min.css'
 import Heading from './components/Heading.vue'
 import RecipeDetails from './components/RecipeDetails.vue'
 import RecipeList from './components/RecipeList.vue'
 import Planner from './components/Planner.vue'
 
-
 export default {
   name: 'app',
   components: {
@@ -59,6 +59,10 @@ export default {
     closeActiveView: function() {
       this.active_view = -1;
     },
+    addToPlanning: function(mealKey, id) {
+      let mealData = this.items.find((recipe) => recipe.id == id);
+      this.$refs.weekPlanning.setMeal(mealKey, mealData);
+    },
     deleteRecipe: function(id) {
       fetch("http://localhost:8000/api/delete/" + id)
         .then((res) => res.json())
@@ -86,11 +90,17 @@ export default {
           this.statue.error_msg = err;
           console.error(err);
         });
+    },
+    initWeekPlanning: function() {
+      this.$refs.weekPlanning.fetchSolution();
     }
   },
   mounted () {
     this.fetchRecipesList();
+
+    console.log("MOUNTED !");
   }
+
 }
 </script>
 

web/vue/src/components/Heading.vue

@@ -1,5 +1,5 @@
 <template>
-  <nav class="navbar" role="navigation" aria-label="main navigation">
+  <nav class="navbar is-dark" role="navigation" aria-label="main navigation">
   <div class="navbar-brand">
     <a class="navbar-item" href="#">
       {{ msg }}

web/vue/src/components/Planner.vue

@@ -1,18 +1,21 @@
 <template>
   <div class="box">
-    <button @click="fetchSolution" class="button is-primary">FetchSolution</button>
-    <hr />
-    <div v-if="template">
-      <div class="columns is-desktop is-vcentered">
-        <div v-for="day_meals in itemsGroupedByDay"
-             class="column">
-          <strong> {{ day_meals[0] }}</strong>
-          <div v-for="meal in day_meals[1]">
-            <div v-if="meal.value" class="tags has-addons">
-              <span class="tag is-info">{{ meal.value.title }}</span>
+    <button @click="fetchCompletion"
+            class="button is-primary is-fullwidth"
+            v-bind:class="{'is-loading': is_loading }">
+    FetchSolution</button>
+    <div class="box">
+      <div class="columns is-mobile is-vcentered is-multiline">
+        <div v-for="[day, meals] in itemsGroupedByDay"
+             class="column is-one-quarter-desktop is-half-mobile">
+          <p class="subtitle"><strong> {{ day }}</strong></p>
+          <div v-for="meal in meals">
+            <p v-if="meal.value" class="tags has-addons">
+              <span class="tag is-info">{{ meal.key[1] }}</span>
+              <span class="tag is-light">{{ meal.value.title }}</span>
               <a @click="unsetMeal(meal.key)"
                  class="tag is-delete"></a>
-            </div>
+            </p>
             <div v-else class="tag is-warning">Empty</div>
           </div>
         </div>
@@ -23,20 +26,6 @@
 
 <script>
 
-const groupBy = function(items, keyGetter) {
-  const map = new Map();
-  items.forEach((item) => {
-    const key = keyGetter(item);
-    const collection = map.get(key);
-    if (!collection) {
-      map.set(key, [item]);
-    } else {
-      collection.push(item);
-    }
-  });
-  return map;
-};
-
 const DAYS = ["Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche"];
 const compareWeekDay = function(entryA, entryB) {
   return DAYS.indexOf(entryA[0]) - DAYS.indexOf(entryB[0]);
@@ -47,33 +36,110 @@ const compareMealType = function(mealA, mealB) {
   return MEALS.indexOf(mealA.key[1]) - MEALS.indexOf(mealB.key[1]);
 }
 
+function TemplateSlot(key, value) {
+  this.key = key;
+  this.value = value;
+}
+
+function Template() {
+  this.items = [];
+  var day;
+  for (day in DAYS) {
+    var meal;
+    for (meal in MEALS) {
+      this.items.push(
+        new TemplateSlot(
+              [DAYS[day], MEALS[meal]], //slotKey
+              null)                     //value
+        );
+    }
+  }
+}
+
+/// Given that Template.items are kept in order, we can
+/// use a very simple solution (yields slices of 3, with name)
+Template.prototype.groupedByDays = function() {
+  var i;
+  var grouped = [];
+  for (i = 0; i < this.items.length / 3; i++) {
+    let start = i * 3;
+    let end = (i + 1) * 3;
+    let day = this.items[start].key[0];
+    let slice = this.items.slice(start, end);
+    console.log(day, slice);
+    grouped.push([day, slice]);
+  }
+  return grouped;
+}
+
+Template.prototype.findIndexByKey = function(slotKey) {
+  console.log("Search index of key: " + slotKey);
+  var day_idx = DAYS.indexOf(slotKey[0]);
+  var meal_idx = MEALS.indexOf(slotKey[1]);
+  if (day_idx == -1 || meal_idx == -1) {
+    console.error("Index not found");
+  };
+  return day_idx * 3 + meal_idx;
+}
+
+Template.prototype.updateJson = function(data) {
+  var i;
+  for (i in data.items) {
+    let item = data.items[i];
+    let idx = this.findIndexByKey(item.key);
+    this.items[idx].value = item.value;
+  }
+}
+
 export default {
   name: 'Planner',
   data () {
+    var template = new Template();
     return {
-    template: null,
-  };},
+      template,
+      is_loading: false,
+    };
+  },
   methods: {
     fetchSolution: function() {
+      this.is_loading = true;
       fetch("http://localhost:8000/api/solver/one")
-        .then((res) => res.json())
-        .then((data) => this.template = data)
-        .catch((err) => console.log(err));
+        .then((res) => {
+          this.is_loading = false;
+          return res.json();}
+        )
+        .then((data) => this.template.updateJson(data))
+        .catch((err) => console.error(err));
+    },
+    fetchCompletion: function() {
+      this.is_loading = true;
+      // TODO: Keep only value's id
+      let body = JSON.stringify(this.template.items);
+      fetch("http://localhost:8000/api/solver/complete", {
+        method: 'POST',
+        body,
+      })
+        .then((res) => {
+          return res.json();}
+        )
+        .then((data) => this.template.updateJson(data))
+        .catch((err) => console.error(err));
+      this.is_loading = false;
     },
     unsetMeal: function(mealKey) {
-      console.log("Try unsetting " + mealKey);
-      let idx = this.template.items.findIndex((item) => {
-        return item.key == mealKey;
-      });
+      let idx = this.template.findIndexByKey(mealKey);
+      // console.log("Unset " + idx);
       this.template.items[idx].value = null;
+    },
+    setMeal: function(mealKey, mealData) {
+      let idx = this.template.findIndexByKey(mealKey);
+      // console.log("Set " + idx);
+      this.template.items[idx].value = mealData;
     }
   },
   computed: {
     itemsGroupedByDay: function() {
-      let grouped = groupBy(this.template.items, item => item.key[0]);
-      let sorted = new Map([...grouped.entries()].sort(compareWeekDay));
-      sorted.forEach((meals) => meals.sort(compareMealType));
-      return sorted;
+      return this.template.groupedByDays();
     }
   }
 }

web/vue/src/components/RecipeDetails.vue

@@ -1,24 +1,44 @@
 <template>
-  <div class="container box">
-  <button @click="$emit('close')" class="button is-pulled-left">Return to list</button>
+  <div class="columns">
+    <div class="column is-narrow">
+      <a @click="$emit('close')"
+         class="button is-large is-outlined-dark is-fullwidth">
+        <span>Liste</span>
+        <span class="icon is-large">
+          <i class="mdi mdi-36px mdi-view-list"></i>
+        </span>
+      </a>
+      <br class="is-hidden-mobile"/>
+      <SlotSelect v-on:add="addToPlanning" />
+    </div>
+    <div class="column">
       <h4 class="title">{{ item.title }}</h4>
       <h6 class="subtitle">{{ categories[item.category].name }}</h6>
-    <p><strong>Ingredients : </strong></p>
+      <p><strong>Ingredients</strong></p>
       <ul>
         <li v-for="ing in item.ingredients.split('\n')">{{ ing }}</li>
       </ul>
-    <button @click="$emit('delete', item.id)"
-            class="button is-danger is-pulled-right">
-      DELETE !
-    </button>
+    </div>
+    <div class="column is-narrow">
+      <a @click="$emit('delete', item.id)">
+        <span class="icon is-large has-text-danger">
+          <i class="mdi mdi-48px mdi-delete-forever"></i>
+        </span>
+      </a>
+    </div>
   </div>
 </template>
 
 <script>
 import _, {categories} from './RecipeList.vue'
+import SlotSelect from './planner/SlotSelect.vue'
+
 
 export default {
   name: 'RecipeDetails',
+  components: {
+    SlotSelect,
+  },
   props: {
     item: {
       type: Object,
@@ -32,6 +52,11 @@ export default {
     return {
       categories: categories,
     }
+  },
+  methods: {
+    addToPlanning: function(slotKey) {
+      this.$emit('add', slotKey, this.item.id);
+    }
   }
 }
 </script>

web/vue/src/components/RecipeList.vue

@@ -3,14 +3,27 @@
     <div v-if="active_category == -1" class="columns is-multiline is-mobile">
       <div v-for="c in categories" :key="c.id" class="column is-one-quarter-desktop is-half-tablet">
         <button @click="setActiveCategory(c.id)"
-          class="button is-large is-primary has-text-dark button-block">
-        {{ c.name }}</button>
+          class="button is-large is-info is-fullwidth button-block">
+          <span class="icon is-large">
+            <i class="mdi mdi-24px" v-bind:class="c.icon"></i>
+          </span>
+          <br />
+          <p>{{ c.name }}</p></button>
       </div>
     </div>
-    <div v-else class="box">
-      <button @click="setActiveCategory(-1)" class="button is-pulled-left">Categories</button>
-      <h2 class="subtitle">{{ categories[active_category].name }}</h2>
-      <ul>
+    <div v-else class="columns">
+      <div class="column is-narrow">
+        <a @click="setActiveCategory(-1)"
+           class="button is-large is-fullwidth">
+          <span>Catégories</span>
+          <span class="icon is-large" >
+            <i class="mdi mdi-36px mdi-view-grid"></i>
+          </span>
+        </a>
+      </div>
+      <div class="column">
+        <h2 class="title">{{ categories[active_category].name }}</h2>
+        <ul class="content">
           <li v-for="item in displayed" :key="item.id" class="has-text-left">
             <a href=""
                @click.prevent="$emit(
@@ -21,16 +34,18 @@
         </ul>
       </div>
     </div>
+  </div>
 </template>
 
 <script>
 export const categories = [
-  {id: 0, name: "Petit-déjeuner"},
-  {id: 1, name: "Entrée"},
-  {id: 2, name: "Plat principal"},
-  {id: 3, name: "Dessert"}
+  {id: 0, name: "Petit-déjeuner", icon: "mdi-food-croissant"},
+  {id: 1, name: "Entrée", icon: "mdi-bowl"},
+  {id: 2, name: "Plat principal", icon: "mdi-food"},
+  {id: 3, name: "Dessert", icon: "mdi-cupcake"}
 ];
 
+
 export default {
   name: 'RecipeList',
   props: ["items"],
@@ -57,8 +72,7 @@ export default {
 
 <style scoped>
   .button-block {
-    width: 200px;
-    height: 200px;
+    min-height: 150px;
   }
 
   .li {

web/vue/src/components/planner/SlotSelect.vue

@@ -0,0 +1,53 @@
+<template>
+<div class="box">
+<div class="columns">
+  <div class="column">
+    <div class="field">
+      <div class="control is-expanded">
+      <div class="select is-small is-fullwidth">
+        <select v-model="selected_day">
+          <option value="Lundi">Lundi</option>
+          <option value="Mardi">Mardi</option>
+        </select>
+      </div>
+      </div>
+    </div>
+    <div class="field">
+      <p class="control">
+      <div class="select is-small">
+        <select v-model="selected_meal">
+          <option value="Breakfast">Breakfast</option>
+          <option value="Lunch">Lunch</option>
+        </select>
+      </div>
+      </p>
+    </div>
+  </div>
+  <div class="column">
+  <a @click="$emit('add', getSelectedKey)"
+       class="has-text-success">
+      <span class="icon is-large">
+        <i class="mdi mdi-36px mdi-table-plus"></i>
+      </span>
+  </a>
+  </div>
+</div>
+</div>
+</template>
+
+<script>
+export default {
+  name: 'SlotSelect',
+  data () {
+    return {
+      selected_day: "Lundi",
+      selected_meal: "Breakfast",
+    }
+  },
+  computed: {
+    getSelectedKey: function() {
+      return [this.selected_day, this.selected_meal];
+    }
+  }
+}
+</script>