Ensuring the value of a register monotonically increases or decreases

[DaveLanday]

I want to keep track of a value that should always increase, decrease, or remain the same when an update is applied or a merge takes place. It represents a best bound on some computation improving or tending toward an optimal value. Instead of re-writing or customizing the way a register CRDT changes its value, I was wondering: can I simply wrap an operation (or an entire register in the case of a CvRDT) in a match expression that handles updating the value of the register only if the value we want to change it to is greater than or equal to (or less than or equal to) the current value in the register?

For example:

use crdts::LWWReg;

fn main() {
    let mut reg = LWWReg { val: 1, marker: 1 };
    let op: (i32, i32) = (2, 2);
    println!("{}", reg.val);

    match reg.val {
        curr_val => {
            if op.0 >= curr_val {
                reg.update(op.0, op.1)
            }
        }
    }
    assert_eq!(reg.marker, 2);
    assert_eq!(reg.val, 2);
    println!("{:?}", reg);
}

This works, but does it still have the guarantees provided by by the LWWReg CRDT?

[davidrusu]

In this case you are not getting anything by wrapping a LWWReg, it's best to write your own CRDT here.

struct MaxReg<T: Ord>(T); // where merge is equivalent to std::cmp::max(...)
struct MinReg<T: Ord>(T); // where merge is equivalent to std::cmp::min(...)

It would make a good addition to the library as it's one of the simplest CRDT's. If you'd like to add this, please send a PR and I can help on the review side.

[DaveLanday]

Might be a novice question, but if we use T: Ord, won't that prevent the use of floats unless a wrapper is built around the float type, or perhaps an additional dependency like float-ord?

[DaveLanday]

Hi @davidrusu , I will create a PR for this today as I have finished the code. For consistent format, I tried to keep MinReg and MaxReg in line with the format of LWWReg so they both have a single field called val. I anticipate that it might be useful to add another field in the future; such as bound, which can bound how small/large the val can decrease/increase for MinReg/MaxReg respectively. Also, for us to use std::cmp::max(...) and std::cmp::min(...) for the update/merge functions we also require the generic type T to implement the Copy trait, otherwise we get an error when trying to move the value from self.val (at least, the way I coded it makes this a requirement). Essentially, your suggestion above simply changes to:

struct MaxReg<T: Ord + Copy>(T); // where merge is equivalent to std::cmp::max(...)
struct MinReg<T: Ord + Copy>(T); // where merge is equivalent to std::cmp::min(...)

[davidrusu]

Ah in that case, lets not use std::cmp::{min|max}, lets simply write if self.val >/< other.val {...} to do the update so that we don't require a Copy constraint.

Might be a novice question, but if we use T: Ord, won't that prevent the use of floats unless a wrapper is built around the float type, or perhaps an additional dependency like float-ord?

yes, floats won't be natively supported, and that's fine. We want to prioritize correctness here and if you need float support there are workarounds as you mentioned.