hyf

commit f6b0a5046e32ed5be9f201ba2283add5020a6360
parent 7b576ca84ff92bd65df1434ff5b3fc8912478985
Author: triesap <tyson@radroots.org>
Date:   Mon, 21 Sep 2026 12:54:36 +0000

core: add known and unresolved field alternatives

Diffstat:
A
src/hyf_core/domain/field.mojo
 | 
60
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
M
tests/test_domain.mojo
 | 
26
++++++++++++++++++++++++++

2 files changed, 86 insertions(+), 0 deletions(-)
diff --git a/src/hyf_core/domain/field.mojo b/src/hyf_core/domain/field.mojo
@@ -0,0 +1,60 @@
+from std.collections import Optional
+
+
+@fieldwise_init
+struct DecodedField(Copyable, Movable):
+    var state: String
+    var value: Optional[String]
+    var qualifier: String
+    var method: String
+
+
+def known_field(value: String, method: String) raises -> DecodedField:
+    if method.strip() == "":
+        raise Error("field method must not be empty")
+    return DecodedField(
+        state="known",
+        value=Optional[String](String(value)),
+        qualifier="exact",
+        method=String(method),
+    )
+
+
+def known_approximate_field(value: String, method: String) raises -> DecodedField:
+    var field = known_field(value, method)
+    field.qualifier = "approximate"
+    return field^
+
+
+def unresolved_field(method: String) raises -> DecodedField:
+    if method.strip() == "":
+        raise Error("field method must not be empty")
+    return DecodedField(
+        state="unresolved",
+        value=None,
+        qualifier="unknown",
+        method=String(method),
+    )
+
+
+def field_is_known(field: DecodedField) -> Bool:
+    if field.state != "known":
+        return False
+    if not field.value:
+        return False
+    return True
+
+
+def field_known_or(field: DecodedField, fallback: String) -> String:
+    if field_is_known(field):
+        return field.value.value()
+    return String(fallback)
+
+
+def validate_field_consistency(field: DecodedField) raises:
+    if field.state == "known" and not field.value:
+        raise Error("known field must carry a value")
+    if field.state == "unresolved" and field.value:
+        raise Error("unresolved field must not carry a value")
+    if field.state != "known" and field.state != "unresolved":
+        raise Error("field state must be 'known' or 'unresolved'")
diff --git a/tests/test_domain.mojo b/tests/test_domain.mojo
@@ -73,3 +73,29 @@ def test_evidence_rejects_out_of_range_and_revision_mismatch() raises:
     var field = record_field_evidence("s1", "r1", "lot-1", "unreserved_quantity")
     assert_equal(field.kind, "record_field")
     assert_equal(field.record_id.value(), "lot-1")
+
+
+from hyf_core.domain.field import (
+    DecodedField,
+    field_is_known,
+    field_known_or,
+    known_approximate_field,
+    known_field,
+    unresolved_field,
+    validate_field_consistency,
+)
+
+
+def test_field_known_zero_distinct_from_unknown_and_false() raises:
+    var zero = known_field("0", "span")
+    assert_true(field_is_known(zero))
+    assert_equal(field_known_or(zero, "?"), "0")
+    var false_value = known_field("false", "model")
+    assert_true(field_is_known(false_value))
+    var unknown = unresolved_field("span")
+    assert_true(not field_is_known(unknown))
+    assert_equal(field_known_or(unknown, "?"), "?")
+    validate_field_consistency(zero)
+    validate_field_consistency(unknown)
+    var approximate = known_approximate_field("80", "span")
+    assert_equal(approximate.qualifier, "approximate")