ereOn's questions

Eu criei este código para internar strings e manipular &'staticreferências a elas.

Acredito que seja verdade, mas gostaria de ter uma confirmação disso.

Minha justificativa é a seguinte:

• O HashSeté alocado estaticamente e não causa realocação de seus valores (seu armazenamento interno pode ser realocado, mas o Stringpróprio não deve).
• Qualquer inserção é protegida pelo Mutex.
• Como eles Stringnunca são removidos do HashSet, transmuteo envio do conteúdo deles &'staticdeve ser seguro.

use std::{collections::HashSet, sync::Mutex};

lazy_static! {
    static ref LOCKED_HASH: Mutex<HashSet<String>> = Mutex::new(HashSet::new());
}

pub fn intern_string(input: &str) -> &'static str {
    let mut lock = LOCKED_HASH.lock().unwrap();
    if let Some(val) = lock.get(input) {
        unsafe { std::mem::transmute::<&str, &'static str>(val) }
    } else {
        lock.insert(input.to_string());
        let interned = lock.get(input).unwrap();
        unsafe { std::mem::transmute::<&str, &'static str>(interned) }
    }
}

Isso é realmente seguro?