Qual è il sovraccarico del tipo di opzione di Rust?

In Rust, i riferimenti non possono mai essere nulli, quindi nel caso in cui sia effettivamente necessario nullo, come un elenco collegato, si utilizza il Optiontipo:

struct Element {
    value: i32,
    next: Option<Box<Element>>,
}

Quanto overhead è coinvolto in questo in termini di allocazione della memoria e passaggi per la dereferenziazione rispetto a un semplice puntatore? C'è qualche "magia" nel compilatore / runtime da rendere a Optioncosto zero o meno costoso che se si implementasse Optionda soli in una libreria non core utilizzando lo stesso enumcostrutto o avvolgendo il puntatore in un vettore?

Sì, c'è qualche magia del compilatore che ottimizza Option<ptr>a un singolo puntatore (la maggior parte delle volte).

use std::mem::size_of;

macro_rules! show_size {
    (header) => (
        println!("{:<22} {:>4}    {}", "Type", "T", "Option<T>");
    );
    ($t:ty) => (
        println!("{:<22} {:4} {:4}", stringify!($t), size_of::<$t>(), size_of::<Option<$t>>())
    )
}

fn main() {
    show_size!(header);
    show_size!(i32);
    show_size!(&i32);
    show_size!(Box<i32>);
    show_size!(&[i32]);
    show_size!(Vec<i32>);
    show_size!(Result<(), Box<i32>>);
}

Vengono stampate le seguenti dimensioni (su una macchina a 64 bit, quindi i puntatori sono 8 byte):

// As of Rust 1.22.1
Type                      T    Option<T>
i32                       4    8
&i32                      8    8
Box<i32>                  8    8
&[i32]                   16   16
Vec<i32>                 24   24
Result<(), Box<i32>>      8   16

Si noti che &i32, Box, &[i32], Vec<i32>tutto l'uso l'ottimizzazione non annullabile puntatore all'interno di una Option!