Rust: Systems Programming for Everyone
Felix Klock (@pnkfelix), Mozilla
space: next slide; esc: overview; arrows navigate http://bit.ly/1LQM3PS
let christine = Car::new();This is "Christine"
(apologies to Stephen King)
let read_only_borrow = &christine;
(apologies to Randall Munroe)
read_only_borrows[2] = &christine;
read_only_borrows[3] = &christine;
read_only_borrows[4] = &christine;
When inspectors are finished, we are left again with:
let mutable_borrow = &mut christine; // like taking keys ...
give_arnie(mutable_borrow); // ... and giving them to someone
Can't mix the two in safe code!
|
|
Otherwise: (data) races!
read_only_borrows[2] = &christine;
let mutable_borrow = &mut christine;
read_only_borrows[3] = &christine;
// ⇒ CHAOS!
Stack allocation
let b = B::new();
let b = B::new();
let r1: &B = &b;
let r2: &B = &b;
(b has lost write capability)
let mut b = B::new();
let w: &mut B = &mut b;
(b has temporarily lost both read and write capabilities)
Heap allocation: Box<B>
let a = Box::new(B::new());
a (as owner) has both read and write capabilities
Immutably borrowing a box
let a = Box::new(B::new());
let r_of_box: &Box<B> = &a; // (not directly a ref of B)
let r1: &B = &*a;
let r2: &B = &a; // <-- coercion!
a retains read capabilities (has temporarily lost write)
Mutably borrowing a box
let mut a = Box::new(B::new());
let w: &mut B = &mut a; // (again, coercion happening here)
a has temporarily lost both read and write capabilities
Heap allocation: Vec<B>
let mut a = Vec::new();
for i in 0..n { a.push(B::new()); }
Vec Reallocation
...
a.push(B::new());| before | after | |
|
 |
Basic Vec<B>
let mut a = Vec::new();
for i in 0..n { a.push(B::new()); }
(a has read and write capabilities)
Immutable borrowed slices
let mut a = Vec::new();
for i in 0..n { a.push(B::new()); }
let r1 = &a[0..3];
let r2 = &a[7..n-4];
(a has only read capability now; shares it with r1 and r2)
Safe overlap between &[..]
let mut a = Vec::new();
for i in 0..n { a.push(B::new()); }
let r1 = &a[0..7];
let r2 = &a[3..n-4];
Basic Vec<B> again
(a has read and write capabilities)
Mutable slice of whole vec
let w = &mut a[0..n];
(a has no capabilities; w now has read and write capability)
Mutable disjoint slices
let (w1,w2) = a.split_at_mut(n-4);
(w1 and w2 share read and write capabilities for disjoint portions)
Shared Ownership
let rc1 = Rc::new(B::new());
let rc2 = rc1.clone(); // increments ref-count on heap-alloc'd value
(rc1 and rc2 each have read access; but neither can statically assume exclusive (mut) access, nor can they provide &mut borrows without assistance.)
RefCell<T>: Dynamic Exclusivity
let b = Box::new(RefCell::new(B::new()));
let r1: &RefCell<B> = &b;
let r2: &RefCell<B> = &b;
RefCell<T>: Dynamic Exclusivity
let b = Box::new(RefCell::new(B::new()));
let r1: &RefCell<B> = &b;
let r2: &RefCell<B> = &b;
let w = r2.borrow_mut(); // if successful, `w` acts like `&mut B`
// below panics if `w` still in scope
let w2 = b.borrow_mut();Rc<RefCell<T>>
let rc1 = Rc::new(RefCell::new(B::new()));
let rc2 = rc1.clone(); // increments ref-count on heap-alloc'd value
Rc<RefCell<T>>
let rc1 = Rc::new(RefCell::new(B::new()));
let rc2 = rc1.clone();
let r1: &RefCell<B> = &rc1;
let r2: &RefCell<B> = &rc2; // (or even just `r1`)
Rc<RefCell<T>>
let rc1 = Rc::new(RefCell::new(B::new()));
let rc2 = rc1.clone();
let w = rc2.borrow_mut();
Crate dependency graph
Compiler ensures one cannot pass struct defined via X version 2.x.y into function expecting X version 1.m.n, or vice versa.
A: Graph Structure |
B: Token API |
|
C: Lexical Scanner |
D: GLL Parser |
P: Linked Program |
Thanks
www.rust-lang.org
Hack Without Fear