ghost-collections VS qcell

Apart from that, I goofed around and implemented some collections on top, to test the ergonomics.

I read a while ago about a paper on a concept called GhostCell, and i believe it solves this problem in safe rust with zero runtime overhead. I just found this implementation, but I didn't have time to read it: https://github.com/matthieu-m/ghost-collections/blob/master/src/linked_list.rs Anyway, from my understanding, if you want to implement some sort of non trivial data structure in rust efficiency, you have to use a little bit of unsafe code. I believe this isn't the case thanks to GhostCell (if my understanding of the problem it aims to solve is correct)

In the tripod_tree container -- just a binary tree, really -- I exposed a cursor modeled after Rust's LinkedList Cursor.

GhostCell is powerful enough to implement doubly linked lists in safe Rust which is quite a feat. https://github.com/matthieu-m/ghost-collections

May I interest you in https://github.com/matthieu-m/ghost-collections ?

It's fairly complicated: https://github.com/matthieu-m/ghost-collections/blob/master/src/linked_list.rs

> I think linked lists are a great example of something that causes Rust's ownership model to fall apart. I've seen it done with tradeoffs, but it's something that you're best off implementing with pointers and unsafe blocks

It's worth checking https://plv.mpi-sws.org/rustbelt/ghostcell/ and https://github.com/matthieu-m/ghost-collections for an alternate approach that's currently being worked on.

Quite non-intuitive and it has yet to be proven 100% safe, plus it doesn't actually obviate everything you might want to do w/ potentially-aliased pointers, meaning that some desirable patterns are still off-limits - but it has the best chance of working out so far.

I managed to implement the basic operations of the LinkedList this way, as well as a full Cursor, then I hit a wall.

An unsoundness issue in TCell and TLCell was discovered and fixed by GitHub user steffahn. This is due to Rust TypeId taking into account the lifetime, i.e. you get a different type-id for the same type with different lifetimes, and Rust will automatically cast between them. The solution is to force invariance with some type voodoo. This is a weird corner of Rust I'd never understood before. Ideally std::any::TypeId docs should be improved. (This bug does not affect the safety of correct use of the crate, but fixing it blocks a malicious coder from getting potential unsoundness through a code review.)

This is slightly unrelated, but this thread made me dig up my own code that I was writing which was going to be essentially the same as the QCell crate, until I discovered that the QCell crate exists, at which point I stopped working on it and contributed to QCell instead (this PR).