anchor.diff:  %% @private
   %% Connect the socket if disconnected
   connect(State) when State#state.sock =:= undefined ->
  -    #state{address = Address, port = Port, connects = Connects} = State,
  +    #state{address = Address, port = Port} = State,
       case gen_tcp:connect(Address, Port,
                            [binary, {active, once}, {packet, 4},
                             {keepalive, State#state.keepalive}],
                            State#state.connect_timeout) of
           {ok, Sock} ->
  -            State1 = State#state{sock = Sock, connects = Connects+1,
  -                                 reconnect_interval = ?FIRST_RECONNECT_INTERVAL},
  -            {ok, State1};
  +            {ok, State#state{sock = Sock}};
           Error -> Error
       end.
   
  -handle_call({req, Msg}, From, State) ->
  -    {reply, send_request(new_request(Msg, From, infinity), State),State}.
  -
  -%% @private Like `gen_server:call/3', but with the timeout hardcoded
  -%% to `infinity'.
  -call_infinity(Pid, Msg) ->
  -    gen_server:call(Pid, Msg, infinity).
   
   %% @private
  -%% Make a new request that can be sent or queued
  -%% @todo Support Context?? see riak-erlang-client. Also removed timeout (must do this)
   new_request(Msg, From, Timeout) ->
       Ref = make_ref(),
       #request{ref = Ref, msg = Msg, from = From, timeout = Timeout, tref = create_req_timer(Timeout, Ref)}.
  
positive.code:           address :: address(),    % address to connect to
            port :: portnum(),       % port to connect to
            sock :: port(),       % gen_tcp socket
            queue :: queue() | undefined,
            auto_reconnect = false :: boolean(), % if true, automatically reconnects to server
                                                 % if false, exits on connection failure/request timeout
            connect_timeout=infinity :: timeout(), % timeout of TCP connection
            keepalive = false :: boolean(), % if true, enabled TCP keepalive for the socket
            connects=0 :: non_neg_integer(), % number of successful connects
            reconnect_interval=?FIRST_RECONNECT_INTERVAL :: non_neg_integer(),
            credentials :: undefined | {string(), string()} % username/password
           }).
  
  -export([start_link/2, start_link/3,
  
negative.code:          terminate/2]).
  
  -export([
           increment/3
          ]).
  
  %Must abstract data-type interface
  increment(Key,Amount,Pid) ->
      Req = #fpbincrementreq{key=Key, amount=Amount},
      call_infinity(Pid, {req, Req, ?TIMEOUT}).
  
  %% Callback functions
  
  %% @private
  init([Address, Port, _Options]) ->
      State = #state{address = Address, port = Port, active = undefined},
      case connect(State) of
          {error, Reason} ->
              {stop, {tcp, Reason}};
  