CRDT.Cm

Documentation

class CausalOrd a where

Partial order for causal semantics. Values of some type may be ordered and causally-ordered different ways.

Minimal complete definition

precedes

Methods

precedes :: a -> a -> Bool

x precedes y means that x must go before y and y can not go before x.

Instances

CausalOrd (LWW a)

Methods

precedes :: LWW a -> LWW a -> Bool

Eq a => CausalOrd (TwoPSet a)

Methods

precedes :: TwoPSet a -> TwoPSet a -> Bool

CausalOrd (RGA a)

Methods

precedes :: RGA a -> RGA a -> Bool

CausalOrd (ORSet a)

Methods

precedes :: ORSet a -> ORSet a -> Bool

CausalOrd (GSet a)

Methods

precedes :: GSet a -> GSet a -> Bool

CausalOrd (Counter a)

Empty order, allowing arbitrary reordering

Methods

precedes :: Counter a -> Counter a -> Bool

class (CausalOrd op, Eq (Payload op)) => CmRDT op where

Operation-based, or commutative (Cm) replicated data type.

Implementation

In Haskell, a CmRDT implementation consists of 3 types — a payload, an operation (op) and an intent.

Payload

Internal state of a replica.

Intent

User's request to update.

Operation (Op)

Operation to be applied to other replicas.

For many types operation and intent may be the same. But for LWW, for instance, this rule doesn't hold: user can request only value, and type attaches a timestamp to it.

Additional constraint — commutativity law

Concurrent updates are observed equally.

∀ op1 op2 .
concurrent op1 op2 ==> apply op1 . apply op2 == apply op2 . apply op1

Idempotency doesn't need to hold.

Minimal complete definition

initial, apply

Associated Types

type Intent op

type Payload op

Methods

initial :: Payload op

makeOp :: Clock m => Intent op -> Payload op -> Maybe (m op)

Generate an update to the local and remote replicas.

Returns Nothing if the intended operation is not applicable.

makeOp :: (Intent op ~ op, Applicative m) => Intent op -> Payload op -> Maybe (m op)

Generate an update to the local and remote replicas.

Returns Nothing if the intended operation is not applicable.

apply :: op -> Payload op -> Payload op

Apply an update to the payload (downstream). An invalid update must be ignored.

TODO(Syrovetsky, 2017-12-05) There is no downstream precondition yet. We must make a test for it first.

Instances

Eq a => CmRDT (LWW a)

Associated Types

type Intent (LWW a) :: *

type Payload (LWW a) :: *

Methods

initial :: Payload (LWW a)

makeOp :: Clock m => Intent (LWW a) -> Payload (LWW a) -> Maybe (m (LWW a))

apply :: LWW a -> Payload (LWW a) -> Payload (LWW a)

Ord a => CmRDT (TwoPSet a)

Associated Types

type Intent (TwoPSet a) :: *

type Payload (TwoPSet a) :: *

Methods

initial :: Payload (TwoPSet a)

makeOp :: Clock m => Intent (TwoPSet a) -> Payload (TwoPSet a) -> Maybe (m (TwoPSet a))

apply :: TwoPSet a -> Payload (TwoPSet a) -> Payload (TwoPSet a)

(AsEmpty a, Ord a) => CmRDT (RGA a)

Associated Types

type Intent (RGA a) :: *

type Payload (RGA a) :: *

Methods

initial :: Payload (RGA a)

makeOp :: Clock m => Intent (RGA a) -> Payload (RGA a) -> Maybe (m (RGA a))

apply :: RGA a -> Payload (RGA a) -> Payload (RGA a)

Ord a => CmRDT (ORSet a)

Associated Types

type Intent (ORSet a) :: *

type Payload (ORSet a) :: *

Methods

initial :: Payload (ORSet a)

makeOp :: Clock m => Intent (ORSet a) -> Payload (ORSet a) -> Maybe (m (ORSet a))

apply :: ORSet a -> Payload (ORSet a) -> Payload (ORSet a)

Ord a => CmRDT (GSet a)

Associated Types

type Intent (GSet a) :: *

type Payload (GSet a) :: *

Methods

initial :: Payload (GSet a)

makeOp :: Clock m => Intent (GSet a) -> Payload (GSet a) -> Maybe (m (GSet a))

apply :: GSet a -> Payload (GSet a) -> Payload (GSet a)

(Num a, Eq a) => CmRDT (Counter a)

Associated Types

type Intent (Counter a) :: *

type Payload (Counter a) :: *

Methods

initial :: Payload (Counter a)

makeOp :: Clock m => Intent (Counter a) -> Payload (Counter a) -> Maybe (m (Counter a))

apply :: Counter a -> Payload (Counter a) -> Payload (Counter a)

concurrent :: CausalOrd a => a -> a -> Bool

Not comparable, i. e. ¬(a ≤ b) ∧ ¬(b ≤ a).

query :: forall op f. (CmRDT op, Foldable f) => f op -> Payload op

makeAndApplyOp :: (CmRDT op, Clock m, MonadFail m, MonadState (Payload op) m) => Intent op -> m op

Make op and apply it to the payload -- a common routine at the source node.

makeAndApplyOps :: (CmRDT op, Clock m, MonadFail m, MonadState (Payload op) m, Traversable f) => f (Intent op) -> m (f op)