Rust – il linguaggio – 1

bb0OK, Robitex mi ha convinto|coinvolto. Ma io sono niubbassay, anzi di più (nel senso di meno) e allora il manuale; viene installato in locale, come ho detto qui.
Oggi sono qui: /usr/local/share/doc/rust/html/book/index.html.
Comincia bene, cos’è Rust: Rust is a systems programming language focused on three goals: safety, speed, and concurrency.

“The Rust Programming Language” [questo doc] is split into eight sections. ma di questo dopo; prima un po’ di gossip 😉

Consideriamo il seguente programma:

fn main() {
    let mut x = vec!["Hello", "world"];
}

quante cose 😀 una variabile mutabile, un vettore di tipo inferito creato con una macro.

Un concetto importante è l’ownership, proprietà nel senso di a chi appartiene. Per Rust x è proprietario (own) il vettore, quindi quando x non è più accessibile la memoria occupata dal vettore sarà deallocata, cosa fatta automaticamente dal compilatore, niente di simile a malloc e free.

fn main() {
    let mut x = vec!["Hello", "world"];

    let y = &x[0];
}

un altro collegamento (binding), in questo caso y è una reference al primo elemento del vettore x. La reference è un prestito, quando y non è più accessibile la memoria cui si riferiva non viene liberata.

Adesso una cosa che non si può fare:

fn main() {
    let mut x = vec!["Hello", "world"];

    let y = &x[0];

    x.push("foo");
}

sto mischiando mutabili e no; errore. Il compilatore è esaustivo, chiaro (no, non lo riporto, c’è di là).

Possiamo seguire due vie, con una reference:

fn main() {
    let mut x = vec!["Hello", "world"];

    let y = x[0].clone();

    x.push("foo");
}

in questo caso y contiene adesso una copia del valore di x[0]. In alternativa possiamo assicurarci di effettuare il push quando y non è più accessibile:

fn main() {
    let mut x = vec!["Hello", "world"];

    {
        let y = &x[0];
    }

    x.push("foo");
}

abbiamo creato uno scopo (scope, mi sa che uso scopo finché non mi sgridano ma bisogna ricordarsi che sta per è visibile, vivo).

OK, [t]his concept of ownership isn’t just good for preventing dangling pointers, but an entire set of related problems, like iterator invalidation, concurrency, and more.

Prima di partire sul serio (e studierò riassumendo molto più di quanto non abbia fatto finora) una curiosità che devo togliermi, cioè si potrebbe scrivere così:

fn main() {
    let mut x = vec!["Hello", "world"];
    { let y = &x[0]; }
    x.push("foo");
}

Sì, compilando ottengo lo stesso warning (y non viene usata) e l’eseguibile è lo stesso (anche se è finto, non fa niente).

Dubbio: ma è usabile|utile? o sono io che devo dis-lisparmi quando sono qui?
Continua, anzi si comincia per davvero 😀

:mrgreen:

Posta un commento o usa questo indirizzo per il trackback.

Trackback

Rispondi

Inserisci i tuoi dati qui sotto o clicca su un'icona per effettuare l'accesso:

Logo di WordPress.com

Stai commentando usando il tuo account WordPress.com. Chiudi sessione /  Modifica )

Google photo

Stai commentando usando il tuo account Google. Chiudi sessione /  Modifica )

Foto Twitter

Stai commentando usando il tuo account Twitter. Chiudi sessione /  Modifica )

Foto di Facebook

Stai commentando usando il tuo account Facebook. Chiudi sessione /  Modifica )

Connessione a %s...

Questo sito utilizza Akismet per ridurre lo spam. Scopri come vengono elaborati i dati derivati dai commenti.

%d blogger hanno fatto clic su Mi Piace per questo: