Hey, thanks for reaching out!

Yes, this would technically be the preferred way to resolve this particular instance. But it still requires delicate care with transmutation, possibly one of the most dangerous aspects of unsafe code. I deliberately did not use this approach in the blog post though, because it's limited to contiguous collections. So, for example, it cannot be used for matrix/tensor views (very important use case!), or certain more esoteric data structures.

You're right that it's not Sync, but it's Send, so you could just copy &[UnsafeCell<T>] into each thread and use .get() in there. This would require a bit less ceremony than the pointer-based approach.

There are quite a few other alternative ways to approach many of the things I did in the blog post, so I decided against mentioning the alternatives, as the blog post might read like a sequence of "but actually you could also ...". I've gotten quite a few mentions about this particular point though, so perhaps I should have mentioned it :-)

Very cool. (Thanks to This Week in Rust for pointing me to your post!)

I don't have any immediate use for paradis, but I'll be keeping it in mind. I've long muttered to myself over the problem of doing funny array access patterns in Rust while avoiding any run-time checks that they are legal. (One doesn't just want speed, knowing at compile time that code can't panic is also nice.) I like your abstracting away whether the access is safe from that access itself. If I am understanding correctly.

paradis, I need to remember that name. Good luck in moving it forward.

Thanks,

-kb