Genéricos de armazenamento em ponteiro via `mem :: transmute ()`

Estou tentando escrever ligações Rust para uma biblioteca de coleções C (Judy Arrays [1]), que só oferece espaço para armazenar um valor de largura de ponteiro. Minha empresa possui uma quantidade razoável de código existente que utiliza esse espaço para armazenar diretamente valores que não são de ponteiros, como números inteiros de largura de ponteiro e estruturas pequenas. Eu gostaria que minhas ligações Rust permitissem acesso seguro a essas coleções usando genéricos, mas estou tendo problemas para que a semântica de acumulação de ponteiros funcione corretamente.

omem::transmute() A função parece ser uma ferramenta potencial para implementar o comportamento desejado, mas a tentativa de usá-lo em uma instância de um tipo parametrizado gera um erro de compilação confuso para mim.

Código de exemplo:

pub struct Example<T> {
    v: usize,
    t: PhantomData<T>,
}

impl<T> Example<T> {
    pub fn new() -> Example<T> {
        Example { v: 0, t: PhantomData }
    }

    pub fn insert(&mut self, val: T) {
        unsafe {
            self.v = mem::transmute(val);
        }
    }
}

Erro resultante:

src/lib.rs:95:22: 95:36 error: cannot transmute to or from a type that contains type parameters in its interior [E0139]
src/lib.rs:95             self.v = mem::transmute(val);
                                   ^~~~~~~~~~~~~~

Isso significa que um tipo que consiste apenas em um parâmetro "contém parâmetros de tipo em seu interior" e, portanto,transmute() simplesmente não vai funcionar aqui? Alguma sugestão da maneira certa de fazer isso?

(Pergunta relacionada, tentando alcançar o mesmo resultado, mas não necessariamente viamem::transmute().)

[1] Eu estou ciente do existenterust-judy projeto, mas não suporta o armazenamento de ponteiros que eu quero, e estou escrevendo essas novas ligações em grande parte como um exercício de aprendizado.