anchor.diff:  
   header(Head, Value)
    when is_list(Value) ->
  -   m_state:put(header(scalar:s(Head)), scalar:s(Value));
  +   m_state:put(req_header(scalar:s(Head)), scalar:s(Value));
   
   header(Head, Value) ->
  -   m_state:put(header(scalar:s(Head)), Value).
  +   m_state:put(req_header(scalar:s(Head)), Value).
   
   
   %%
  
positive.code: %%
  send(Sock, State) ->
     [either ||
        Request <- http_request(State),
        Payload <- http_payload(State),
        knet:send(Sock, Request),
        knet:send(Sock, Payload),
        knet:send(Sock, eof)
     ].
  
  http_request(State) ->
     {ok, [identity ||
        default_headers(State),
        lens:get(req(), _)
     ]}.
     
  http_payload(State) ->
     case lens:get(req_payload(), State) of
        [] ->
           {ok, []};
        Payload ->
           htcodec:encode(lens:get(req_header(<<"Content-Type">>), State), Payload)
     end.
  
  
  %%
  %%
  default_headers(State) ->
     [identity ||
        cats:unit(State),
        default_headers_connection(_),
        default_headers_accept(_),
        default_headers_transfer_encoding(_)
     ].
  
  default_headers_connection(State) ->
     default_header(<<"Connection">>, <<"close">>, State).
  
  default_headers_accept(State) ->
     default_header(<<"Accept">>, <<"*/*">>, State).
  
  default_headers_transfer_encoding(State) ->
     case lens:get(req_payload(), State) of
        [] ->
           State;
        _  ->
           default_header(<<"Transfer-Encoding">>, <<"chunked">>, State)
     end.
  
  default_header(Head, Value, State) ->
     case lens:get(req_header(Head), State) of
        ?None ->
           lens:put(req_header(Head), Value, State);
        _     ->
           State
     end.
  
  
  % %%
  % %% 
  % head(State) ->
  %    [$.||
  %       lens:get(headers(), State),
  %       head_connection(_),
  %       head_te(lens:get(content(), State), _)
  %    ].
  
  % head_connection(Head) ->
  %    case lens:get(lens:pair(<<"Connection">>, ?None), Head) of
  %       ?None ->
  %          [{<<"Connection">>, <<"close">>}|Head];
  %       _     ->
  %          Head
  %    end.
  
  % head_te(undefined, Head) ->
  %    Head;
  % head_te(_, Head) ->
  %    case lens:get(lens:pair(<<"Transfer-Encoding">>, ?None), Head) of
  %       ?None ->
  %          [{<<"Transfer-Encoding">>, <<"chunked">>}|Head];
  %       _     ->
  %          Head
  %    end.
  
  %%
  %%
  recv(Sock, Timeout, _State) ->
     {ok, stream:list(knet:stream(Sock, Timeout))}.   
  
  %%
  %%
  
negative.code:    lens:c(lens:at(req), lens:tl()).
  
  
  %%
  %%
  ret() ->
     lens:c(lens:at(ret), lens:hd()).
  
  
  
  uri() ->
  