A key created by a Slots instance can be used to access an other

[bugadani]

See this test case provided by @chrysn

#[test]
fn use_across_slots() {
    let mut a: Slots<u8, U4> = Slots::new();
    let mut b: Slots<u8, U4> = Slots::new();

    let k = a.store(5).expect("There should be room");

    b.take(k);
}

[chrysn]

Some possible approaches (just to have them documented and avoid duplication of work):

• Make each Slots instance type-unique. That would allow safely using keys (possibly even without having access to the Slots, as sketched in an article on zero-sized references). On the downside, that would practically limit the use of Slots to globally allocated arrays.
• Have references inside keys. This makes keys a lot larger, and adds the kind of lifetime requirements to the keys which a system like this is often designed to prevent. (So it probably doesn't work for the use cases.)
• Have raw pointers inside keys. This is tempting, as it works without unsafe code as pointers are only ever compared but not used (to access, you'd still need the Slots instance). Unfortunately, this does not achieve the desired result: If a key outlives its Slots instance and another instance is created at (accidentally or deliberately) the same memory allocation, that key would be usable again.
• Do nothing in the code, but acknowledge that panics may occur when any key is used with a Slots that it was not designed for. (Sounds viable: As there is no unsafe code around, this is just logic errors creating other logic errors, but never unsafe behavior).

[bugadani]

Fortunately, in Rust it is possible to turn on and off library features. I'm considering giving each Slots instance a unique ID that is inherited by its keys. In release builds this protection can be turned off (probably done by default), or re-enabled through configuration.

Not an elegant solution, but simple enough to implement.