anchor.diff:                    let! state = commanderRoute commander
                     let! f = FormatExtractor request format
                     let! timestamp = timeRoute timestampString
  -                  return state.Operations
  -                          |> List.ofSeq
  -                          |> List.filter
  +                  return state.Operations
  +                          |> Seq.filter
                               (fun e -> match e.Timestamp with
                                         | t when t >= timestamp -> true
                                         | _                     -> false)
  
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:     |> Seq.map (fun (k, v) -> v)
      |> Seq.head
      |> fun x -> x.Split [|';'|]
      |> Seq.fold(fun acc elem -> match acc with
                                   | Some(r) -> Some(r)
                                   | _       -> match elem with
                                                | "text/json" -> Some(Json)
  