Introduction to Rust
•
1 like•339 views
Rust is a systems programming language that was first initiated in 2006 and reached 1.0 in 2015. It is used by Mozilla in Firefox and focuses on memory safety without garbage collection through features like ownership and borrowing. The document provides an introduction to Rust and covers topics like variables, functions, primitive types, if/loop control structures, ownership, references, and encourages readers to explore further topics in the Rust Book and Rust by Example.
Report
Share
Introduction to Rust
- 2. Brief Introduction First initiated by Graydon Hoare in 2006 as a part-time project Adopted by Mozilla Foundation in ~2009 Reached 1.0 in May 2015 Currently on 1.12 (stable), 1.13 (beta) and 1.14(nightly) Firefox is already shipping with Rust code since version 48
- 4. Why Rust?
- 5. Problems? Memory safety while being performant Modern Concurrency Tooling
- 7. Rust Features move semantics guaranteed memory safety type inference minimal runtime zero-cost abstractions fearless concurrency trait-based generics pattern matching ef cient C bindings
- 9. Instalation easiest way curl -sSf https://static.rust-lang.org/rustup.sh | sh
- 10. Hello World fn main() { println!("Hello, world!"); } run example
- 11. Hello, Cargo! cargo new hello_world --bin
- 12. Variable bindings let x = 5; // x: i32 let (x, y) = (1, 2); //type annotations let x: i32 = 5; let mut x = 5; // mut x: i32 x = 10;
- 13. Functions fn print_number(x: i32) { println!("x is: {}", x); } fn main() { print_number(4); }
- 14. Primitive Types Booleans let x = true; let y: bool = false; Char let x = 'x'; let two_hearts = ' ' Numeric let x = 42; // x has type i32 let y = 1.0; // y has type f64
- 15. List of di erent numeric types
- 17. IF let x = 5; if x == 5 { println!("x is five!"); } else { println!("x is not five :("); } let x = 5; if x == 5 { println!("x is five!"); } else if x == 6 { println!("x is six!"); } else { println!("x is not five or six :("); }
- 18. IF let x = 5; let y = if x == 5 { 10 } else { 15 }; // y: i32
- 19. Loops loop { println!("Loop forever!"); } let mut x = 5; // mut x: i32 let mut done = false; // mut done: bool while !done { x += x - 3; println!("{}", x); if x % 5 == 0 { done = true; } }
- 20. Loops Rust does not have the “C-style” for loop on purpose. Manually controlling each element of the loop is complicated and error prone, even for experienced C developers. for x in 0..10 { println!("{}", x); // x: i32 } for (index, value) in (5..10).enumerate() { //When you need to keep track of how many times you already looped println!("index = {} and value = {}", index, value); }
- 21. Ownership Variable bindings have a property in Rust: they ‘have ownership’ of what they’re bound to. This means that when a binding goes out of scope, Rust will free the bound resources. For example: let v = vec![1, 2, 3]; let v2 = v; println!("v[0] is: {}", v[0]);//error: use of moved value: `v`
- 22. 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, used of moved value `v`</i32>
- 23. Ownership Heap and stack let x = Box::new(5); //heap let y = 42; //stack
- 24. Ownership 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);</i32></i32></i32></i32>
- 25. Ownership References n 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!</i32></i32>
- 27. References Rust Book Rust by example
- 28. Thanks