Ecosistema

• rustc

• cargo

• rustup

• crates.io 

michele@DartVader:~/bite_of_rust$ cargo init hello --bin
     Created binary (application) project
michele@DartVader:~/bite_of_rust$ cd hello/
michele@DartVader:~/bite_of_rust/hello$ cargo run
   Compiling hello v0.1.0 (file:///home/michele/bite_of_rust/hello)
    Finished dev [unoptimized + debuginfo] target(s) in 0.54 secs
     Running `target/debug/hello`
Hello, world!
michele@DartVader:~/bite_of_rust/hello$ echo "
#[test]
fn ok() { assert!(true) }
#[test]
fn ko() { assert!(false) }
" >> src/main.rs 
michele@DartVader:~/bite_of_rust/hello$ cargo test
   Compiling hello v0.1.0 (file:///home/michele/bite_of_rust/hello)
    Finished dev [unoptimized + debuginfo] target(s) in 0.37 secs
     Running target/debug/deps/hello-e41301c0dacd96ed

running 2 tests
test ok ... ok
test ko ... FAILED

failures:

---- ko stdout ----
	thread 'ko' panicked at 'assertion failed: false', src/main.rs:8
note: Run with `RUST_BACKTRACE=1` for a backtrace.


failures:
    ko

test result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured

error: test failed

Alcune Caratteristiche

• Variabili (move, copy, borrowing)

• Ownership

• Mutabilità per istanza

• inferenza di tipo

• Gestione stringhe

• Gestione memoria

• ....

Alcune Caratteristiche (Cont)

• Enum ++(+)

• Gestione Errori (no eccezioni)

• Derivano solo le interfacce

• Generic (Trait) con bound

• Destrutturazione (pattern)

• Closure e First-Class functions

• macro (hygenic)

Sicuro e Veloce... Ma come?

Senza garbage collector come fa a gestire la memoria?

Sicuro e Veloce... Ma come?

Per quanto riguarda il data race?

fn mutability_and_refernce() {
    let mut a = 42;
    let mut_ref = &mut a;
    let other_ref = &a;
}

error[E0502]: cannot borrow `a` as immutable because it is also borrowed as mutable
 --> src/main.rs:7:22
  |
6 |     let mut_ref = &mut a;
  |                        - mutable borrow occurs here
7 |     let other_ref = &a;
  |                      ^ immutable borrow occurs here
8 | }
  | - mutable borrow ends here

Cosa ci guadagno?

... non compila ...

   Compiling vspython_remove v0.1.0 (file:///home/michele/learning/rust/vspython_remove)
error[E0502]: cannot borrow `my_vec` as mutable because it is also borrowed as immutable
 --> src/main.rs:5:13
  |
3 |     for (index, &val) in my_vec.iter().enumerate() {
  |                          ------ immutable borrow occurs here
4 |         if val > 4 {
5 |             my_vec.remove(index);
  |             ^^^^^^ mutable borrow occurs here
6 |         }
7 |     }
  |     - immutable borrow ends here

error: aborting due to previous error

... dobbiamo fare i bravi!

fn main() {
    let mut my_vec = vec![1, 3, 5, 7, 9];
    my_vec = my_vec.into_iter().filter(|val| *val <= 4).collect();
    println!("Output:\n{:?}", my_vec);
}

Thread safe?

import threading
import time

N = 10000
a = [0]
threads = []

def update():
    v = a[0]
    time.sleep(0)
    a[0] = v + 1

for i in range(N):
    t = threading.Thread(target=update)
    t.start()
    threads.append(t)

for t in threads:
    t.join()

assert a[0] == N, "a = {} != N = {}".format(a[0], N)

import kotlin.concurrent.thread

fun main(args : Array<String>) {
    val N = 10000
    var a = 0
    val threads = (1..N).map {
        thread { a += 1 }
    }
    threads.map { it.join() }

    assert(a == N) {
        "$a != $N"
    }
}

RUST

use std::thread::spawn;
use std::sync::{Arc, Mutex};

fn main() {
    static N: usize = 10000;
    let r_val = Arc::new(Mutex::new(0));
    let mut handlers: Vec<_> = Default::default();

    for _ in 0..N {
        let r_val = r_val.clone();
        handlers.push(spawn(move || {
            let mut r_val = r_val.lock().unwrap();
            *r_val += 1;
        }
        ));
    }
    for h in handlers {
        h.join().unwrap();
    }
    let result = r_val.lock().unwrap().clone();
    print!("Sum = {}", result);
    assert_eq!(N, result);
}

Come abbiamo fatto?

use std::thread::spawn;

fn main() {
    static N: usize = 10000;
    let mut val = 0;
    let r_val = &mut val;
    let mut handlers: Vec<_> = Default::default();

    for _ in 0..N {
        handlers.push(spawn(|| {
            *r_val += 1;
        }
        ));
    }
    for h in handlers {
        h.join().unwrap();
    }
    print!("Sum = {}", val);
    assert_eq!(N, val);
}

Assecondiamo...

for _ in 0..N {
    handlers.push(spawn(move || {
        *r_val += 1;
    }
    ));
}

usiamo move come suggerito

...Reference Counting?

use std::thread::spawn;

fn main() {
    static N: usize = 10000;
    let r_val = std::rc::Rc::new(0);
    let mut handlers: Vec<_> = Default::default();

    for _ in 0..N {
        let r_val = r_val.clone();
        handlers.push(spawn(move || {
            *r_val += 1;
        }
        ));
    }
    for h in handlers {
        h.join().unwrap();
    }
    print!("Sum = {}", r_val);
    assert_eq!(N, *r_val);
}

...Asincrono?

use std::thread::spawn;

fn main() {
    static N: usize = 10000;
    let r_val = std::sync::Arc::new(0);
    let mut handlers: Vec<_> = Default::default();

    for _ in 0..N {
        let r_val = r_val.clone();
        handlers.push(spawn(move || {
            *r_val += 1;
        }
        ));
    }
    for h in handlers {
        h.join().unwrap();
    }
    print!("Sum = {}", r_val);
    assert_eq!(N, *r_val);
}

Arc al posto di Rc ...

mut(able) o mut(ex) ?

use std::thread::spawn;

fn main() {
    static N: usize = 10000;
    let r_val = std::sync::Arc::new(std::sync::Mutex::new(0));
    let mut handlers: Vec<_> = Default::default();

    for _ in 0..N {
        let r_val = r_val.clone();
        handlers.push(spawn(move || {
            let mut r_val = r_val.lock().unwrap();
            *r_val += 1;
        }
        ));
    }
    for h in handlers {
        h.join().unwrap();
    }
    let result = r_val.lock().unwrap().clone();
    print!("Sum = {}", result);
    assert_eq!(N, result);
}

Wrappiamo il valore con un mutex