Struct hazardflow_designs::std::hazard::I

pub struct I<H: Hazard, const D: Dep> { /* private fields */ }

Hazard interface.

Implementations

impl<P: Copy, R: Copy, const D: Dep> I<ValidH<P, R>, D>

pub fn filter(self, f: impl Fn(P) -> bool) -> I<ValidH<P, R>, D>

Filters the ingress payload.

• Payload: Filtered by f.
• Resolver: Preserved.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<P>
Bwd	R	R

impl<P: Copy, R: Copy, const D: Dep> I<VrH<P, R>, D>

pub fn filter(self, f: impl Fn(P) -> bool) -> I<VrH<P, R>, D>

Filters the ingress payload.

• Payload: Filtered by f.
• Resolver: Preserved.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<P>
Bwd	Ready<R>	Ready<R>

impl<H: Hazard, const D: Dep> I<H, D>

pub fn filter_drop<EH: Hazard<P = H::P, R = H::R>>( self, f: impl Fn(H::P) -> bool ) -> I<EH, { Dep::Demanding }>

Filters the ingress payload.

• Payload: Filtered by f. The payload is dropped if H::ready(ip, ir) or EH::ready(ep, er) is false, even if f returns true. (why?)
• Resolver: Preserved.

Interface	Ingress	Egress
Fwd	HOption<H::P>	HOption<H::P>
Bwd	H::R	H::R

impl<P: Copy, R: Copy, const D: Dep> I<ValidH<P, R>, D>

pub fn filter_map<EP: Copy>( self, f: impl Fn(P) -> HOption<EP> ) -> I<ValidH<EP, R>, D>

Filter-maps the ingress payload into the egress payload.

• Payload: Filter-maped by f.
• Resolver: Preserved.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<EP>
Bwd	R	R

pub fn filter_map_with_r<EP: Copy>( self, f: impl Fn(P, R) -> HOption<EP> ) -> I<ValidH<EP, R>, { Dep::Demanding }>

A variation of filter_map that allows f to consider the egress resolver in addition to the ingress payload while calculating the egress payload.

• Payload: Filter-maped by f.
• Resolver: Preserved.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<EP>
Bwd	R	R

impl<P: Copy, R: Copy, const D: Dep> I<VrH<P, R>, D>

pub fn filter_map<EP: Copy>( self, f: impl Fn(P) -> HOption<EP> ) -> I<VrH<EP, R>, D>

Filter-maps the ingress payload into the egress payload.

• Payload: Filter-maped by f.
• Resolver: Preserved.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<EP>
Bwd	Ready<R>	Ready<R>

pub fn filter_map_drop_with_r_inner<EP: Copy>( self, f: impl Fn(P, R) -> HOption<EP> ) -> I<VrH<EP, R>, { Dep::Demanding }>

A variation of filter_map that allows f to consider the inner value of the egress resolver in addition to the ingress payload while calculating the egress payload.

• Payload: Filter-mapped by f. The payload is dropped if er.ready is false, even if f returns Some. (why?)
• Resolver: Preserved.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<EP>
Bwd	Ready<R>	Ready<R>

impl<H: Hazard, const D: Dep> I<H, D>

pub fn filter_map_drop_with_r<EH: Hazard<R = H::R>>( self, f: impl Fn(H::P, H::R) -> HOption<EH::P> ) -> I<EH, { Dep::Demanding }>

Filter-maps the ingress payload and the egress resolver to the egress payload.

• Payload: Filter-mapped by f. The payload is dropped if H::ready(ip, ir) or EH::ready(ep, er) is false, even if f returns Some. (why?)
• Resolver: Preserved.

Interface	Ingress	Egress
Fwd	HOption<H::P>	HOption<EH::P>
Bwd	H::R	H::R

impl<P: Copy, R: Copy, const D: Dep> I<ValidH<HOption<P>, R>, D>

pub fn flatten(self) -> I<ValidH<P, R>, D>

Flattens the payload.

• Payload: Flattened.
• Resolver: Preserved.

Interface	Ingress	Egress
Fwd	HOption<HOption<P>>	HOption<P>
Bwd	R	R

impl<P: Copy, R: Copy, const D: Dep> I<VrH<HOption<P>, R>, D>

pub fn flatten(self) -> I<VrH<P, R>, D>

Flattens the payload.

• Payload: Flattened.
• Resolver: Preserved.

Interface	Ingress	Egress
Fwd	HOption<HOption<P>>	HOption<P>
Bwd	Ready<R>	Ready<R>

impl<P: Copy, R: Copy, const D: Dep> I<ValidH<P, R>, D>

pub fn map<EP: Copy>(self, f: impl Fn(P) -> EP) -> I<ValidH<EP, R>, D>

Maps the ingress payload into the egress payload.

• Payload: Mapped by f.
• Resolver: Preserved.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<EP>
Bwd	R	R

impl<P: Copy, R: Copy, const D: Dep> I<VrH<P, R>, D>

pub fn map<EP: Copy>(self, f: impl Fn(P) -> EP) -> I<VrH<EP, R>, D>

Maps the ingress payload into the egress payload.

• Payload: Mapped by f.
• Resolver: Preserved.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<EP>
Bwd	Ready<R>	Ready<R>

impl<H: Hazard, const D: Dep> I<H, D>

pub fn map_drop<EH: Hazard<R = H::R>>( self, f: impl Fn(H::P) -> EH::P ) -> I<EH, { Dep::Demanding }>

Maps the ingress payload to the egress payload.

• Payload: Mapped by f. The payload is dropped if H::ready(ip, ir) or EH::ready(ep, er) is false. (why?)
• Resolver: Preserved.

Interface	Ingress	Egress
Fwd	HOption<H::P>	HOption<EH::P>
Bwd	H::R	H::R

impl<P: Copy, R: Copy, const D: Dep> I<ValidH<P, R>, D>

pub fn map_resolver<ER: Copy>(self, f: impl Fn(ER) -> R) -> I<ValidH<P, ER>, D>

Maps the egress resolver into the ingress resolver.

• Payload: Preserved.
• Resolver: Mapped by f.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<P>
Bwd	R	ER

impl<P: Copy, R: Copy> I<ValidH<P, R>, { Dep::Helpful }>

pub fn map_resolver_with_p<ER: Copy>( self, f: impl Fn(HOption<P>, ER) -> R ) -> I<ValidH<P, ER>, { Dep::Helpful }>

A variation of map_resolver that allows f to consider the ingress payload in addition to the egress resolver while calculating the ingress resolver.

This is possible because the ingress interface is Dep::Helpful.

• Payload: Preserved.
• Resolver: Mapped by f.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<P>
Bwd	R	ER

impl<P: Copy, R: Copy, const D: Dep> I<VrH<P, R>, D>

pub fn map_resolver<ER: Copy>( self, f: impl Fn(Ready<ER>) -> R ) -> I<VrH<P, ER>, D>

Maps the egress resolver into the ingress resolver.

Note that it disallows changing the ready signal, since if D is Dep::Demanding, changing the ready signal may break the Dep::Demanding condition.

• Payload: Preserved.
• Resolver: The egress resolver Ready<ER> is mapped to the inner value R of the ingress resolver by f.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<P>
Bwd	Ready<R>	Ready<ER>

pub fn map_resolver_inner<ER: Copy>( self, f: impl Fn(ER) -> R ) -> I<VrH<P, ER>, D>

A variation of map_resolver that does not use the egress ready signal.

• Payload: Preserved.
• Resolver: The inner value ER of the egress resolver is mapped into the inner value R of the ingress resolver by f.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<P>
Bwd	Ready<R>	Ready<ER>

impl<P: Copy, R: Copy> I<VrH<P, R>, { Dep::Helpful }>

pub fn map_resolver_with_p<ER: Copy>( self, f: impl Fn(HOption<P>, Ready<ER>) -> Ready<R> ) -> I<VrH<P, ER>, { Dep::Helpful }>

A variation of map_resolver that allows f to consider the ingress payload in addition to the egress resolver while calculating the ingress resolver.

This is possible because the ingress interface is Dep::Helpful.

Note that it allows changing the ready signal unlike the original map_resolver, since the egress interface is Dep::Helpful.

• Payload: Preserved.
• Resolver: Mapped by f.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<P>
Bwd	R	ER

pub fn map_resolver_inner_with_p<ER: Copy>( self, f: impl Fn(HOption<P>, ER) -> R ) -> I<VrH<P, ER>, { Dep::Helpful }>

A variation of I::map_resolver_inner that allows f to consider the ingress payload in addition to the egress resolver while calculating the ingress resolver.

This is possible because the ingress interface is Dep::Helpful.

• Payload: Preserved.
• Resolver: The inner value ER of the egress resolver is mapped into the inner value R of the ingress resolver by f.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<P>
Bwd	Ready<R>	Ready<ER>

impl<H: Hazard, const D: Dep> I<H, D>

pub fn map_resolver_drop<EH: Hazard<P = H::P>>( self, f: impl Fn(EH::R) -> H::R ) -> I<EH, { Dep::Demanding }>

Maps the egress resolver into the ingress resolver.

• Payload: Droppped if H::ready(ip, ir) or EH::ready(ep, er) is false. (why?)
• Resolver: Mapped by f.

Interface	Ingress	Egress
Fwd	HOption<H::P>	HOption<H::P>
Bwd	H::R	EH::R

impl<H: Hazard> I<H, { Dep::Helpful }>

pub fn map_resolver_drop_with_p<EH: Hazard<P = H::P>>( self, f: impl Fn(HOption<H::P>, EH::R) -> H::R ) -> I<EH, { Dep::Demanding }>

A variation of I::map_resolver_drop that allows f to consider the ingress payload in addition to the egress resolver while calculating the ingress resolver.

This is possible because the ingress interface is Dep::Helpful.

• Payload: The same behavior as I::map_resolver_drop
• Resolver: The same behavior as I::map_resolver_drop

Interface	Ingress	Egress
Fwd	HOption<H::P>	HOption<H::P>
Bwd	H::R	EH::R

impl<H: Hazard> I<AndH<H>, { Dep::Helpful }>

pub fn map_resolver_block<EH: Hazard<P = H::P>>( self, f: impl Fn(EH::R) -> H::R ) -> I<EH, { Dep::Demanding }>

Maps the egress resolver into the ingress resolver with an additional ready signal for blocking.

• Payload: Preserved. Technically, the payload is dropped if H::ready(ip, ir) or EH::ready(ep, er) is false. But since the added ready signal informs the ingress interface that a transfer did not happen (i.e. blocks the transfer) in such a case, no payload will be lost.
• Resolver: An additional ready signal is attached to the ingress resolver, which will be turned off if the egress ready condition EH::ready(ep, er) is false. The egress resolver EH::R is mapped to the inner ingress resolver H::R by f.

Interface	Ingress	Egress
Fwd	HOption<H::P>	HOption<H::P>
Bwd	Ready<H::R>	EH::R

pub fn map_resolver_block_with_p<EH: Hazard<P = H::P>>( self, f: impl Fn(HOption<H::P>, EH::R) -> H::R ) -> I<EH, { Dep::Demanding }>

A variation of I::map_resolver_block that allows f to consider the ingress payload in addition to the egress resolver while calculating the ingress resolver.

This is possible because the ingress interface is Dep::Helpful.

• Payload: The same behavior as I::map_resolver_block.
• Resolver: The same behavior as I::map_resolver_block.

Interface	Ingress	Egress
Fwd	HOption<H::P>	HOption<H::P>
Bwd	Ready<H::R>	EH::R

impl<P: Copy, R1: Copy, R2: Copy, const D: Dep> I<ValidH<(P, BoundedU<2>), (R1, R2)>, D>

pub fn branch(self) -> (I<ValidH<P, R1>, D>, I<ValidH<P, R2>, D>)

Branches into two ValidH hazard interfaces based on the selector.

The selector chooses which egress interface to connect to the ingress interface.

• Payload: Only the selected interface’s payload will be valid.
• Resolvers: Preserved, and combined into one interface.

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, const D: Dep> I<ValidH<(P, BoundedU<3>), (R1, R2, R3)>, D>

pub fn branch( self ) -> (I<ValidH<P, R1>, D>, I<ValidH<P, R2>, D>, I<ValidH<P, R3>, D>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, const D: Dep> I<ValidH<(P, BoundedU<4>), (R1, R2, R3, R4)>, D>

pub fn branch( self ) -> (I<ValidH<P, R1>, D>, I<ValidH<P, R2>, D>, I<ValidH<P, R3>, D>, I<ValidH<P, R4>, D>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, const D: Dep> I<ValidH<(P, BoundedU<5>), (R1, R2, R3, R4, R5)>, D>

pub fn branch( self ) -> (I<ValidH<P, R1>, D>, I<ValidH<P, R2>, D>, I<ValidH<P, R3>, D>, I<ValidH<P, R4>, D>, I<ValidH<P, R5>, D>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, const D: Dep> I<ValidH<(P, BoundedU<6>), (R1, R2, R3, R4, R5, R6)>, D>

pub fn branch( self ) -> (I<ValidH<P, R1>, D>, I<ValidH<P, R2>, D>, I<ValidH<P, R3>, D>, I<ValidH<P, R4>, D>, I<ValidH<P, R5>, D>, I<ValidH<P, R6>, D>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy, const D: Dep> I<ValidH<(P, BoundedU<7>), (R1, R2, R3, R4, R5, R6, R7)>, D>

pub fn branch( self ) -> (I<ValidH<P, R1>, D>, I<ValidH<P, R2>, D>, I<ValidH<P, R3>, D>, I<ValidH<P, R4>, D>, I<ValidH<P, R5>, D>, I<ValidH<P, R6>, D>, I<ValidH<P, R7>, D>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy, R8: Copy, const D: Dep> I<ValidH<(P, BoundedU<8>), (R1, R2, R3, R4, R5, R6, R7, R8)>, D>

pub fn branch( self ) -> (I<ValidH<P, R1>, D>, I<ValidH<P, R2>, D>, I<ValidH<P, R3>, D>, I<ValidH<P, R4>, D>, I<ValidH<P, R5>, D>, I<ValidH<P, R6>, D>, I<ValidH<P, R7>, D>, I<ValidH<P, R8>, D>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy, R8: Copy, R9: Copy, const D: Dep> I<ValidH<(P, BoundedU<9>), (R1, R2, R3, R4, R5, R6, R7, R8, R9)>, D>

pub fn branch( self ) -> (I<ValidH<P, R1>, D>, I<ValidH<P, R2>, D>, I<ValidH<P, R3>, D>, I<ValidH<P, R4>, D>, I<ValidH<P, R5>, D>, I<ValidH<P, R6>, D>, I<ValidH<P, R7>, D>, I<ValidH<P, R8>, D>, I<ValidH<P, R9>, D>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy, R8: Copy, R9: Copy, R10: Copy, const D: Dep> I<ValidH<(P, BoundedU<10>), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)>, D>

pub fn branch( self ) -> (I<ValidH<P, R1>, D>, I<ValidH<P, R2>, D>, I<ValidH<P, R3>, D>, I<ValidH<P, R4>, D>, I<ValidH<P, R5>, D>, I<ValidH<P, R6>, D>, I<ValidH<P, R7>, D>, I<ValidH<P, R8>, D>, I<ValidH<P, R9>, D>, I<ValidH<P, R10>, D>)

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

impl<P: 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> I<ValidH<(P, BoundedU<11>), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)>, D>

pub fn branch( self ) -> (I<ValidH<P, R1>, D>, I<ValidH<P, R2>, D>, I<ValidH<P, R3>, D>, I<ValidH<P, R4>, D>, I<ValidH<P, R5>, D>, I<ValidH<P, R6>, D>, I<ValidH<P, R7>, D>, I<ValidH<P, R8>, D>, I<ValidH<P, R9>, D>, I<ValidH<P, R10>, D>, I<ValidH<P, R11>, D>)

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

impl<P: 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> I<ValidH<(P, BoundedU<12>), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)>, D>

pub fn branch( self ) -> (I<ValidH<P, R1>, D>, I<ValidH<P, R2>, D>, I<ValidH<P, R3>, D>, I<ValidH<P, R4>, D>, I<ValidH<P, R5>, D>, I<ValidH<P, R6>, D>, I<ValidH<P, R7>, D>, I<ValidH<P, R8>, D>, I<ValidH<P, R9>, D>, I<ValidH<P, R10>, D>, I<ValidH<P, R11>, D>, I<ValidH<P, R12>, D>)

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

impl<P: Copy, R: Copy, const N: usize, const D: Dep> I<ValidH<(P, BoundedU<N>), Array<R, N>>, D>

pub fn branch(self) -> [I<ValidH<P, R>, D>; N]

Branches into N ValidH hazard interfaces based on the selector.

The selector chooses which egress interface to connect to the ingress interface.

• Payload: Only the selected interface’s payload will be valid.
• Resolvers: Preserved, and combined into one interface.

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

impl<P: Copy, const N: usize> I<ValidH<(P, BoundedU<N>), ()>, { Dep::Helpful }>

pub fn branch(self) -> [Valid<P>; N]

A variation of branch for a valid interface, that has the correct resolver type.

• Payload: Only the selected interface’s payload will be valid.
• Resolvers: The resolvers carry no information.

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

impl<P: Copy, R1: Copy, R2: Copy> I<VrH<(P, BoundedU<2>), (R1, R2)>, { Dep::Helpful }>

pub fn branch( self ) -> (I<VrH<P, R1>, { Dep::Helpful }>, I<VrH<P, R2>, { Dep::Helpful }>)

Branches into two VrH hazard interfaces based on the selector.

The selector chooses which egress interface to connect to the ingress interface.

• Payload: Only the selected interface’s payload will be valid.
• Resolvers: The ingress ready signal follows the selected interface’s ready signal. If the selector is not valid, the ingress ready signal is true. The inner values R1, R2 of the resolvers are preserved, and combined into one interface.

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy> I<VrH<(P, BoundedU<3>), (R1, R2, R3)>, { Dep::Helpful }>

pub fn branch( self ) -> (I<VrH<P, R1>, { Dep::Helpful }>, I<VrH<P, R2>, { Dep::Helpful }>, I<VrH<P, R3>, { Dep::Helpful }>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy> I<VrH<(P, BoundedU<4>), (R1, R2, R3, R4)>, { Dep::Helpful }>

pub fn branch( self ) -> (I<VrH<P, R1>, { Dep::Helpful }>, I<VrH<P, R2>, { Dep::Helpful }>, I<VrH<P, R3>, { Dep::Helpful }>, I<VrH<P, R4>, { Dep::Helpful }>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy> I<VrH<(P, BoundedU<5>), (R1, R2, R3, R4, R5)>, { Dep::Helpful }>

pub fn branch( self ) -> (I<VrH<P, R1>, { Dep::Helpful }>, I<VrH<P, R2>, { Dep::Helpful }>, I<VrH<P, R3>, { Dep::Helpful }>, I<VrH<P, R4>, { Dep::Helpful }>, I<VrH<P, R5>, { Dep::Helpful }>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy> I<VrH<(P, BoundedU<6>), (R1, R2, R3, R4, R5, R6)>, { Dep::Helpful }>

pub fn branch( self ) -> (I<VrH<P, R1>, { Dep::Helpful }>, I<VrH<P, R2>, { Dep::Helpful }>, I<VrH<P, R3>, { Dep::Helpful }>, I<VrH<P, R4>, { Dep::Helpful }>, I<VrH<P, R5>, { Dep::Helpful }>, I<VrH<P, R6>, { Dep::Helpful }>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy> I<VrH<(P, BoundedU<7>), (R1, R2, R3, R4, R5, R6, R7)>, { Dep::Helpful }>

pub fn branch( self ) -> (I<VrH<P, R1>, { Dep::Helpful }>, I<VrH<P, R2>, { Dep::Helpful }>, I<VrH<P, R3>, { Dep::Helpful }>, I<VrH<P, R4>, { Dep::Helpful }>, I<VrH<P, R5>, { Dep::Helpful }>, I<VrH<P, R6>, { Dep::Helpful }>, I<VrH<P, R7>, { Dep::Helpful }>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy, R8: Copy> I<VrH<(P, BoundedU<8>), (R1, R2, R3, R4, R5, R6, R7, R8)>, { Dep::Helpful }>

pub fn branch( self ) -> (I<VrH<P, R1>, { Dep::Helpful }>, I<VrH<P, R2>, { Dep::Helpful }>, I<VrH<P, R3>, { Dep::Helpful }>, I<VrH<P, R4>, { Dep::Helpful }>, I<VrH<P, R5>, { Dep::Helpful }>, I<VrH<P, R6>, { Dep::Helpful }>, I<VrH<P, R7>, { Dep::Helpful }>, I<VrH<P, R8>, { Dep::Helpful }>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy, R8: Copy, R9: Copy> I<VrH<(P, BoundedU<9>), (R1, R2, R3, R4, R5, R6, R7, R8, R9)>, { Dep::Helpful }>

pub fn branch( self ) -> (I<VrH<P, R1>, { Dep::Helpful }>, I<VrH<P, R2>, { Dep::Helpful }>, I<VrH<P, R3>, { Dep::Helpful }>, I<VrH<P, R4>, { Dep::Helpful }>, I<VrH<P, R5>, { Dep::Helpful }>, I<VrH<P, R6>, { Dep::Helpful }>, I<VrH<P, R7>, { Dep::Helpful }>, I<VrH<P, R8>, { Dep::Helpful }>, I<VrH<P, R9>, { Dep::Helpful }>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy, R8: Copy, R9: Copy, R10: Copy> I<VrH<(P, BoundedU<10>), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)>, { Dep::Helpful }>

pub fn branch( self ) -> (I<VrH<P, R1>, { Dep::Helpful }>, I<VrH<P, R2>, { Dep::Helpful }>, I<VrH<P, R3>, { Dep::Helpful }>, I<VrH<P, R4>, { Dep::Helpful }>, I<VrH<P, R5>, { Dep::Helpful }>, I<VrH<P, R6>, { Dep::Helpful }>, I<VrH<P, R7>, { Dep::Helpful }>, I<VrH<P, R8>, { Dep::Helpful }>, I<VrH<P, R9>, { Dep::Helpful }>, I<VrH<P, R10>, { Dep::Helpful }>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy, R8: Copy, R9: Copy, R10: Copy, R11: Copy> I<VrH<(P, BoundedU<11>), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)>, { Dep::Helpful }>

pub fn branch( self ) -> (I<VrH<P, R1>, { Dep::Helpful }>, I<VrH<P, R2>, { Dep::Helpful }>, I<VrH<P, R3>, { Dep::Helpful }>, I<VrH<P, R4>, { Dep::Helpful }>, I<VrH<P, R5>, { Dep::Helpful }>, I<VrH<P, R6>, { Dep::Helpful }>, I<VrH<P, R7>, { Dep::Helpful }>, I<VrH<P, R8>, { Dep::Helpful }>, I<VrH<P, R9>, { Dep::Helpful }>, I<VrH<P, R10>, { Dep::Helpful }>, I<VrH<P, R11>, { Dep::Helpful }>)

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

impl<P: 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> I<VrH<(P, BoundedU<12>), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)>, { Dep::Helpful }>

pub fn branch( self ) -> (I<VrH<P, R1>, { Dep::Helpful }>, I<VrH<P, R2>, { Dep::Helpful }>, I<VrH<P, R3>, { Dep::Helpful }>, I<VrH<P, R4>, { Dep::Helpful }>, I<VrH<P, R5>, { Dep::Helpful }>, I<VrH<P, R6>, { Dep::Helpful }>, I<VrH<P, R7>, { Dep::Helpful }>, I<VrH<P, R8>, { Dep::Helpful }>, I<VrH<P, R9>, { Dep::Helpful }>, I<VrH<P, R10>, { Dep::Helpful }>, I<VrH<P, R11>, { Dep::Helpful }>, I<VrH<P, R12>, { Dep::Helpful }>)

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

impl<P: Copy, R: Copy, const N: usize> I<VrH<(P, BoundedU<N>), Array<R, N>>, { Dep::Helpful }>

pub fn branch(self) -> [I<VrH<P, R>, { Dep::Helpful }>; N]

Branches into N VrH hazard interfaces based on the selector.

The selector chooses which egress interface to connect to the ingress interface.

• Payload: Only the selected interface’s payload will be valid.
• Resolvers: The ingress ready signal follows the selected interface’s ready signal. If the selector is not valid, the ingress ready signal is true. The inner values R of the resolvers are preserved, and combined into one interface.

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

impl<P: Copy, const N: usize> I<AndH<ValidH<(P, BoundedU<N>), ()>>, { Dep::Helpful }>

pub fn branch(self) -> [Vr<P>; N]

A variation of branch for a valid-ready interface, that has the correct resolver type.

• Payload: Only the selected interface’s payload will be valid.
• Resolvers: The ingress ready signal follows the selected interface’s ready signal. If the selector is not valid, the ingress ready signal is true.

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

impl<P: Copy, R1: Copy, R2: Copy, const D: Dep> I<ValidH<P, (R1, R2)>, D>

pub fn lfork(self) -> (I<ValidH<P, R1>, D>, I<ValidH<P, R2>, D>)

Forks into two ValidH hazard interfaces.

• Payload: Duplicated to multiple interfaces.
• Resolvers: Preserved, and combined into one interface.

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, const D: Dep> I<ValidH<P, (R1, R2, R3)>, D>

pub fn lfork( self ) -> (I<ValidH<P, R1>, D>, I<ValidH<P, R2>, D>, I<ValidH<P, R3>, D>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, const D: Dep> I<ValidH<P, (R1, R2, R3, R4)>, D>

pub fn lfork( self ) -> (I<ValidH<P, R1>, D>, I<ValidH<P, R2>, D>, I<ValidH<P, R3>, D>, I<ValidH<P, R4>, D>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, const D: Dep> I<ValidH<P, (R1, R2, R3, R4, R5)>, D>

pub fn lfork( self ) -> (I<ValidH<P, R1>, D>, I<ValidH<P, R2>, D>, I<ValidH<P, R3>, D>, I<ValidH<P, R4>, D>, I<ValidH<P, R5>, D>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, const D: Dep> I<ValidH<P, (R1, R2, R3, R4, R5, R6)>, D>

pub fn lfork( self ) -> (I<ValidH<P, R1>, D>, I<ValidH<P, R2>, D>, I<ValidH<P, R3>, D>, I<ValidH<P, R4>, D>, I<ValidH<P, R5>, D>, I<ValidH<P, R6>, D>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy, const D: Dep> I<ValidH<P, (R1, R2, R3, R4, R5, R6, R7)>, D>

pub fn lfork( self ) -> (I<ValidH<P, R1>, D>, I<ValidH<P, R2>, D>, I<ValidH<P, R3>, D>, I<ValidH<P, R4>, D>, I<ValidH<P, R5>, D>, I<ValidH<P, R6>, D>, I<ValidH<P, R7>, D>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy, R8: Copy, const D: Dep> I<ValidH<P, (R1, R2, R3, R4, R5, R6, R7, R8)>, D>

pub fn lfork( self ) -> (I<ValidH<P, R1>, D>, I<ValidH<P, R2>, D>, I<ValidH<P, R3>, D>, I<ValidH<P, R4>, D>, I<ValidH<P, R5>, D>, I<ValidH<P, R6>, D>, I<ValidH<P, R7>, D>, I<ValidH<P, R8>, D>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy, R8: Copy, R9: Copy, const D: Dep> I<ValidH<P, (R1, R2, R3, R4, R5, R6, R7, R8, R9)>, D>

pub fn lfork( self ) -> (I<ValidH<P, R1>, D>, I<ValidH<P, R2>, D>, I<ValidH<P, R3>, D>, I<ValidH<P, R4>, D>, I<ValidH<P, R5>, D>, I<ValidH<P, R6>, D>, I<ValidH<P, R7>, D>, I<ValidH<P, R8>, D>, I<ValidH<P, R9>, D>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy, R8: Copy, R9: Copy, R10: Copy, const D: Dep> I<ValidH<P, (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)>, D>

pub fn lfork( self ) -> (I<ValidH<P, R1>, D>, I<ValidH<P, R2>, D>, I<ValidH<P, R3>, D>, I<ValidH<P, R4>, D>, I<ValidH<P, R5>, D>, I<ValidH<P, R6>, D>, I<ValidH<P, R7>, D>, I<ValidH<P, R8>, D>, I<ValidH<P, R9>, D>, I<ValidH<P, R10>, D>)

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

impl<P: 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> I<ValidH<P, (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)>, D>

pub fn lfork( self ) -> (I<ValidH<P, R1>, D>, I<ValidH<P, R2>, D>, I<ValidH<P, R3>, D>, I<ValidH<P, R4>, D>, I<ValidH<P, R5>, D>, I<ValidH<P, R6>, D>, I<ValidH<P, R7>, D>, I<ValidH<P, R8>, D>, I<ValidH<P, R9>, D>, I<ValidH<P, R10>, D>, I<ValidH<P, R11>, D>)

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

impl<P: 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> I<ValidH<P, (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)>, D>

pub fn lfork( self ) -> (I<ValidH<P, R1>, D>, I<ValidH<P, R2>, D>, I<ValidH<P, R3>, D>, I<ValidH<P, R4>, D>, I<ValidH<P, R5>, D>, I<ValidH<P, R6>, D>, I<ValidH<P, R7>, D>, I<ValidH<P, R8>, D>, I<ValidH<P, R9>, D>, I<ValidH<P, R10>, D>, I<ValidH<P, R11>, D>, I<ValidH<P, R12>, D>)

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

impl<P: Copy, R: Copy, const N: usize, const D: Dep> I<ValidH<P, Array<R, N>>, D>

pub fn lfork(self) -> [I<ValidH<P, R>, D>; N]

Forks into N ValidH hazard interfaces.

• Payload: Duplicated to multiple interfaces.
• Resolvers: Preserved, and combined into one interface.

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

impl<P: Copy> I<ValidH<P, ()>, { Dep::Helpful }>

pub fn lfork(self) -> (Valid<P>, Valid<P>)

A variation of lfork for a valid interface, that has the correct resolver type.

• Payload: Duplicated to multiple interfaces.
• Resolvers: The resolvers carry no information.

Interface	Ingress	Egress
Fwd	HOption<P>	(HOption<P>, HOption<P>)
Bwd	()	((), ())

impl<P: Copy, R1: Copy, R2: Copy, const D: Dep> I<VrH<P, (R1, R2)>, D>

pub fn lfork(self) -> (I<VrH<P, R1>, D>, I<VrH<P, R2>, D>)

Lazy-forks into two VrH hazard interfaces.

An ingress transfer and all egress transfers happen at once when the ingress payload is valid and all the egress ready signals are true.

• Payload: All the egress payloads become available at once when all the egress ready signals are true. Note that In the actual implementation, each egress payload does not check its own interface’s ready signal. This is fine since a transfer would not happen if the ready signal is false. It’s to allow the returned interfaces to be Dep::Helpful. The payload value P is duplicated to multiple interfaces.
• Resolvers: The ingress ready signal is true if all the egress ready signals are true. The inner values R1, R2 of the resolvers are preserved, and combined into one interface.

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, const D: Dep> I<VrH<P, (R1, R2, R3)>, D>

pub fn lfork(self) -> (I<VrH<P, R1>, D>, I<VrH<P, R2>, D>, I<VrH<P, R3>, D>)

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

impl<P: Copy, R: Copy, const N: usize, const D: Dep> I<VrH<P, Array<R, N>>, D>

pub fn lfork(self) -> [I<VrH<P, R>, { Dep::Demanding }>; N]

Lazy-forks into N VrH hazard interfaces.

An ingress transfer and all egress transfers happen at once when the ingress payload is valid and all the egress ready signals are true.

• Payload: All the egress payloads become available at once when all the egress ready signals are true. The payload value P is duplicated to mulitple interfaces.
• Resolvers: The ingress ready signal is true if all the egress ready signals are true. The inner values R of the resolvers are preserved, and combined into one interface.

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

impl<P: Copy, const D: Dep> I<AndH<ValidH<P, ()>>, D>

pub fn lfork(self) -> (Vr<P, D>, Vr<P, D>)

A variation of lfork for a valid-ready interface, that has the correct resolver type.

• Payload: All the egress payloads become available at once when all the egress ready signals are true. The payload value P is duplicated to mulitple interfaces.
• Resolvers: The ingress ready signal is true if all the egress ready signals are true.

Interface	Ingress	Egress
Fwd	HOption<P>	(HOption<P>, HOption<P>)
Bwd	Ready<()>	(Ready<()>, Ready<()>)

impl<const D: Dep, H: Hazard> I<H, D>

pub fn lfork_uni(self) -> (Self, Valid<H::P>)

Lazy-forks a hazard interface unidirectionally.

• Payload: The payload for I<H, D> is preserved. The payload for Valid<H::P> is valid if a transfer for I<H, D> happens.
• Resolvers: The resolver is preserved through I<H, D>.

Interface	Ingress	Egress
Fwd	HOption<H::P>	(HOption<H::P>, HOption<H::P>)
Bwd	H::R	(H::R, ())

pub fn fork_r_to_p(self) -> (Self, Valid<H::R>)

Forks the egress resolver to an egress payload.

• Payload: The payload for I<H, D> is preserved. The payload for Valid<H::R> is from the egress resolver of I<H, D>, and is always valid.
• Resolvers: The resolver is preserved through I<H, D>, and forked to the payload of Valid<H::R>.

Interface	Ingress	Egress
Fwd	HOption<H::P>	(HOption<H::P>, HOption<H::R>)
Bwd	H::R	(H::R, ())

impl<P: Copy, R1: Copy, R2: Copy, const D: Dep> I<VrH<P, (R1, R2)>, D>

pub fn fork_some( self ) -> (I<VrH<P, R1>, { Dep::Demanding }>, I<VrH<P, R2>, { Dep::Demanding }>)

Forks into some of the two VrH hazard interfaces.

An ingress transfer and egress transfers happen as soon as when the ingress payload is valid and at least one of the egress ready signals is true. Note that the egress transfers happen only for the ready egress interfaces.

• Payload: Each egress payload becomes available when its own egress ready signal is true. The payload value P is duplicated to multiple interfaces.
• Resolvers: The ingress ready signal is true if any of the egress ready signals are true. The inner values R1, R2 of the resolvers are preserved, and combined into one interface.

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, const D: Dep> I<VrH<P, (R1, R2, R3)>, D>

pub fn fork_some( self ) -> (I<VrH<P, R1>, { Dep::Demanding }>, I<VrH<P, R2>, { Dep::Demanding }>, I<VrH<P, R3>, { Dep::Demanding }>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, const D: Dep> I<VrH<P, (R1, R2, R3, R4)>, D>

pub fn fork_some( self ) -> (I<VrH<P, R1>, { Dep::Demanding }>, I<VrH<P, R2>, { Dep::Demanding }>, I<VrH<P, R3>, { Dep::Demanding }>, I<VrH<P, R4>, { Dep::Demanding }>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, const D: Dep> I<VrH<P, (R1, R2, R3, R4, R5)>, D>

pub fn fork_some( self ) -> (I<VrH<P, R1>, { Dep::Demanding }>, I<VrH<P, R2>, { Dep::Demanding }>, I<VrH<P, R3>, { Dep::Demanding }>, I<VrH<P, R4>, { Dep::Demanding }>, I<VrH<P, R5>, { Dep::Demanding }>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, const D: Dep> I<VrH<P, (R1, R2, R3, R4, R5, R6)>, D>

pub fn fork_some( self ) -> (I<VrH<P, R1>, { Dep::Demanding }>, I<VrH<P, R2>, { Dep::Demanding }>, I<VrH<P, R3>, { Dep::Demanding }>, I<VrH<P, R4>, { Dep::Demanding }>, I<VrH<P, R5>, { Dep::Demanding }>, I<VrH<P, R6>, { Dep::Demanding }>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy, const D: Dep> I<VrH<P, (R1, R2, R3, R4, R5, R6, R7)>, D>

pub fn fork_some( self ) -> (I<VrH<P, R1>, { Dep::Demanding }>, I<VrH<P, R2>, { Dep::Demanding }>, I<VrH<P, R3>, { Dep::Demanding }>, I<VrH<P, R4>, { Dep::Demanding }>, I<VrH<P, R5>, { Dep::Demanding }>, I<VrH<P, R6>, { Dep::Demanding }>, I<VrH<P, R7>, { Dep::Demanding }>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy, R8: Copy, const D: Dep> I<VrH<P, (R1, R2, R3, R4, R5, R6, R7, R8)>, D>

pub fn fork_some( self ) -> (I<VrH<P, R1>, { Dep::Demanding }>, I<VrH<P, R2>, { Dep::Demanding }>, I<VrH<P, R3>, { Dep::Demanding }>, I<VrH<P, R4>, { Dep::Demanding }>, I<VrH<P, R5>, { Dep::Demanding }>, I<VrH<P, R6>, { Dep::Demanding }>, I<VrH<P, R7>, { Dep::Demanding }>, I<VrH<P, R8>, { Dep::Demanding }>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy, R8: Copy, R9: Copy, const D: Dep> I<VrH<P, (R1, R2, R3, R4, R5, R6, R7, R8, R9)>, D>

pub fn fork_some( self ) -> (I<VrH<P, R1>, { Dep::Demanding }>, I<VrH<P, R2>, { Dep::Demanding }>, I<VrH<P, R3>, { Dep::Demanding }>, I<VrH<P, R4>, { Dep::Demanding }>, I<VrH<P, R5>, { Dep::Demanding }>, I<VrH<P, R6>, { Dep::Demanding }>, I<VrH<P, R7>, { Dep::Demanding }>, I<VrH<P, R8>, { Dep::Demanding }>, I<VrH<P, R9>, { Dep::Demanding }>)

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

impl<P: Copy, R1: Copy, R2: Copy, R3: Copy, R4: Copy, R5: Copy, R6: Copy, R7: Copy, R8: Copy, R9: Copy, R10: Copy, const D: Dep> I<VrH<P, (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)>, D>

pub fn fork_some( self ) -> (I<VrH<P, R1>, { Dep::Demanding }>, I<VrH<P, R2>, { Dep::Demanding }>, I<VrH<P, R3>, { Dep::Demanding }>, I<VrH<P, R4>, { Dep::Demanding }>, I<VrH<P, R5>, { Dep::Demanding }>, I<VrH<P, R6>, { Dep::Demanding }>, I<VrH<P, R7>, { Dep::Demanding }>, I<VrH<P, R8>, { Dep::Demanding }>, I<VrH<P, R9>, { Dep::Demanding }>, I<VrH<P, R10>, { Dep::Demanding }>)

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

impl<P: 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> I<VrH<P, (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)>, D>

pub fn fork_some( self ) -> (I<VrH<P, R1>, { Dep::Demanding }>, I<VrH<P, R2>, { Dep::Demanding }>, I<VrH<P, R3>, { Dep::Demanding }>, I<VrH<P, R4>, { Dep::Demanding }>, I<VrH<P, R5>, { Dep::Demanding }>, I<VrH<P, R6>, { Dep::Demanding }>, I<VrH<P, R7>, { Dep::Demanding }>, I<VrH<P, R8>, { Dep::Demanding }>, I<VrH<P, R9>, { Dep::Demanding }>, I<VrH<P, R10>, { Dep::Demanding }>, I<VrH<P, R11>, { Dep::Demanding }>)

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

impl<P: 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> I<VrH<P, (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)>, D>

pub fn fork_some( self ) -> (I<VrH<P, R1>, { Dep::Demanding }>, I<VrH<P, R2>, { Dep::Demanding }>, I<VrH<P, R3>, { Dep::Demanding }>, I<VrH<P, R4>, { Dep::Demanding }>, I<VrH<P, R5>, { Dep::Demanding }>, I<VrH<P, R6>, { Dep::Demanding }>, I<VrH<P, R7>, { Dep::Demanding }>, I<VrH<P, R8>, { Dep::Demanding }>, I<VrH<P, R9>, { Dep::Demanding }>, I<VrH<P, R10>, { Dep::Demanding }>, I<VrH<P, R11>, { Dep::Demanding }>, I<VrH<P, R12>, { Dep::Demanding }>)

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

impl<P: Copy, R: Copy, const N: usize, const D: Dep> I<VrH<P, Array<R, N>>, D>

pub fn fork_some(self) -> [I<VrH<P, R>, { Dep::Demanding }>; N]

Forks into some of the N VrH hazard interfaces.

An ingress transfer and egress transfers happen as soon as when the ingress payload is valid and at least one of the egress ready signals are true. Note that the egress transfers happen only for the ready egress interfaces.

• Payload: Each egress payload becomes available when its own egress ready signal is true. The payload value P is duplicated to multiple interfaces.
• Resolvers: The ingress ready signal is true if any of the egress ready signals are true. The inner values R of the resolvers are preserved, and combined into one interface.

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

impl<P: Copy, const D: Dep> I<AndH<ValidH<P, ()>>, D>

pub fn fork_some(self) -> (Vr<P, { Dep::Demanding }>, Vr<P, { Dep::Demanding }>)

A variation of fork_some for a valid-ready interface, that has the correct resolver type.

• Payload: Each egress payload becomes available when its own egress ready signal is true. The payload value P is duplicated to multiple interfaces.
• Resolvers: The ingress ready signal is true if any of the egress ready signals are true.

Interface	Ingress	Egress
Fwd	HOption<P>	(HOption<P>, HOption<P>)
Bwd	Ready<()>	(Ready<()>, Ready<()>)

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

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

Unzips a ValidH hazard interface into two ValidH hazard interfaces.

• Payload: Unzipped to multiple interfaces.
• Resolvers: Preserved, and combined into one interface.

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

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

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

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

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

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

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

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

pub fn unzip( self ) -> (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>)

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

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> I<ValidH<(P1, P2, P3, P4, P5, P6), (R1, R2, R3, R4, R5, R6)>, D>

pub fn unzip( self ) -> (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>)

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

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> I<ValidH<(P1, P2, P3, P4, P5, P6, P7), (R1, R2, R3, R4, R5, R6, R7)>, D>

pub fn unzip( self ) -> (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>)

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

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> I<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8), (R1, R2, R3, R4, R5, R6, R7, R8)>, D>

pub fn unzip( self ) -> (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>)

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

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> I<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8, P9), (R1, R2, R3, R4, R5, R6, R7, R8, R9)>, D>

pub fn unzip( self ) -> (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>)

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

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> I<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)>, D>

pub fn unzip( self ) -> (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>)

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

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> 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>

pub fn unzip( self ) -> (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>)

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

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> 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>

pub fn unzip( self ) -> (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>)

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

impl<P: Copy, R: Copy, const N: usize, const D: Dep> I<ValidH<Array<P, N>, Array<R, N>>, D>

pub fn unzip(self) -> [I<ValidH<P, R>, D>; N]

Unzips a ValidH hazard interface into N ValidH hazard interfaces.

• Payload: Unzipped to multiple interfaces.
• Resolvers: Preserved, and combined into one interface.

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

impl<P1: Copy, P2: Copy> I<ValidH<(P1, P2), ()>, { Dep::Helpful }>

pub fn unzip(self) -> (Valid<P1>, Valid<P2>)

A variation of unzip for a valid interface, that has the correct resolver type.

• Payload: Unzipped to multiple interfaces.
• Resolvers: The resolvers carry no information.

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

impl<P1: Copy, P2: Copy, P3: Copy> I<ValidH<(P1, P2, P3), ()>, { Dep::Helpful }>

pub fn unzip(self) -> (Valid<P1>, Valid<P2>, Valid<P3>)

A variation of unzip to 3-12 valid interfaces. See the 2-tuple version for more information.

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy> I<ValidH<(P1, P2, P3, P4), ()>, { Dep::Helpful }>

pub fn unzip(self) -> (Valid<P1>, Valid<P2>, Valid<P3>, Valid<P4>)

A variation of unzip to 3-12 valid interfaces. See the 2-tuple version for more information.

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy> I<ValidH<(P1, P2, P3, P4, P5), ()>, { Dep::Helpful }>

pub fn unzip(self) -> (Valid<P1>, Valid<P2>, Valid<P3>, Valid<P4>, Valid<P5>)

A variation of unzip to 3-12 valid interfaces. See the 2-tuple version for more information.

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy> I<ValidH<(P1, P2, P3, P4, P5, P6), ()>, { Dep::Helpful }>

pub fn unzip( self ) -> (Valid<P1>, Valid<P2>, Valid<P3>, Valid<P4>, Valid<P5>, Valid<P6>)

A variation of unzip to 3-12 valid interfaces. See the 2-tuple version for more information.

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, P7: Copy> I<ValidH<(P1, P2, P3, P4, P5, P6, P7), ()>, { Dep::Helpful }>

pub fn unzip( self ) -> (Valid<P1>, Valid<P2>, Valid<P3>, Valid<P4>, Valid<P5>, Valid<P6>, Valid<P7>)

A variation of unzip to 3-12 valid interfaces. See the 2-tuple version for more information.

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, P7: Copy, P8: Copy> I<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8), ()>, { Dep::Helpful }>

pub fn unzip( self ) -> (Valid<P1>, Valid<P2>, Valid<P3>, Valid<P4>, Valid<P5>, Valid<P6>, Valid<P7>, Valid<P8>)

A variation of unzip to 3-12 valid interfaces. See the 2-tuple version for more information.

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, P7: Copy, P8: Copy, P9: Copy> I<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8, P9), ()>, { Dep::Helpful }>

pub fn unzip( self ) -> (Valid<P1>, Valid<P2>, Valid<P3>, Valid<P4>, Valid<P5>, Valid<P6>, Valid<P7>, Valid<P8>, Valid<P9>)

A variation of unzip to 3-12 valid interfaces. See the 2-tuple version for more information.

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, P7: Copy, P8: Copy, P9: Copy, P10: Copy> I<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10), ()>, { Dep::Helpful }>

pub fn unzip( self ) -> (Valid<P1>, Valid<P2>, Valid<P3>, Valid<P4>, Valid<P5>, Valid<P6>, Valid<P7>, Valid<P8>, Valid<P9>, Valid<P10>)

A variation of unzip to 3-12 valid interfaces. See the 2-tuple version for more information.

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, P7: Copy, P8: Copy, P9: Copy, P10: Copy, P11: Copy> I<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11), ()>, { Dep::Helpful }>

pub fn unzip( self ) -> (Valid<P1>, Valid<P2>, Valid<P3>, Valid<P4>, Valid<P5>, Valid<P6>, Valid<P7>, Valid<P8>, Valid<P9>, Valid<P10>, Valid<P11>)

A variation of unzip to 3-12 valid interfaces. See the 2-tuple version for more information.

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> I<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12), ()>, { Dep::Helpful }>

pub fn unzip( self ) -> (Valid<P1>, Valid<P2>, Valid<P3>, Valid<P4>, Valid<P5>, Valid<P6>, Valid<P7>, Valid<P8>, Valid<P9>, Valid<P10>, Valid<P11>, Valid<P12>)

A variation of unzip to 3-12 valid interfaces. See the 2-tuple version for more information.

impl<P: Copy, const N: usize> I<ValidH<Array<P, N>, ()>, { Dep::Helpful }>

pub fn unzip(self) -> [Valid<P>; N]

A variation of unzip for a valid interface, that has the correct resolver type.

• Payload: Unzipped to multiple interfaces.
• Resolvers: The resolvers carry no information.

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

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

pub fn unzip(self) -> (I<VrH<P1, R1>, D>, I<VrH<P2, R2>, D>)

Unzips a VrH hazard interface into two VrH hazard interfaces.

An ingress transfer and all egress transfers happen at once when the ingress payload is valid and all the egress ready signals are true.

• Payload: Unzipped to multiple interfaces, and all the egress payloads become available at once when all the egress ready signals are true.
• Resolvers: The ingress ready signal is true if all the egress ready signals are true. The inner values R1, R2 of the resolvers are preserved, and combined into one interface.

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

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

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

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

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

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

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

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

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

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

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> I<VrH<(P1, P2, P3, P4, P5, P6), (R1, R2, R3, R4, R5, R6)>, D>

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

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

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> I<VrH<(P1, P2, P3, P4, P5, P6, P7), (R1, R2, R3, R4, R5, R6, R7)>, D>

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

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

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> I<VrH<(P1, P2, P3, P4, P5, P6, P7, P8), (R1, R2, R3, R4, R5, R6, R7, R8)>, D>

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

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

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> I<VrH<(P1, P2, P3, P4, P5, P6, P7, P8, P9), (R1, R2, R3, R4, R5, R6, R7, R8, R9)>, D>

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

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

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> I<VrH<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)>, D>

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

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

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> I<VrH<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)>, D>

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

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

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> 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)>, D>

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

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

impl<P: Copy, R: Copy, const N: usize, const D: Dep> I<VrH<Array<P, N>, Array<R, N>>, D>

pub fn unzip(self) -> [I<VrH<P, R>, { Dep::Demanding }>; N]

Unzips a VrH hazard interface into N VrH hazard interfaces.

An ingress transfer and all egress transfers happen at once when the ingress payload is valid and all the egress ready signals are true.

• Payload: Unzipped to multiple interfaces, and all the egress payloads become available at once when all the egress ready signals are true.
• Resolvers: The ingress ready signal is true if all the egress ready signals are true. The inner values R of the resolvers are preserved, and combined into one interface.

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

impl<P1: Copy, P2: Copy, const D: Dep> I<AndH<ValidH<(P1, P2), ()>>, D>

pub fn unzip(self) -> (Vr<P1, D>, Vr<P2, D>)

A variation of unzip for a valid-ready interface, that has the correct resolver type.

• Payload: Unzipped to multiple interfaces, and all the egress payloads become available at once when all the egress ready signals are true.
• Resolvers: The ingress ready signal is true if all the egress ready signals are true.

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

impl<P1: Copy, P2: Copy, P3: Copy, const D: Dep> I<AndH<ValidH<(P1, P2, P3), ()>>, D>

pub fn unzip( self ) -> (Vr<P1, { Dep::Demanding }>, Vr<P2, { Dep::Demanding }>, Vr<P3, { Dep::Demanding }>)

A variation of unzip to 3-12 valid-ready interfaces. See the 2-tuple version for more information.

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, const D: Dep> I<AndH<ValidH<(P1, P2, P3, P4), ()>>, D>

pub fn unzip( self ) -> (Vr<P1, { Dep::Demanding }>, Vr<P2, { Dep::Demanding }>, Vr<P3, { Dep::Demanding }>, Vr<P4, { Dep::Demanding }>)

A variation of unzip to 3-12 valid-ready interfaces. See the 2-tuple version for more information.

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, const D: Dep> I<AndH<ValidH<(P1, P2, P3, P4, P5), ()>>, D>

pub fn unzip( self ) -> (Vr<P1, { Dep::Demanding }>, Vr<P2, { Dep::Demanding }>, Vr<P3, { Dep::Demanding }>, Vr<P4, { Dep::Demanding }>, Vr<P5, { Dep::Demanding }>)

A variation of unzip to 3-12 valid-ready interfaces. See the 2-tuple version for more information.

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, const D: Dep> I<AndH<ValidH<(P1, P2, P3, P4, P5, P6), ()>>, D>

pub fn unzip( self ) -> (Vr<P1, { Dep::Demanding }>, Vr<P2, { Dep::Demanding }>, Vr<P3, { Dep::Demanding }>, Vr<P4, { Dep::Demanding }>, Vr<P5, { Dep::Demanding }>, Vr<P6, { Dep::Demanding }>)

A variation of unzip to 3-12 valid-ready interfaces. See the 2-tuple version for more information.

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, P7: Copy, const D: Dep> I<AndH<ValidH<(P1, P2, P3, P4, P5, P6, P7), ()>>, D>

pub fn unzip( self ) -> (Vr<P1, { Dep::Demanding }>, Vr<P2, { Dep::Demanding }>, Vr<P3, { Dep::Demanding }>, Vr<P4, { Dep::Demanding }>, Vr<P5, { Dep::Demanding }>, Vr<P6, { Dep::Demanding }>, Vr<P7, { Dep::Demanding }>)

A variation of unzip to 3-12 valid-ready interfaces. See the 2-tuple version for more information.

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, P7: Copy, P8: Copy, const D: Dep> I<AndH<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8), ()>>, D>

pub fn unzip( self ) -> (Vr<P1, { Dep::Demanding }>, Vr<P2, { Dep::Demanding }>, Vr<P3, { Dep::Demanding }>, Vr<P4, { Dep::Demanding }>, Vr<P5, { Dep::Demanding }>, Vr<P6, { Dep::Demanding }>, Vr<P7, { Dep::Demanding }>, Vr<P8, { Dep::Demanding }>)

A variation of unzip to 3-12 valid-ready interfaces. See the 2-tuple version for more information.

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, P7: Copy, P8: Copy, P9: Copy, const D: Dep> I<AndH<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8, P9), ()>>, D>

pub fn unzip( self ) -> (Vr<P1, { Dep::Demanding }>, Vr<P2, { Dep::Demanding }>, Vr<P3, { Dep::Demanding }>, Vr<P4, { Dep::Demanding }>, Vr<P5, { Dep::Demanding }>, Vr<P6, { Dep::Demanding }>, Vr<P7, { Dep::Demanding }>, Vr<P8, { Dep::Demanding }>, Vr<P9, { Dep::Demanding }>)

A variation of unzip to 3-12 valid-ready interfaces. See the 2-tuple version for more information.

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, P7: Copy, P8: Copy, P9: Copy, P10: Copy, const D: Dep> I<AndH<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10), ()>>, D>

pub fn unzip( self ) -> (Vr<P1, { Dep::Demanding }>, Vr<P2, { Dep::Demanding }>, Vr<P3, { Dep::Demanding }>, Vr<P4, { Dep::Demanding }>, Vr<P5, { Dep::Demanding }>, Vr<P6, { Dep::Demanding }>, Vr<P7, { Dep::Demanding }>, Vr<P8, { Dep::Demanding }>, Vr<P9, { Dep::Demanding }>, Vr<P10, { Dep::Demanding }>)

A variation of unzip to 3-12 valid-ready interfaces. See the 2-tuple version for more information.

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, P7: Copy, P8: Copy, P9: Copy, P10: Copy, P11: Copy, const D: Dep> I<AndH<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11), ()>>, D>

pub fn unzip( self ) -> (Vr<P1, { Dep::Demanding }>, Vr<P2, { Dep::Demanding }>, Vr<P3, { Dep::Demanding }>, Vr<P4, { Dep::Demanding }>, Vr<P5, { Dep::Demanding }>, Vr<P6, { Dep::Demanding }>, Vr<P7, { Dep::Demanding }>, Vr<P8, { Dep::Demanding }>, Vr<P9, { Dep::Demanding }>, Vr<P10, { Dep::Demanding }>, Vr<P11, { Dep::Demanding }>)

A variation of unzip to 3-12 valid-ready interfaces. See the 2-tuple version for more information.

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, const D: Dep> I<AndH<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12), ()>>, D>

pub fn unzip( self ) -> (Vr<P1, { Dep::Demanding }>, Vr<P2, { Dep::Demanding }>, Vr<P3, { Dep::Demanding }>, Vr<P4, { Dep::Demanding }>, Vr<P5, { Dep::Demanding }>, Vr<P6, { Dep::Demanding }>, Vr<P7, { Dep::Demanding }>, Vr<P8, { Dep::Demanding }>, Vr<P9, { Dep::Demanding }>, Vr<P10, { Dep::Demanding }>, Vr<P11, { Dep::Demanding }>, Vr<P12, { Dep::Demanding }>)

A variation of unzip to 3-12 valid-ready interfaces. See the 2-tuple version for more information.

impl<P: Copy, const N: usize, const D: Dep> I<AndH<ValidH<Array<P, N>, ()>>, D>

pub fn unzip(self) -> [Vr<P, { Dep::Demanding }>; N]

A variation of unzip for a valid-ready interface, that has the correct resolver type.

• Payload: Unzipped to multiple interfaces, and all the egress payloads become available at once when all the egress ready signals are true.
• Resolvers: The ingress ready signal is true if all the egress ready signals are true.

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

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

pub fn unzip_some( self ) -> (I<VrH<P1, R1>, { Dep::Demanding }>, I<VrH<P2, R2>, { Dep::Demanding }>)

Unzips the VrH hazard interface into some of the two VrH hazard interfaces.

An ingress transfer and egress transfers happen as soon as when the ingress payload is valid and at least one of the egress ready signals is true. Note that the egress transfers happen only for the ready egress interfaces.

• Payload: Unzipped to multiple interfaces, and each egress payload becomes available when its own egress ready signal is true.
• Resolvers: The ingress ready signal is true if any of the egress ready signals are true. The inner values R1, R2 of the resolvers are preserved, and combined into one interface.

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

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

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

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

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

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

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

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

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

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

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> I<VrH<(P1, P2, P3, P4, P5, P6), (R1, R2, R3, R4, R5, R6)>, D>

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

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

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> I<VrH<(P1, P2, P3, P4, P5, P6, P7), (R1, R2, R3, R4, R5, R6, R7)>, D>

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

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

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> I<VrH<(P1, P2, P3, P4, P5, P6, P7, P8), (R1, R2, R3, R4, R5, R6, R7, R8)>, D>

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

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

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> I<VrH<(P1, P2, P3, P4, P5, P6, P7, P8, P9), (R1, R2, R3, R4, R5, R6, R7, R8, R9)>, D>

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

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

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> I<VrH<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)>, D>

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

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

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> I<VrH<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)>, D>

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

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

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> 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)>, D>

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

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

impl<P: Copy, R: Copy, const N: usize, const D: Dep> I<VrH<Array<P, N>, Array<R, N>>, D>

pub fn unzip_some(self) -> [I<VrH<P, R>, { Dep::Demanding }>; N]

Unzips the VrH hazard interface into some of the N VrH hazard interfaces.

An ingress transfer and egress transfers happen as soon as when the ingress payload is valid and at least one of the egress ready signals is true. Note that the egress transfers happen only for the ready egress interfaces.

• Payload: Unzipped to multiple interfaces, and each egress payload becomes available when its own egress ready signal is true.
• Resolvers: The ingress ready signal is true if any of the egress ready signals are true. The inner values R of the resolvers are preserved, and combined into one interface.

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

impl<P1: Copy, P2: Copy, const D: Dep> I<AndH<ValidH<(P1, P2), ()>>, D>

pub fn unzip_some( self ) -> (Vr<P1, { Dep::Demanding }>, Vr<P2, { Dep::Demanding }>)

A variation of unzip_some for a valid-ready interface, that has the correct resolver type.

• Payload: Unzipped to multiple interfaces, and each egress payload becomes available when its own egress ready signal is true.
• Resolvers: The ingress ready signal is true if any of the egress ready signals are true.

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

impl<P1: Copy, P2: Copy, P3: Copy, const D: Dep> I<AndH<ValidH<(P1, P2, P3), ()>>, D>

pub fn unzip_some( self ) -> (Vr<P1, { Dep::Demanding }>, Vr<P2, { Dep::Demanding }>, Vr<P3, { Dep::Demanding }>)

A variation of unzip_some to 3-12 valid-ready interfaces. See the 2-tuple version for more information.

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, const D: Dep> I<AndH<ValidH<(P1, P2, P3, P4), ()>>, D>

pub fn unzip_some( self ) -> (Vr<P1, { Dep::Demanding }>, Vr<P2, { Dep::Demanding }>, Vr<P3, { Dep::Demanding }>, Vr<P4, { Dep::Demanding }>)

A variation of unzip_some to 3-12 valid-ready interfaces. See the 2-tuple version for more information.

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, const D: Dep> I<AndH<ValidH<(P1, P2, P3, P4, P5), ()>>, D>

pub fn unzip_some( self ) -> (Vr<P1, { Dep::Demanding }>, Vr<P2, { Dep::Demanding }>, Vr<P3, { Dep::Demanding }>, Vr<P4, { Dep::Demanding }>, Vr<P5, { Dep::Demanding }>)

A variation of unzip_some to 3-12 valid-ready interfaces. See the 2-tuple version for more information.

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, const D: Dep> I<AndH<ValidH<(P1, P2, P3, P4, P5, P6), ()>>, D>

pub fn unzip_some( self ) -> (Vr<P1, { Dep::Demanding }>, Vr<P2, { Dep::Demanding }>, Vr<P3, { Dep::Demanding }>, Vr<P4, { Dep::Demanding }>, Vr<P5, { Dep::Demanding }>, Vr<P6, { Dep::Demanding }>)

A variation of unzip_some to 3-12 valid-ready interfaces. See the 2-tuple version for more information.

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, P7: Copy, const D: Dep> I<AndH<ValidH<(P1, P2, P3, P4, P5, P6, P7), ()>>, D>

pub fn unzip_some( self ) -> (Vr<P1, { Dep::Demanding }>, Vr<P2, { Dep::Demanding }>, Vr<P3, { Dep::Demanding }>, Vr<P4, { Dep::Demanding }>, Vr<P5, { Dep::Demanding }>, Vr<P6, { Dep::Demanding }>, Vr<P7, { Dep::Demanding }>)

A variation of unzip_some to 3-12 valid-ready interfaces. See the 2-tuple version for more information.

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, P7: Copy, P8: Copy, const D: Dep> I<AndH<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8), ()>>, D>

pub fn unzip_some( self ) -> (Vr<P1, { Dep::Demanding }>, Vr<P2, { Dep::Demanding }>, Vr<P3, { Dep::Demanding }>, Vr<P4, { Dep::Demanding }>, Vr<P5, { Dep::Demanding }>, Vr<P6, { Dep::Demanding }>, Vr<P7, { Dep::Demanding }>, Vr<P8, { Dep::Demanding }>)

A variation of unzip_some to 3-12 valid-ready interfaces. See the 2-tuple version for more information.

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, P7: Copy, P8: Copy, P9: Copy, const D: Dep> I<AndH<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8, P9), ()>>, D>

pub fn unzip_some( self ) -> (Vr<P1, { Dep::Demanding }>, Vr<P2, { Dep::Demanding }>, Vr<P3, { Dep::Demanding }>, Vr<P4, { Dep::Demanding }>, Vr<P5, { Dep::Demanding }>, Vr<P6, { Dep::Demanding }>, Vr<P7, { Dep::Demanding }>, Vr<P8, { Dep::Demanding }>, Vr<P9, { Dep::Demanding }>)

A variation of unzip_some to 3-12 valid-ready interfaces. See the 2-tuple version for more information.

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, P7: Copy, P8: Copy, P9: Copy, P10: Copy, const D: Dep> I<AndH<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10), ()>>, D>

pub fn unzip_some( self ) -> (Vr<P1, { Dep::Demanding }>, Vr<P2, { Dep::Demanding }>, Vr<P3, { Dep::Demanding }>, Vr<P4, { Dep::Demanding }>, Vr<P5, { Dep::Demanding }>, Vr<P6, { Dep::Demanding }>, Vr<P7, { Dep::Demanding }>, Vr<P8, { Dep::Demanding }>, Vr<P9, { Dep::Demanding }>, Vr<P10, { Dep::Demanding }>)

A variation of unzip_some to 3-12 valid-ready interfaces. See the 2-tuple version for more information.

impl<P1: Copy, P2: Copy, P3: Copy, P4: Copy, P5: Copy, P6: Copy, P7: Copy, P8: Copy, P9: Copy, P10: Copy, P11: Copy, const D: Dep> I<AndH<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11), ()>>, D>

pub fn unzip_some( self ) -> (Vr<P1, { Dep::Demanding }>, Vr<P2, { Dep::Demanding }>, Vr<P3, { Dep::Demanding }>, Vr<P4, { Dep::Demanding }>, Vr<P5, { Dep::Demanding }>, Vr<P6, { Dep::Demanding }>, Vr<P7, { Dep::Demanding }>, Vr<P8, { Dep::Demanding }>, Vr<P9, { Dep::Demanding }>, Vr<P10, { Dep::Demanding }>, Vr<P11, { Dep::Demanding }>)

A variation of unzip_some to 3-12 valid-ready interfaces. See the 2-tuple version for more information.

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, const D: Dep> I<AndH<ValidH<(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12), ()>>, D>

pub fn unzip_some( self ) -> (Vr<P1, { Dep::Demanding }>, Vr<P2, { Dep::Demanding }>, Vr<P3, { Dep::Demanding }>, Vr<P4, { Dep::Demanding }>, Vr<P5, { Dep::Demanding }>, Vr<P6, { Dep::Demanding }>, Vr<P7, { Dep::Demanding }>, Vr<P8, { Dep::Demanding }>, Vr<P9, { Dep::Demanding }>, Vr<P10, { Dep::Demanding }>, Vr<P11, { Dep::Demanding }>, Vr<P12, { Dep::Demanding }>)

A variation of unzip_some to 3-12 valid-ready interfaces. See the 2-tuple version for more information.

impl<P: Copy, const N: usize, const D: Dep> I<AndH<ValidH<Array<P, N>, ()>>, D>

pub fn unzip_some(self) -> [Vr<P, { Dep::Demanding }>; N]

A variation of unzip_some for a valid-ready interface, that has the correct resolver type.

• Payload: Unzipped to multiple interfaces, and each egress payload becomes available when its own egress ready signal is true.
• Resolvers: The ingress ready signal is true if any of the egress ready signals are true.

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

impl<P: Copy, R: Copy, const D: Dep> I<VrH<P, R>, D>

pub fn fifo<const N: usize>(self) -> I<VrH<P, R>, { Dep::Helpful }>

FIFO queue with N entries.

This queue is fully pipelined, which means it can accept a new element every cycle.

• Payload: If an ingress transfer happens, the ingress payload is enqueued. If an egress transfer happens, the egress payload is dequeued. The front (dequeue-side) element is outputted as an egress payload.
• Resolver: The ingress ready signal is true if the queue can accept new elements, i.e. not full. The inner value R of the resolver is preserved.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<P>
Bwd	Ready<R>	Ready<R>

impl<const D: Dep, const N: usize, P: Copy, R: Copy> I<VrH<P, (R, FifoS<P, N>)>, D>

pub fn transparent_fifo(self) -> I<VrH<P, R>, { Dep::Helpful }>

A variation of I::fifo that additionally outputs the internal FIFO state to the ingress resolver.

• Payload: The same behavior as I::fifo.
• Resolver: The same behavior as I::fifo, but additionally the FIFO state FifoS<P, N> is outputted.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<P>
Bwd	Ready<(R, FifoS<P, N>)>	Ready<R>

pub fn multi_headed_transparent_fifo( self ) -> I<VrH<FifoS<P, N>, (R, U<{ _ }>)>, { Dep::Helpful }>

A variation of I::transparent_fifo that outputs the FIFO state instead of the front element as the egress payload, and takes an additional egress resolver signal representing how many elements will be popped.

• Payload: The same behavior as I::transparent_fifo, but the FIFO state FifoS<P, N> is outputted instead.
• Resolver: The same behavior as I::transparent_fifo, but additionally takes a U<{ clog2(N + 1) }> that represents how many elements to pop.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<FifoS<P, N>>
Bwd	Ready<(R, FifoS<P, N>)>	Ready<(R, U<{ clog2(N + 1) }>)>

impl<const D: Dep, const N: usize, P: Copy> I<VrH<P, FifoS<P, N>>, D>

pub fn transparent_fifo(self) -> Vr<P>

A variation of I::transparent_fifo that has valid-ready egress interface.

• Payload: The same behavior as I::transparent_fifo.
• Resolver: The same behavior as I::transparent_fifo, but unnecessary unit type is removed in the ingress resolver signal.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<P>
Bwd	Ready<FifoS<P, N>>	Ready<()>

pub fn multi_headed_transparent_fifo( self ) -> I<VrH<FifoS<P, N>, U<{ _ }>>, { Dep::Helpful }>

A variation of I::multi_headed_transparent_fifo that has valid-ready egress interface.

• Payload: The same behavior as I::multi_headed_transparent_fifo.
• Resolver: The same behavior as I::multi_headed_transparent_fifo, but unnecessary unit type is removed in the ingress resolver signal.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<FifoS<P, N>>
Bwd	Ready<FifoS<P, N>>	Ready<U<{ clog2(N + 1) }>>

impl<P: Copy, R: Copy, const D: Dep> I<ValidH<P, R>, D>

pub fn reg_fwd_always(self) -> I<ValidH<P, R>, { Dep::Helpful }>

A 1-cycle buffer for payloads.

• Payload: Buffered by 1 cycle.
• Resolver: Preserved.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<P>
Bwd	R	R

pub fn reg_fwd_valid(self) -> I<ValidH<P, R>, { Dep::Helpful }>

A register that is enabled only if the payload is valid.

• Payload: Only valid payloads are stored, and the stored payload will keep being outputted until a new valid payload comes in.
• Resolver: Preserved.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<P>
Bwd	R	R

pub fn shift_reg_fwd<const LATENCY: usize>( self ) -> I<ValidH<P, R>, { Dep::Helpful }>

A shift register for payloads, with LATENCY-cycle latency.

• Payload: Stored, and outputted after LATENCY cycles.
• Resolver: Preserved.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<P>
Bwd	R	R

Currently only supports SISO.

impl<P: Copy, R: Copy, const D: Dep> I<VrH<P, R>, D>

pub fn reg_fwd(self, pipe: bool) -> I<VrH<P, R>, { Dep::Helpful }>

A register for a VrH hazard interface.

If pipe is true, payloads can be pushed into the state with full throughput. Specifically, the register can accept a new payload in the same cycle as an egress transfer.

• Payload: Stored after an ingress transfer happens. The stored payload is outputted, and cleared after an egress transfer happens.
• Resolver: The ingress ready signal is true when nothing is stored in the state (or additionally when an egress transfer is happening if pipe is true). The inner value R of the resolver is preserved.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<P>
Bwd	Ready<R>	Ready<R>

pub fn reg_fwd_with_init( self, pipe: bool, init: P ) -> I<VrH<P, R>, { Dep::Helpful }>

A variant of I::reg_fwd that takes the initial value of the state.

• Payload: The same behavior as I::reg_fwd.
• Resolver: The same behavior as I::reg_fwd.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<P>
Bwd	Ready<R>	Ready<R>

impl<P: Copy, const D: Dep> I<AndH<ValidH<P, ()>>, D>

pub fn reg_fwd_ready(self) -> Vr<P>

A register that is enabled only if the egress ready signal is true.

• Payload: Outputs the stored payload.
• Resolver: Preserved.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<P>
Bwd	Ready<()>	Ready<()>

pub fn reg_bwd(self) -> Vr<P>

A backward register for the resolver ready signal.

• Payload: Preserved.
• Resolver: The egress ready signal is stored, and outputted after 1 cycle.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<P>
Bwd	Ready<()>	Ready<()>

pub fn reg_bwd_drop(self) -> Vr<P>

A backward register for the resolver ready signal that drops the payload if the stored ready signal is false.

• Payload: Dropped if the stored ready signal is false.
• Resolver: The egress ready signal is stored, and outputted after 1 cycle.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<P>
Bwd	Ready<()>	Ready<()>

impl<const D: Dep, P: Copy, R: Copy, H: Hazard<P = P, R = (R, HOption<P>)>> I<AndH<H>, D>

pub fn transparent_reg_fwd<EH: Hazard<P = P, R = R>>( self, pipe: bool ) -> I<AndH<EH>, { Dep::Helpful }>

A register for an AndH hazard interface.

If pipe is true, payloads can be pushed into the state with full throughput. Specifically, the register can accept a new payload in the same cycle as an egress transfer.

• Payload: Stored after an ingress transfer happens. The stored payload is outputted, and cleared after an egress transfer happens.
• Resolver: The ingress ready signal is true when nothing is stored in the state (or additionally when an egress transfer is happening if pipe is true). The inner value R of the resolver is preserved, and additionally the internal state HOption<P> is outputted to the ingress resolver.

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

pub fn transparent_reg_fwd_with_init<EH: Hazard<P = P, R = R>>( self, pipe: bool, init: P ) -> I<AndH<EH>, { Dep::Helpful }>

A variant of I::transparent_reg_fwd that takes the initial value of the state.

• Payload: The same behavior as I::transparent_reg_fwd.
• Resolver: The same behavior as I::transparent_reg_fwd.

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

impl<P: Copy, const D: Dep> I<AndH<ValidH<P, ()>>, D>

pub fn reg_skid(self) -> Vr<P>

A skid-buffer for a valid-ready interface.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<P>
Bwd	Ready<()>	Ready<()>

impl<H: Hazard> I<H, { Dep::Helpful }>

pub fn sink_map(self, f: impl Fn(HOption<H::P>) -> H::R)

A sink that maps and returns the data from the payload to the resolver.

• Payload: Mapped to the resolver by f.
• Resolver: Outputs the mapped value.

Interface	Ingress
Fwd	HOption<H::P>
Bwd	H::R

pub fn sink_fsm_map<S: Copy>( self, init_state: S, f: impl Fn(HOption<H::P>, S) -> (H::R, S) )

A I::sink_map with an internal state.

f additionally takes the current state and returns the next state. The state is updated when an ingress transfer happens.

• Payload: Mapped to the resolver by f.
• Resolver: Outputs the mapped value.

Interface	Ingress
Fwd	HOption<H::P>
Bwd	H::R

impl<P: Copy> I<ValidH<P, P>, { Dep::Demanding }>

pub fn source() -> I<ValidH<P, P>, { Dep::Demanding }>

A source that returns the data coming from the resolver to the payload.

• Payload: Outputs the resolver data. Always valid.
• Resolver: Returned to the payload.

Interface	Egress
Fwd	HOption<P>
Bwd	P

impl<P: Copy> I<VrH<P, P>, { Dep::Demanding }>

pub fn source_drop() -> I<VrH<P, P>, { Dep::Demanding }>

A source that returns the data coming from the resolver to the payload.

• Payload: Outputs the resolver data. Dropped if the egress ready signal is false.
• Resolver: Returned to the payload.

Interface	Egress
Fwd	HOption<P>
Bwd	Ready<P>

impl<H: Hazard> I<H, { Dep::Demanding }>

pub fn source_map_drop( f: impl Fn(H::R) -> HOption<H::P> ) -> I<H, { Dep::Demanding }>

A source that maps and returns the data coming from the resolver to the payload.

• Payload: Outputs the resolver data. Dropped if H::ready is false.
• Resolver: Returned to the payload.

Interface	Egress
Fwd	HOption<H::P>
Bwd	H::R

impl<P: Copy> I<ValidH<P, ()>, { Dep::Helpful }>

pub fn constant(value: P) -> Self

A constant signal.

• Payload: Always valid.
• Resolver: The resolver carries no information.

Interface	Egress
Fwd	HOption<P>
Bwd	()

impl<P: Copy> I<AndH<ValidH<P, ()>>, { Dep::Helpful }>

pub fn constant(value: P) -> Vr<P>

A constant signal.

• Payload: Always valid.
• Resolver: Ignored.

Interface	Egress
Fwd	HOption<P>
Bwd	Ready<()>

impl<P: Copy, R: Copy, const D: Dep> I<VrH<P, R>, D>

pub fn fsm_egress<EP: Copy, S: Copy>( self, init: S, pipe: bool, flow: bool, f: impl Fn(P, S) -> (EP, S, bool) ) -> I<VrH<EP, R>, D>

For each transferred ingress payload, runs a finite state machine described by f until f returns true for is_last.

This allows you to process each ingress payload using multiple FSM states.

• Payload: Controlled by the combinator’s behavior.
• Resolver: The ingress ready signal is controlled by the combinator’s behavior. The inner value R of the resolver is preserved.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<EP>
Bwd	Ready<R>	Ready<R>

Detailed explanation

Parameters

• init: The initial state for the FSM.
• pipe: If true, starts a new FSM immediately after an FSM finishes if an input is available. If false, transitions to a waiting case first then accept an input for a new FSM.
• flow: If true, starts running the FSM immediately from the cycle of an ingress transfer. If false, starts running the FSM from the next cycle of an ingress transfer.
• f: The function that describes the FSM. If let (ep, s_next, is_last) = f(p, s),
  • p: The current saved ingress payload for this FSM.
  • s: The current FSM state.
  • ep: The calculated egress payload.
  • s_next: The next FSM state.
  • is_last: Whether this is the last state of the FSM for the current saved payload.

The pipe and flow parameters are inspired by https://github.com/chipsalliance/chisel/blob/9c1829e6afe8a08630c90d5a0f30bce9c487075f/src/main/scala/chisel3/util/Decoupled.scala#L243.

High-level overview of the behavior

The combinator can be in one of the two cases: Waiting for an ingress transfer and Running the FSM.

Initially, the combinator is in the Waiting for an ingress transfer case and waits for an ingress transfer to happen. Once an ingress transfer happens, it saves the ingress payload to transition to the Running the FSM case, and starts a new FSM. Whether this happens on the same cycle as the transfer or on the next cycle depends on flow.

In the Running the FSM case, the combinator runs the FSM with the saved payload outputting egress payloads. When f returns true for is_last, it will save a new ingress payload and start a new FSM, if pipe is true and the new ingress payload is already available. Otherwise, it will transition back to the Waiting for an ingress transfer case next cycle.

Detailed behavior

NOTE: The description below assumes the following naming convention. Here, sp is the saved ingress payload and determines the case the combinator is in. s is the FSM state. The description is organized sligtly differently from the actual implementation for better clarity.

// an implementation of `fsm_egress`
self.fsm((None, init), |ip, er, (sp, s)| {
    // ... the description below would fit here
    (ep, ir, (sp_next, s_next))
})

• Waiting for an ingress transfer (sp == None)
  • Do not produce an egress payload: ep = None
  • Can accept a new ingress payload: ir = (true, er.inner)
  • If an ingress transfer happens (if it),
    • If flow,
      • (The description below is not how the actual code works, but conceptually the behavior should be the same.)
      • Conceptually save the ingress payload and transition to the Running the FSM case this cycle: sp = ip
      • Start a new FSM with the initial state this cycle: s = init
      • Run the logic for the Running the FSM case, except for ir which remains (true, er.inner).
        • Output the calculated egress payload: ep = Some(ep_f)
        • The case next cycle is determined by the logic: sp_next = ...
        • The FSM state next cycle is determined by the logic: s_next = ...
    • If not flow,
      • Save the ingress payload to transition to the Running the FSM case next cycle: sp_next = ip
      • Start a new FSM with the initial state next cycle: s_next = init
  • If no ingress transfer happens (else),
    • Remain in the current case: sp_next = sp
    • Do not change the FSM state: s_next = s
• Running the FSM (sp == Some)
  • Run f: let (ep_f, s_next_f, is_last) = f(sp.unwrap(), s)
  • Output the calculated egress payload: ep = Some(ep_f)
  • (Let’s say that “the FSM finishes” if an egress transfer happens and this is the last state of the FSM (et && is_last).)
  • For the ingress resolver,
    • If pipe, do not accept a new ingress payload but can accept one if the FSM finishes: ir = (et && is_last, er.inner)
    • If not pipe, do not accept a new ingress payload: ir = (false, er.inner)
  • If the FSM finishes and an ingress transfer happens (if it),
    • (Note that this can only happen if pipe.)
    • Save the new ingress payload and remain in the current case: sp_next = ip
    • Start a new FSM with the initial state next cycle: s_next = init
  • If the FSM finishes but no ingress transfer happens (if et && is_last),
    • Remove the saved payload to transition to the Waiting for an ingress transfer case next cycle: sp_next = None
    • Reset the FSM state next cycle: s_next = init
  • If an egress transfer happens but this is not the last state of the FSM (else if et),
    • Remain in the current case: sp_next = sp
    • Update the FSM state next cycle: s_next = s_next_f
  • If no egress transfer happens (else),
    • Remain in the current case: sp_next = sp
    • Do not update the FSM state: s_next = s

pub fn fsm_egress_with_r<EP: Copy, S: Copy>( self, init: S, pipe: bool, f: impl Fn(P, R, S) -> (EP, S, bool) ) -> I<VrH<EP, R>, { Dep::Demanding }>

For each transferred ingress payload, runs a finite state machine described by f until f returns true for is_last. Specifically, this version of the combinator allows you to access the egress resolver while running the FSM.

This allows you to process each ingress payload using multiple FSM states.

• Payload: Controlled by the combinator’s behavior.
• Resolver: The ingress ready signal is controlled by the combinator’s behavior. The inner value R of the resolver is preserved.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<EP>
Bwd	Ready<R>	Ready<R>

Detailed explanation

Parameters

• init: The initial state for the FSM.
• f: The function that describes the FSM. If let (ep, s_next, is_last) = f(p, er_inner, s),
  • p: The current saved ingress payload for this FSM.
  • er_inner: The inner value of the egress resolver.
  • s: The current FSM state.
  • ep: The calculated egress payload.
  • s_next: The next FSM state.
  • is_last: Whether this is the last state of the FSM for the current saved payload.

High-level overview of the behavior

The combinator can be in one of the two cases: Waiting for an ingress transfer and Running the FSM.

Initially, the combinator is in the Waiting for an ingress transfer case and waits for an ingress transfer to happen. Once an ingress transfer happens, it saves the ingress payload to transition to the Running the FSM case, and starts a new FSM.

In the Running the FSM case, the combinator runs the FSM with the saved payload, outputting egress payloads. When f returns true for is_last, it will transition back to the Waiting for an ingress transfer case next cycle.

Detailed behavior

NOTE: The description below assumes the following naming convention. Here, sp is the saved ingress payload and determines the case the combinator is in. s is the FSM state. The description is organized sligtly differently from the actual implementation for better clarity.

// an implementation of `fsm_egress_with_r`
self.fsm((None, init), |ip, er, (sp, s)| {
    // ... the description below would fit here
    (ep, ir, (sp_next, s_next))
})

• Waiting for an ingress transfer (sp == None)
  • Do not produce an egress payload: ep = None
  • Can accept a new ingress payload: ir = (true, er.inner)
  • If an ingress transfer happens (if it),
    • Save the ingress payload and transit to the Running the FSM case next cycle: sp_next = ip
    • Start a new FSM with the initial state next cycle: s_next = init
• Running the FSM (sp == Some)
  • Run f: let (ep_f, s_next_f, is_last) = f(sp.unwrap(), er.inner, s)
  • Output the calculated egress payload: ep = Some(ep_f)
  • Let’s say that “the FSM finishes” if an egress transfer happens and this is the last state of the FSM (et && is_last).
  • Do not accept a new ingress payload, but can accept one if the FSM finishes: ir = (et && is_last, er.inner)
  • If the FSM finishes and an ingress transfer happens (if it),
    • Save the new ingress payload and remain in the current case: sp_next = ip
    • Start a new FSM with the initial state next cycle: s_next = init
  • If the FSM finishes but no ingress transfer happens (if et && is_last),
    • Remove the saved payload to transition to the Waiting for an ingress transfer case next cycle: sp_next = None
    • Reset the FSM state next cycle: s_next = init
  • If an egress transfer happens but this is not the last state of the FSM (else if et),
    • Remain in the current case: sp_next = sp
    • Update the FSM state next cycle: s_next = s_next_f
  • If no egress transfer happens (else),
    • Remain in the current case: sp_next = sp
    • Do not update the FSM state: s_next = s

impl<P: Copy, R: Copy, S: Copy, const D: Dep> I<VrH<P, (R, (HOption<P>, S))>, D>

pub fn transparent_fsm_egress<EP: Copy>( self, init: S, pipe: bool, flow: bool, f: impl Fn(P, S) -> (EP, S, bool) ) -> I<VrH<EP, R>, D>

A variation of I::fsm_egress that additionally outputs the internal state to the ingress resolver.

• Payload: The same behavior as I::fsm_egress.
• Resolver: The same behavior as I::fsm_egress, but additionally the internal state (HOption<P>, S) is outputted.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<EP>
Bwd	Ready<(R, (HOption<P>, S))>	Ready<R>

impl<P: Copy, R: Copy, const D: Dep> I<VrH<P, (R, HOption<P>)>, D>

pub fn transparent_fsm_egress_with_r<EP: Copy, S: Copy>( self, init: S, pipe: bool, f: impl Fn(P, R, S) -> (EP, S, bool) ) -> I<VrH<EP, R>, { Dep::Demanding }>

TODO: Documentation

impl<P: Copy, R: Copy, const D: Dep> I<VrH<P, R>, D>

pub fn fsm_ingress<S: Copy>( self, init: S, f: impl Fn(P, R, S) -> (S, bool) ) -> I<VrH<S, R>, { Dep::Helpful }>

Runs a finite state machine described by f, accepting successive ingress payloads until f returns true for done_next. Then, outputs the resulting FSM state and reset.

This allows you to accumulate successive ingress payloads into the internal FSM state until it is ready to be transmitted.

• Payload: Controlled by the combinator’s behavior.
• Resolver: The ingress ready signal is controlled by the combinator’s behavior. The inner value R of the resolver is preserved.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<S>
Bwd	Ready<R>	Ready<R>

Detailed explanation

Parameters

• init: The initial state for the FSM.
• f: The function that describes the FSM. If let (s_next, done_next) = f(p, r, s),
  • p: The ingress payload.
  • r: The inner value of the egress resolver.
  • s: The current FSM state.
  • s_next: The next FSM state.
  • done_next: Whether the FSM is done accumulating.

High-level overview of the behavior

The combinator can be in one of the two cases: Accumulating and Outputting.

The combinator is initially in the Acumulating case. In this case, it keeps accepting ingress payloads and runs the FSM, allowing it to accumulate the payloads. When f returns true for done_next, the combinator will transition to the Outputting case next cycle.

In the Outputting case, the combinator outputs the resulting FSM state and blocks the ingress. When the egress transfer of the state happens, it will transition back to the Accumulating case next cycle.

Detailed behavior

NOTE: The description below assumes the following naming convention. Here, s is the FSM state, and done represents the current case the combinator is in. The description is organized sligtly differently from the actual implementation for better clarity.

// an implementation of `fsm_ingress`
self.fsm((init, false), |ip, er, (s, done)| {
    // ... (the description below would fit here)
    (ep, ir, (s_next, done_next))
})

• Accumulating (done == false)
  • Do not produce an egress payload: ep = None
  • Accept ingress payloads: ir = (true, er.inner)
  • If an ingress transfer happens (if it),
    • Run f: let (s_next_f, done_next_f) = f(ip.unwrap(), er.inner, s)
    • Update the FSM state next cycle: s_next = s_next_f
    • Remain in the current case or transition to the Outputting case next cycle, depending on the returned value: done_next = done_next_f
  • If no ingress transfer happens (else),
    • Do not update the FSM state: s_next = s
    • Remain in the current case: done_next = done
• Outputting (done == true)
  • Output the FSM state: ep = Some(s)
  • Block ingress payloads: ir = (false, er.inner)
  • If an egress transfer happens (if et)
    • Reset the FSM state next cycle: s_next = init
    • Transition to the Accumulating case next cycle: done_next = false
  • If no egress transfer happens (else)
    • Do not change the FSM state: s_next = s
    • Remain in the current case: done_next = done

impl<P: Copy, R: Copy, const D: Dep> I<ValidH<P, R>, D>

pub fn fsm_map<EP: Copy, S: Copy>( self, init_state: S, f: impl Fn(P, S) -> (EP, S) ) -> I<ValidH<EP, R>, D>

A map with an internal state.

f additionally takes the current state and returns the next state. The state is updated if the ingress payload is valid and so an ingress transfer happens.

• Payload: Mapped by f.
• Resolver: Preserved.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<EP>
Bwd	R	R

pub fn fsm_filter_map<EP: Copy, S: Copy>( self, init: S, f: impl Fn(P, S) -> (HOption<EP>, S) ) -> I<ValidH<EP, R>, D>

A filter_map with an internal state.

f additionally takes the current state and returns the next state. The state is updated if the ingress payload is valid and so an ingress transfer happens.

• Payload: Filter-mapped by f.
• Resolver: Preserved.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<EP>
Bwd	R	R

impl<P: Copy, R: Copy, S: Copy, const D: Dep> I<ValidH<P, (R, S)>, D>

pub fn transparent_fsm_map<EP: Copy>( self, init_state: S, f: impl Fn(P, S) -> (EP, S) ) -> I<ValidH<EP, R>, D>

A variation of fsm_map that attaches an additional internal state signal to the ingress resolver.

• Payload: Mapped by f.
• Resolver: Preserved. The internal state S is additionally outputted.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<EP>
Bwd	(R, S)	R

pub fn transparent_fsm_map_with_r<EP: Copy>( self, init_state: S, f: impl Fn(P, R, S) -> (EP, S) ) -> I<ValidH<EP, R>, { Dep::Demanding }>

A variation of transparent_fsm_map that allows f to additionally consider the egress resolver.

• Payload: Mapped by f.
• Resolver: Preserved. The internal state S is additionally outputted.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<EP>
Bwd	(R, S)	R

pub fn transparent_fsm_filter_map<EP: Copy>( self, init: S, f: impl Fn(P, S) -> (HOption<EP>, S) ) -> I<ValidH<EP, R>, D>

A variation of fsm_filter_map that attaches an additional internal state signal to the ingress resolver.

• Payload: Filter-mapped by f.
• Resolver: Preserved. The internal state S is additionally outputted.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<EP>
Bwd	(R, S)	R

pub fn transparent_fsm_filter_map_with_r<EP: Copy>( self, init: S, f: impl Fn(P, R, S) -> (HOption<EP>, S) ) -> I<ValidH<EP, R>, { Dep::Demanding }>

A variation of transparent_fsm_filter_map that allows f to additionally consider the egress resolver.

• Payload: Filter-mapped by f.
• Resolver: Preserved. The internal state S is additionally outputted.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<EP>
Bwd	(R, S)	R

impl<P: Copy, R: Copy, const D: Dep> I<VrH<P, R>, D>

pub fn fsm_map<EP: Copy, S: Copy>( self, init_state: S, f: impl Fn(P, S) -> (EP, S) ) -> I<VrH<EP, R>, D>

A map with an internal state.

f additionally takes the current state and returns the next state. The state is updated if an ingress transfer happens.

• Payload: Mapped by f.
• Resolver: Preserved.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<EP>
Bwd	Ready<R>	Ready<R>

pub fn fsm_filter_map<EP: Copy, S: Copy>( self, init: S, f: impl Fn(P, S) -> (HOption<EP>, S) ) -> I<VrH<EP, R>, D>

A filter_map with an internal state.

f additionally takes the current state and returns the next state. The state is updated if an ingress transfer happens.

• Payload: Filter-mapped by f.
• Resolver: Preserved.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<EP>
Bwd	Ready<R>	Ready<R>

impl<P: Copy, R: Copy, S: Copy, const D: Dep> I<VrH<P, (R, S)>, D>

pub fn transparent_fsm_map<EP: Copy>( self, init_state: S, f: impl Fn(P, S) -> (EP, S) ) -> I<VrH<EP, R>, D>

A variation of fsm_map that attaches an additional internal state signal to the ingress resolver.

• Payload: Mapped by f.
• Resolver: Preserved. The internal state S is additionally outputted.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<EP>
Bwd	Ready<(R, S)>	Ready<R>

pub fn transparent_fsm_map_drop_with_r<EP: Copy>( self, init: S, f: impl Fn(P, Ready<R>, S) -> (EP, S) ) -> I<VrH<EP, R>, { Dep::Demanding }>

A variation of transparent_fsm_map that allows f to additionally consider the egress resolver.

• Payload: Mapped by f. The payload is dropped if er.ready is false, even if f returns Some. (why?)
• Resolver: Preserved. The internal state S is additionally outputted.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<EP>
Bwd	Ready<(R, S)>	Ready<R>

pub fn transparent_fsm_filter_map<EP: Copy>( self, init: S, f: impl Fn(P, S) -> (HOption<EP>, S) ) -> I<VrH<EP, R>, D>

A variation of fsm_filter_map that attaches an additional internal state signal to the ingress resolver.

• Payload: Filter-mapped by f.
• Resolver: Preserved. The internal state S is additionally outputted.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<EP>
Bwd	Ready<(R, S)>	Ready<R>

pub fn transparent_fsm_filter_map_drop_with_r<EP: Copy>( self, init: S, f: impl Fn(P, Ready<R>, S) -> (HOption<EP>, S) ) -> I<VrH<EP, R>, { Dep::Demanding }>

A variation of transparent_fsm_filter_map that allows f to additionally consider the egress resolver.

• Payload: Filter-mapped by f. The payload is dropped if er.ready is false, even if f returns Some. (why?)
• Resolver: Preserved. The internal state S is additionally outputted.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<EP>
Bwd	Ready<(R, S)>	Ready<R>

impl<P: Copy> I<ValidH<P, ()>, { Dep::Demanding }>

pub fn into_helpful(self) -> Valid<P>

Converts the dependency type of a valid interface back into Dep::Helpful.

When applying some combinator, the dependency type of a valid interface could be changed to Dep::Demanding. This function is used to convert the dependency type back to Dep::Helpful.

• Payload: Preserved.
• Resolver: The resolver carries no information.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<P>
Bwd	()	()

impl<P: Copy, R: Copy> I<ValidH<P, R>, { Dep::Helpful }>

pub fn discard_into_vr(self) -> I<VrH<P, R>, { Dep::Helpful }>

Converts a ValidH interface into a VrH interface, by allowing the payload to be discarded.

Note that the ingress ready condition ValidH::ready is always true, but the egress ready condition VrH::ready is er.ready. This means if er.ready is false, the payload will be discarded/ignored by combinators after this one even if it is valid.

• Payload: Preserved, but may be discarded by combinators after this one.
• Resolver: The ready signal is stripped.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<P>
Bwd	R	Ready<R>

impl<P: Copy, R: Copy, const D: Dep> I<VrH<P, R>, D>

pub fn always_into_valid(self) -> I<ValidH<P, R>, D>

Converts a VrH hazard interface into a ValidH hazard interface, by setting the ingress ready signal to be always true.

• Payload: Preserved.
• Resolver: Wrapped in an always ready Ready.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<P>
Bwd	Ready<R>	R

impl<H: Hazard> I<H, { Dep::Helpful }>

pub fn drop_into_demanding(self) -> I<H, { Dep::Demanding }>

Converts a Dep::Helpful hazard interface into a Dep::Demanding one, by dropping the payload if H::ready is false.

• Payload: Dropped if H::ready is false.
• Resolver: Preserved.

Interface	Ingress	Egress
Fwd	HOption<H::P>	HOption<H::P>
Bwd	H::R	H::R

impl<H: Hazard, const D: Dep> I<H, D>

pub fn drop_into_hazard<EH: Hazard<P = H::P, R = H::R>>( self ) -> I<EH, { Dep::Demanding }>

Converts a hazard interface into another one with the same payload/resolver types.

In effect, this changes the ready condition from the ingress side H::ready to the egress side EH::ready.

• Payload: Dropped if H::ready or EH::ready is false.
• Resolver: Preserved.

Interface	Ingress	Egress
Fwd	HOption<H::P>	HOption<H::P>
Bwd	H::R	H::R

impl<H: Hazard> I<AndH<H>, { Dep::Helpful }>

pub fn block_into_hazard<EH: Hazard<P = H::P, R = H::R>>( self ) -> I<EH, { Dep::Demanding }>

Converts a hazard interface wrapped in an AndH into another one with the same payload/resolver types.

In effect, this changes the ready condition from the ingress side <AndH<H>>::ready to the egress side EH::ready.

• Payload: Preserved.
• Resolver: An additional ready signal is attached to the ingress resolver, which will be turned off to block ingress transfers if the egress ready condition EH::ready is false. The egress resolver H::R is preserved.

Interface	Ingress	Egress
Fwd	HOption<H::P>	HOption<H::P>
Bwd	Ready<H::R>	H::R

impl<P: Copy> I<AndH<ValidH<P, ()>>, { Dep::Helpful }>

pub fn block_into_hazard_vr<EH: Hazard<P = P>>( self ) -> I<EH, { Dep::Demanding }>

A variation of I::block_into_hazard for a valid-ready interface that drops the resolver.

• Payload: Preserved.
• Resolver: The ingress ready signal will be turned off to block ingress transfers if the egress ready condition EH::ready is false. The egress resolver EH::R is dropped.

Interface	Ingress	Egress
Fwd	HOption<P>	HOption<P>
Bwd	Ready<()>	EH::R

impl<const D: Dep, P: Copy, R: Copy> I<ValidH<P, R>, D>

pub fn generator<EP: Copy, S: Copy>( self, init: S, f_write_state: impl Fn(P, R, S) -> S, f_read_state: impl Fn(S) -> HOption<EP> ) -> I<ValidH<EP, R>, { Dep::Helpful }>

Generator.

TODO: Documentation

impl<const D: Dep, P: Copy, R: Copy> I<VrH<P, R>, D>

pub fn generator<EP: Copy, S: Copy>( self, init: S, f_write_state: impl Fn(P, R, S) -> S, f_read_state: impl Fn(S) -> (HOption<EP>, bool) ) -> I<VrH<EP, R>, { Dep::Helpful }>

Generator.

Input

• init: Initial state.
• f_write_state: Write state function. This will set the state when ingress ingress_transfer happens.
• f_read_state: Read state function. This will read the state and trigger egress transfer when egess ready is true and the function returns Some. Also, the boolean value returned by this function will work as the ready signal for the ingress transfer(i.e., backpressure).

impl<const N: usize, H: Hazard, const D: Dep> I<SelH<H, N>, D>

pub fn into_inner(self) -> I<H, D>

Transforms the muxed hazard to the inner hazard.

impl<H: Hazard, const D: Dep> I<H, D>

pub unsafe fn fsm<S: Copy, const ED: Dep, EH: Hazard>( self, init_state: S, f: impl Fn(HOption<H::P>, EH::R, S) -> (HOption<EH::P>, H::R, S) ) -> I<EH, ED>

A generic FSM combinator for a hazard interface.

For more information, you can check the documentation for Interface::fsm.

Safety

To enforce the invariant of the hazard protocol, you have to consider the following depending on the dependency type of the ingress/egress interface.

• Ingress interface
  • Dep::Helpful: In the ingress interface’s fsm, its payload does not depend on its resolver. So in this fsm, we can use the fact that ip does not depend on ir. That means we can make ir depend on ip.
  • Dep::Demanding: In the ingress interface’s fsm, its payload depends on its resolver, and if the payload is Some, Hazard::ready(p, r) is true. So in this fsm, we must consider that ip depends on ir, but can assume that if ip is Some, H::ready(ip, ir) is true regardless of ir.
• Egress interface
  • Dep::Helpful: In this fsm, we ensure that ep does not depend on er. If the dependency chain goes through the ingress interface, we must consider that as well.
  • Dep::Demanding: In this fsm, we make ep depend on er, and guarantee that if ep is Some, EH::ready(ep, er) is true.

Type parameters

• H: The ingress interface’s hazard type.
• D: The ingress interface’s dependency type.
• S: The state type.
• ED: The egress interface’s dependency type.
• EH: The egress interface’s hazard type.

Parameters

• self: The ingress interface.
• init_state: The initial state.
• f: Output calculation and state transition logic. If let (ep, ir, s_next) = f(ip, er, s),
  • ip: The ingress payload.
  • er: The egress resolver.
  • s: The current state.
  • ep: The egress payload.
  • ir: The ingress resolver.
  • s_next: The next state.

Note: preventing combinational loops

Combinational loops are among the most common causes of instability and unreliability in digital designs. Combinational loops generally violate synchronous design principles by establishing a direct feedback loop that contains no registers.

• To prevent combinational loops, programmers have to make sure that there is no circular dependency between the payload and resolver of the same interface.
• Dependency types help with this.

Trait Implementations

impl<H: Debug + Hazard, const D: Dep> Debug for I<H, D>

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

Formats the value using the given formatter.

impl<H: Hazard, const D: Dep> Interface for I<H, D>

type Bwd = <H as Hazard>::R

Resolver.

type Fwd = HOption<<H as Hazard>::P>

Payload.

Some(p) means a valid payload with data p, and None means an invalid payload.

unsafe fn fsm<E: Interface, S: Copy>( self, _init_state: S, _f: impl Fn(Self::Fwd, E::Bwd, S) -> (E::Fwd, Self::Bwd, S) ) -> E

A generic FSM combinator.

fn comb<E: Interface>(self, m: impl FnOnce(Self) -> E) -> E

Combines the module to the given interface and returns the egress interface.