anchor.diff:      Members = [P || {P, _, _} <- members(Membership)],
       {reply, {ok, Members}, State};
   
  +handle_call(connections, _From, #state{connections=Connections}=State) ->
  +    {reply, {ok, Connections}, State};
  +
   handle_call(get_local_state, _From, #state{membership=Membership}=State) ->
       {reply, {ok, Membership}, State};
   
  
positive.code:                     dict:store(Name, [], Connections0)
              end
      end,
      Connections.
  
  %% @private
  connect(Node) ->
  
negative.code: %% keys in the dict pointing to empty list if they are disconnected or a
  %% socket pid if they are connected.
  %%
  maybe_connect({Name, _, _} = Node, {Connections0, MemberParallelism}) ->
      %% Compute desired parallelism.
      Parallelism  = case dict:find(Node, MemberParallelism) of
          {ok, V} ->
              %% We learned about a node via an explicit join.
              V;
          error ->
              %% We learned about a node through a state merge; assume the
              %% default unless later specified.
              partisan_config:get(parallelism, ?PARALLELISM)
      end,
  
      lager:debug("Connecting ~p with parallelism: ~p",
                  [Node, Parallelism]),
  
      %% Initiate connections.
      Connections = case dict:find(Name, Connections0) of
          %% Found in dict, and disconnected.
          {ok, []} ->
              case connect(Node) of
                  {ok, Pid} ->
                      dict:store(Name, [Pid], Connections0);
                  _ ->
                      dict:store(Name, [], Connections0)
              end;
          %% Found in dict and connected.
          {ok, Pids} ->
              lager:debug("Node ~p connected with ~p processes of ~p processes.",
                          [Node, length(Pids), Parallelism]),
              case length(Pids) < Parallelism of
                  true ->
                      case connect(Node) of
                          {ok, Pid} ->
                              dict:store(Name, [Pid], Connections0);
                          _ ->
                              dict:store(Name, [], Connections0)
                      end;
                  false ->
                      Connections0
              end;
          %% Not present; disconnected.
          error ->
              case connect(Node) of
  