anchor.diff:  
   (1) A "zero" knapsack is created with the given capacity. This is just a convenience to avoid calling the `Knapsack.empty()` method several times.
   
  -(2) A list of integers is build by first creating a list of integers from the given capacity to 1. The `range` method must be added to the `List` class.
  +(2) A list of integers from the given capacity to 1 is built by calling the `range` method. This method must be added to the `List` class.
   
   (3) This list of integers is mapped to a list of knapsacks. While constructing this list (named `acc`, for "accumulator", by convention), the previously created knapsacks are available.
   
  
positive.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 none 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
  
  
negative.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 knapsacks of capacity varying from 1 to the given capacity, in reverse order.
  
  - for each item in the list,
  
  