Struct Segment 

pub struct Segment<Args, Stack = <<Args as IntoList>::Output<CNil<()>> as List>::ReverseOnto<<<Args as IntoList>::Output<CNil<()>> as List>::Empty>>
where
    Args: IntoList + 'static,
    Stack: List,
{ /* 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> Segment<Args>

where Args: IntoList + 'static,

pub fn new() -> Segment<Args>

Creates a new empty segment with no operations.

impl<Args, Stack> Segment<Args, Stack>

where Args: IntoList + 'static, Stack: StackResult + 'static, <Stack as List>::Tail: CStackListHeadLimit,

pub fn op0<R, F>(self, op: F) -> Segment<Args, <Stack as List>::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 as List>::Push<R>>

where F: Fn() -> Result<R, Error> + '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 as List>::Tail>>

where Stack: CStackListHeadPadded, F: Fn(<Stack as List>::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 as List>::Tail>>

where Stack: CStackListHeadPadded, F: Fn(<Stack as List>::Head) -> Result<R, Error> + '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 as List>::Tail as List>::Tail as List>::Push<R>>

where Stack: CStackListHeadPadded, <Stack as List>::Tail: CStackListHeadPadded, F: Fn(<<Stack as List>::Tail as List>::Head, <Stack as List>::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> Default for Segment<Args>

where Args: IntoList + 'static,

fn default() -> Segment<Args>

Returns the “default value” for a type.

impl<T> SegmentCallable<()> for Segment<(), T>

where T: StackResult + 'static, <T as List>::Tail: EmptyList + CStackListHeadLimit,

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

The result type produced by calling with Args.

fn call(&self, _args: ()) -> <Segment<(), T> as SegmentCallable<()>>::Output

Invokes the segment with the supplied arguments.

impl<T, A, B> SegmentCallable<(A, B)> for Segment<(A, B), T>

where T: StackResult + 'static, A: 'static, B: 'static, <T as List>::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), ) -> <Segment<(A, B), T> as SegmentCallable<(A, B)>>::Output

Invokes the segment with the supplied arguments.

impl<T, A> SegmentCallable<(A,)> for Segment<(A,), T>

where T: StackResult + 'static, A: 'static, <T as List>::Tail: EmptyList + CStackListHeadLimit,

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

The result type produced by calling with Args.

fn call( &self, args: (A,), ) -> <Segment<(A,), T> as SegmentCallable<(A,)>>::Output

Invokes the segment with the supplied arguments.

impl<Args, Stack> TryFrom<DynSegment> for Segment<Args, Stack>

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

type Error = Error

The type returned in the event of a conversion error.

fn try_from( value: DynSegment, ) -> Result<Segment<Args, Stack>, <Segment<Args, Stack> as TryFrom<DynSegment>>::Error>

Performs the conversion.