SlideShare a Scribd company logo
Rust Intro
by Artur Gavkaliuk
Mozilla
The 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 language
Rust 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
Structs
struct 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);
}
Enums
enum BoardGameTurn {
Move { squares: i32 },
Pass,
}
let y: BoardGameTurn = BoardGameTurn::Move { squares: 1 };
Generics
struct 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 syntax
struct 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 syntax
impl Circle {
fn area(&self) -> f64 {
std::f64::consts::PI * (self.radius * self.radius)
}
}
Traits
trait HasArea {
fn area(&self) -> f64;
}
impl HasArea for Circle {
fn area(&self) -> f64 {
std::f64::consts::PI * (self.radius * self.radius)
}
}
Traits
fn 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
Functions
fn add_one(x: i32) -> i32 {
x + 1
}
Functions
fn add_one(x: i32) -> i32 {
x + 1;
}
We would get an error:
error: not all control paths return a value
fn add_one(x: i32) -> i32 {
x + 1;
}
help: consider removing this semicolon:
x + 1;
^
Functions
fn 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 inference
let f: fn(i32) -> i32 = plus_one;
// with type inference
let f = plus_one;
Mutability
let x = 5;
x = 10;
error: re-assignment of immutable variable `x`
x = 10;
^~~~~~~
Mutability
let mut x = 5; // mut x: i32
x = 10;
Option
pub 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 matching
let 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 option
let result = divide(2.0, 3.0);
// Pattern match to retrieve the value
match 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 value
match 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 functions
let plus_one = |x: i32| x + 1;
assert_eq!(2, plus_one(1));
Closures
let num = 5;
let plus_num = |x: i32| x + num;
assert_eq!(10, plus_num(5));
Function pointers
fn 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 Stack
fn foo() {
let y = 5;
let z = 100;
}
fn main() {
let x = 42;
foo();
}
The Stack
fn foo() {
let y = 5;
let z = 100;
}
fn main() {
let x = 42; <-
foo();
}
Address Name Value
0 x 42
The Stack
fn 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 Stack
fn foo() {
let y = 5;
let z = 100;
}
fn main() {
let x = 42;
foo();
} <-
Address Name Value
0 x 42
The Heap
fn main() {
let x = Box::new(5);
let y = 42;
}
Address Name Value
(230) - 1 5
... ... ...
1 y 42
0 x → (230) - 1
Ownership
let 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]);
^
Ownership
fn 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’.
Borrowing
fn 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);
Borrowing
fn 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 references
fn foo(v: &Vec<i32>) {
v.push(5);
}
let v = vec![];
foo(&v);
errors with:
error: cannot borrow immutable borrowed content `*v` as mutable
v.push(5);
^
&mut references
fn 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
// implicit
fn foo(x: &i32) {
}
// explicit
fn bar<'a>(x: &'a i32) {
}
Lifetimes
You’ll also need explicit lifetimes when working with structs that contain
references.
Lifetimes
struct 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 scopes
fn main() {
let y = &5; // -+ y goes into scope
// |
// stuff // |
// |
} // -+ y goes out of scope
Thinking in scopes
struct 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 scopes
struct 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!

More Related Content

PPTX
Rust vs C++
PDF
Why rust?
PDF
An introduction to Rust: the modern programming language to develop safe and ...
PPTX
Introduction to Rust language programming
PDF
[143] Modern C++ 무조건 써야 해?
PDF
Introduction to Rust
PDF
Deep drive into rust programming language
PDF
The Rust Programming Language: an Overview
Rust vs C++
Why rust?
An introduction to Rust: the modern programming language to develop safe and ...
Introduction to Rust language programming
[143] Modern C++ 무조건 써야 해?
Introduction to Rust
Deep drive into rust programming language
The Rust Programming Language: an Overview

What's hot (20)

PDF
Algebraic Data Types for Data Oriented Programming - From Haskell and Scala t...
PDF
PHP, Under The Hood - DPC
PDF
The Functional Programming Triad of Map, Filter and Fold
PPTX
Clean Code
PDF
AI 연구자를 위한 클린코드 - GDG DevFest Seoul 2019
PDF
Defending against Java Deserialization Vulnerabilities
PDF
Functional Programming Patterns (BuildStuff '14)
PPTX
React hooks
PDF
Fun with Lambdas: C++14 Style (part 1)
PPTX
Présentation de ECMAScript 6
PPTX
깨끗한 코드 (클린 코드, Clean Code)
PPTX
[OKKYCON] 박재성 - 의식적인 연습으로 TDD, 리팩토링 연습하기
PDF
PHP unserialization vulnerabilities: What are we missing?
PDF
Rust system programming language
PPT
Introduction to Data Oriented Design
PPTX
파이썬 Numpy 선형대수 이해하기
DOCX
Python Interview Questions For Experienced
PDF
[TechDays Korea 2015] 녹슨 C++ 코드에 모던 C++로 기름칠하기
Algebraic Data Types for Data Oriented Programming - From Haskell and Scala t...
PHP, Under The Hood - DPC
The Functional Programming Triad of Map, Filter and Fold
Clean Code
AI 연구자를 위한 클린코드 - GDG DevFest Seoul 2019
Defending against Java Deserialization Vulnerabilities
Functional Programming Patterns (BuildStuff '14)
React hooks
Fun with Lambdas: C++14 Style (part 1)
Présentation de ECMAScript 6
깨끗한 코드 (클린 코드, Clean Code)
[OKKYCON] 박재성 - 의식적인 연습으로 TDD, 리팩토링 연습하기
PHP unserialization vulnerabilities: What are we missing?
Rust system programming language
Introduction to Data Oriented Design
파이썬 Numpy 선형대수 이해하기
Python Interview Questions For Experienced
[TechDays Korea 2015] 녹슨 C++ 코드에 모던 C++로 기름칠하기
Ad

Viewers also liked (18)

PDF
Caution this information can blow your head
PPTX
šK hádzaná detva prezentácia
PDF
PPTX
Geospatial Analytics
PPTX
PPTX
štrukturované produkty
PDF
01 triangle new
PPTX
Ingreso a exel
PDF
Seri dreamweaver -_membuat_menu_bertingkat_tree_menu
PDF
Analýza ŠK Hádzaná Detva
PDF
Sejam bem vindos
Caution this information can blow your head
šK hádzaná detva prezentácia
Geospatial Analytics
štrukturované produkty
01 triangle new
Ingreso a exel
Seri dreamweaver -_membuat_menu_bertingkat_tree_menu
Analýza ŠK Hádzaná Detva
Sejam bem vindos
Ad

Similar to Rust Intro (20)

PDF
Rustlabs Quick Start
PDF
golang_refcard.pdf
PDF
Briefly Rust - Daniele Esposti - Codemotion Rome 2017
PPTX
Briefly Rust
PDF
Le langage rust
PDF
Introduction to Rust
PDF
Rust Workshop - NITC FOSSMEET 2017
PDF
Introduction to Rust - Waterford Tech Meetup 2025
PDF
Geeks Anonymes - Le langage Go
PDF
Introduction to go
PPTX
golang_getting_started.pptx
PDF
Short intro to the Rust language
PDF
Haskell - Being lazy with class
PPTX
Qcon2011 functions rockpresentation_f_sharp
PPTX
Qcon2011 functions rockpresentation_f_sharp
PDF
PDF
Introduction to Functional Programming
PDF
Explaining ES6: JavaScript History and What is to Come
PPT
Isorerism in relative strength in inline functions in pine script.ppt
PDF
The mighty js_function
Rustlabs Quick Start
golang_refcard.pdf
Briefly Rust - Daniele Esposti - Codemotion Rome 2017
Briefly Rust
Le langage rust
Introduction to Rust
Rust Workshop - NITC FOSSMEET 2017
Introduction to Rust - Waterford Tech Meetup 2025
Geeks Anonymes - Le langage Go
Introduction to go
golang_getting_started.pptx
Short intro to the Rust language
Haskell - Being lazy with class
Qcon2011 functions rockpresentation_f_sharp
Qcon2011 functions rockpresentation_f_sharp
Introduction to Functional Programming
Explaining ES6: JavaScript History and What is to Come
Isorerism in relative strength in inline functions in pine script.ppt
The mighty js_function

Recently uploaded (20)

PDF
Addressing The Cult of Project Management Tools-Why Disconnected Work is Hold...
PDF
Design an Analysis of Algorithms I-SECS-1021-03
PDF
Adobe Illustrator 28.6 Crack My Vision of Vector Design
PDF
System and Network Administration Chapter 2
PDF
2025 Textile ERP Trends: SAP, Odoo & Oracle
PPTX
Odoo POS Development Services by CandidRoot Solutions
PDF
AI in Product Development-omnex systems
PDF
How to Choose the Right IT Partner for Your Business in Malaysia
PDF
Raksha Bandhan Grocery Pricing Trends in India 2025.pdf
PDF
Internet Downloader Manager (IDM) Crack 6.42 Build 42 Updates Latest 2025
PDF
How Creative Agencies Leverage Project Management Software.pdf
PDF
Why TechBuilder is the Future of Pickup and Delivery App Development (1).pdf
PDF
How to Migrate SBCGlobal Email to Yahoo Easily
PDF
Flood Susceptibility Mapping Using Image-Based 2D-CNN Deep Learnin. Overview ...
PPTX
Operating system designcfffgfgggggggvggggggggg
PDF
Wondershare Filmora 15 Crack With Activation Key [2025
PDF
PTS Company Brochure 2025 (1).pdf.......
PPTX
history of c programming in notes for students .pptx
PDF
Upgrade and Innovation Strategies for SAP ERP Customers
PDF
EN-Survey-Report-SAP-LeanIX-EA-Insights-2025.pdf
Addressing The Cult of Project Management Tools-Why Disconnected Work is Hold...
Design an Analysis of Algorithms I-SECS-1021-03
Adobe Illustrator 28.6 Crack My Vision of Vector Design
System and Network Administration Chapter 2
2025 Textile ERP Trends: SAP, Odoo & Oracle
Odoo POS Development Services by CandidRoot Solutions
AI in Product Development-omnex systems
How to Choose the Right IT Partner for Your Business in Malaysia
Raksha Bandhan Grocery Pricing Trends in India 2025.pdf
Internet Downloader Manager (IDM) Crack 6.42 Build 42 Updates Latest 2025
How Creative Agencies Leverage Project Management Software.pdf
Why TechBuilder is the Future of Pickup and Delivery App Development (1).pdf
How to Migrate SBCGlobal Email to Yahoo Easily
Flood Susceptibility Mapping Using Image-Based 2D-CNN Deep Learnin. Overview ...
Operating system designcfffgfgggggggvggggggggg
Wondershare Filmora 15 Crack With Activation Key [2025
PTS Company Brochure 2025 (1).pdf.......
history of c programming in notes for students .pptx
Upgrade and Innovation Strategies for SAP ERP Customers
EN-Survey-Report-SAP-LeanIX-EA-Insights-2025.pdf

Rust Intro

  • 2. Mozilla The 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.
  • 3. Safe, concurrent, practical language Rust 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.
  • 5. Structs struct 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); }
  • 6. Enums enum BoardGameTurn { Move { squares: i32 }, Pass, } let y: BoardGameTurn = BoardGameTurn::Move { squares: 1 };
  • 7. Generics struct Point<T> { x: T, y: T, } let int_origin = Point { x: 0, y: 0 }; let float_origin = Point { x: 0.0, y: 0.0 };
  • 8. Method syntax struct Circle { x: f64, y: f64, radius: f64, } fn main() { let c = Circle { x: 0.0, y: 0.0, radius: 2.0 }; println!("{}", c.area()); }
  • 9. Method syntax impl Circle { fn area(&self) -> f64 { std::f64::consts::PI * (self.radius * self.radius) } }
  • 10. Traits trait HasArea { fn area(&self) -> f64; } impl HasArea for Circle { fn area(&self) -> f64 { std::f64::consts::PI * (self.radius * self.radius) } }
  • 11. Traits fn print_area<T: HasArea>(shape: T) { println!("This shape has an area of {}", shape.area()); }
  • 12. Functional Functions Function pointers Type inference Immutable by default Option and Result Pattern matching Lambda functions
  • 13. Functions fn add_one(x: i32) -> i32 { x + 1 }
  • 14. Functions fn add_one(x: i32) -> i32 { x + 1; } We would get an error: error: not all control paths return a value fn add_one(x: i32) -> i32 { x + 1; } help: consider removing this semicolon: x + 1; ^
  • 15. Functions fn plus_one(i: i32) -> i32 { i + 1 } let f: fn(i32) -> i32 = plus_one; let six = f(5);
  • 16. 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 inference let f: fn(i32) -> i32 = plus_one; // with type inference let f = plus_one;
  • 17. Mutability let x = 5; x = 10; error: re-assignment of immutable variable `x` x = 10; ^~~~~~~
  • 18. Mutability let mut x = 5; // mut x: i32 x = 10;
  • 19. Option pub enum Option<T> { None, Some(T), }
  • 20. Option fn divide(numerator: f64, denominator: f64) -> Option<f64> { if denominator == 0.0 { None } else { Some(numerator / denominator) } }
  • 21. Result enum Result<T, E> { Ok(T), Err(E) }
  • 22. 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
  • 23. Pattern matching let x = 5; match x { 1 => println!("one"), 2 => println!("two"), 3 => println!("three"), 4 => println!("four"), 5 => println!("five"), _ => println!("something else"), }
  • 24. 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
  • 25. Pattern matching // The return value of the function is an option let result = divide(2.0, 3.0); // Pattern match to retrieve the value match result { // The division was valid Some(x) => println!("Result: {}", x), // The division was invalid None => println!("Cannot divide by 0"), }
  • 26. 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 value match result { // The division was valid Ok(x) => println!("Result: {}", x), // The division was invalid Err(e) => println!(e), }
  • 27. 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.
  • 28. Lambda functions let plus_one = |x: i32| x + 1; assert_eq!(2, plus_one(1));
  • 29. Closures let num = 5; let plus_num = |x: i32| x + num; assert_eq!(10, plus_num(5));
  • 30. Function pointers fn 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);
  • 31. Memory Safe The Stack and the Heap Ownership Borrowing Lifetimes
  • 32. The Stack fn foo() { let y = 5; let z = 100; } fn main() { let x = 42; foo(); }
  • 33. The Stack fn foo() { let y = 5; let z = 100; } fn main() { let x = 42; <- foo(); } Address Name Value 0 x 42
  • 34. The Stack fn 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
  • 35. The Stack fn foo() { let y = 5; let z = 100; } fn main() { let x = 42; foo(); } <- Address Name Value 0 x 42
  • 36. The Heap fn main() { let x = Box::new(5); let y = 42; } Address Name Value (230) - 1 5 ... ... ... 1 y 42 0 x → (230) - 1
  • 37. Ownership let 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]); ^
  • 38. Ownership fn 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’.
  • 39. Borrowing fn 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);
  • 40. Borrowing fn 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!
  • 41. &mut references fn foo(v: &Vec<i32>) { v.push(5); } let v = vec![]; foo(&v); errors with: error: cannot borrow immutable borrowed content `*v` as mutable v.push(5); ^
  • 42. &mut references fn foo(v: &mut Vec<i32>) { v.push(5); } let mut v = vec![]; foo(&mut v);
  • 43. 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).
  • 44. 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.
  • 45. 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.
  • 46. Lifetimes // implicit fn foo(x: &i32) { } // explicit fn bar<'a>(x: &'a i32) { }
  • 47. Lifetimes You’ll also need explicit lifetimes when working with structs that contain references.
  • 48. Lifetimes struct 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); }
  • 49. Lifetimes We need to ensure that any reference to a Foo cannot outlive the reference to an i32 it contains.
  • 50. Thinking in scopes fn main() { let y = &5; // -+ y goes into scope // | // stuff // | // | } // -+ y goes out of scope
  • 51. Thinking in scopes struct 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
  • 52. Thinking in scopes struct 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
  • 53. Not Covered Macros Tests Concurrency Foreign Function Interface Cargo and much much more
  • 54. 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.