toc: > I think the problem is that you want control/inspection into the internal workings of this datastructure. Access to head index alone isn't enough. There is no equivalent accessor for it. `deq.get(0)` is the same as `deq.front()`, and indexing works well enough from that. > > Essentially what you're requesting is for `VecDeque` to open up a very narrow part of what it guarantees to the outside world, via some API. I don't think I'm trying to peer into implementation details here. I explicitly _don't_ want to mess around with internals, in the sense that I want to avoid things like `unsafe` and `as_ranges`. The things that I want guaranteed are _already_ guaranteed: * `pop_front` increases `head_index` by one. (Guaranteed by `VecDeque` being a ring buffer. The existence of `as_ranges` forces this to be an increment, and not a decrement, since ranges have a direction built-in.) * `push_front` decreases `head_index` by one. * pushing doesn't reallocate if there is space. (I believe this is already guaranteed by `with_capacity`) * The items aren't moved, aside from methods that explicitly say they will. (Methods that talk about their running time are nonsensical without this.) * `get()` operates over the elements linearly, wrapping at the end of the buffer. (This is guaranteed by the requirements of `push` and `pop` - since they add items sequentially, it follows that `get(1)` must be next to `get(0)`, modulo capacity. This is also guaranteed by the existence of `as_ranges`.) Given those things, all that's needed is access to `head_index`. If there's a flaw in my reasoning, I'd like to know where. Edit: In the posts above, I have mentioned `physical_idx`, and perhaps that confused you? Although it's true that that is the location in the physical backing store, _I don't actually care about that fact_. All I care about is that it is a stable value that I can use to recover a logical index from, later. I believe the stability of it is already guaranteed by the points I outlined above.

d0sboots: > "An empty tail pointing to the front of the buffer is not guaranteed" is exactly the problem I have I think the problem is that you want control/inspection into the internal workings of this datastructure. Access to head index alone isn't enough. There is no equivalent accessor for it. `deq.get(0)` is the same as `deq.front()`, and indexing works well enough from that. Essentially what you're requesting is for `VecDeque` to open up a very narrow part of what it guarantees to the outside world, via some API. This can be reasonable! `Vec` is a very useful building block for other datastructures. But sometimes implementing a datastructure on top of another datastructure requires being able to dig into its implementation, and requires the building block datastructure to guarantee more about exactly how it works. For `Vec` this API looks like `RawVec`, but it also takes the form of `into_parts`/`from_parts`/`into_raw_parts`/`from_raw_parts`. * * * I don't think it would be unreasonable for `VecDeque` to guarantee its whole implementation and expose its internal bits so that it can be used as a better building block for more complicated datastructures. I also don't think that API would look like `pub fn head_index(&self) -> usize`.

d0sboots: > "An empty tail pointing to the front of the buffer is not guaranteed" is exactly the problem I have I think the problem is that you want control/inspection into the internal workings of this datastructure. Access to head index alone isn't enough. There is no equivalent accessor for it. `deq.get(0)` is the same as `deq.front()`, and indexing works well enough from that. Essentially what you're requesting is for `VecDeque` to open up a very narrow part of what it guarantees to the outside world, via some API. This can be reasonable! `Vec` is a very useful building block for other datastructures. But sometimes implementing a datastructure on top of another datastructure requires being able to dig into its implementation, and requires the building block datastructure to guarantee more about exactly how it works. For `Vec` this API looks like `RawVec`, but it also takes the form of `into_parts`/`from_parts`/`into_raw_parts`/`from_raw_parts`. * * * I don't think it would be unreasonable for `VecDeque` to guarantee its whole implementation and expose its internal bits so that it can be used as a better building block for more complicated datastructures. I also don't think that API would look like `pub fn head_index(&self) -> usize`.

d0sboots: > `(current_logical_item_index + head_index()) % capacity()` - because that's the physical index Except it's not, from the perspective of a particular `VecDeque` you could have done any number of `.pop_front`/`.push_front`/whatever operations in between acquiring `current_logical_item_index` and using it. Taking a step back, what you're describing is a separate datastructure. With a little extra bookkeeping and some judicious use of VecDeque::as_slices it is reasonable functionality to implement on top of a VecDeque, but I don't think introducing indexes makes sense for the version in std.

Boost key-value lookups with Prolly, a content-addressed map for efficient data retrieval

A sensor integration framework should be sufficiently general to accurately represent all information sources, and also be able to summarize information in a faithful way that emphasizes important, ac...