Struct ChainMap

pub struct ChainMap<const NUM_INPUT_LISTS: usize> { /* private fields */ }

Applies a given function f to every element of all given lists, collecting the new elements into a new list.

The given function f must produce elements of a type for which the encoded length is statically known. The input type may have either statically or dynamically known length:

• In the static case, the entire element is placed on the stack before passing control to f.
• In the dynamic case, a memory pointer to the encoded element and the item’s length is placed on the stack before passing control to f. The input list must be encoded according to BFieldCodec. Otherwise, behavior of ChainMap is undefined!

The stack layout is independent of the list currently being processed. This allows the InnerFunction f to use runtime parameters from the stack. Note that the chain map requires a certain number of stack registers for internal purposes. This number can be accessed through ChainMap::NUM_INTERNAL_REGISTERS. As mentioned above, the stack layout upon starting execution of f depends on the input type’s static length. In the static case, the stack layout is:

// _ <accessible> [_; ChainMap::<N>::NUM_INTERNAL_REGISTERS] [input_element; len]

In the case of input elements with a dynamic length, the stack layout is:

// _ <accessible> [_; ChainMap::<N>::NUM_INTERNAL_REGISTERS] *elem_i elem_i_len

Implementations

impl<const NUM_INPUT_LISTS: usize> ChainMap<NUM_INPUT_LISTS>

pub const NUM_INTERNAL_REGISTERS: usize = _

The number of registers required internally. See ChainMap for additional details.

pub fn new(f: InnerFunction) -> Self

Panics

• if the input type has [static length] and takes up OpStackElement::COUNT or more words
• if the input type has dynamic length and is anything but a tuple (_, BFieldElement)
• if the output type takes up OpStackElement::COUNT - 1 or more words
• if the output type does not have a static length

Trait Implementations

impl<const NUM_INPUT_LISTS: usize> BasicSnippet for ChainMap<NUM_INPUT_LISTS>

fn inputs(&self) -> Vec<(DataType, String)>

fn outputs(&self) -> Vec<(DataType, String)>

fn entrypoint(&self) -> String

fn code(&self, library: &mut Library) -> Vec<LabelledInstruction>

fn annotated_code(&self, library: &mut Library) -> Vec<LabelledInstruction>

fn link_for_isolated_run(&self) -> Vec<LabelledInstruction>

fn init_stack_for_isolated_run(&self) -> Vec<BFieldElement>

Intial stack on program start, when the snippet runs in isolation.

fn stack_diff(&self) -> isize

impl<const NUM_INPUT_LISTS: usize> Function for ChainMap<NUM_INPUT_LISTS>

fn rust_shadow( &self, stack: &mut Vec<BFieldElement>, memory: &mut HashMap<BFieldElement, BFieldElement>, )

fn pseudorandom_initial_state( &self, seed: [u8; 32], bench: Option<BenchmarkCase>, ) -> FunctionInitialState

Return (init_stack, init_memory)

fn corner_case_initial_states(&self) -> Vec<FunctionInitialState>