anchor.diff:      let compositeFunctions functions = 
            Seq.fold ( >> ) id functions
   
  -    let populationToMatrix (population: ChromosomeType list) = 
  +    let populationToMatrix<'T,'S when 'S: comparison> (population: ChromosomeType<'T,'S> list) = 
           [ for i in population do yield (i.ToRows()) ] 
           |> List.concat
   
   open EvolutionaryComputation
   
  -let lociFunction() = box(random.Next(10))
  +let lociFunction() = random.Next(10)
   
  -let fitnessF (items:obj list) = 
  -    items |> Seq.map (System.Convert.ToInt32) |> Seq.sum
  +let fitnessF (items: int list) = items |> List.sum 
   
  -let populationSize = 20
  +let populationSize = 50
   let chromosomeSize = 10
  -let myPopulation = Population lociFunction populationSize chromosomeSize
  +let myPopulation = Population<int,int> lociFunction fitnessF id populationSize chromosomeSize
   
   for i in myPopulation do printfn "%A" (i.ToRows())
   
   let elitism = true
  -let myEvolve population = Evolve population RankSelection ShuffleCrossover fitnessF 0.9 0.1 elitism
  +let selectionF (x: ChromosomeType<int,int> list) = RankSelection<int,int> x
  +let shuffleCrossover x y = ShuffleCrossover<int,int> x y
  +let crossoverRate = 0.9
  +let mutationRate = 0.1
   
  -let result = composite myEvolve 75 myPopulation 
  - 
  -printfn "%A" (maxFitness result fitnessF)
  -System.Console.ReadKey() |> ignore
  +let evolve (x: ChromosomeType<int,int> list) = 
  +    Evolve<int,int>(x, selectionF, shuffleCrossover, crossoverRate, mutationRate, elitism)
   
  +let result = composite evolve 75 myPopulation
  +printfn "%A" (maxFitness result)
  +
  +System.Console.ReadLine() |> ignore
  +
  
positive.code: // System.Console.ReadKey() |> ignore
  
  /// Evolutionary computation module
  /// this module is for Genetic Algorithm(GA) only
  
  module EvolutionaryComputation =
  
      /// random number generator
      let random = new System.Random((int)System.DateTime.Now.Ticks)
  
  
negative.code:     /// random float (double) generator
      let randomFloatF() = random.NextDouble()
  
      type unitTo<'T> = unit -> 'T
      type ConvertersType<'T> = ('T -> 'T) list
      type FitnessType<'T,'S> = 'T list -> 'S 
  
      /// Chromosome type to represent the individuals involved in the GA
      type ChromosomeType<'T,'S when 'S: comparison> (initialF: unitTo<'T>, 
                                                      fitnessF: FitnessType<'T,'S>, 
                                                      toInt: 'T -> int, 
                                                      size, 
                                                      ?converters: ConvertersType<'T>) = 
          let mutable genos = [for i in 1..size do yield initialF()]
          let mutable genoPhenoConverters = converters
  
          /// make a duplicate copy of this chromosome
          member this.Clone() =
              let newValue = 
                  match converters with
                      | Some(converters) -> new ChromosomeType<'T,'S>(initialF, fitnessF, toInt, size, converters)
                      | None -> new ChromosomeType<'T,'S>(initialF, fitnessF, toInt, size)
              newValue.Genos <- this.Genos 
              newValue 
  
          /// get fitness value with given fitness function
          member this.Fitness() = this.Pheno |> fitnessF
  
          /// gets and sets the Geno values
          member this.Genos
  