Al explorar implementaciones de bajo nivel o bibliotecas que gestionan memoria de forma manual en Rust, es común encontrarse con tipos como *const () y firmas de función del estilo fn(*const ()). Estos elementos son fundamentales para implementar polimorfismo en tiempo de ejecución y borrado de tipos (type erasure), permitiendo que el lenguaje interactúe con datos cuyo tipo concreto no se conoce de antemano.

El concepto de puntero opaco

En Rust, () representa la unidad (empty tuple). Cuando se utiliza en el contexto de un puntero crudo, como *const () o *mut (), actúa de forma similar al void* en C. Indica un puntero a una ubicación de memoria donde la estructura del dato subyacente ha sido "borrada" para el sistema de tipos.

Un ejemplo clásico se encuentra en la gestión de buffers atómicos. Consideremos una estructura simplificada inspirada en la arquitectura de almacenamiento de datos genéricos:

use std::sync::atomic::AtomicPtr;
use std::ptr;

pub struct ContenedorDatos {
    memoria: *const u8,
    capacidad: usize,
    // El uso de () indica que el puntero es opaco
    contexto_dinamico: AtomicPtr<()>,
}

impl ContenedorDatos {
    pub fn nuevo(p: *mut u8, cap: usize) -> Self {
        Self {
            memoria: p,
            capacidad: cap,
            contexto_dinamico: AtomicPtr::new(ptr::null_mut()),
        }
    }
}

Aquí, AtomicPtr<()> permite almacenar una dirección de memoria de forma segura entre hilos sin comprometerse con un tipo específico, lo que resulta útil para implementar contadores de referencia o metdaatos personalizados.

Conversión entre funciones y punteros crudos

Dado que las funciones en Rust también tienen una ubicación en memoria, podemos tratarlas como punteros opacos. Esto es útil cuando necesitamos almacenar diferentes tipos de funciones en una misma estructura de datos (como en una tabla de métodos virtuales).

fn duplicar(n: i32) -> i32 {
    n * 2
}

fn saludar() {
    println!("¡Hola desde el puntero!");
}

fn main() {
    // Convertir funciones a punteros opacos
    let ptr_operacion = duplicar as *const ();
    let ptr_accion = saludar as *const ();

    // Recuperar la función mediante transmute
    unsafe {
        let fn_recuperada: fn(i32) -> i32 = std::mem::transmute(ptr_operacion);
        let resultado = fn_recuperada(10);
        assert_eq!(resultado, 20);

        let accion_recuperada: fn() = std::mem::transmute(ptr_accion);
        accion_recuperada();
    }
}

Borrado de tipos en estructuras asíncronas

El ecosistema de Future en Rust utiliza este concepto extensivamente a través de la estructura RawWaker. Para que el ejecutor pueda despertar una tarea sin conocer el tipo exacto del Waker, utiliza una tabla de funciones (VTable) que operan sobre *const ().

pub struct TablaOperaciones {
    pub clonar: unsafe fn(*const ()) -> *const (),
    pub ejecutar: unsafe fn(*const ()),
    pub liberar: unsafe fn(*const ()),
}

pub struct GestorTareas {
    datos: *const (),
    vtable: &'static TablaOperaciones,
}

Implementación práctica: El operador "_" y la abstracción

El borrado de tipos permite encapsular lógica compleja. Podemos usar el guion bajo _ para que el compilador infiera la conversión a un puntero sin tipo definido, facilitando la creación de interfaces genéricas manuales.

struct Componente(u32);

impl Componente {
    fn procesar(&self) {
        println!("Procesando valor: {}", self.0);
    }

    fn obtener_metrica(&self) -> usize {
        (self.0 * 2) as usize
    }
}

struct InterfazBorrada {
    instancia: *const (),
    metodo_ejecutar: unsafe fn(*const ()),
    metodo_metrica: unsafe fn(*const ()) -> usize,
}

fn main() {
    let comp = Componente(42);
    
    // Usamos 'as _' para convertir a *const ()
    let ptr_instancia: *const () = &comp as *const Componente as _;

    unsafe {
        let f_ejecutar: unsafe fn(*const ()) = std::mem::transmute(Componente::procesar as fn(&Componente));
        let f_metrica: unsafe fn(*const ()) -> usize = std::mem::transmute(Componente::obtener_metrica as fn(&Componente) -> usize);

        let interfaz = InterfazBorrada {
            instancia: ptr_instancia,
            metodo_ejecutar: f_ejecutar,
            metodo_metrica: f_metrica,
        };

        // Invocación polimórfica manual
        (interfaz.metodo_ejecutar)(interfaz.instancia);
        let val = (interfaz.metodo_metrica)(interfaz.instancia);
        println!("Métrica obtenida: {}", val);
    }
}

Simplificación mediente clausuras

En casos donde solo necesitamos inicializar estructuras que requieren punteros a funciones pero no tenemos una implementación real todavía, las clausuras que no capturan variables pueden coerced (coaccionadas) a punteros de función, lo que simplifica el código de prueba o inicialización:

struct MockHandler {
    callback: unsafe fn(*const ()),
}

fn main() {
    // Las clausuras sin captura pueden actuar como fn pointers
    let manejador = MockHandler {
        callback: |_| { 
            println!("Callback ejecutado silenciosamente");
        },
    };
    
    unsafe { (manejador.callback)(std::ptr::null()); }
}

El uso de *const () es una herramienta avanzada que sacrifica la seguridad del sistema de tipos en favor de la flexibilidad y el rendimiento, siendo la base sobre la cual se construyen abstracciones de alto nivel en Rust.