Skip to main content

qualia_core_db/poet_host/
values.rs

1//! Value ↔ Quin conversions. Host seals parity; scripts never write it.
2
3use crate::lexicon::generate_60bit_token;
4use crate::NQuin;
5use vibe::Value;
6
7const RDF_REIFIES: &[u8] = b"http://www.w3.org/1999/02/22-rdf-syntax-ns#reifies";
8
9/// q_hash of a Vibe `Value`, or `None` when unhashable.
10pub(crate) fn hash_val(v: &Value) -> Option<u64> {
11    match v {
12        Value::U64(n) => Some(*n),
13        Value::I64(n) => Some(*n as u64),
14        Value::Iri(s) | Value::String(s) => Some(generate_60bit_token(s.as_bytes())),
15        Value::Prefixed(p, l) => Some(generate_60bit_token(format!("{p}:{l}").as_bytes())),
16        Value::QuinRef(qr) => Some(qr.raw_fields()[0]),
17        _ => None,
18    }
19}
20
21/// Converts a `Value` term to an `NQuin` in `context`.
22pub(crate) fn value_to_quin(term: &Value, context: u64) -> Option<NQuin> {
23    match term {
24        Value::QuinRef(qr) => {
25            let [subject, predicate, object, ctx, metadata, _parity] = qr.raw_fields();
26            let parity = NQuin::calculate_parity(subject, predicate, object, ctx, metadata);
27            Some(NQuin {
28                subject,
29                predicate,
30                object,
31                context: ctx,
32                metadata,
33                parity,
34            })
35        }
36        Value::Triple(s, p, o) => {
37            let subject = hash_val(s)?;
38            let predicate = hash_val(p)?;
39            let object = hash_val(o)?;
40            let metadata = 0;
41            let parity = NQuin::calculate_parity(subject, predicate, object, context, metadata);
42            Some(NQuin {
43                subject,
44                predicate,
45                object,
46                context,
47                metadata,
48                parity,
49            })
50        }
51        Value::Reified { s, p, o, .. } => {
52            value_to_quin(&Value::Triple(s.clone(), p.clone(), o.clone()), context)
53        }
54        _ => None,
55    }
56}
57
58/// Builds a reifier quin for `term`.
59pub(crate) fn reifier_quin(term: &Value, context: u64) -> Option<NQuin> {
60    let Value::Reified { s, p, o, r } = term else {
61        return None;
62    };
63    let subject = hash_val(r)?;
64    let predicate = generate_60bit_token(RDF_REIFIES);
65    let object = hash_val(s)? ^ hash_val(p)? ^ hash_val(o)?;
66    let metadata = 0;
67    let parity = NQuin::calculate_parity(subject, predicate, object, context, metadata);
68    Some(NQuin {
69        subject,
70        predicate,
71        object,
72        context,
73        metadata,
74        parity,
75    })
76}
77
78/// Local name of a shape `Value`.
79pub(crate) fn shape_local_name(shape: &Value) -> String {
80    match shape {
81        Value::Prefixed(_, local) => local.clone(),
82        Value::Iri(s) | Value::String(s) => {
83            s.rsplit(['#', '/', ':']).next().unwrap_or(s).to_string()
84        }
85        _ => String::new(),
86    }
87}
88
89/// Renders a `Value` to a display string.
90pub fn format_value(v: &Value) -> String {
91    match v {
92        Value::Null => "null".into(),
93        Value::Bool(b) => b.to_string(),
94        Value::I64(n) => n.to_string(),
95        Value::U64(n) => n.to_string(),
96        Value::F64(n) => n.to_string(),
97        Value::String(s) => format!("\"{s}\""),
98        Value::Iri(s) => format!("<{s}>"),
99        Value::Ok(inner) => format!("Ok({})", format_value(inner)),
100        Value::Err(inner) => format!("Err({})", format_value(inner)),
101        Value::Receipt => "Receipt".into(),
102        Value::List(xs) => {
103            let parts: Vec<String> = xs.iter().map(format_value).collect();
104            format!("[{}]", parts.join(", "))
105        }
106        Value::Record(map) => {
107            let parts: Vec<String> = map
108                .iter()
109                .map(|(k, v)| format!("{k}: {}", format_value(v)))
110                .collect();
111            format!("{{{}}}", parts.join(", "))
112        }
113        Value::QuinRef(qr) => {
114            let f = qr.raw_fields();
115            format!(
116                "Quin(s={:#x},p={:#x},o={:#x},c={:#x})",
117                f[0], f[1], f[2], f[3]
118            )
119        }
120        Value::Triple(s, p, o) => format!(
121            "<<( {} {} {} )>>",
122            format_value(s),
123            format_value(p),
124            format_value(o)
125        ),
126        other => format!("{other:?}"),
127    }
128}