anchor.diff:                      EmptyMembership = empty_membership(Actor),
                       persist_state(EmptyMembership),
   
  -                    {stop, normal, State#state{membership_strategy_state=EmptyMembership}}
  +                    {stop, normal, State#state{membership=[],
  +                                               membership_strategy_state=EmptyMembership}}
               end
       end;
   
  
positive.code: schedule_connections() ->
      ConnectionInterval = partisan_config:get(connection_interval, 1000),
      erlang:send_after(ConnectionInterval, ?MODULE, connections).
  
  %% @private
  do_gossip(Membership, Connections) ->
      do_gossip(Membership, Membership, Connections).
  
  %% @private
  do_gossip(Recipients, Membership, Connections) ->
      ShouldGossip = partisan_config:get(gossip, true),
  
      case ShouldGossip of
          true ->
              case get_peers(Recipients) of
                  [] ->
                      ok;
                  AllPeers ->
                      Members = [N || #{name := N} <- members(Membership)],
  
                      lager:debug("Sending state with updated membership: ~p", [Members]),
  
                      lists:foreach(fun(Peer) ->
                                  do_send_message(Peer,
                                                  ?DEFAULT_CHANNEL,
                                                  ?DEFAULT_PARTITION_KEY,
                                                  {protocol, myself(), Membership},
                                                  Connections)
                          end, AllPeers),
                      ok
              end;
          _ ->
              ok
      end.
  
  %% @private
  get_peers(Local) ->
      Members = members(Local),
      Peers = [X || #{name := X} <- Members, X /= partisan_peer_service_manager:mynode()],
      Peers.
  
  %% @private
  -spec do_send_message(Node :: atom() | node_spec(),
  
negative.code: 
                      lager:debug("Received updated membership state: ~p from ~p", [Members, From]),
  
                      {ok, Membership, OutgoingMessages, _MembershipStrategyState} = MembershipStrategy:periodic(Merged),
  
                      lists:foreach(fun({Peer, Message}) ->
                                  do_send_message(Peer,
                                                  ?MEMBERSHIP_PROTOCOL_CHANNEL,
                                                  ?DEFAULT_PARTITION_KEY,
                                                  Message,
                                                  Connections)
                          end, OutgoingMessages),
  
                      {reply, ok, State#state{membership=Membership,
                                              membership_strategy_state=Merged,
                                              connections=Connections}};
                  false ->
                      lager:debug("Node ~p is no longer part of the cluster, setting empty membership.", [partisan_peer_service_manager:mynode()]),
  