Rápida Introdução ao Rust

História

• Criada em 2006 por Graydon Hoare.
• Patrocinada pela Mozilla em 2009.
• Versão 1.0 em 2015.
• Versão atual: 1.35
• Objetivo: Criar uma linguagem rápida mas com seguraça de memória.

História

Basic (com números e estruturado), dBase III Plus, Clipper, Pascal, Cobol, Delphi (ObjectPascal), C, C++, ActionScript (Flash), PHP, JavaScript, Python, Objective-C, Clojure, Java, Scala, Rust.

Meu Primeiro Rust

fn main() {
    println!("Hello, world!");
}
                        

Meu Primeiro Rust

Tempo para gerar esse código:

0 segundos

cargo init

Cargo

"Cargo is the Rust package manager"

"Cargo downloads your Rust package’s dependencies, compiles your packages, makes distributable packages, and uploads them to crates.io, the Rust community’s package registry."

De Volta Ao Rust - Static Typed

fn main() {
    let a: u8 = 2;
    println!("{}", a);
}
                        

Mas De Volta Ao Rust

fn main() {
    let a = 2u8;
    println!("{}", a);
}
                        

Mas De Volta Ao Rust

fn main() {
    let a = 2;
    println!("{}", a);
}
                        

De Volta ao Rust - Pattern Matching

fn factorial(i: u64) -> u64 {
    match i {
        0 => 1,
        n => n * factorial(n-1)
    }
}
                        

De Volta ao Rust - Returns are not necessary

fn is_pred(i: u64) -> Bool {
    if i % 2 == 0 {
       True
    } else {
       False
    }
}
                        

De Volta ao Rust - Returns are not necessary

fn is_pred(i: u64) -> Bool {
    i % 2 == 0
}
                        

De Volta ao Rust - Enums

enum IPAddr {
    IPV4,
    IPV6
}
                        

Mas De Volta ao Rust

enum IPAddr {
    IPV4(String),
    IPV6(String)
}
                        

Mas De Volta ao Rust

let home = IpAddr::IPV4(String::from("127.0.0.1");

match home {
    IPV4(ipv4_address) => println!("IPv4 addr: {}", ipv4_address),
    IPV6(ipv6_address) => println!("Ipv6 addr: {}", ipv6_address),
}
                        

De Volta ao Rust - No OO

No OO

struct MyStruct {
    a_field: String,
    r_a: [2u64; 10],
}
                        

No OO - But "functions in structs"

impl MyStruct {
    fn first_element(&self) -> u64 {
        self.r_a.get(0)
    }
}
                        

No OO - But Traits

trait Summarize {
    fn summarize(&self) -> String;
}
                        

No OO - But Traits

impl Summarize for MyStruct {
    fn summarize(&self) -> String {
        self.a_field
    }
}
                        

No OO - But Generics

fn make_summary<T>(summarizable: T) {
    T.summarize()
}
                        

No OO - But Generic Traits

fn make_summary<T>(summarizable: T)
    where T: Summarize
{
    T.summarize()
}
                        

E Aquela "Segurança de Memória"?

1. No Null Pointers

fn may_not_exist(value: Option<String>) {
    match value {
        Some(the_string) => println!("I got a string! {}", the_string),
        None => println!("I got nothing")
    }
}
                        

2. No Shared Memory

fn main() {
   let a = String::from("A reference to a string in the code section copied to the stack");
   let b = a;
   println!("The string is: {}", a);
}
                        

2. No Shared Memory

fn main() {
   let a = String::from("A reference to a string in the code section copied to the stack");
   let b = &a;
   println!("The string is: {}", a);
}
                        

presente := Presente { ... }
canal <- presente
 

presente := Presente { ... }
canal <- presente
presente.abrir()

3. Immutable variables by default

fn main() {
    let a = 3;
    a = 5;
}
                        

Error Control

enum Result<T, E> {
    Ok(T),
    Err(E),
}
                        

match File::create("something.txt") {
    Ok(fp) => fp.write_all(b"Hello world"),
    Err(err) => println!("Failure! {}", err),
}
                        

Compilador Chato mas Amigável

fn main() {
    let a = 2;
    a = 3;
    println!("{}", a);
}
                        

3 |     let a = 2;
  |         -
  |         |
  |         first assignment to `a`
  |         help: make this binding mutable: `mut a`
4 |     a = 3;
  |     ^^^^^ cannot assign twice to immutable variable
                        

3 |     let a = 2;
  |         -
  |         |
  |         first assignment to `a`
  |         help: make this binding mutable: `mut a`
4 |     a = 3;
  |     ^^^^^ cannot assign twice to immutable variable
                        

3 |     let a = 2;
  |         -
  |         |
  |         first assignment to `a`
  |         help: make this binding mutable: `mut a`
4 |     a = 3;
  |     ^^^^^ cannot assign twice to immutable variable
                        

A linguagem mais amada segundo o StackOverflow Survey 2019

... pelo 4⁰ ano seguido.