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: 
  %%
  %%
  recv(Sock, State) ->
     case recv(Sock) of
        {ok, Pckt} ->
           unit(Sock, Pckt, State);
        {error, Reason} ->
           exit({knet, Reason})
     end.
  
  recv(Sock) ->
     case knet:recv(Sock, 60000, [noexit]) of
        {http, Sock, eof} ->
           {ok, []};
        {http, Sock, {_, _, _, _} = Http} ->
           [$? || recv(Sock), join(Http, _)];
        {http, Sock, Pckt} ->
           [$? || recv(Sock), join(Pckt, _)];
        {ioctl, _, _} ->
           recv(Sock);
        {error, _} = Error ->
           Error
     end.
  
negative.code: %%
  -spec return(A) -> m(A).
  
  return(X) ->
     m_state:return(X).
  
  %%
  %%
  