Struct Penta 

pub struct Penta<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc>
where
    Sc: Score,
    P1: CompileCondition<Plan: IndexedPlan>,
    P2: CompileCondition<Plan: IndexedPlan>,
    P3: CompileCondition<Plan: IndexedPlan>,
    P4: CompileCondition<Plan: IndexedPlan>,
{ /* private fields */ }

Implementations

impl<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc> Penta<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc>

where S: Send + Sync + 'static, A: Clone + Send + Sync + 'static, B: Clone + Send + Sync + 'static, C: Clone + Send + Sync + 'static, D: Clone + Send + Sync + 'static, E: Clone + Send + Sync + 'static, EA: 'static, EB: 'static, EC: 'static, ED: 'static, EE: 'static, P1: CompileCondition<Plan: IndexedPlan> + 'static, P2: CompileCondition<Plan: IndexedPlan> + 'static, P3: CompileCondition<Plan: IndexedPlan> + 'static, P4: CompileCondition<Plan: IndexedPlan> + 'static, for<'a> JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, CollectionNode<S, EA>, CollectionNode<S, EB>, <P1 as CompileCondition>::Plan>, CollectionNode<S, EC>, <P2 as CompileCondition>::Plan>, CollectionNode<S, ED>, <P3 as CompileCondition>::Plan>, CollectionNode<S, EE>, <P4 as CompileCondition>::Plan>: Operator<S>, F: PentaFilter<S, A, B, C, D, E>, Sc: Score + 'static,

pub fn filter<P>( self, predicate: P, ) -> Penta<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, AndPentaFilter<F, FnPentaFilter<impl Fn(&S, &A, &B, &C, &D, &E, usize, usize, usize, usize, usize) -> bool + Send + Sync>>, Sc>

where P: Fn(&A, &B, &C, &D, &E) -> bool + Send + Sync,

pub fn penalize<W>( self, weight: W, ) -> PentaBuilder<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, impl Fn(&A, &B, &C, &D, &E) -> Sc + Send + Sync, Sc>

where W: for<'w> ConstraintWeight<(&'w A, &'w B, &'w C, &'w D, &'w E), Sc> + Send + Sync,

pub fn reward<W>( self, weight: W, ) -> PentaBuilder<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, impl Fn(&A, &B, &C, &D, &E) -> Sc + Send + Sync, Sc>

where W: for<'w> ConstraintWeight<(&'w A, &'w B, &'w C, &'w D, &'w E), Sc> + Send + Sync,

impl<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc> Penta<S, A, B, C, D, E, EA, EB, EC, ED, EE, P1, P2, P3, P4, F, Sc>

where S: Send + Sync + 'static, A: Clone + Send + Sync + 'static, B: Clone + Send + Sync + 'static, C: Clone + Send + Sync + 'static, D: Clone + Send + Sync + 'static, E: Clone + Send + Sync + 'static, EA: 'static, EB: 'static, EC: 'static, ED: 'static, EE: 'static, P1: CompileCondition<Plan: IndexedPlan> + 'static, P2: CompileCondition<Plan: IndexedPlan> + 'static, P3: CompileCondition<Plan: IndexedPlan> + 'static, P4: CompileCondition<Plan: IndexedPlan> + 'static, F: PentaFilter<S, A, B, C, D, E> + 'static, Sc: Score + 'static, for<'a> JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, CollectionNode<S, EA>, CollectionNode<S, EB>, <P1 as CompileCondition>::Plan>, CollectionNode<S, EC>, <P2 as CompileCondition>::Plan>, CollectionNode<S, ED>, <P3 as CompileCondition>::Plan>, CollectionNode<S, EE>, <P4 as CompileCondition>::Plan>: Operator<S, View<'a> = Pair<Pair<Pair<Pair<Leaf<'a, A>, Leaf<'a, B>>, Leaf<'a, C>>, Leaf<'a, D>>, Leaf<'a, E>>> + Send + Sync,

pub fn join<G, EG, P5>( self, target: (EG, P5), ) -> Chain<S, JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, CollectionNode<S, EA>, CollectionNode<S, EB>, <P1 as CompileCondition>::Plan>, CollectionNode<S, EC>, <P2 as CompileCondition>::Plan>, CollectionNode<S, ED>, <P3 as CompileCondition>::Plan>, CollectionNode<S, EE>, <P4 as CompileCondition>::Plan>, CollectionNode<S, EG>, <P5 as CompileCondition>::Plan>, Sc>

where G: Clone + Send + Sync + 'static, EG: CollectionExtract<S, Item = G> + 'static, P5: CompileCondition + 'static, for<'a> P5::Plan: IndexedPlan + ExecutablePlan<<JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, CollectionNode<S, EA>, CollectionNode<S, EB>, <P1 as CompileCondition>::Plan>, CollectionNode<S, EC>, <P2 as CompileCondition>::Plan>, CollectionNode<S, ED>, <P3 as CompileCondition>::Plan>, CollectionNode<S, EE>, <P4 as CompileCondition>::Plan> as Operator<S>>::View<'a>, Leaf<'a, G>>, for<'a> JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, JoinNode<S, CollectionNode<S, EA>, CollectionNode<S, EB>, <P1 as CompileCondition>::Plan>, CollectionNode<S, EC>, <P2 as CompileCondition>::Plan>, CollectionNode<S, ED>, <P3 as CompileCondition>::Plan>, CollectionNode<S, EE>, <P4 as CompileCondition>::Plan>, CollectionNode<S, EG>, <P5 as CompileCondition>::Plan>: Operator<S>,

Continues the chain past the named cross-stream arities.

Returns a Chain wrapping this penta’s tree; subsequent .join(...) calls nest further JoinNodes with no fixed ceiling. The continuation drops the penta’s authored filter slot, so apply .filter(...) on the returned chain instead.

Key shapes

This join also takes VIEW keys, not entity keys: the left key closure receives the whole borrowed (A, B, C, D, E) row and the right key receives &Leaf<'_, G> (read fields via .entity). equal_bi with entity closures does NOT typecheck here (E0631) — use equal_on.