Well, it’s actually more borrowing than stealing, and Rust is pretty much into that. :-)

One thing that is curiously absent from the discussion is dependency management. This may seem trivial but is full of interesting edge cases, e.g. multiple versions of a dependency, to which current state of the art has not yet appeared to find an optimal solution.

I wrote about this and more on my blog

One optimization the author doesn’t address that can be done in plain rust is to get rid of the branches in the loop (there are two: One for the bounds check because of indexing, the second for the if). In fact, I introduced a small optimization to iterators that do the trick (in nightly and possibly beta), so you can simply write:

bwt[(i * self.k) + 1 .. r + 1].iter().filter(|x| *x == a).count()

This gets inlined into roughly:

let mut count = 0;
for x in &bwt[(i * self.k) + 1 .. r + 1] { // look ma, no branches!
    count += (*x == a) as usize; // boolean false is 0 and true is 1
}
count

This is the naive way, and also the fastest for small slices. If you want to go even faster, the bytecount crate has the currently fastest implementation, and is used by both ripgrep and xi. If you are on nightly, you can even enable SSE / AVX for best-in-class performance.

Kind of a bummer that it goes directly to C++. I was hoping to see how to finish the job in Rust.