Upload
arthur-gavkaluk
View
53
Download
4
Embed Size (px)
Citation preview
Rust Intro
by Artur Gavkaliuk
MozillaThe language grew out of a personal project by Mozilla employee Graydon Hoare. Mozilla began sponsoring the project in 2009 and announced it in 2010. The same year, work shifted from the initial compiler (written in OCaml) to the self-hosting compiler written in Rust. Known as rustc, it successfully compiled itself in 2011. rustc uses LLVM as its back end.
Safe, concurrent, practical languageRust is a general-purpose, multi-paradigm, compiled programming language.
It is designed to be a "safe, concurrent, practical language", supporting pure-functional, imperative-procedural, and object-oriented styles.
Object oriented
Structs
Enums
Method Syntax
Generics
Traits
Structsstruct Point { x: i32, y: i32,}
fn main() { let origin = Point { x: 0, y: 0 }; // origin: Point
println!("The origin is at ({}, {})", origin.x, origin.y);}
Enumsenum BoardGameTurn { Move { squares: i32 }, Pass,}
let y: BoardGameTurn = BoardGameTurn::Move { squares: 1 };
Genericsstruct Point<T> { x: T, y: T,}
let int_origin = Point { x: 0, y: 0 };let float_origin = Point { x: 0.0, y: 0.0 };
Method syntaxstruct Circle { x: f64, y: f64, radius: f64,}
fn main() { let c = Circle { x: 0.0, y: 0.0, radius: 2.0 }; println!("{}", c.area());}
Method syntaximpl Circle { fn area(&self) -> f64 { std::f64::consts::PI * (self.radius * self.radius) }}
Traitstrait HasArea { fn area(&self) -> f64;}
impl HasArea for Circle { fn area(&self) -> f64 { std::f64::consts::PI * (self.radius * self.radius) }}
Traitsfn print_area<T: HasArea>(shape: T) { println!("This shape has an area of {}", shape.area());}
Functional
Functions
Function pointers
Type inference
Immutable by default
Option and Result
Pattern matching
Lambda functions
Functionsfn add_one(x: i32) -> i32 { x + 1}
Functionsfn add_one(x: i32) -> i32 { x + 1;}
We would get an error:
error: not all control paths return a valuefn add_one(x: i32) -> i32 { x + 1;}
help: consider removing this semicolon: x + 1; ^
Functionsfn plus_one(i: i32) -> i32 { i + 1}
let f: fn(i32) -> i32 = plus_one;
let six = f(5);
Type inference
Rust has this thing called ‘type inference’. If it can figure out what the type of something is, Rust doesn’t require you to actually type it out.
let x = 5; // x: i32
fn plus_one(i: i32) -> i32 { i + 1}
// without type inferencelet f: fn(i32) -> i32 = plus_one;
// with type inferencelet f = plus_one;
Mutabilitylet x = 5;x = 10;
error: re-assignment of immutable variable `x` x = 10; ^~~~~~~
Mutabilitylet mut x = 5; // mut x: i32x = 10;
Optionpub enum Option<T> { None, Some(T),}
Option
fn divide(numerator: f64, denominator: f64) -> Option<f64> { if denominator == 0.0 { None } else { Some(numerator / denominator) }}
Result
enum Result<T, E> { Ok(T), Err(E)}
fn divide(numerator: f64, denominator: f64) -> Result<f64, &'static str> { if denominator == 0.0 { Err("Can not divide by zero") } else { Ok(numerator / denominator) }}
Result
Pattern matchinglet x = 5;
match x { 1 => println!("one"), 2 => println!("two"), 3 => println!("three"), 4 => println!("four"), 5 => println!("five"), _ => println!("something else"),}
Pattern matching
One of the many advantages of match is it enforces ‘exhaustiveness checking’. For example if we remove the last arm with the underscore _, the compiler will give us an error:
error: non-exhaustive patterns: `_` not covered
Pattern matching
// The return value of the function is an optionlet result = divide(2.0, 3.0);
// Pattern match to retrieve the valuematch result { // The division was valid Some(x) => println!("Result: {}", x), // The division was invalid None => println!("Cannot divide by 0"),}
Pattern matching
// The return value of the function is an Result<f64, &'static str>let result = divide(2.0, 3.0);
// Pattern match to retrieve the valuematch result { // The division was valid Ok(x) => println!("Result: {}", x), // The division was invalid Err(e) => println!(e),}
Pattern matching
Again, the Rust compiler checks exhaustiveness, so it demands that you have a match arm for every variant of the enum. If you leave one off, it will give you a compile-time error unless you use _ or provide all possible arms.
Lambda functionslet plus_one = |x: i32| x + 1;
assert_eq!(2, plus_one(1));
Closureslet num = 5;let plus_num = |x: i32| x + num;
assert_eq!(10, plus_num(5));
Function pointersfn call_with_one(some_closure: &Fn(i32) -> i32) -> i32 { some_closure(1)}
fn add_one(i: i32) -> i32 { i + 1}
let f = add_one;
let answer = call_with_one(&f);
assert_eq!(2, answer);
Memory Safe
The Stack and the Heap
Ownership
Borrowing
Lifetimes
The Stackfn foo() { let y = 5; let z = 100;}
fn main() { let x = 42;
foo();}
The Stackfn foo() { let y = 5; let z = 100;}
fn main() { let x = 42; <-
foo();}
Address Name Value
0 x 42
The Stackfn foo() { let y = 5; let z = 100;}
fn main() { let x = 42;
foo(); <-}
Address Name Value
2 z 1000
1 y 5
0 x 42
The Stackfn foo() { let y = 5; let z = 100;}
fn main() { let x = 42;
foo();} <-
Address Name Value
0 x 42
The Heapfn main() { let x = Box::new(5); let y = 42;}
Address Name Value
(230) - 1 5
... ... ...
1 y 42
0 x → (230) - 1
Ownershiplet v = vec![1, 2, 3];
let v2 = v;
println!("v[0] is: {}", v[0]);
error: use of moved value: `v`println!("v[0] is: {}", v[0]); ^
Ownershipfn take(v: Vec<i32>) { // what happens here isn’t important.}
let v = vec![1, 2, 3];
take(v);
println!("v[0] is: {}", v[0]);
Same error: ‘use of moved value’.
Borrowingfn foo(v1: Vec<i32>, v2: Vec<i32>) -> (Vec<i32>, Vec<i32>, i32) { // do stuff with v1 and v2
// hand back ownership, and the result of our function (v1, v2, 42)}
let v1 = vec![1, 2, 3];let v2 = vec![1, 2, 3];
let (v1, v2, answer) = foo(v1, v2);
Borrowingfn foo(v1: &Vec<i32>, v2: &Vec<i32>) -> i32 { // do stuff with v1 and v2
// return the answer 42}
let v1 = vec![1, 2, 3];let v2 = vec![1, 2, 3];
let answer = foo(&v1, &v2);
// we can use v1 and v2 here!
&mut referencesfn foo(v: &Vec<i32>) { v.push(5);}
let v = vec![];
foo(&v);
errors with:
error: cannot borrow immutable borrowed content `*v` as mutablev.push(5);^
&mut referencesfn foo(v: &mut Vec<i32>) { v.push(5);}
let mut v = vec![];
foo(&mut v);
The Rules
First, any borrow must last for a scope no greater than that of the owner. Second, you may have one or the other of these two kinds of borrows, but not both at the same time:
one or more references (&T) to a resource,
exactly one mutable reference (&mut T).
Rust prevents data races at compile time
There is a ‘data race’ when two or more pointers access the same memory location at the same time, where at least one of them is writing, and the operations are not synchronized.
Lifetimes
1. I acquire a handle to some kind of resource.
2. I lend you a reference to the resource.
3. I decide I’m done with the resource, and deallocate it, while you still have your reference.
4. You decide to use the resource.
Lifetimes// implicitfn foo(x: &i32) {}
// explicitfn bar<'a>(x: &'a i32) {}
Lifetimes
You’ll also need explicit lifetimes when working with structs that contain references.
Lifetimesstruct Foo<'a> { x: &'a i32,}
fn main() { let y = &5; // this is the same as `let _y = 5; let y = &_y;` let f = Foo { x: y };
println!("{}", f.x);}
Lifetimes
We need to ensure that any reference to a Foo cannot outlive the reference to an i32 it contains.
Thinking in scopesfn main() { let y = &5; // -+ y goes into scope // | // stuff // | // |} // -+ y goes out of scope
Thinking in scopesstruct Foo<'a> { x: &'a i32,}
fn main() { let y = &5; // -+ y goes into scope let f = Foo { x: y }; // -+ f goes into scope // stuff // | // |} // -+ f and y go out of scope
Thinking in scopesstruct Foo<'a> { x: &'a i32,}
fn main() { let x; // -+ x goes into scope // | { // | let y = &5; // ---+ y goes into scope let f = Foo { x: y }; // ---+ f goes into scope x = &f.x; // | | error here } // ---+ f and y go out of scope // | println!("{}", x); // |} // -+ x goes out of scope
Not Covered
Macros
Tests
Concurrency
Foreign Function Interface
Cargo
and much much more
Resources
The Rust Programming Language. Also known as “The Book”, The Rust Programming Language is the
most comprehensive resource for all topics related to Rust, and is the primary official document of the
language.
Rust by Example. A collection of self-contained Rust examples on a variety of topics, executable in-
browser.
Frequently asked questions.
The Rustonomicon. An entire book dedicated to explaining how to write unsafe Rust code. It is for
advanced Rust programmers.
rust-learning. A community-maintained collection of resources for learning Rust.
Thank You!