Function half_join_internal_unsafe

pub fn half_join_internal_unsafe<G, K, V, R, Tr, FF, CF, DOut, ROut, Y, I, S>(
    stream: &Collection<G, (K, V, G::Timestamp), R>,
    arrangement: Arranged<G, Tr>,
    frontier_func: FF,
    comparison: CF,
    yield_function: Y,
    output_func: S,
) -> Collection<G, DOut, ROut>
where
    G: Scope<Timestamp = Tr::Time>,
    K: Hashable + ExchangeData,
    V: ExchangeData,
    R: ExchangeData + Monoid,
    Tr: TraceReader + Clone + 'static,
    for<'a> Tr::Key<'a>: IntoOwned<'a, Owned = K>,
    FF: Fn(&G::Timestamp, &mut Antichain<G::Timestamp>) + 'static,
    CF: Fn(Tr::TimeGat<'_>, &Tr::Time) -> bool + 'static,
    DOut: Clone + 'static,
    ROut: Semigroup + 'static,
    Y: Fn(Instant, usize) -> bool + 'static,
    I: IntoIterator<Item = (DOut, G::Timestamp, ROut)>,
    S: FnMut(&K, &V, Tr::Val<'_>, &G::Timestamp, &G::Timestamp, &R, &Tr::Diff) -> I + 'static,

An unsafe variant of half_join where the output_func closure takes additional arguments for time and diff as input and returns an iterator over (data, time, diff) triplets. This allows for more flexibility, but is more error-prone.

This operator responds to inputs of the form

((key, val1, time1), initial_time, diff1)

where initial_time is less or equal to time1, and produces as output

output_func(key, val1, val2, initial_time, lub(time1, time2), diff1, diff2)

for each ((key, val2), time2, diff2) present in arrangement, where time2 is less than initial_time UNDER THE TOTAL ORDER ON TIMES.

The yield_function allows the caller to indicate when the operator should yield control, as a function of the elapsed time and the number of matched records. Note this is not the number of output records, owing mainly to the number of matched records being easiest to record with low overhead.