anchor.diff:  
   %%
   %%
  --spec new(atom()) -> m(_).
  --spec new(atom(), list()) -> m(_).
  -
  -new(Mthd) ->
  +-spec new(_) -> m(_).
  +-spec new(_, list()) -> m(_).
  +
  +new(Uri) ->
  +   new(Uri, []).
  +
  +new(Uri, SOpt) ->
  +   fun(State0) ->
  +      Id = scalar:s(Uri),
  +      [Id|lens:put(so(), SOpt, lens:put(uri(), uri:new(Uri), lens:put(id(), Id, State0)))]
  +   end.
  +
  +%%
  +%%
  +-spec x(_) -> m(_).
  +-spec method(_) -> m(_).
  +
  +x(Mthd) ->
  +   method(Mthd).
  +
  +method(Mthd) ->
      m_state:put(method(), Mthd).
  -
  -new(Mthd, SOpt) ->
  -   fun(State) ->
  -      [Mthd|lens:put(method(), Mthd, lens:put(so(), SOpt, State))]
  -   end.
  -
  -%%
  -%%
  --spec url(_) -> m(_).
  -
  -url(Url) ->
  -   m_state:put(url(), Url).
   
   %%
   %%
  
positive.code: %%%
  %%%----------------------------------------------------------------------------
  
  http_io(State) ->
     Sock = sock(State),
     Tx   = erlang:monitor(process, Sock),
     send(Sock, State),
     receive
        {'DOWN', Tx, _, _, _Reason} ->
           erlang:demonitor(Tx, [flush]),
           Url       = uri:new(lens:get(url(), State)),
           Authority = uri:authority(Url),
           http_io(maps:remove(Authority, State))
     after 0 ->
        erlang:demonitor(Tx, [flush]),
        recv(Sock, State)
     end.
  
  %%
  %% create a new socket or re-use existed one
  sock(State) ->
     SOpt      = lens:get(so(), State),
     Url       = uri:new(lens:get(url(), State)),
     Authority = uri:authority(Url),
     case State of
        #{Authority := Sock} ->
           Sock;
        _ ->
           knet:socket(Url, SOpt)
     end.
  
  %%
  %%
  send(Sock, State) ->
     Mthd = lens:get(method(), State),   
     Url  = uri:new(lens:get(url(), State)),
     Head = lens:get(header(), State),
     knet:send(Sock, {Mthd, Url, Head}),
     [$?|| lens:get(payload(), State), knet:send(Sock, _)],
  
negative.code: 
  %%
  %%
  -spec d(_) -> m(_).
  -spec payload(_) -> m(_).
  
  d(Value) ->
     payload(Value).
  
  payload(Value) ->
     m_state:put(payload(), Value).
  
  %%
  %%
  -spec r() -> m(_).
  -spec request() -> m(_).
  -spec request(_) -> m(_).
  
  r() ->
     request().
  
  request() ->
     request(30000).
  
  request(Timeout) ->
     fun(State) -> http_io(Timeout, State) end.   
  
  %%%----------------------------------------------------------------------------   
  %%%
  %%% http environment
  %%%
  %%%----------------------------------------------------------------------------
  
  id() ->
     lens:map(id, ?NONE).
  
  focus() ->
     fun(Fun, Map) ->
        Key = maps:get(id, Map),
        lens:fmap(fun(X) -> maps:put(Key, X, Map) end, Fun(maps:get(Key, Map, #{})))
     end.
  
  so() ->
     lens:c([focus(), lens:map(so, [])]).
  
  method() ->
     lens:c([focus(), lens:map(method, ?NONE)]).
  
  uri() ->
     lens:c([focus(), lens:map(uri, ?NONE)]).
  
  header() ->
     lens:c([focus(), lens:map(head, [])]).
  
  header(Head) ->
     lens:c([focus(), lens:map(head, []), lens:pair(Head, ?NONE)]).
  
  payload() ->
     lens:c([focus(), lens:map(payload, ?NONE)]).
  
  %%%----------------------------------------------------------------------------   
  %%%
  