Struct AddrBounds 

pub struct AddrBounds;

The shared capacity profile. Every realization’s PrismModel binds this B.

Trait Implementations

impl Clone for AddrBounds

fn clone(&self) -> AddrBounds

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AddrBounds

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

Formats the value using the given formatter.

impl Default for AddrBounds

fn default() -> AddrBounds

Returns the “default value” for a type.

impl Hash for AddrBounds

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

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 HostBounds for AddrBounds

const FINGERPRINT_MIN_BYTES: usize = 32

Minimum content-fingerprint width in bytes that the application’s selected Hasher impl MUST produce. Derived from the application’s collision-probability target (16 bytes ≈ 2^-64 under the birthday bound; raise to 32 to reach 2^-128).

const FINGERPRINT_MAX_BYTES: usize = 32

Maximum content-fingerprint width in bytes — the inline buffer capacity carried by every ContentFingerprint. The application’s selected Hasher MUST produce output no wider than this.

const TRACE_MAX_EVENTS: usize = 256

Maximum number of TraceEvent values a Trace may carry. Bounds the inline event buffer and caps verification time.

const WITT_LEVEL_MAX_BITS: u32 = 32

Algebraic-level bit-width ceiling. Caps the Witt-level any value along the principal data path may compute against. A value of 64 corresponds to WittLevel::W64.

const FOLD_UNROLL_THRESHOLD: usize = 8

ADR-037: threshold below which fold_n(n, init, step) lowers to an unrolled Term::Application chain (one application per iteration). Counts n >= FOLD_UNROLL_THRESHOLD lower to Term::Recurse instead.

const BETTI_DIMENSION_MAX: usize = 74

ADR-037: maximum dimension index for BettiNumbers arrays — β_k(K) is stored for k in 0..BETTI_DIMENSION_MAX.

const NERVE_CONSTRAINTS_MAX: usize = 128

ADR-037: maximum number of constraints in a single constraint nerve’s array representation.

const NERVE_SITES_MAX: usize = 74

ADR-037: maximum number of sites in a single constraint nerve’s array representation.

const JACOBIAN_SITES_MAX: usize = 74

ADR-037: maximum number of sites for which a Jacobian matrix can be stored inline.

const RECURSION_TRACE_DEPTH_MAX: usize = 16

ADR-037: maximum recursion depth for the trace-replay stack.

const OP_CHAIN_DEPTH_MAX: usize = 8

ADR-037: maximum operator-chain depth in a single operation.

const AFFINE_COEFFS_MAX: usize = 80

ADR-037: maximum number of affine coefficients per ConstraintRef::Affine.

const CONJUNCTION_TERMS_MAX: usize = 128

ADR-037: maximum number of conjuncts per ConstraintRef::Conjunction.

const UNFOLD_ITERATIONS_MAX: usize = 256

ADR-037: maximum iteration count for Term::Unfold evaluation.

impl PartialEq for AddrBounds

fn eq(&self, other: &AddrBounds) -> 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<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Blake3Hasher, 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<Blake3Hasher>> for AddressModelBlake3

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 = AddressLabelBlake3

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

type Route = AddressRouteBlake3

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, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, 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, Blake3Hasher, 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<Blake3Hasher>> for AddressModelBlake3

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 = AddressLabelBlake3

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

type Route = AddressRouteBlake3

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, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, 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, Blake3Hasher, 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<Blake3Hasher>> for AddressModelBlake3

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 = AddressLabelBlake3

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

type Route = AddressRouteBlake3

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, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, 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, Blake3Hasher, 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<Blake3Hasher>> for AddressModelBlake3

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 = AddressLabelBlake3

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

type Route = AddressRouteBlake3

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, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, 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, Blake3Hasher, 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<Blake3Hasher>> for AddressModelBlake3

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 = AddressLabelBlake3

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

type Route = AddressRouteBlake3

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, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, 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, Blake3Hasher, 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<Blake3Hasher>> for AddressModelBlake3

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 = AddressLabelBlake3

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

type Route = AddressRouteBlake3

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, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, 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, Blake3Hasher, 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<Blake3Hasher>> for AddressModelBlake3

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 = AddressLabelBlake3

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

type Route = AddressRouteBlake3

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, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, 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, Blake3Hasher, 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<Blake3Hasher>> for AddressModelBlake3

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 = AddressLabelBlake3

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

type Route = AddressRouteBlake3

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, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, 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, Blake3Hasher, 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<Blake3Hasher>> for AddressModelBlake3

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 = AddressLabelBlake3

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

type Route = AddressRouteBlake3

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, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, 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, Blake3Hasher, 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<Blake3Hasher>> for CompositionModelE6Blake3

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 = CompositionLabelE6Blake3

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

type Route = CompositionRouteE6Blake3

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, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, 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, Blake3Hasher, 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<Blake3Hasher>> for CompositionModelE7Blake3

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 = CompositionLabelE7Blake3

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

type Route = CompositionRouteE7Blake3

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, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, 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, Blake3Hasher, 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<Blake3Hasher>> for CompositionModelE8Blake3

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 = CompositionLabelE8Blake3

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

type Route = CompositionRouteE8Blake3

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, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, 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, Blake3Hasher, 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<Blake3Hasher>> for CompositionModelF4Blake3

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 = CompositionLabelF4Blake3

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

type Route = CompositionRouteF4Blake3

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, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, 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, Blake3Hasher, 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<Blake3Hasher>> for CompositionModelG2Blake3

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 = CompositionLabelG2Blake3

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

type Route = CompositionRouteG2Blake3

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, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Blake3Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Blake3Hasher>, 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, Keccak256Hasher, 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<Keccak256Hasher>> for AddressModelKeccak256

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 = AddressLabelKeccak256

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

type Route = AddressRouteKeccak256

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, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, 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, Keccak256Hasher, 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<Keccak256Hasher>> for AddressModelKeccak256

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 = AddressLabelKeccak256

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

type Route = AddressRouteKeccak256

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, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, 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, Keccak256Hasher, 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<Keccak256Hasher>> for AddressModelKeccak256

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 = AddressLabelKeccak256

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

type Route = AddressRouteKeccak256

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, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, 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, Keccak256Hasher, 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<Keccak256Hasher>> for AddressModelKeccak256

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 = AddressLabelKeccak256

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

type Route = AddressRouteKeccak256

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, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, 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, Keccak256Hasher, 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<Keccak256Hasher>> for AddressModelKeccak256

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 = AddressLabelKeccak256

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

type Route = AddressRouteKeccak256

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, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, 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, Keccak256Hasher, 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<Keccak256Hasher>> for AddressModelKeccak256

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 = AddressLabelKeccak256

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

type Route = AddressRouteKeccak256

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, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, 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, Keccak256Hasher, 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<Keccak256Hasher>> for AddressModelKeccak256

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 = AddressLabelKeccak256

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

type Route = AddressRouteKeccak256

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, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, 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, Keccak256Hasher, 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<Keccak256Hasher>> for AddressModelKeccak256

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 = AddressLabelKeccak256

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

type Route = AddressRouteKeccak256

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, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, 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, Keccak256Hasher, 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<Keccak256Hasher>> for AddressModelKeccak256

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 = AddressLabelKeccak256

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

type Route = AddressRouteKeccak256

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, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, 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, Keccak256Hasher, 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<Keccak256Hasher>> for CompositionModelE6Keccak256

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 = CompositionLabelE6Keccak256

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

type Route = CompositionRouteE6Keccak256

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, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, 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, Keccak256Hasher, 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<Keccak256Hasher>> for CompositionModelE7Keccak256

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 = CompositionLabelE7Keccak256

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

type Route = CompositionRouteE7Keccak256

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, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, 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, Keccak256Hasher, 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<Keccak256Hasher>> for CompositionModelE8Keccak256

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 = CompositionLabelE8Keccak256

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

type Route = CompositionRouteE8Keccak256

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, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, 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, Keccak256Hasher, 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<Keccak256Hasher>> for CompositionModelF4Keccak256

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 = CompositionLabelF4Keccak256

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

type Route = CompositionRouteF4Keccak256

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, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, 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, Keccak256Hasher, 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<Keccak256Hasher>> for CompositionModelG2Keccak256

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 = CompositionLabelG2Keccak256

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

type Route = CompositionRouteG2Keccak256

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, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, 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 = 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<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Sha3_256Hasher, 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<Sha3_256Hasher>> for AddressModelSha3_256

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 = AddressLabelSha3_256

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

type Route = AddressRouteSha3_256

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, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, 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, Sha3_256Hasher, 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<Sha3_256Hasher>> for AddressModelSha3_256

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 = AddressLabelSha3_256

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

type Route = AddressRouteSha3_256

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, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, 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, Sha3_256Hasher, 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<Sha3_256Hasher>> for AddressModelSha3_256

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 = AddressLabelSha3_256

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

type Route = AddressRouteSha3_256

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, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, 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, Sha3_256Hasher, 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<Sha3_256Hasher>> for AddressModelSha3_256

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 = AddressLabelSha3_256

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

type Route = AddressRouteSha3_256

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, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, 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, Sha3_256Hasher, 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<Sha3_256Hasher>> for AddressModelSha3_256

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 = AddressLabelSha3_256

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

type Route = AddressRouteSha3_256

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, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, 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, Sha3_256Hasher, 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<Sha3_256Hasher>> for AddressModelSha3_256

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 = AddressLabelSha3_256

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

type Route = AddressRouteSha3_256

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, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, 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, Sha3_256Hasher, 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<Sha3_256Hasher>> for AddressModelSha3_256

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 = AddressLabelSha3_256

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

type Route = AddressRouteSha3_256

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, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, 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, Sha3_256Hasher, 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<Sha3_256Hasher>> for AddressModelSha3_256

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 = AddressLabelSha3_256

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

type Route = AddressRouteSha3_256

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, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, 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, Sha3_256Hasher, 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<Sha3_256Hasher>> for AddressModelSha3_256

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 = AddressLabelSha3_256

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

type Route = AddressRouteSha3_256

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, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, 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, Sha3_256Hasher, 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<Sha3_256Hasher>> for CompositionModelE6Sha3_256

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 = CompositionLabelE6Sha3_256

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

type Route = CompositionRouteE6Sha3_256

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, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, 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, Sha3_256Hasher, 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<Sha3_256Hasher>> for CompositionModelE7Sha3_256

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 = CompositionLabelE7Sha3_256

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

type Route = CompositionRouteE7Sha3_256

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, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, 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, Sha3_256Hasher, 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<Sha3_256Hasher>> for CompositionModelE8Sha3_256

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 = CompositionLabelE8Sha3_256

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

type Route = CompositionRouteE8Sha3_256

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, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, 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, Sha3_256Hasher, 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<Sha3_256Hasher>> for CompositionModelF4Sha3_256

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 = CompositionLabelF4Sha3_256

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

type Route = CompositionRouteF4Sha3_256

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, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, 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, Sha3_256Hasher, 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<Sha3_256Hasher>> for CompositionModelG2Sha3_256

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 = CompositionLabelG2Sha3_256

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

type Route = CompositionRouteG2Sha3_256

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, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Sha3_256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Sha3_256Hasher>, 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 Copy for AddrBounds

impl Eq for AddrBounds

impl StructuralPartialEq for AddrBounds