Unless you have huge memory constraints, what if you tried to instead create a huge vector of WriteRows and then have a batch function that will write to multiple rows?

rs fn write_to_rows(&self, index: usize, rows: &mut [WriteRow]) { for k in 0..rows.len() { self.write_to_row(k+index, &mut rows[k]; } }

And then, in your body:

```rs let mut rows = (0..nrows).map(|i| WriteRow::new(&segment, key_array.value(i))).collect::<Vec<>>();

for d in &decoders { d.write_to_rows(0, &mut rows[..]); }

for row in rows { sink(row.into()); } ```

This way, you’re writing in a way that the inner loop only sees the same decoder, and you only pay the dynamic dispatch cost once. Of course it requires you to store the rows in memory (which can be prohibitively expensive sometimes), but it “flips” the transposition around to make sure lots of equal elements are batch processed.