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:     match format with
      | Some(f) -> f
      | _       -> Json
  
    let da = fun format -> format |> json |> OK
  
    let test d =
      request(fun request ->
          let format = AcceptExtractor request
          d format
      )
  
    let FormatPicker = fun f ->
      match f with
  
negative.code:                                          | e when e.Success = true -> Parsed e.Value
                                           | _                       -> BadString t
                              | None    -> Parsed Instant.MinValue
  
    let AcceptExtractor = fun(request:HttpRequest) ->
      let accept = request.headers.Where(fun (k, v) -> k = "accept").Select(fun (k, v) -> v).First()
  