Module runtime 

Re-exports from the cel-runtime crate for convenient access.

Modules

array

Concrete typed ownership for homogeneous, contiguous arrays. Concrete, contiguous ownership for homogeneous CEL arrays.

c_stack_list

Compile-time stack list implementation for type-safe stack operations. A CStackList is a List with guaranteed memory layout (repr(C)). The tail is stored first, so appending items does not change the memory layout of prior items (though the required alignment may increase). CNil<T> represents the empty list where T is used to hide the tail for std::ops::RangeTo and std::ops::RangeToInclusive indexing.

callable

Signature-typed callable facade over the canonical shared carrier. Calls native and prepared bodies through one statically fixed signature.

dyn_closure

First-class callable CEL values with declared signatures. A first-class, callable CEL value: a compiled body plus its declared signature.

dyn_segment

Dynamic segment implementation with runtime type checking. Builds checked instructions for the canonical raw interpreter.

list_traits

Traits for working with type lists and type information. A collection of traits for homegenous lists (cons cells), similar to tuples.

memory

Memory management and alignment utilities for the runtime.

owned_value

Whole-value ownership with complete checked representation witnesses. Owns an erased whole value together with its frozen ownership descriptor.

prepared_segment

Prepared typed execution over the existing raw interpreter. Executes one construction-validated canonical borrowed frame.

raw_segment

Raw segment implementation without type safety.

raw_sequence

Raw sequence implementation for operation sequences.

raw_stack

Raw stack implementation for low-level stack operations.

raw_vec

Raw vector implementation for dynamic memory allocation.

segment

Type-safe segment implementation with compile-time validation.

tuple_list

Tuple list implementation for type-safe tuple operations. Implements List for tuples where () is an empty list and (H, T) is a list with a head and tail.

value_type

Complete recursive canonical metadata and sealed concrete representation witnesses. Describes complete recursive identities independently of interpreter descriptors.

Structs

Array

Owns homogeneous, contiguous elements without bounds on the element type.

ArrayOf

Names a homogeneous array whose elements use witness E.

AssociatedType

Associates a source-ordered tuple field with its canonical physical offset.

CNil

Empty repr(C) list used as the tail sentinel for CStackList.

CStackList

A list using a guaranteed memory layout (repr(C)), with tail stored first so appending items does not change the memory layout of prior items.

Callable

Shares a callable whose borrowed arguments and owned result have fixed Rust types.

Cons

Names a source-first tuple head H followed by canonical list tail T.

DynClosure

A first-class, callable CEL value: a compiled body plus its declared parameter/return types.

DynSegment

Owns validated raw instructions and complete canonical stack metadata.

FnOf

Names a callable with a complete canonical parameter and result signature.

Leaf

Names an opaque host leaf of type T, including explicitly registered ().

ListTypeIterator

Iterator over type-level List values producing properties via P.

Nil

Names canonical source unit, represented by CNil<()>, not a host ().

OwnedValue

Owns exactly one live erased value and its complete immutable descriptor.

PreparedSegment

Owns a frozen raw body with exact canonical argument/result witnesses.

RawSegment

A segment represents a sequence of operations that can be executed.

RawSequence

A sequence that stores heterogeneous values with proper alignment.

RawStack

A simple raw stack that stores values as raw bytes. Each value is naturally aligned given the base alignment of the stack, which is the maximum alignment of any value stored in the stack. Live values are owned until popped, explicitly released, or destroyed in reverse push order.

RawVec

A vector of bytes aligned to a given value. The alignment can be increase by calling align.

Segment

A type-safe segment that represents a sequence of operations.

StackInfo

Describes a live canonical stack slot.

Undefined

Marker type representing the head of an empty list.

ValueType

Owns immutable recursive identity, canonical layout, and trusted operations.

Enums

ValueKind

Identifies a value structurally, independently of aggregate storage markers.

Traits

ArgumentList

Names a canonical tuple argument list, sealed to Nil and Cons.

CStackListHeadLimit

A trait describing the memory layout of a CStackList. Describes the memory layout of a CStackList’s head and tail boundary.

CStackListHeadPadded

Indicates whether the head element is padded to satisfy alignment.

EmptyList

Trait implemented by empty lists to support list construction.

IntoCStackList

Converts tuples and list-like values into a source-ordered CStackList.

IntoList

Convert into a type-level List, consuming self.

IntoRustTuple

Moves a canonical list into a native Rust tuple in logical source order.

IntoTupleList

Converts tuples into a List representation where () is empty and (H, T) is a cons cell.

List

A trait representing a homogeneous list (cons cell) with a head and tail.

ListIndex

Indexing for lists using typenum-based indices and ranges.

ListTypeIteratorAdvance

Advance function provider used by ListTypeIterator.

ListTypeProperty

Property generator for iterating over type-level lists.

SegmentCallable

Callable segment abstraction for uniform invocation across arities.

StackResult

Extracts a typed segment’s result or its empty-stack marker.

ToList

Convert to a type-level List without consuming self.

ToTypeIdList

Enumerates opaque leaf types in a concrete preloaded stack list.

ValueRepr

Names a trusted concrete representation without wrapping its runtime value.

Functions

align_index

Aligns an index to the specified alignment boundary. Returns the next aligned position that satisfies the alignment requirement.

Type Aliases

CallDynFn

A monomorphized dispatcher for DynClosure::call_boxed: runs a closure’s body via DynSegment::call_dyn::<R> for some concrete R the dispatcher itself already knows, boxing the result so the caller (which only knows R dynamically, as a TypeId) doesn’t need to.

Item

Type alias for getting element type at index N, following std::ops::Index convention Element type at index N of list L.

ReverseList

Convenience alias for reversing a List onto its empty counterpart.

TypeIdIterator

Iterator that yields the TypeId of each head in the List.