anchor.diff:  handle_message({receive_state, #{name := From}, PeerMembership},
                  #state{actor=Actor,
                         pending=Pending,
  -                      membership=Membership,
  +                      membership_strategy_state=MembershipStrategyState,
                         connections=Connections0}=State) ->
  -    case ?SET:equal(PeerMembership, Membership) of
  +    case ?SET:equal(PeerMembership, MembershipStrategyState) of
           true ->
               %% No change.
               {reply, ok, State};
           false ->
               %% Merge data items.
  -            Merged = ?SET:merge(PeerMembership, Membership),
  +            Merged = ?SET:merge(PeerMembership, MembershipStrategyState),
   
               %% Persist state.
               persist_state(Merged),
  
positive.code: %% @private
  -spec handle_info(term(), state_t()) -> {noreply, state_t()}.
  handle_info(gossip, #state{pending=Pending,
                             membership=Membership,
                             connections=Connections0}=State) ->
      Connections = establish_connections(Pending,
                                          Membership,
                                          Connections0),
      do_gossip(Membership, Connections),
      schedule_gossip(),
      {noreply, State#state{connections=Connections}};
  
  handle_info(retransmit, #state{connections=Connections}=State) ->
  
negative.code: %% @private
  internal_leave(Node, #state{actor=Actor,
                              connections=Connections,
                              membership_strategy_state=MembershipStrategyState0}=State) ->
      lager:debug("Leaving node ~p at node ~p", [Node, partisan_peer_service_manager:mynode()]),
  
      %% Node may exist in the membership on multiple ports, so we need to
      %% remove all.
      MembershipStrategyState = lists:foldl(fun(#{name := Name} = N, M0) ->
                          case Node of
                              Name ->
                                  {ok, M} = ?SET:mutate({rmv, N}, Actor, M0),
  