fn minimize_keys(&mut self, storage: &[C::Storage]) {

        self.min_key.clear();

        // We'll visit each non-`None` key, maintaining the indexes of the least keys in `self.min_key`.
        let mut iter = self.cursors.iter().enumerate().flat_map(|(idx, cur)| cur.get_key(&storage[idx]).map(|key| (idx, key)));
        if let Some((idx, key)) = iter.next() {
            let mut min_key = key;
            self.min_key.push(idx);
            for (idx, key) in iter {
                match key.cmp(&min_key) {
                    std::cmp::Ordering::Less => {
                        self.min_key.clear();
                        self.min_key.push(idx);
                        min_key = key;
                    }
                    std::cmp::Ordering::Equal => {
                        self.min_key.push(idx);
                    }
                    std::cmp::Ordering::Greater => { }
                }
            }
        }

        self.minimize_vals(storage);
    }
Initialize min_key with the indices of cursors with the minimum key.

This method scans the current keys of each cursor, and tracks the indices
of cursors whose key equals the minimum valid key seen so far. As it goes,
if it observes an improved key it clears the current list, updates the
minimum key, and continues.

Once finished, it invokes `minimize_vals()` to ensure the value cursor is
in a consistent state as well.
differential-dataflow/src/trace/cursor/cursor_list.rs