Struct Segment 

pub struct Segment<Args: IntoList + 'static, Stack: List = ReverseList<<Args as IntoList>::Output<CNil<()>>>> { /* private fields */ }

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

The segment takes input arguments of type Args and maintains a type stack Stack that tracks the types of values produced by operations.

Type Parameters

• Args: The input argument types, must implement IntoList
• Stack: The type stack tracking operation results, defaults to the reverse of Args

Examples

use cel_runtime::segment::*;

assert_eq!(Segment::<(i32,)>::new() // create a new segment that takes an i32 argument
    .op1(|x| x * 2)                 // push a unary operation that multiplies the argument by 2
    .op0(|| 10)                     // push a nullary operation that returns 10
    .op2(|x, y| x + y)              // push a binary operation that adds two arguments
    .op1(|x| x.to_string())         // push a unary operation returning a string of the argument
    .call((42, )).unwrap(),         // call the segment with an argument 42
    "94");                          // the result is (42 * 2 + 10).to_string()

Implementations

impl<Args: IntoList + 'static> Segment<Args>

pub fn new() -> Segment<Args>

Creates a new empty segment with no operations.

impl<Args: IntoList + 'static, Stack> Segment<Args, Stack>

where Stack: StackResult + 'static, Stack::Tail: CStackListHeadLimit,

pub fn op0<R, F>(self, op: F) -> Segment<Args, Stack::Push<R>>

where F: Fn() -> R + 'static, R: 'static,

Pushes a nullary operation that takes no arguments and returns a value of type R.

pub fn op0r<R, F>(self, op: F) -> Segment<Args, Stack::Push<R>>

where F: Fn() -> Result<R> + 'static, R: 'static,

Pushes a fallible nullary operation that returns Result<R>.

pub fn op1<R, F>(self, op: F) -> Segment<Args, CStackList<R, Stack::Tail>>

where Stack: CStackListHeadPadded, F: Fn(Stack::Head) -> R + 'static, R: 'static,

Pushes a unary operation that takes the current stack value and returns a new value.

pub fn op1r<R, F>(self, op: F) -> Segment<Args, CStackList<R, Stack::Tail>>

where Stack: CStackListHeadPadded, F: Fn(Stack::Head) -> Result<R> + 'static, R: 'static,

Pushes a fallible unary operation that takes the current stack value and returns Result<R>.

pub fn op2<R, F>( self, op: F, ) -> Segment<Args, <<Stack::Tail as List>::Tail as List>::Push<R>>

where Stack: CStackListHeadPadded, Stack::Tail: CStackListHeadPadded, F: Fn(<Stack::Tail as List>::Head, Stack::Head) -> R + 'static, R: 'static,

Pushes a binary operation that takes the top two stack values and returns a new value.

Trait Implementations

impl<Args: IntoList + 'static> Default for Segment<Args>

fn default() -> Self

Returns the “default value” for a type.

impl<T: StackResult + 'static> SegmentCallable<()> for Segment<(), T>

where T::Tail: EmptyList + CStackListHeadLimit,

type Output = Result<<T as List>::Head, Error>

The result type produced by calling with Args.

fn call(&self, _args: ()) -> Self::Output

Invokes the segment with the supplied arguments.

impl<T: StackResult + 'static, A: 'static, B: 'static> SegmentCallable<(A, B)> for Segment<(A, B), T>

where T::Tail: EmptyList + CStackListHeadLimit,

type Output = Result<<T as List>::Head, Error>

The result type produced by calling with Args.

fn call(&self, args: (A, B)) -> Self::Output

Invokes the segment with the supplied arguments.

impl<T: StackResult + 'static, A: 'static> SegmentCallable<(A,)> for Segment<(A,), T>

where T::Tail: EmptyList + CStackListHeadLimit,

type Output = Result<<T as List>::Head, Error>

The result type produced by calling with Args.

fn call(&self, args: (A,)) -> Self::Output

Invokes the segment with the supplied arguments.

impl<Args: IntoList + 'static, Stack> TryFrom<DynSegment> for Segment<Args, Stack>

where ReverseList<<Args as IntoList>::Output<CNil<()>>>: ListTypeIteratorAdvance<TypeId>, Stack: ListTypeIteratorAdvance<TypeId> + List + 'static,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: DynSegment) -> Result<Self, Self::Error>

Performs the conversion.