Trait IntoRustTuple 

pub trait IntoRustTuple {
    type Tuple;

    // Required method
    fn into_rust_tuple(self) -> Self::Tuple;
}

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

Canonical lists terminate in CNil<()>. Native tuple bridges support zero through twelve fields; lists themselves have no arity limit. Nested list fields remain lists rather than being recursively converted or flattened. Conversion requires no cloning, equality, or formatting capabilities.

Examples

use cel_runtime::{IntoCStackList, IntoRustTuple};

let list = (String::from("left"), 7_u8, 2.5_f64).into_c_stack_list();
let value: (String, u8, f64) = list.into_rust_tuple();
assert_eq!(value, (String::from("left"), 7, 2.5));

Required Associated Types

type Tuple

The native tuple type with fields in logical source order.

Required Methods

fn into_rust_tuple(self) -> Self::Tuple

Moves each logical field into the corresponding native tuple field.

• Complexity: O(n) field moves for n fields, without heap allocation.

Examples

use cel_runtime::{IntoCStackList, IntoRustTuple};

let value: (String,) = (String::from("owned"),)
    .into_c_stack_list()
    .into_rust_tuple();
assert_eq!(value.0, "owned");

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl IntoRustTuple for CNil<()>

type Tuple = ()

impl<A, B, C, D, E, F, G, H, I, J, K, L> IntoRustTuple for CStackList<A, CStackList<B, CStackList<C, CStackList<D, CStackList<E, CStackList<F, CStackList<G, CStackList<H, CStackList<I, CStackList<J, CStackList<K, CStackList<L, CNil<()>>>>>>>>>>>>>

where A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static,

type Tuple = (A, B, C, D, E, F, G, H, I, J, K, L)

impl<A, B, C, D, E, F, G, H, I, J, K> IntoRustTuple for CStackList<A, CStackList<B, CStackList<C, CStackList<D, CStackList<E, CStackList<F, CStackList<G, CStackList<H, CStackList<I, CStackList<J, CStackList<K, CNil<()>>>>>>>>>>>>

where A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static,

type Tuple = (A, B, C, D, E, F, G, H, I, J, K)

impl<A, B, C, D, E, F, G, H, I, J> IntoRustTuple for CStackList<A, CStackList<B, CStackList<C, CStackList<D, CStackList<E, CStackList<F, CStackList<G, CStackList<H, CStackList<I, CStackList<J, CNil<()>>>>>>>>>>>

where A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static,

type Tuple = (A, B, C, D, E, F, G, H, I, J)

impl<A, B, C, D, E, F, G, H, I> IntoRustTuple for CStackList<A, CStackList<B, CStackList<C, CStackList<D, CStackList<E, CStackList<F, CStackList<G, CStackList<H, CStackList<I, CNil<()>>>>>>>>>>

where A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static,

type Tuple = (A, B, C, D, E, F, G, H, I)

impl<A, B, C, D, E, F, G, H> IntoRustTuple for CStackList<A, CStackList<B, CStackList<C, CStackList<D, CStackList<E, CStackList<F, CStackList<G, CStackList<H, CNil<()>>>>>>>>>

where A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static,

type Tuple = (A, B, C, D, E, F, G, H)

impl<A, B, C, D, E, F, G> IntoRustTuple for CStackList<A, CStackList<B, CStackList<C, CStackList<D, CStackList<E, CStackList<F, CStackList<G, CNil<()>>>>>>>>

where A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static,

type Tuple = (A, B, C, D, E, F, G)

impl<A, B, C, D, E, F> IntoRustTuple for CStackList<A, CStackList<B, CStackList<C, CStackList<D, CStackList<E, CStackList<F, CNil<()>>>>>>>

where A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static,

type Tuple = (A, B, C, D, E, F)

impl<A, B, C, D, E> IntoRustTuple for CStackList<A, CStackList<B, CStackList<C, CStackList<D, CStackList<E, CNil<()>>>>>>

where A: 'static, B: 'static, C: 'static, D: 'static, E: 'static,

type Tuple = (A, B, C, D, E)

impl<A, B, C, D> IntoRustTuple for CStackList<A, CStackList<B, CStackList<C, CStackList<D, CNil<()>>>>>

where A: 'static, B: 'static, C: 'static, D: 'static,

type Tuple = (A, B, C, D)

impl<A, B, C> IntoRustTuple for CStackList<A, CStackList<B, CStackList<C, CNil<()>>>>

where A: 'static, B: 'static, C: 'static,

type Tuple = (A, B, C)

impl<A, B> IntoRustTuple for CStackList<A, CStackList<B, CNil<()>>>

where A: 'static, B: 'static,

type Tuple = (A, B)

impl<A> IntoRustTuple for CStackList<A, CNil<()>>

where A: 'static,

type Tuple = (A,)