Rust

RUST
郭⾄至軒 [:kuoe0]

kuoe0.tw@gmail.com

⾃自由的狐狸

NCKU
2008.09 ~ 2014.12
Programming Contests
Mozilla
2015.01 ~ 2018.01
Firefox Development
NEET
2018.01 ~ Present
Sleep until Noon

System Programming
Language with Memory
Safety

Memory Leak
/* C++ */
while (true) {
int* data = new int[10];
}
Dangling Pointer
Wild Pointer
/* C++ */
int* ptr1 = new int[10];
int* ptr2 = ptr1;
delete ptr2;
ptr1[0] = 0;
ptr2[1] = 1;
/* C++ */
int* ptr;
ptr[0] = 0;

Rust can Avoid Those Issues
in Compilation Time.

Rule 1
Each Value Has Only ONE Owner
Rule 2
Variable Releases OWNING VALUE when Destroying
Rule 3
Not Allow to Use INVALID Variables

let x = vec![1, 2, 3];
variable value
own

Rule 1
Each Value Has Only ONE Owner
Rule 2
Variable Releases OWNING VALUE when Destroying
Rule 3
Not Allow to Use INVALID Variables
not owning or borrowing any value
INVALID

Ownership Control
Lifetime Tracking
Copyable Type
Borrowing & Reference

fn foo(v: Vec<i32>) {
println!("{:?}", v);
}
→ fn main() {
let a = vec![1; 5];
let b = a;
{
let c = b;
}
let d = vec![2; 5];
foo(d);
}
variables
values

}
fn main() {
→ let a = vec![1; 5];
let b = a;
{
let c = b;
}
let d = vec![2; 5];
foo(d);
}
a
vec![1;5]
variables
values

}
fn main() {
let a = vec![1; 5];
→ let b = a;
{
let c = b;
}
let d = vec![2; 5];
foo(d);
}
a b
vec![1;5]
variables
values

}
fn main() {
let a = vec![1; 5];
let b = a;
{
→ let c = b;
}
let d = vec![2; 5];
foo(d);
}
a b c
vec![1;5]
variables
values

}
fn main() {
let a = vec![1; 5];
let b = a;
{
let c = b;
}
→ let d = vec![2; 5];
foo(d);
}
a b c d
variables
values
vec![2;5]

}
fn main() {
let a = vec![1; 5];
let b = a;
{
let c = b;
}
let d = vec![2; 5];
→ foo(d);
}
a b c d
variables
values
vec![2;5]

→ fn foo(v: Vec<i32>) {
}
fn main() {
let a = vec![1; 5];
let b = a;
{
let c = b;
}
let d = vec![2; 5];
foo(d);
}
a b c d v
variables
values
vec![2;5]

→ println!("{:?}", v);
}
fn main() {
let a = vec![1; 5];
let b = a;
{
let c = b;
}
let d = vec![2; 5];
foo(d);
}
a b c d v
variables
values
vec![2;5]

→ }
fn main() {
let a = vec![1; 5];
let b = a;
{
let c = b;
}
let d = vec![2; 5];
foo(d);
}
a b c d
variables
values

}
fn main() {
let a = vec![1; 5];
let b = a;
{
let c = b;
}
let d = vec![2; 5];
foo(d);
→ }
variables
values

}
fn main() {
let a: Vec<i32>;
→ println!("{:?}", a);
let b = vec![1; 5];
let c = b;
→ println!("{:?}", b);
}
error[E0381]: use of possibly
uninitialized variable: `a`
--> src/main.rs:7:22
|
7 | println!("{:?}", a);
| ^ use of
| possibly uninitialized `a`
error[E0382]: use of moved value: `b`
--> src/main.rs:11:22
|
10 | let c = b;
| - value moved here
11 | println!("{:?}", b);
| ^ value used
|. here after move
|

Type implemented Copy trait
do COPY instead of MOVE.

fn foo(v: i32) {
}
→ fn main() {
let a = 10;
let b = a;
println!("{:?}", a);
let c = 20;
foo(c);
println!("{:?}", c);
}
variables
values

fn foo(v: i32) {
}
fn main() {
→ let a = 10;
let b = a;
let c = 20;
foo(c);
}
variables
values
a
10

fn foo(v: i32) {
}
fn main() {
let a = 10;
→ let b = a;
let c = 20;
foo(c);
}
variables
values
a b
10 10

fn foo(v: i32) {
}
fn main() {
let a = 10;
let b = a;
→ println!("{:?}", a);
let c = 20;
foo(c);
}
variables
values
a b
10 10

fn foo(v: i32) {
}
fn main() {
let a = 10;
let b = a;
→ let c = 20;
foo(c);
}
variables
values
a b c
10 10 20

fn foo(v: i32) {
}
fn main() {
let a = 10;
let b = a;
let c = 20;
→ foo(c);
}
variables
values
a b c
10 10 20

→ fn foo(v: i32) {
}
fn main() {
let a = 10;
let b = a;
let c = 20;
foo(c);
}
variables
values
a b c v
10 10 20 20

fn foo(v: i32) {
→ println!("{:?}", v);
}
fn main() {
let a = 10;
let b = a;
let c = 20;
foo(c);
}
variables
values
a b c v
10 10 20 20

fn foo(v: i32) {
→ }
fn main() {
let a = 10;
let b = a;
let c = 20;
foo(c);
}
variables
values
a b c
10 10 20

fn foo(v: i32) {
}
fn main() {
let a = 10;
let b = a;
let c = 20;
foo(c);
→ println!("{:?}", c);
}
variables
values
a b c
10 10 20

fn foo(v: i32) {
}
fn main() {
let a = 10;
let b = a;
let c = 20;
foo(c);
→ }
variables
values

let x = vec![1, 2, 3];
let y = &x;

let x = vec![1, 2, 3];
let y = &x;
own
own

let x = vec![1, 2, 3];
let y = &x;
own
own
reference

let x = vec![1, 2, 3];
let y = &x;
own
own
reference
borrow

let x = vec![1, 2, 3];
let y = &x;
borrow

fn foo(v: &Vec<i32>) {
}
→ fn main() {
let a = vec![1; 5];
let b = &a;
let c = vec![2; 5];
foo(&c);
}
variables
values

}
fn main() {
→ let a = vec![1; 5];
let b = &a;
let c = vec![2; 5];
foo(&c);
}
variables
values
a
vec![1;5]

}
fn main() {
let a = vec![1; 5];
→ let b = &a;
let c = vec![2; 5];
foo(&c);
}
variables
values
a b
vec![1;5]

}
fn main() {
let a = vec![1; 5];
let b = &a;
→ println!("{:?}", a);
let c = vec![2; 5];
foo(&c);
}
variables
values
a b
vec![1;5]

}
fn main() {
let a = vec![1; 5];
let b = &a;
→ let c = vec![2; 5];
foo(&c);
}
variables
values
a b c
vec![2;5]vec![1;5]

}
fn main() {
let a = vec![1; 5];
let b = &a;
let c = vec![2; 5];
→ foo(&c);
}
variables
values
a b c
vec![2;5]vec![1;5]

→ fn foo(v: &Vec<i32>) {
}
fn main() {
let a = vec![1; 5];
let b = &a;
let c = vec![2; 5];
foo(&c);
}
variables
values
a b c v
vec![2;5]vec![1;5]

→ println!("{:?}", v);
}
fn main() {
let a = vec![1; 5];
let b = &a;
let c = vec![2; 5];
foo(&c);
}
variables
values
a b c v
vec![2;5]vec![1;5]

→ }
fn main() {
let a = vec![1; 5];
let b = &a;
let c = vec![2; 5];
foo(&c);
}
variables
values
a b c
vec![2;5]vec![1;5]

}
fn main() {
let a = vec![1; 5];
let b = &a;
let c = vec![2; 5];
foo(&c);
→ println!("{:?}", c);
}
variables
values
a b c
vec![2;5]vec![1;5]

}
fn main() {
let a = vec![1; 5];
let b = &a;
let c = vec![2; 5];
foo(&c);
→ }
variables
values

Build System
Dependencies Management
Test Framework
Documentation

Project Initialization
$ cargo new helloworld --bin
Create a new project with Cargo:
Generated ﬁles by `cargo new`:
$ tree helloworld
helloworld
!"" Cargo.toml
#"" src
#"" main.rs

Build & Run
$ cargo build
Compiling helloworld v0.1.0 (file:///helloworld)
Finished dev [unoptimized + debuginfo] target(s) in 4.60 secs
Build a project with cargo:
Run the executable program:
$ cargo run
Running `target/debug/helloworld`
Hello, world!

Cargo.toml
[package]
# project name
name = "helloworld"
# project version
version = "0.1.0"
# auto info
authors = ["kuoe0 <kuoe0.tw@gmail.com>"]
[dependencies]
rand = "0.4.2" # random number generator

Cargo.toml
[package]
# project name
name = "helloworld"
# project version
version = "0.1.0"
# auto info
[dependencies]
rand = "0.4.2" # random number generator
Package Info
Dependencies List

Dependencies List
[package]
# project name
name = "helloworld"
# project version
version = "0.1.0"
# auto info
[dependencies]
rand = "0.4.2"
libc = "0.2.40"
bitflags = "1.0.3"
serde = "1.0.44"
log = "0.4.1"

$ cargo build
Updating registry `https://github.com/rust-lang/crates.io-
index`
Downloading libc v0.2.40
Downloading cfg-if v0.1.2
Downloading serde v1.0.44
Downloading bitflags v1.0.3
Downloading log v0.4.1
Downloading rand v0.4.2
Compiling libc v0.2.40
Compiling cfg-if v0.1.2
Compiling serde v1.0.44
Compiling bitflags v1.0.3
Compiling log v0.4.1
Compiling rand v0.4.2
Compiling helloworld v0.1.0 (file:///helloworld)
Install dependencies with `cargo build`

Unit Test
extern crate rand;
fn gen_rand_int_less_100() -> u32 {
rand::random::<u32>() % 100
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn should_less_100() {
assert!(gen_rand_int_less_100() < 100);
}
}

$ cargo test
Compiling helloworld v0.1.0 (file:///private/tmp/helloworld)
Running target/debug/deps/helloworld-7a8984a66f00dd7b
running 1 test
test tests::should_less_100 ... ok
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0
filtered out
Run unit test with `cargo test`

Documentation
extern crate rand;
/// Return a random number in [0, 100)
///
/// # Example
///
/// ```
/// let r = gen_rand_int_less_100();
/// ```
pub fn gen_rand_int_less_100() -> u32 {
rand::random::<u32>() % 100
}

$ cargo doc
Documenting helloworld v0.1.0 (file:///private/tmp/helloworld)
Generate the document with `cargo doc`

Firefox ♥ Rust
Use Rust in Firefox

Servo Browser Engine
A browser engine written in Rust with parallel mechanism

Servo Browser Engine
A browser engine written in Rust with parallel mechanism
Quantum CSS (a.k.a. Stylo)
Use the parallel style engine from Servo in Firefox

Firefox Style Engine Servo Style Engine
replace

Rust

More Related Content

What's hot

What's hot (20)

Similar to Rust

Similar to Rust (20)

More from Chih-Hsuan Kuo

More from Chih-Hsuan Kuo (20)

Recently uploaded

Recently uploaded (20)

Rust