Convergent Replicated Data Types in Rust.

A set of data types built for eventually consistent systems.

Current data types are:

• GCounter: A grow only counter.
• PnCounter: A counter supporting increment and decrement operations.
• GSet: A grow only set.
• TwoPSet: A set supporting insert and remove operations.

Add the crate to your Cargo.toml

[dependencies]
fly = "0.1.0"

And import the crate in your lib.rs file.

extern crate fly;

G-Counters are the building blocks for eventually consistent counters. They can only be incremented, never decremented.

// Let's create a new GCounter
let mut a = GCounter::new();
let mut b = GCounter::new();

a.incr(1, 2);
b.incr(2, 9);

// Converge onto an eventual counter. This returns a new `GCounter`.
let converged = a.merge(&b);

The first argument to incr is the current node or replica, which is a generic data type.

The second argument is the delta — how much we want to increment the counter.

The node id is bound to the following trait constraints:

Eq + Hash + Copy + Clone

Example replica ids:

counter.incr("node1".to_string(), 5);
counter.incr(Uuid::new_v4(), 4);

A PN-Counter uses two GCounters to build a full counter, with the ability to decrement. One of the GCounters is used for increments and the second is used for decrements.

let mut a = PnCounter::new();
let mut b = PnCounter::new();

a.incr(1, 3);
a.incr(3, 2);
b.decr(2, 1);

let converged = a.merge(&b);

MIT