anchor.diff:  
   (defun evolve (primitives actions conditionals args fargs fitness-function fitness-p &optional
                             (max-tree-depth 5) (member-count 1000) (repeat-var 60)
  -                          (percentage 10) (program-count 7)
  +                          (copy-percentage 10) (crossover-percentage 90) (program-count 7)
                             &key (generation nil) (max-run-count 10))
  +  "Main function to run the evolution process.
  +
  +  Mandatory arguments -
  +
  +  primitives - Primitive functions to be used (eg., if, and, or and not).
  +  actions - User defined functions that operate on the user-defined world.
  +  conditionals - User defined 'sensors' that operate on the user-defined world.
  +  args - A raw list of the arguments that the 'action' functions can take.
  +  fargs - An evaluted list of arguments that the 'action' functions can take.
  +  fitness-function - The fitness function that takes a set of results and returns a fitness.
  +  fitness-p - Predicate function that determines if a fitness has reached 'success' state.
  +  max-tree-depth - Maximum allowed depth of program trees that need to be generated.
  +
  +  Optional arguments -
  +
  +  max-tree-depth - Maximum depth of program trees generated. Default 5.
  +  member-count - Number of programs in each generation. Default 1000.
  +  repeat-var - Number of evaluations needed on each program. Default 60.
  +  copy-percentage - Percentage of programs to evolve by direct copying.
  +  crossover-percentage - Percentage of programs to evolve by crossing over.
  +  program-count - Number of programs to be selected on each round of tournament selection.
  +
  +  Keyword arguments -
  +  max-run-count - Maximum number of evolutions to be run."
     (let* ((population
              (if generation
                generation
  
positive.code:         (evolve primitives actions conditionals args fargs fitness-function fitness-p
                  max-tree-depth member-count repeat-var percentage program-count
                  :generation
                  (append (copy-population population-fitness percentage program-count)
                          (crossover-population population-fitness percentage program-count))
                  :max-run-count (- max-run-count 1)))
        population-fitness)))
  
  
negative.code:                             fargs))) population))
  
  (defun generation-fitness (population args fargs fitness-function &optional (repeat-var 50))
    "Evaluate the fitness of a generation of programs using provided fitness-function."
    (pairlis population
             (mapcar #'(lambda (result) (fitness-function (cadr result)))
                     (evaluate-population population repeat-var args fargs))))
  
  (defun get-min-max (alist predicate key)
    "Depending on the predicate arg, get the min or max element
    from an association list by value."
    (when alist
      (let* ((m0 (first alist))
             (m1 (funcall key m0)))
  