anchor.diff:    
   syncs_running(cluster) ->
     {Good,_} = rpc:multicall(sync_manager, running, []),
  -  lists:map(fun({Part, NodeA, NodeB}) -> 
  -      {obj, [{partition, Part}, {nodes, [NodeA, NodeB]}]}
  -    end, lists:flatten(Good));
  +  {array, lists:map(fun({Part, NodeA, NodeB}) -> 
  +      {struct, [{partition, Part}, {nodes, [NodeA, NodeB]}]}
  +    end, lists:flatten(Good))};
     
   syncs_running(Node) ->
  -  lists:map(fun({Part, NodeA, NodeB}) -> 
  -      {obj, [{partition, Part}, {nodes, [NodeA, NodeB]}]}
  -    end, sync_manager:running(Node)).
  +  {array, lists:map(fun({Part, NodeA, NodeB}) -> 
  +      {struct, [{partition, Part}, {nodes, [NodeA, NodeB]}]}
  +    end, sync_manager:running(Node))}.
   
   diff_size(cluster) ->
     {Good,_} = rpc:multicall(sync_manager, diffs, []),
  -  {obj,
  +  {struct,
         lists:map(fun({Part, Diffs}) ->
  -          {integer_to_list(Part), {obj, Diffs}}
  +          {integer_to_list(Part), {struct, Diffs}}
           end, lists:flatten(Good))
       }.
   
  
positive.code: %%--------------------------------------------------------------------
  
  info(stats) ->
    {obj, [
      {node,node()}, 
      {running_nodes,lists:sort(nodes([this,visible]))},
      {member_nodes,transform_partitions(lists:keysort(1, membership:partitions()))}
    ]};
    
  info(partitions) ->
    lists:map(fun({Node, Part}) -> 
        {obj, [{node,Node},{partition,Part}]}
      end,   lists:keysort(2, membership:partitions()));
      
  info(nodes) ->
    membership:nodes().
  
  rates(cluster) ->
    {obj, [
      {get_rate, lists:foldl(fun(Node, Acc) -> Acc + stats_server:rate(Node, get_rate, 1) end, 0, nodes([this,visible]))},
      {put_rate, lists:foldl(fun(Node, Acc) -> Acc + stats_server:rate(Node, put_rate, 1) end, 0, nodes([this,visible]))},
      {in_rate, lists:foldl(fun(Node, Acc) -> Acc + stats_server:rate(Node, in_rate, 1) end, 0, nodes([this,visible]))},
  
negative.code: %%====================================================================
  
  transform_partitions(Partitions) ->
    {array, lists:map(fun([Node,Parts]) -> 
        {struct, [
          {name, Node},
          {partitions, {array, Parts}},
          {replicas, {array, membership:replica_nodes(Node)}}
        ]}
      end, transform_partitions([], Partitions))}.
  
  transform_partitions([], [{Node,Part}|Parts]) ->
    transform_partitions([[Node,[Part]]], Parts);
  