Struct GroundingProgram 

pub struct GroundingProgram<Out, Map>
where
    Map: GroundingMapKind,
{ /* private fields */ }

v0.2.2 Phase J: sealed grounding program. A composition of combinators with a statically tracked marker tuple. Constructed only via GroundingProgram::from_primitive, which requires via the MarkersImpliedBy<Map> trait bound that the primitive’s marker tuple carries every property declared by Map: GroundingMapKind.

Implementations

impl<Out, Map> GroundingProgram<Out, Map>

where Map: GroundingMapKind,

pub fn from_primitive<Markers>( primitive: GroundingPrimitive<Out, Markers>, ) -> GroundingProgram<Out, Map>

where Markers: MarkerTuple + MarkersImpliedBy<Map>,

Foundation-verified constructor. Accepts a primitive whose marker tuple satisfies MarkersImpliedBy<Map>. Programs built from combinators whose marker tuple lacks a property Map requires are rejected at compile time — this is Phase J’s marquee correctness claim: misdeclarations fail to compile.

Example: valid program

use uor_foundation::enforcement::{GroundingProgram, IntegerGroundingMap, combinators};
let prog: GroundingProgram<u64, IntegerGroundingMap> =
    GroundingProgram::from_primitive(combinators::interpret_le_integer::<u64>());
let _ = prog;

Example: rejected misdeclaration

use uor_foundation::enforcement::{GroundingProgram, IntegerGroundingMap, combinators};
// digest returns (TotalMarker,) which does NOT satisfy
// MarkersImpliedBy<IntegerGroundingMap> — the line below fails to compile.
let prog: GroundingProgram<[u8; 32], IntegerGroundingMap> =
    GroundingProgram::from_primitive(combinators::digest::<[u8; 32]>());
let _ = prog;

pub const fn primitive(&self) -> &GroundingPrimitive<Out>

Access the underlying primitive (erased marker tuple).

impl<Map> GroundingProgram<GroundedCoord, Map>

where Map: GroundingMapKind,

Phase K (target §4.3 / §9 criterion 1): foundation-supplied interpreter for grounding programs whose Out is GroundedCoord. Handles every op in the closed 12-combinator catalogue: leaf ops (ReadBytes, InterpretLeInteger, InterpretBeInteger, Digest, DecodeUtf8, DecodeJson, ConstValue, SelectField, SelectIndex) call interpret_leaf_op directly; composition ops (Then, AndThen, MapErr) walk the chain recorded in the primitive and thread external through each leaf step. The interpreter surfaces GroundedCoord::w8(byte) values; richer outputs compose through combinator chains producing GroundedTuple<N>. No ground() override exists after W4 closure — downstream provides only program(), and GroundingExt::ground is foundation-authored.

pub fn run(&self, external: &[u8]) -> Option<GroundedCoord>

Run this program on external bytes, producing a GroundedCoord. Returns None if the input is malformed/undersized for the program’s op chain.

impl<const N: usize, Map> GroundingProgram<GroundedTuple<N>, Map>

where Map: GroundingMapKind,

W4 closure (target §4.3 + §9 criterion 1): foundation-supplied interpreter for programs producing GroundedTuple<N>. Splits external into N equal windows and runs the same dispatch that GroundingProgram<GroundedCoord, Map>::run performs on each window. Returns None if N == 0, the input is empty, the input length isn’t divisible by N, or any window fails.

pub fn run(&self, external: &[u8]) -> Option<GroundedTuple<N>>

Run this program on external bytes, producing a GroundedTuple<N>.

Trait Implementations

impl<Out, Map> Clone for GroundingProgram<Out, Map>

where Out: Clone, Map: Clone + GroundingMapKind,

fn clone(&self) -> GroundingProgram<Out, Map>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Out, Map> Debug for GroundingProgram<Out, Map>

where Out: Debug, Map: Debug + GroundingMapKind,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<Map> GroundingProgramRun<GroundedCoord> for GroundingProgram<GroundedCoord, Map>

where Map: GroundingMapKind,

fn run_program(&self, external: &[u8]) -> Option<GroundedCoord>

Run the program on external bytes.

impl<const N: usize, Map> GroundingProgramRun<GroundedTuple<N>> for GroundingProgram<GroundedTuple<N>, Map>

where Map: GroundingMapKind,

fn run_program(&self, external: &[u8]) -> Option<GroundedTuple<N>>

Run the program on external bytes.

impl<Out, Map> Hash for GroundingProgram<Out, Map>

where Out: Hash, Map: Hash + GroundingMapKind,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<Out, Map> PartialEq for GroundingProgram<Out, Map>

where Out: PartialEq, Map: PartialEq + GroundingMapKind,

fn eq(&self, other: &GroundingProgram<Out, Map>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Out, Map> Copy for GroundingProgram<Out, Map>

where Out: Copy, Map: Copy + GroundingMapKind,

impl<Out, Map> Eq for GroundingProgram<Out, Map>

where Out: Eq, Map: Eq + GroundingMapKind,

impl<Out, Map> StructuralPartialEq for GroundingProgram<Out, Map>

where Map: GroundingMapKind,