anchor.diff:  
     let referenceData = fun (state:Func<IDictionary<string, State>>) -> state.Invoke().First().Value
   
  -  let cargoExtractor = fun (commander:State, kind) -> commander.Cargo
  -                                                      |> List.ofSeq
  -                                                      |> List.filter 
  -                                                        (fun e -> match kind with
  -                                                                  | Some(Kind.Commodity) -> e.Value.Data.Kind = Kind.Commodity
  -                                                                  | Some(Kind.Data)      -> e.Value.Data.Kind = Kind.Data
  -                                                                  | Some(Kind.Material)  -> e.Value.Data.Kind = Kind.Material
  -                                                                  | _                    -> true)
  -                                                      |> List.map (fun e -> e.Value)
  -                                                      |> List.map (fun e -> e.Data.Name, e.Count)
  -                                                      |> dict
  -
  -  let cargoRoute = fun(state, kind) -> (state, kind) |> cargoExtractor |> json |> OK
  +
  +  let cargoExtractor = fun (state:State, kind) -> state.Cargo
  +                                                  |> List.ofSeq
  +                                                  |> List.filter 
  +                                                    (fun e -> match kind with
  +                                                              | Some(Kind.Commodity) -> e.Value.Data.Kind = Kind.Commodity
  +                                                              | Some(Kind.Data)      -> e.Value.Data.Kind = Kind.Data
  +                                                              | Some(Kind.Material)  -> e.Value.Data.Kind = Kind.Material
  +                                                              | _                    -> true)
  +                                                  |> List.map (fun e -> e.Value)
  +                                                  |> List.map (fun e -> e.Data.Name, e.Count)
  +                                                  |> dict
   
     let commanderRoute = fun commander ->
                            match state.Invoke().TryGetValue(commander) with
  
positive.code:                                          | e when e.Success = true -> Parsed e.Value
                                           | _                       -> BadString t
                              | None    -> Parsed Instant.MinValue
  
    let listOperations commander =
      request(fun request ->
        let timestampString = match request.queryParam "last" with
                              | Choice1Of2 s     -> Some(s)
                              | Choice2Of2 other -> None
  
        cmdr {
          let! timestamp = timeRoute timestampString
          let! state = commanderRoute commander
          return state.Operations
                 |> List.ofSeq
                 |> List.filter
                   (fun e -> match e.Timestamp with
                             | t when t >= timestamp -> true
                             | _                     -> false)
                 |> json 
                 |> OK
        }
      )
      
    let FormatExtractor = fun(extension) ->
      match extension with
      | "json" -> KnownFormat Json
      | "csv"  -> KnownFormat Csv
      | "xml"  -> KnownFormat Xml
      | f      -> UnknownFormat f
  
    let AcceptExtractor = fun(request:HttpRequest) ->
      let accept = request.headers.Where(fun (k, v) -> k = "accept").Select(fun (k, v) -> v).First()
  
negative.code:     match format with
      | Some(f) -> f
      | _       -> Json
      
    let FormatExtractor = fun(extension, request:HttpRequest) ->
      match extension with
      | "json" -> KnownFormat Json
      | "csv"  -> KnownFormat Csv
      | "xml"  -> KnownFormat Xml
      | s when s.StartsWith(".") -> UnknownFormat s
      | s when s = "" -> 
        let formatFromRequest = AcceptExtractor request
        KnownFormat formatFromRequest
      | f      -> RouteNotFound f
  
    let da = fun format -> format |> json |> OK
  
    let FormatPicker = fun f ->
      match f with
  