Struct HCons 

pub struct HCons<H, T> {
    pub head: H,
    pub tail: T,
}

Non-empty heterogeneous list node.

HCons<H, T> holds a head element and a tail (which can be another HCons or HSingle).

Fields

head: H

The first element of this list segment.

tail: T

The remaining elements (another HCons or HSingle).

Implementations

impl<H, T> HCons<H, T>

pub fn new(head: H, tail: T) -> Self

Create a new HCons with the given head and tail.

Trait Implementations

impl<H: Clone, T: Clone> Clone for HCons<H, T>

fn clone(&self) -> HCons<H, T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<H: Debug, T: Debug> Debug for HCons<H, T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, H, T> Deserialize<'de> for HCons<H, T>

where H: Deserialize<'de>, T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S, Ctx, Err, T> InstructionList<Ctx, Err> for HCons<StepWrapper<S, Ctx, Err>, T>

where S: Step<Ctx, Err>, Ctx: Send + Sync + 'static, Err: Send + Sync + Clone + 'static, T: InstructionList<Ctx, Err>,

Implementation for multi-element list (recursive case).

const LEN: usize

Number of steps in this instruction list.

fn execute_all<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 mut Ctx, state: &'life2 mut ExecutionState, ) -> Pin<Box<dyn Future<Output = BlockResult<Err>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Execute all instructions in forward order.

fn compensate_all<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 mut Ctx, state: &'life2 mut ExecutionState, ) -> Pin<Box<dyn Future<Output = Result<CompensationOutcome, Err>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Compensate executed instructions in reverse order.

fn execute_at<'life0, 'life1, 'async_trait>( &'life0 self, index: usize, ctx: &'life1 mut Ctx, ) -> Pin<Box<dyn Future<Output = Result<StepOutcome, Err>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute a single step at the given index.

fn compensate_at<'life0, 'life1, 'async_trait>( &'life0 self, index: usize, ctx: &'life1 mut Ctx, ) -> Pin<Box<dyn Future<Output = Result<CompensationOutcome, Err>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Compensate a single step at the given index.

fn retry_policy_at(&self, index: usize) -> RetryPolicy

Get the retry policy for the step at the given index.

impl<H, T> Serialize for HCons<H, T>

where H: Serialize, T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.