CAP told you what breaks.
PACELC tells you what you choose every second.

use std::collections::HashMap;

#[derive(Debug, Clone, Copy)]
enum ConsistencyLevel {
    One,    // EL: fastest, least consistent
    Quorum, // balanced: majority must agree
    All,    // EC: slowest, most consistent
}

struct DistributedKV {
    nodes: Vec<HashMap<String, u64>>,
}

impl DistributedKV {
    fn read(&self, key: &str, level: ConsistencyLevel) -> Option<u64> {
        let responses: Vec<Option<u64>> = self
            .nodes
            .iter()
            .map(|node| node.get(key).copied())
            .collect();

        match level {
            // EL: return first available response. Fast, may be stale.
            ConsistencyLevel::One => responses.iter().flatten().next().copied(),

            // Balanced: a majority must agree.
            ConsistencyLevel::Quorum => {
                let quorum = self.nodes.len() / 2 + 1;
                let mut counts: HashMap<u64, usize> = HashMap::new();
                for val in responses.iter().flatten() {
                    *counts.entry(*val).or_insert(0) += 1;
                }
                counts
                    .into_iter()
                    .find(|(_, count)| *count >= quorum)
                    .map(|(val, _)| val)
            }

            // EC: ALL nodes must agree. Slowest, most consistent.
            ConsistencyLevel::All => {
                let values: Vec<u64> = responses.iter().flatten().copied().collect();
                if values.len() == self.nodes.len()
                    && values.windows(2).all(|w| w[0] == w[1])
                {
                    values.first().copied()
                } else {
                    None // nodes disagree: refuse
                }
            }
        }
    }
}

fn main() {
    let db = DistributedKV {
        nodes: vec![
            [("balance".to_string(), 500)].into(),
            [("balance".to_string(), 500)].into(),
            [("balance".to_string(), 495)].into(), // stale
        ],
    };

    println!("{:?}", db.read("balance", ConsistencyLevel::One));    // Some(500)
    println!("{:?}", db.read("balance", ConsistencyLevel::Quorum)); // Some(500)
    println!("{:?}", db.read("balance", ConsistencyLevel::All));    // None
}

#include <stdio.h>
#include <stdint.h>
#include <stddef.h>

typedef enum {
    CONSISTENCY_ONE,    // EL: fastest
    CONSISTENCY_QUORUM, // balanced
    CONSISTENCY_ALL     // EC: most consistent
} ConsistencyLevel;

// Returns -1 if consistency cannot be guaranteed.
int64_t distributed_read(
    const int64_t *node_values, // -1 = unreachable
    size_t node_count,
    ConsistencyLevel level
) {
    size_t quorum = node_count / 2 + 1;
    size_t reachable = 0, agreements = 0;
    int64_t first_value = -1;

    for (size_t i = 0; i < node_count; i++) {
        if (node_values[i] < 0) continue;
        reachable++;
        if (first_value < 0) first_value = node_values[i];
        if (node_values[i] == first_value) agreements++;
    }

    switch (level) {
        case CONSISTENCY_ONE:
            return first_value; // EL: first wins
        case CONSISTENCY_QUORUM:
            return (agreements >= quorum) ? first_value : -1;
        case CONSISTENCY_ALL:
            return (reachable == node_count && agreements == node_count)
                   ? first_value : -1;
    }
    return -1;
}

int main(void) {
    int64_t nodes[] = {500, 500, 495}; // two agree, one stale
    printf("ONE:    %lld\n", distributed_read(nodes, 3, CONSISTENCY_ONE));    // 500
    printf("QUORUM: %lld\n", distributed_read(nodes, 3, CONSISTENCY_QUORUM)); // 500
    printf("ALL:    %lld\n", distributed_read(nodes, 3, CONSISTENCY_ALL));    // -1
    return 0;
}