anchor.diff:          |_ -> failwith "Invalid player index" // should never appear
           players.[playerIndex]
   
  -    let rec move (player: IConnectFour) (pitchSoFar:int[,]) =
  +    let rec move (player: IConnectFour) pitchSoFar =
           let column = player.Move(pitchSoFar)
           match isValidMove column pitchSoFar with
           | Valid ->        // x        y                           usualy 4       pitch with modified state
  
positive.code:                                                    | s when s = howManyInARow -> Won(valuesAndIndices |> List.map (fun (_,indices) -> indices))
                                                     | _ -> None
  
  
  let getResult (x, y) howManyInARow getNextX getNextY (pitch: int[,]) = getValuesWithIndices x getNextX y getNextY howManyInARow pitch
                                                                         |> getMoveResult howManyInARow
  
      
  let check (x,y) howManyInARow checkBounds calcResult (pitch: int[,])= 
      match checkBounds (x,y) howManyInARow pitch with
      | true -> None
      | _ -> calcResult (x,y) howManyInARow pitch
  
  
  let checkLeftBounds (x,_) howManyInARow (pitch: int[,]) = x+1 < howManyInARow
  let checkRightBounds (x,_) howManyInARow (pitch: int[,]) = x + howManyInARow > Array2D.length1 pitch
  let checkDownBounds (_,y) howManyInARow (pitch: int[,]) = y+1 < howManyInARow
  
  
  let leftResult (x, y) howManyInARow (pitch: int[,]) = getResult (x,y) howManyInARow (fun x -> x-1) (fun y -> y) pitch
  let rightResult (x,y) howManyInARow (pitch: int[,]) = getResult (x,y) howManyInARow (fun x -> x+1) (fun y -> y) pitch
  let downResult (x,y) howManyInARow (pitch: int[,]) = getResult (x,y) howManyInARow (fun x -> x) (fun y -> y-1) pitch
  
  
  //Highlevel API checks
  let leftCheck (x,y) howManyInARow pitch = check (x,y) howManyInARow checkLeftBounds leftResult pitch
  let rightCheck (x,y) howManyInARow pitch = check (x,y) howManyInARow checkRightBounds rightResult pitch
  let downCheck (x,y) howManyInARow pitch = check (x,y) howManyInARow checkDownBounds downResult pitch
  
  
  let invertPitch (pitch: int[,]) = Array2D.map (fun elem -> elem * (-1)) pitch
  
  
  let won (x,y) howManyInARow pitch = false
  
  
negative.code:                        loop (nextX x) (nextY y) (i + 1) (valueWithIndices::acc)
              loop startX startY 0 []
  
  let getMoveResult howManyInARow valuesAndIndices = let sum = valuesAndIndices 
                                                                  |> List.map (fun (value,_) -> value)
                                                                  |> List.reduce (fun acc elem -> acc + elem)
  