Struct Sha256Hasher 

pub struct Sha256Hasher { /* private fields */ }

The admissible σ-axes (re-exports of prism’s hashers). Every realization binds Sha256Hasher by default and admits the others via its address_<algorithm> entry points. Sha512Hasher is a Hasher<64> (bound with AddrBounds64); the rest are Hasher<32>. FIPS-180-4 SHA-256 hasher. 32-byte digest.

Trait Implementations

impl AddrHash for Sha256Hasher

const LABEL_PREFIX: &'static str = "sha256"

The lowercase algorithm token at the head of the κ-label.

const OUTPUT_BYTES: usize = 32

The σ-axis digest width in bytes (Hasher::OUTPUT_BYTES).

fn digest_carrier<const N: usize>(input: &TermValue<'_, N>) -> [u8; 64]

Fold the (streamed) canonical carrier through this σ-axis, returning the digest in a MAX_DIGEST_BYTES buffer (first OUTPUT_BYTES significant; the rest zero). Bounded resident memory — never materializes the carrier.

const LABEL_BYTES: usize = _

Total κ-label ASCII width = LABEL_PREFIX.len() + 1 + 2 × OUTPUT_BYTES. The realization’s output shape declares exactly this many Site constraints, and the entry point returns KappaLabel<{LABEL_BYTES}>.

impl<const INLINE_BYTES: usize, const FP_MAX: usize> AxisExtension<INLINE_BYTES, FP_MAX> for Sha256Hasher

const AXIS_ADDRESS: &'static str = <Sha256Hasher as HashAxis>::AXIS_ADDRESS

ADR-017 content address of this axis trait. The SDK macro derives this from the trait name and method signatures.

const MAX_OUTPUT_BYTES: usize = <Sha256Hasher as HashAxis>::MAX_OUTPUT_BYTES

Maximum bytes any kernel of this axis returns.

fn dispatch_kernel( kernel_id: u32, input: &[u8], out: &mut [u8], ) -> Result<usize, ShapeViolation>

Dispatch the kernel identified by kernel_id against the evaluated input bytes. The implementation copies the kernel’s output into out and returns the written length.

impl Clone for Sha256Hasher

fn clone(&self) -> Sha256Hasher

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Sha256Hasher

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

Formats the value using the given formatter.

impl Default for Sha256Hasher

fn default() -> Sha256Hasher

Returns the “default value” for a type.

impl HashAxis for Sha256Hasher

const AXIS_ADDRESS: &'static str = "https://uor.foundation/axis/HashAxis/Sha256"

const MAX_OUTPUT_BYTES: usize = SHA256_BYTES

fn hash(input: &[u8], out: &mut [u8]) -> Result<usize, ShapeViolation>

Compute the digest of input into out[..n], returning n.

impl Hasher for Sha256Hasher

const OUTPUT_BYTES: usize = SHA256_BYTES

Active output width in bytes. Must lie within the bounds the application’s selected HostBounds declares — [<B as HostBounds>::FINGERPRINT_MIN_BYTES, FP_MAX].

fn initial() -> Sha256Hasher

Initial hasher state.

fn fold_byte(self, b: u8) -> Sha256Hasher

Fold a single byte into the running state.

fn fold_bytes(self, bytes: &[u8]) -> Sha256Hasher

Fold a slice of bytes (default impl: byte-by-byte).

fn finalize(self) -> [u8; 32]

Finalize into the canonical max-width buffer of FP_MAX bytes. Bytes 0..OUTPUT_BYTES carry the hash result; bytes OUTPUT_BYTES..FP_MAX MUST be zero.

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Sha256Hasher>> for AddressModel

type Input = Asn1Carrier<'a>

Input feature type — a ConstrainedTypeShape impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by IntoBindingValue<'a> so run_route can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = AddressLabelSha256

Output label type — a ConstrainedTypeShape impl declared in foundation vocabulary that is also a crate::enforcement::GroundedShape.

type Route = AddressRoute

Type-level witness of the term tree mapping Input to Output. Bound by FoundationClosed: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into run_route’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Sha256Hasher>> for AddressModel

type Input = CborCarrier<'a>

Input feature type — a ConstrainedTypeShape impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by IntoBindingValue<'a> so run_route can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = AddressLabelSha256

Output label type — a ConstrainedTypeShape impl declared in foundation vocabulary that is also a crate::enforcement::GroundedShape.

type Route = AddressRoute

Type-level witness of the term tree mapping Input to Output. Bound by FoundationClosed: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into run_route’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Sha256Hasher>> for AddressModel

type Input = CodeModuleCarrier<'a>

Input feature type — a ConstrainedTypeShape impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by IntoBindingValue<'a> so run_route can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = AddressLabelSha256

Output label type — a ConstrainedTypeShape impl declared in foundation vocabulary that is also a crate::enforcement::GroundedShape.

type Route = AddressRoute

Type-level witness of the term tree mapping Input to Output. Bound by FoundationClosed: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into run_route’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Sha256Hasher>> for AddressModel

type Input = GgufCarrier<'a>

Input feature type — a ConstrainedTypeShape impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by IntoBindingValue<'a> so run_route can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = AddressLabelSha256

Output label type — a ConstrainedTypeShape impl declared in foundation vocabulary that is also a crate::enforcement::GroundedShape.

type Route = AddressRoute

Type-level witness of the term tree mapping Input to Output. Bound by FoundationClosed: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into run_route’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Sha256Hasher>> for AddressModel

type Input = JsonCarrier<'a>

Input feature type — a ConstrainedTypeShape impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by IntoBindingValue<'a> so run_route can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = AddressLabelSha256

Output label type — a ConstrainedTypeShape impl declared in foundation vocabulary that is also a crate::enforcement::GroundedShape.

type Route = AddressRoute

Type-level witness of the term tree mapping Input to Output. Bound by FoundationClosed: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into run_route’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Sha256Hasher>> for AddressModel

type Input = OnnxCarrier<'a>

Input feature type — a ConstrainedTypeShape impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by IntoBindingValue<'a> so run_route can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = AddressLabelSha256

Output label type — a ConstrainedTypeShape impl declared in foundation vocabulary that is also a crate::enforcement::GroundedShape.

type Route = AddressRoute

Type-level witness of the term tree mapping Input to Output. Bound by FoundationClosed: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into run_route’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Sha256Hasher>> for AddressModel

type Input = RingElement

Input feature type — a ConstrainedTypeShape impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by IntoBindingValue<'a> so run_route can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = AddressLabelSha256

Output label type — a ConstrainedTypeShape impl declared in foundation vocabulary that is also a crate::enforcement::GroundedShape.

type Route = AddressRoute

Type-level witness of the term tree mapping Input to Output. Bound by FoundationClosed: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into run_route’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Sha256Hasher>> for AddressModel

type Input = SExprValue<'a>

Input feature type — a ConstrainedTypeShape impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by IntoBindingValue<'a> so run_route can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = AddressLabelSha256

Output label type — a ConstrainedTypeShape impl declared in foundation vocabulary that is also a crate::enforcement::GroundedShape.

type Route = AddressRoute

Type-level witness of the term tree mapping Input to Output. Bound by FoundationClosed: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into run_route’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Sha256Hasher>> for AddressModel

type Input = XmlValue<'a>

Input feature type — a ConstrainedTypeShape impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by IntoBindingValue<'a> so run_route can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = AddressLabelSha256

Output label type — a ConstrainedTypeShape impl declared in foundation vocabulary that is also a crate::enforcement::GroundedShape.

type Route = AddressRoute

Type-level witness of the term tree mapping Input to Output. Bound by FoundationClosed: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into run_route’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Sha256Hasher>> for CompositionModelE6Sha256

type Input = E6Carrier<'a>

Input feature type — a ConstrainedTypeShape impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by IntoBindingValue<'a> so run_route can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = CompositionLabelE6Sha256

Output label type — a ConstrainedTypeShape impl declared in foundation vocabulary that is also a crate::enforcement::GroundedShape.

type Route = CompositionRouteE6Sha256

Type-level witness of the term tree mapping Input to Output. Bound by FoundationClosed: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into run_route’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Sha256Hasher>> for CompositionModelE7Sha256

type Input = E7Carrier<'a>

Input feature type — a ConstrainedTypeShape impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by IntoBindingValue<'a> so run_route can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = CompositionLabelE7Sha256

Output label type — a ConstrainedTypeShape impl declared in foundation vocabulary that is also a crate::enforcement::GroundedShape.

type Route = CompositionRouteE7Sha256

Type-level witness of the term tree mapping Input to Output. Bound by FoundationClosed: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into run_route’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Sha256Hasher>> for CompositionModelE8Sha256

type Input = E8Carrier<'a>

Input feature type — a ConstrainedTypeShape impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by IntoBindingValue<'a> so run_route can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = CompositionLabelE8Sha256

Output label type — a ConstrainedTypeShape impl declared in foundation vocabulary that is also a crate::enforcement::GroundedShape.

type Route = CompositionRouteE8Sha256

Type-level witness of the term tree mapping Input to Output. Bound by FoundationClosed: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into run_route’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Sha256Hasher>> for CompositionModelF4Sha256

type Input = F4Carrier<'a>

Input feature type — a ConstrainedTypeShape impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by IntoBindingValue<'a> so run_route can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = CompositionLabelF4Sha256

Output label type — a ConstrainedTypeShape impl declared in foundation vocabulary that is also a crate::enforcement::GroundedShape.

type Route = CompositionRouteF4Sha256

Type-level witness of the term tree mapping Input to Output. Bound by FoundationClosed: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into run_route’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Sha256Hasher>> for CompositionModelG2Sha256

type Input = G2Carrier<'a>

Input feature type — a ConstrainedTypeShape impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by IntoBindingValue<'a> so run_route can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = CompositionLabelG2Sha256

Output label type — a ConstrainedTypeShape impl declared in foundation vocabulary that is also a crate::enforcement::GroundedShape.

type Route = CompositionRouteG2Sha256

Type-level witness of the term tree mapping Input to Output. Bound by FoundationClosed: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into run_route’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, prism_model! { pub struct AddressSignedModel; pub struct AddressSignedRoute; impl PrismModel< DefaultHostTypes, AddrBounds, Sha256Hasher, AddressResolverTuple<Sha256Hasher>, SignedCommitment > for AddressSignedModel { type Input = JsonCarrier<'a>; type Output = AddressLabel; type Route = AddressSignedRoute; fn route(input: Self::Input) -> Self::Output { address_inference(input) } fn commitment() -> SignedCommitment { SIGNED_COMMITMENT_INSTANCE } } }, prism_model! { pub struct AddressSignedModel; pub struct AddressSignedRoute; impl PrismModel< DefaultHostTypes, AddrBounds, Sha256Hasher, AddressResolverTuple<Sha256Hasher>, SignedCommitment > for AddressSignedModel { type Input = JsonCarrier<'a>; type Output = AddressLabel; type Route = AddressSignedRoute; fn route(input: Self::Input) -> Self::Output { address_inference(input) } fn commitment() -> SignedCommitment { SIGNED_COMMITMENT_INSTANCE } } }, AddressResolverTuple<Sha256Hasher>, SingletonCommitment<UltrametricCloseTo<2>>> for AddressSignedModel

type Input = JsonCarrier<'a>

Input feature type — a ConstrainedTypeShape impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by IntoBindingValue<'a> so run_route can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = AddressLabelSha256

Output label type — a ConstrainedTypeShape impl declared in foundation vocabulary that is also a crate::enforcement::GroundedShape.

type Route = AddressSignedRoute

Type-level witness of the term tree mapping Input to Output. Bound by FoundationClosed: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, SignedCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, SignedCommitment>>::Output, { _ }, { <AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into run_route’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, prism_model! { pub struct AddressStorageModel; pub struct AddressStorageRoute; impl PrismModel< DefaultHostTypes, AddrBounds, Sha256Hasher, AddressResolverTuple<Sha256Hasher>, StorageCommitment > for AddressStorageModel { type Input = JsonCarrier<'a>; type Output = AddressLabel; type Route = AddressStorageRoute; fn route(input: Self::Input) -> Self::Output { address_inference(input) } fn commitment() -> StorageCommitment { STORAGE_COMMITMENT_INSTANCE } } }, prism_model! { pub struct AddressStorageModel; pub struct AddressStorageRoute; impl PrismModel< DefaultHostTypes, AddrBounds, Sha256Hasher, AddressResolverTuple<Sha256Hasher>, StorageCommitment > for AddressStorageModel { type Input = JsonCarrier<'a>; type Output = AddressLabel; type Route = AddressStorageRoute; fn route(input: Self::Input) -> Self::Output { address_inference(input) } fn commitment() -> StorageCommitment { STORAGE_COMMITMENT_INSTANCE } } }, AddressResolverTuple<Sha256Hasher>, AndCommitment<EmptyCommitment, SingletonCommitment<LexicographicLessEqThreshold>>> for AddressStorageModel

type Input = JsonCarrier<'a>

Input feature type — a ConstrainedTypeShape impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by IntoBindingValue<'a> so run_route can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = AddressLabelSha256

Output label type — a ConstrainedTypeShape impl declared in foundation vocabulary that is also a crate::enforcement::GroundedShape.

type Route = AddressStorageRoute

Type-level witness of the term tree mapping Input to Output. Bound by FoundationClosed: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, StorageCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha256Hasher, { _ }, { <AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha256Hasher>, StorageCommitment>>::Output, { _ }, { <AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into run_route’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<const INLINE_BYTES: usize> SubstrateTermBody<INLINE_BYTES> for Sha256Hasher

fn body_arena() -> &'static [Term<'static, INLINE_BYTES>]

The Term arena the kernel decomposes to. Empty slice signals a primitive-fast-path axis whose body the implementation may evaluate through dispatch_kernel directly per ADR-055’s optional fast-path.