anchor.diff:  
   - From the resulting knapsack list, select the one with the maximum value. This is the result of the packing.
   
  -Note that if we add a knapsack to the list, we put it in front of the list. So, the knapsack with the maximum value will simply be the head of the list. This is why we select the knapsack of index (`item.weight - 1`). This corresponds to an index of `i - it.weight` if the list was build the other way, where `i` would be the index of the knapsack we are in.
  +Note that if we add a knapsack to the list, we put it in front of the list. So, the knapsack with the maximum value will simply be the head of the list. This is why we select the knapsack of index (`item.weight - 1`). This would correspond to an index of `i - it.weight` if the list was build the other way, where `i` would be the index of the knapsack we are in.
   
   Here is the corresponding code:
   
  
positive.code: 
  To avoid bi-recursion, we have to memorize the result of each step in order not not have to compute it again and again. It is obvious that when examining an item to see if we should put it in the knapsack, we must consider what we have already put in at previous steps. What we will do is:
  
  - build a list of knapsack of capacity varying from 1 to the given capacity, in reverse order.
  
  - for each item in the list,
  
  
negative.code: 
  (8) Once the list of integers is folded to a list of knapsacks, we just have to select the maximum value, which is automatically the head of the list. As the head method returns a singleton list, we use a "getOrElse" technique to select either the value if it is present, or a default value if not.
  
  The technique used here is very well known in functional programming and is called _memoization_. It consists in keeping access to the previous results instead of recomputing them at each step. This technique is also used in imperative programming. The particularity of the functional programming version is the way the previous results are transported in the fold (in the `acc` parameter).
  
  == Implementing the missing methods
  
  