Function half_join_internal_unsafe

pub fn half_join_internal_unsafe<G, K, V, R, Tr, FF, CF, Y, S, CB>(
    stream: &VecCollection<G, (K, V, G::Timestamp), R>,
    arrangement: Arranged<G, Tr>,
    frontier_func: FF,
    comparison: CF,
    yield_function: Y,
    output_func: S,
) -> StreamCore<G, CB::Container>
where
    G: Scope<Timestamp = Tr::Time>,
    K: Hashable + ExchangeData,
    V: ExchangeData,
    R: ExchangeData + Monoid,
    Tr: for<'a> TraceReader<KeyOwn = K, Time: Hash> + Clone + 'static,
    FF: Fn(&G::Timestamp, &mut Antichain<G::Timestamp>) + 'static,
    CF: Fn(Tr::TimeGat<'_>, &Tr::Time) -> bool + 'static,
    Y: Fn(Instant, usize) -> bool + 'static,
    S: FnMut(&mut Session<'_, '_, <G as ScopeParent>::Timestamp, CB, Capability<<G as ScopeParent>::Timestamp>>, &K, &V, Tr::Val<'_>, &G::Timestamp, &R, &mut Vec<(G::Timestamp, Tr::Diff)>) + 'static,
    CB: ContainerBuilder,

An unsafe variant of half_join where the output_func closure takes additional arguments a vector of time and diff tuples as input and writes its outputs at a container builder. The container builder can, but isn’t required to, accept (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(session, key, val1, val2, initial_time, diff1, &[lub(time1, time2), 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.