fn push_update(&mut self, time: <L::Target as Update>::Time, diff: <L::Target as Update>::Diff) {
            // If a just-pushed update exactly equals `(time, diff)` we can avoid pushing it.
            let t1 = <<L::TimeContainer as BatchContainer>::ReadItem<'_> as IntoOwned>::borrow_as(&time);
            let d1 = <<L::DiffContainer as BatchContainer>::ReadItem<'_> as IntoOwned>::borrow_as(&diff);
            if self.result.times.last().map(|t| t == t1).unwrap_or(false) && self.result.diffs.last().map(|d| d == d1).unwrap_or(false) {
                assert!(self.singleton.is_none());
                self.singleton = Some((time, diff));
            }
            else {
                // If we have pushed a single element, we need to copy it out to meet this one.
                if let Some((time, diff)) = self.singleton.take() {
                    self.result.times.push(time);
                    self.result.diffs.push(diff);
                }
                self.result.times.push(time);
                self.result.diffs.push(diff);
            }
        }
Pushes a single update, which may set `self.singleton` rather than push.

This operation is meant to be equivalent to `self.results.updates.push((time, diff))`.
However, for "clever" reasons it does not do this. Instead, it looks for opportunities
to encode a singleton update with an "absert" update: repeating the most recent offset.
This otherwise invalid state encodes "look back one element".

When `self.singleton` is `Some`, it means that we have seen one update and it matched the
previously pushed update exactly. In that case, we do not push the update into `updates`.
The update tuple is retained in `self.singleton` in case we see another update and need
to recover the singleton to push it into `updates` to join the second update.
differential-dataflow/src/trace/implementations/rhh.rs