Trait hazardflow_designs::std::combinators::join::JoinExt

pub trait JoinExt: Interface {
    type E: Interface;

    // Required method
    fn join(self) -> Self::E;
}

Extension trait for join.

Required Associated Types

type E: Interface

Egress interface.

Required Methods

fn join(self) -> Self::E

Join.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, P7: Copy, P8: Copy, P9: Copy, P10: Copy, P11: Copy, P12: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy, R8: Copy, R9: Copy, R10: Copy, R11: Copy, R12: Copy> JoinExt for (I<VrH<P1, R1>, { Dep::Helpful }>, I<VrH<P2, R2>, { Dep::Helpful }>, I<VrH<P3, R3>, { Dep::Helpful }>, I<VrH<P4, R4>, { Dep::Helpful }>, I<VrH<P5, R5>, { Dep::Helpful }>, I<VrH<P6, R6>, { Dep::Helpful }>, I<VrH<P7, R7>, { Dep::Helpful }>, I<VrH<P8, R8>, { Dep::Helpful }>, I<VrH<P9, R9>, { Dep::Helpful }>, I<VrH<P10, R10>, { Dep::Helpful }>, I<VrH<P11, R11>, { Dep::Helpful }>, I<VrH<P12, R12>, { Dep::Helpful }>)

fn join( self ) -> I<VrH<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)>, { Dep::Helpful }>

A variation of join for 3-12 VrH hazard interfaces. See the 2-tuple version for more information.

type E = I<AndH<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)>>, { Dep::Helpful }>

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, P7: Copy, P8: Copy, P9: Copy, P10: Copy, P11: Copy, P12: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy, R8: Copy, R9: Copy, R10: Copy, R11: Copy, R12: Copy, const D: Dep> JoinExt for (I<ValidH<P1, R1>, D>, I<ValidH<P2, R2>, D>, I<ValidH<P3, R3>, D>, I<ValidH<P4, R4>, D>, I<ValidH<P5, R5>, D>, I<ValidH<P6, R6>, D>, I<ValidH<P7, R7>, D>, I<ValidH<P8, R8>, D>, I<ValidH<P9, R9>, D>, I<ValidH<P10, R10>, D>, I<ValidH<P11, R11>, D>, I<ValidH<P12, R12>, D>)

fn join( self ) -> I<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)>, D>

A variation of join for 3-12 ValidH hazard interfaces. See the 2-tuple version for more information.

type E = I<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)>, D>

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, P7: Copy, P8: Copy, P9: Copy, P10: Copy, P11: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy, R8: Copy, R9: Copy, R10: Copy, R11: Copy> JoinExt for (I<VrH<P1, R1>, { Dep::Helpful }>, I<VrH<P2, R2>, { Dep::Helpful }>, I<VrH<P3, R3>, { Dep::Helpful }>, I<VrH<P4, R4>, { Dep::Helpful }>, I<VrH<P5, R5>, { Dep::Helpful }>, I<VrH<P6, R6>, { Dep::Helpful }>, I<VrH<P7, R7>, { Dep::Helpful }>, I<VrH<P8, R8>, { Dep::Helpful }>, I<VrH<P9, R9>, { Dep::Helpful }>, I<VrH<P10, R10>, { Dep::Helpful }>, I<VrH<P11, R11>, { Dep::Helpful }>)

fn join( self ) -> I<VrH<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)>, { Dep::Helpful }>

A variation of join for 3-12 VrH hazard interfaces. See the 2-tuple version for more information.

type E = I<AndH<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)>>, { Dep::Helpful }>

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, P7: Copy, P8: Copy, P9: Copy, P10: Copy, P11: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy, R8: Copy, R9: Copy, R10: Copy, R11: Copy, const D: Dep> JoinExt for (I<ValidH<P1, R1>, D>, I<ValidH<P2, R2>, D>, I<ValidH<P3, R3>, D>, I<ValidH<P4, R4>, D>, I<ValidH<P5, R5>, D>, I<ValidH<P6, R6>, D>, I<ValidH<P7, R7>, D>, I<ValidH<P8, R8>, D>, I<ValidH<P9, R9>, D>, I<ValidH<P10, R10>, D>, I<ValidH<P11, R11>, D>)

fn join( self ) -> I<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)>, D>

A variation of join for 3-12 ValidH hazard interfaces. See the 2-tuple version for more information.

type E = I<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)>, D>

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, P7: Copy, P8: Copy, P9: Copy, P10: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy, R8: Copy, R9: Copy, R10: Copy> JoinExt for (I<VrH<P1, R1>, { Dep::Helpful }>, I<VrH<P2, R2>, { Dep::Helpful }>, I<VrH<P3, R3>, { Dep::Helpful }>, I<VrH<P4, R4>, { Dep::Helpful }>, I<VrH<P5, R5>, { Dep::Helpful }>, I<VrH<P6, R6>, { Dep::Helpful }>, I<VrH<P7, R7>, { Dep::Helpful }>, I<VrH<P8, R8>, { Dep::Helpful }>, I<VrH<P9, R9>, { Dep::Helpful }>, I<VrH<P10, R10>, { Dep::Helpful }>)

fn join( self ) -> I<VrH<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)>, { Dep::Helpful }>

A variation of join for 3-12 VrH hazard interfaces. See the 2-tuple version for more information.

type E = I<AndH<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)>>, { Dep::Helpful }>

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, P7: Copy, P8: Copy, P9: Copy, P10: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy, R8: Copy, R9: Copy, R10: Copy, const D: Dep> JoinExt for (I<ValidH<P1, R1>, D>, I<ValidH<P2, R2>, D>, I<ValidH<P3, R3>, D>, I<ValidH<P4, R4>, D>, I<ValidH<P5, R5>, D>, I<ValidH<P6, R6>, D>, I<ValidH<P7, R7>, D>, I<ValidH<P8, R8>, D>, I<ValidH<P9, R9>, D>, I<ValidH<P10, R10>, D>)

fn join( self ) -> I<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)>, D>

A variation of join for 3-12 ValidH hazard interfaces. See the 2-tuple version for more information.

type E = I<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)>, D>

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, P7: Copy, P8: Copy, P9: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy, R8: Copy, R9: Copy> JoinExt for (I<VrH<P1, R1>, { Dep::Helpful }>, I<VrH<P2, R2>, { Dep::Helpful }>, I<VrH<P3, R3>, { Dep::Helpful }>, I<VrH<P4, R4>, { Dep::Helpful }>, I<VrH<P5, R5>, { Dep::Helpful }>, I<VrH<P6, R6>, { Dep::Helpful }>, I<VrH<P7, R7>, { Dep::Helpful }>, I<VrH<P8, R8>, { Dep::Helpful }>, I<VrH<P9, R9>, { Dep::Helpful }>)

fn join( self ) -> I<VrH<(P1, P2, P3, P4, P5, P6, P7, P8, P9), (R1, R2, R3, R4, R5, R6, R7, R8, R9)>, { Dep::Helpful }>

A variation of join for 3-12 VrH hazard interfaces. See the 2-tuple version for more information.

type E = I<AndH<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8, P9), (R1, R2, R3, R4, R5, R6, R7, R8, R9)>>, { Dep::Helpful }>

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, P7: Copy, P8: Copy, P9: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy, R8: Copy, R9: Copy, const D: Dep> JoinExt for (I<ValidH<P1, R1>, D>, I<ValidH<P2, R2>, D>, I<ValidH<P3, R3>, D>, I<ValidH<P4, R4>, D>, I<ValidH<P5, R5>, D>, I<ValidH<P6, R6>, D>, I<ValidH<P7, R7>, D>, I<ValidH<P8, R8>, D>, I<ValidH<P9, R9>, D>)

fn join( self ) -> I<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8, P9), (R1, R2, R3, R4, R5, R6, R7, R8, R9)>, D>

A variation of join for 3-12 ValidH hazard interfaces. See the 2-tuple version for more information.

type E = I<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8, P9), (R1, R2, R3, R4, R5, R6, R7, R8, R9)>, D>

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, P7: Copy, P8: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy, R8: Copy> JoinExt for (I<VrH<P1, R1>, { Dep::Helpful }>, I<VrH<P2, R2>, { Dep::Helpful }>, I<VrH<P3, R3>, { Dep::Helpful }>, I<VrH<P4, R4>, { Dep::Helpful }>, I<VrH<P5, R5>, { Dep::Helpful }>, I<VrH<P6, R6>, { Dep::Helpful }>, I<VrH<P7, R7>, { Dep::Helpful }>, I<VrH<P8, R8>, { Dep::Helpful }>)

fn join( self ) -> I<VrH<(P1, P2, P3, P4, P5, P6, P7, P8), (R1, R2, R3, R4, R5, R6, R7, R8)>, { Dep::Helpful }>

A variation of join for 3-12 VrH hazard interfaces. See the 2-tuple version for more information.

type E = I<AndH<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8), (R1, R2, R3, R4, R5, R6, R7, R8)>>, { Dep::Helpful }>

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, P7: Copy, P8: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy, R8: Copy, const D: Dep> JoinExt for (I<ValidH<P1, R1>, D>, I<ValidH<P2, R2>, D>, I<ValidH<P3, R3>, D>, I<ValidH<P4, R4>, D>, I<ValidH<P5, R5>, D>, I<ValidH<P6, R6>, D>, I<ValidH<P7, R7>, D>, I<ValidH<P8, R8>, D>)

fn join( self ) -> I<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8), (R1, R2, R3, R4, R5, R6, R7, R8)>, D>

A variation of join for 3-12 ValidH hazard interfaces. See the 2-tuple version for more information.

type E = I<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8), (R1, R2, R3, R4, R5, R6, R7, R8)>, D>

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, P7: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy> JoinExt for (I<VrH<P1, R1>, { Dep::Helpful }>, I<VrH<P2, R2>, { Dep::Helpful }>, I<VrH<P3, R3>, { Dep::Helpful }>, I<VrH<P4, R4>, { Dep::Helpful }>, I<VrH<P5, R5>, { Dep::Helpful }>, I<VrH<P6, R6>, { Dep::Helpful }>, I<VrH<P7, R7>, { Dep::Helpful }>)

fn join( self ) -> I<VrH<(P1, P2, P3, P4, P5, P6, P7), (R1, R2, R3, R4, R5, R6, R7)>, { Dep::Helpful }>

A variation of join for 3-12 VrH hazard interfaces. See the 2-tuple version for more information.

type E = I<AndH<ValidH<(P1, P2, P3, P4, P5, P6, P7), (R1, R2, R3, R4, R5, R6, R7)>>, { Dep::Helpful }>

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, P7: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy, const D: Dep> JoinExt for (I<ValidH<P1, R1>, D>, I<ValidH<P2, R2>, D>, I<ValidH<P3, R3>, D>, I<ValidH<P4, R4>, D>, I<ValidH<P5, R5>, D>, I<ValidH<P6, R6>, D>, I<ValidH<P7, R7>, D>)

fn join( self ) -> I<ValidH<(P1, P2, P3, P4, P5, P6, P7), (R1, R2, R3, R4, R5, R6, R7)>, D>

A variation of join for 3-12 ValidH hazard interfaces. See the 2-tuple version for more information.

type E = I<ValidH<(P1, P2, P3, P4, P5, P6, P7), (R1, R2, R3, R4, R5, R6, R7)>, D>

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy> JoinExt for (I<VrH<P1, R1>, { Dep::Helpful }>, I<VrH<P2, R2>, { Dep::Helpful }>, I<VrH<P3, R3>, { Dep::Helpful }>, I<VrH<P4, R4>, { Dep::Helpful }>, I<VrH<P5, R5>, { Dep::Helpful }>, I<VrH<P6, R6>, { Dep::Helpful }>)

fn join( self ) -> I<VrH<(P1, P2, P3, P4, P5, P6), (R1, R2, R3, R4, R5, R6)>, { Dep::Helpful }>

A variation of join for 3-12 VrH hazard interfaces. See the 2-tuple version for more information.

type E = I<AndH<ValidH<(P1, P2, P3, P4, P5, P6), (R1, R2, R3, R4, R5, R6)>>, { Dep::Helpful }>

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, const D: Dep> JoinExt for (I<ValidH<P1, R1>, D>, I<ValidH<P2, R2>, D>, I<ValidH<P3, R3>, D>, I<ValidH<P4, R4>, D>, I<ValidH<P5, R5>, D>, I<ValidH<P6, R6>, D>)

fn join( self ) -> I<ValidH<(P1, P2, P3, P4, P5, P6), (R1, R2, R3, R4, R5, R6)>, D>

A variation of join for 3-12 ValidH hazard interfaces. See the 2-tuple version for more information.

type E = I<ValidH<(P1, P2, P3, P4, P5, P6), (R1, R2, R3, R4, R5, R6)>, D>

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy> JoinExt for (I<VrH<P1, R1>, { Dep::Helpful }>, I<VrH<P2, R2>, { Dep::Helpful }>, I<VrH<P3, R3>, { Dep::Helpful }>, I<VrH<P4, R4>, { Dep::Helpful }>, I<VrH<P5, R5>, { Dep::Helpful }>)

fn join( self ) -> I<VrH<(P1, P2, P3, P4, P5), (R1, R2, R3, R4, R5)>, { Dep::Helpful }>

A variation of join for 3-12 VrH hazard interfaces. See the 2-tuple version for more information.

type E = I<AndH<ValidH<(P1, P2, P3, P4, P5), (R1, R2, R3, R4, R5)>>, { Dep::Helpful }>

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, const D: Dep> JoinExt for (I<ValidH<P1, R1>, D>, I<ValidH<P2, R2>, D>, I<ValidH<P3, R3>, D>, I<ValidH<P4, R4>, D>, I<ValidH<P5, R5>, D>)

fn join(self) -> I<ValidH<(P1, P2, P3, P4, P5), (R1, R2, R3, R4, R5)>, D>

A variation of join for 3-12 ValidH hazard interfaces. See the 2-tuple version for more information.

type E = I<ValidH<(P1, P2, P3, P4, P5), (R1, R2, R3, R4, R5)>, D>

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy> JoinExt for (I<VrH<P1, R1>, { Dep::Helpful }>, I<VrH<P2, R2>, { Dep::Helpful }>, I<VrH<P3, R3>, { Dep::Helpful }>, I<VrH<P4, R4>, { Dep::Helpful }>)

fn join(self) -> I<VrH<(P1, P2, P3, P4), (R1, R2, R3, R4)>, { Dep::Helpful }>

A variation of join for 3-12 VrH hazard interfaces. See the 2-tuple version for more information.

type E = I<AndH<ValidH<(P1, P2, P3, P4), (R1, R2, R3, R4)>>, { Dep::Helpful }>

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, const D: Dep> JoinExt for (I<ValidH<P1, R1>, D>, I<ValidH<P2, R2>, D>, I<ValidH<P3, R3>, D>, I<ValidH<P4, R4>, D>)

fn join(self) -> I<ValidH<(P1, P2, P3, P4), (R1, R2, R3, R4)>, D>

A variation of join for 3-12 ValidH hazard interfaces. See the 2-tuple version for more information.

type E = I<ValidH<(P1, P2, P3, P4), (R1, R2, R3, R4)>, D>

impl<P1: Copy, P2: Copy, P3: Copy, R1: Copy, R2: Copy, R3: Copy> JoinExt for (I<VrH<P1, R1>, { Dep::Helpful }>, I<VrH<P2, R2>, { Dep::Helpful }>, I<VrH<P3, R3>, { Dep::Helpful }>)

fn join(self) -> I<VrH<(P1, P2, P3), (R1, R2, R3)>, { Dep::Helpful }>

A variation of join for 3-12 VrH hazard interfaces. See the 2-tuple version for more information.

type E = I<AndH<ValidH<(P1, P2, P3), (R1, R2, R3)>>, { Dep::Helpful }>

impl<P1: Copy, P2: Copy, P3: Copy, R1: Copy, R2: Copy, R3: Copy, const D: Dep> JoinExt for (I<ValidH<P1, R1>, D>, I<ValidH<P2, R2>, D>, I<ValidH<P3, R3>, D>)

fn join(self) -> I<ValidH<(P1, P2, P3), (R1, R2, R3)>, D>

A variation of join for 3-12 ValidH hazard interfaces. See the 2-tuple version for more information.

type E = I<ValidH<(P1, P2, P3), (R1, R2, R3)>, D>

impl<P1: Copy, P2: Copy, P3: Copy, R: Copy, const D: Dep> JoinExt for (I<VrH<P1, R>, D>, Valid<P2>, Valid<P3>)

fn join(self) -> I<VrH<(P1, P2, P3), R>, D>

A variation of join for a VrH hazard interface and 2 valid interfaces. See the 2-tuple version for more information.

type E = I<AndH<ValidH<(P1, P2, P3), R>>, D>

impl<P1: Copy, P2: Copy, R1: Copy, R2: Copy> JoinExt for (I<VrH<P1, R1>, { Dep::Helpful }>, I<VrH<P2, R2>, { Dep::Helpful }>)

fn join(self) -> I<VrH<(P1, P2), (R1, R2)>, { Dep::Helpful }>

Joins two VrH hazard interfaces.

All ingress transfers and an egress transfer happen at once when all the ingress payloads are valid and the egress ready signal is true.

• Payloads: Zipped to one interface.
• Resolver: If all the ingress payloads are valid and the egress ready signal is true, then all the ingress ready signals are true and the inner value (R1, R2) of the resolver is preserved and split. Otherwise, all the ingress ready signals are false and the resolver value is dropped.

Interface	Ingress	Egress
Fwd	(HOption<P1>, HOption<P2>)	HOption<(P1, P2)>
Bwd	(Ready<R1>, Ready<R2>)	Ready<(R1, R2)>

type E = I<AndH<ValidH<(P1, P2), (R1, R2)>>, { Dep::Helpful }>

impl<P1: Copy, P2: Copy, R1: Copy, R2: Copy, const D: Dep> JoinExt for (I<ValidH<P1, R1>, D>, I<ValidH<P2, R2>, D>)

fn join(self) -> I<ValidH<(P1, P2), (R1, R2)>, D>

Joins two ValidH hazard interfaces.

• Payloads: Zipped to one interface. Note that a payload may get dropped if the other interface’s payload is None.
• Resolver: Preserved, and split to multiple interfaces.

Interface	Ingress	Egress
Fwd	(HOption<P1>, HOption<P2>)	HOption<(P1, P2)>
Bwd	(R1, R2)	(R1, R2)

type E = I<ValidH<(P1, P2), (R1, R2)>, D>

impl<P1: Copy, P2: Copy, R: Copy, const D: Dep> JoinExt for (I<VrH<P1, R>, D>, Valid<P2>)

fn join(self) -> I<VrH<(P1, P2), R>, D>

Joins a VrH hazard interface and a valid interface.

• Payloads: Zipped to one interface. Note that the valid interface’s payload P2 may get discarded if a transfer does not happen for the VrH hazard interface.
• Resolver: The resolver is preserved through the VrH hazard interface.

Interface	Ingress	Egress
Fwd	(HOption<P1>, HOption<P2>)	HOption<(P1, P2)>
Bwd	(Ready<R>, ())	Ready<R>

type E = I<AndH<ValidH<(P1, P2), R>>, D>

impl<P: Copy, R: Copy, const D: Dep, const N: usize> JoinExt for [I<ValidH<P, R>, D>; N]

fn join(self) -> I<ValidH<Array<P, N>, Array<R, N>>, D>

Joins N ValidH hazard interfaces.

• Payloads: Zipped to one interface. Note that a payload may get dropped if the other interface’s payload is None.
• Resolver: Preserved, and split to multiple interfaces.

Interface	Ingress	Egress
Fwd	Array<HOption<P>, N>	HOption<Array<P, N>>
Bwd	Array<R, N>	Array<R, N>

type E = I<ValidH<Array<P, N>, Array<R, N>>, D>

impl<P: Copy, R: Copy, const N: usize> JoinExt for [I<VrH<P, R>, { Dep::Helpful }>; N]

fn join(self) -> I<VrH<Array<P, N>, Array<R, N>>, { Dep::Helpful }>

Joins N VrH hazard interfaces.

All ingress transfers and an egress transfer happen at once when all the ingress payloads are valid and the egress ready signal is true.

• Payloads: Zipped to one interface.
• Resolver: If all the ingress payloads are valid and the egress ready signal is true, then all the ingress ready signals are true and the inner value Array<R, N> of the resolver is preserved and split. Otherwise, all the ingress ready signals are false and the resolver value is dropped.

Interface	Ingress	Egress
Fwd	Array<HOption<P>, N>	HOption<Array<P, N>>
Bwd	Array<Ready<R>, N>	Ready<Array<R, N>>

type E = I<AndH<ValidH<Array<P, N>, Array<R, N>>>, { Dep::Helpful }>

Implementors