anchor.diff:  % Functional, immutable consistent-hash-ring.
   
   -record(cring, {hash,    % A tuple of {HashMod, HashCfg}.
  -                ring,    % [#cpoint{}, ...], ordered by ascending point field.
  +                ring,    % [#carc{}, ...], ordered by ascending point field.
                   addr_num % length(AddrDataList).
                  }).
  --record(cpoint, {point,     % Integer point from list from HashMod:hash_addr().
  -                 point_ord, % Point ordinal from list from HashMod:hash_addr().
  -                 addr,      % Addr part of an {Addr, Data} tuple.
  -                 data}).    % Data part of an {Addr, Data} tuple.
  +
  +% A CArc is defines an arc in the consistent-hash-ring, in clockwise
  +% fashion, from pt_beg (exclusive) to pt_end (inclusive).
  +% A pt_beg may be an Integer or the atom min.
  +% A pt_end may be an Integer.
  +
  +-record(carc, {pt_beg,   % Integer point, so (pt_beg, pt_end] is an arc.
  +               pt_end,   % Integer point from list from HashMod:hash_addr().
  +               hash_ord, % Point ordinal from list from HashMod:hash_addr().
  +               addr,     % Addr part of an {Addr, Data} tuple.
  +               data      % Data part of an {Addr, Data} tuple.
  +              }).
   
   %% API
   
  
positive.code:     if B =:= max -> delta(BPrev, BList,
                            A, ARest,
                            BAFull,
                            [{A, APrev, delta_next(BList, Before)} | Grows],
                            Shrinks);
         A =:= max -> delta(B, BRest,
                            APrev, AList,
                            BAFull,
                            [{B, BPrev, delta_next(AList, After)} | Grows],
                            Shrinks);
         B < A     -> delta(B, BRest,
                            APrev, AList,
                            BAFull,
                            [{B, BPrev, delta_next(AList, After)} | Grows],
                            Shrinks);
         true      -> delta(BPrev, BList,
                            A, ARest,
                            BAFull,
                            [{A, APrev, delta_next(BList, Before)} | Grows],
                            Shrinks)
      end.
  
  delta_next([], [])      -> undefined;
  delta_next([A | _], _)  -> A;
  delta_next([], Restart) -> delta_next(Restart, []).
  
negative.code:     ok.
  
  delta_check(Before, After, _ExpectGrows, _ExpectShrinks) ->
      {_Grows, _Shrinks} = delta(Before, After),
  %    ?debugVal("------"),
  %    ?debugVal(Before),
  %    ?debugVal(After),
      % ?debugVal(ExpectGrows),
  %    ?debugVal(Grows),
  %    ?debugVal(Shrinks),
      % ?assertEqual(ExpectGrows, Grows),
      % ?assertEqual(ExpectShrinks, Shrinks),
      ok.
  