anchor.diff:  open EDEngineer.Models
   
   type Format = Json | Xml | Csv
  -type cargoType = { Name: string; Count: int }
  +type cargoType = { Kind: string; Name: string; Count: int }
   
   type Cmdr<'TGood, 'TBad> = 
     | Found         of 'TGood
  
positive.code:   let csv = fun s -> JsonConvert.DeserializeObject<DataTable>(json(s)) |> dataTableToCsv
      
    let ingredients = fun (state:State) -> state.Cargo
                                           |> List.ofSeq
                                           |> List.map (fun d -> d.Value.Data)
  
    let blueprints = fun (state:State) -> state.Blueprints
                                          |> List.ofSeq
  
    let referenceData = fun (state:Func<IDictionary<string, State>>) -> state.Invoke().First().Value
  
    let cargoExtractor = fun (state:State, kind) -> state.Cargo
                                                    |> List.ofSeq
                                                    |> List.map (fun e -> e.Value)
                                                    |> List.filter 
                                                      (fun e -> match kind with
                                                                | Some(Kind.Commodity) -> e.Data.Kind = Kind.Commodity
                                                                | Some(Kind.Data)      -> e.Data.Kind = Kind.Data
                                                                | Some(Kind.Material)  -> e.Data.Kind = Kind.Material
                                                                | _                    -> true)
                                                    |> List.map (fun e -> { Name = e.Data.Name; Count = e.Count })
  
    let commanderRoute = fun commander ->
                           match state.Invoke().TryGetValue(commander) with
  
negative.code:                   let! state = commanderRoute commander
                    let! f = FormatExtractor request format
                    let! timestamp = timeRoute timestampString
                    return state.Operations
                            |> Seq.filter
                              (fun e -> match e.Timestamp with
                                        | t when t >= timestamp -> true
                                        | _                     -> false)
  