anchor.diff:  
   %% throttle/1
   
  +%% Still collecting packets for a complete message: keep receiving.
   throttle(#transport{throttled = false} = S) ->
       recv(S);
   
  -throttle(#transport{throttle_cb = F, throttled = B} = S) ->
  -    Res = cb(F, B),
  +%% Decide whether to receive another, or whether to accept a message
  +%% that's been received.
  +throttle(#transport{throttle_cb = F, throttled = T} = S) ->
  +    Res = cb(F, T),
   
       try throttle(Res, S) of
  +        #transport{ssl = SB} = NS when is_boolean(SB) ->
  +            throttle(defrag(NS));
  +        #transport{throttled = Msg} = NS when is_binary(Msg) ->
  +            %% Initial incoming message when we might need to upgrade
  +            %% to TLS: wait for reception of a tls tuple.
  +            defrag(NS)
  +    catch
           #transport{} = NS ->
  -            throttle(defrag(NS))
  -    catch
  -        #transport{throttled = false} = NS ->
  -            recv(NS);
  -        #transport{} = NS ->
  -            NS
  +            recv(NS)
       end.
   
   %% cb/2
  
positive.code: %% Reassemble fragmented messages and extract multiple message sent
  %% using Nagle.
  
  %% Receive packets until a full message is received, then check
  %% whether to keep receiving.
  recv(Bin, #transport{frag = Head, throttled = false} = S) ->
      case rcv(Head, Bin) of
          {Msg, B} ->
  
negative.code:          parent  :: pid(),          %% of process that started us
           module  :: module(),       %% gen_tcp-like module
           frag = <<>> :: frag(),     %% message fragment
           ssl     :: [term()] | boolean(),       %% ssl options, ssl or not
           timeout :: infinity | 0..16#FFFFFFFF,  %% fragment timeout
           tref = false  :: false | reference(),  %% fragment timer reference
           flush = false :: boolean(),            %% flush fragment at timeout?
  