Rust by examples, for a Java developer

// basic enum:
enum UserRole { // convention: PascalCase type name
    Team1,      // convention: PascalCase enum name
    Team2,
    Managers,   // convention: comma after last list element (optional)
}

// enum with value and type:
// We will discuss typed enums and structs in the Object Oriented features.
// Option is part of standard lib, should not redefine it
enum MyOption<T> {
    None,
    Some(T),
}

// basic struct:
struct BasicUser {
    id: u32,    // convention: snake_case variable name
    active: bool,
}

// tuple struct (named tuple type):
struct IP4Address (u8, u8, u8, u8);

// struct with dynamic-size elements
struct User {
    id: u32,
    active: bool,
    name: String,
    roles: Vec<UserRole>,
}

let x: i32 = 1;     // immutable
let mut y: i32 = 2; // mutable

let a: bool = true;               // bool
let b = false;                    // inferred bool
let c: u16 = 1;                   // u16
let c_ptr = &c;                   // inferred &u16, reference to an u16 variable
let mut c_copy = *c_ptr;          // inferred u16, de-reference c_ptr
c_copy = 166;                     // changing c_copy will not impact c_ptr or c
let d = 2 + 2;                    // inferred i32, because i32 is the default integer
let e: f32 = 3.1415;              // f32
let f = 13.5;                     // inferred f64, because f64 is the default float
let g = 3 + c;                    // inferred u16, because c is u16
let h = 0;                        // inferred usize, because it is later used as an array index, which must be usize
let mut arr1: [i64; 2] = [1, 2];  // array of i64, length=3
let i = arr1[h];                  // inferred i64, bacause arr1 is array of i64
arr1[0] = 3;                      // array element is addressed with a 0-based index
let arr2 = [1, 2, 3, 4];          // inferred mutable [i32; 4]
let sli1 = &arr2[0..2];           // inferred &[i32] reference to an array slice ([1, 2])
let tup1: (bool, u32) = (true, 0);// tuple of (bool, u32)
let mut tup2 = (12, 3.14, "abc"); // inferred mutable tuple (i32, f64, &str)
tup2.0 = 13;                      // tuple element is addressed with a 0-based index
let j = '💖';                     // inferred char
let str1: &str = "abcd";          // &str, reference to an str
let sli2 = &str1[0..2];           // &str referring to slice of a string literal ("ab")
let mut user = User {             // mutable structure variable
    id: 1,
    active: true,
    name: String::from("Joe"),    // create a new dynamic String from a literal.
                                  // Equivalent to "Joe".to_string()
    roles: vec![UserRole::Team2], // vec![] is a macro to initialise a Vec
};
user.active = false;              // update mutable structure
user.name.push_str(" Smith");     // append to a String
let localhost = IP4Address(127, 0, 0, 1);
let first_byte = localhost.0;     // a tuple struct is adressed the same way as a tuple

static mut STARTUP_EPOCH_SECS: Option<i64> = None; // convention: globals are in UPPER_SNAKE_CASE
const ABC_DE: &str = "abc de"; // type must be explicit for static and const

// void function with a mutable argument, procedural style solution
// convention: snake_case function and argument names
fn search_pattern_for(pattern: &str, lines: &[&str], idx: &mut usize) {
    for i in 0..lines.len() {
        if lines[i].contains(pattern) {
            *idx = i;
            return;
        }
    }
    *idx = usize::MAX;
}

// function with a return value, FP style solution
// if there is no semicolon after the last line, it is considered a return value
// ("expr" is the same as "return expr;")
fn search_pattern_iter(pattern: &str, lines: &[&str]) -> usize {
    lines
        .iter()  // iterate over the elements,
                 // just like .stream() in Java (:Iterator<&str>)
        .enumerate() // extend each element with an index, as a tuple,
                     // just like .zip in Scala (:Iterator<(usize, &str)>)
        .find(|(_, &line)| line.contains(pattern)) // find the first element where the closure
                                                   // returns true (:Option<(usize, &str)>)
        .map_or(usize::MAX, |(idx, _)| idx) // take the index from the tuple, if found,
                                            // set MAX_USIZE otherwise (:usize)
}

fn main() {
    let lines = ["abcde", "defgh", "ghijk"];
    let pattern = "gh";

    let mut idx: usize = usize::MAX;
    search_pattern_for(pattern, &lines, &mut idx);
    // println!() is a macro. Macros can have variable number of arguments,
    // functions must have fixed number of arguments
    println!("Matching line: {}", if idx < lines.len() {lines[idx]} else {"NOT FOUND"});

    let idx = search_pattern_iter(pattern, &lines);
    println!("Matching line: {}", if idx < lines.len() {lines[idx]} else {"NOT FOUND"});
}

pub struct MyStruct {...}
pub enum MyEnum {...}
pub fn my_func() {...}

fn return_match(pattern: &str, lines: Vec<&str>) -> Option<String> {
    lines
        .iter()
        .find(|&line| line.contains(pattern))
        .map(|&line| line.to_string())  // map &str to a String instance
}

fn ownership() {
    let lines = vec!["abcde", "defgh", "ghijk"];
    let pattern = "gh";
    let line = return_match(pattern, lines);
    // The ownership of "lines" was transferred to the return_match() function
    // the scope of "lines" is ended, it cannot be used below this point
}

    let line = return_match(pattern, lines.clone());

fn return_match_borrow(pattern: &str, lines: &Vec<&str>) -> Option<&str> {
    lines
        .iter()
        .find(|&line| line.contains(&pattern))
        .map(|&line| line)
}
// error: missing lifetime specifier
// this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `pattern` or one of `lines`'s 2 lifetimes

fn return_match_borrow<'a>(pattern: &str, lines: &'a Vec<&str>) -> Option<&'a str> {
    lines
        .iter()
        .find(|&line| line.contains(&pattern))
        .map(|&line| line)
}

fn life_time() {
    let lines = vec!["abcde", "defgh", "ghijk"];
    let pattern = "gh";
    let line = return_match_borrow(pattern, &lines);
    // The ownership of "lines" is not transferred to the return_match() function
    // "lines" can be used below this point:
    let line0 = lines[0];
}

fn return_match_borrow(pattern: &str, lines: &'static Vec<&str>) -> Option<&'static str> {
....

// this is a function:
fn  add_one_v1   (x: u32) -> u32 { x + 1 }
// these are equivalent closures:
let add_one_v2 = |x: u32| -> u32 { x + 1 };
let add_one_v3 = |x|             { x + 1 };
let add_one_v4 = |x|               x + 1  ;

// borrowing immutably:
let list1 = vec![1, 2, 3];
let only_borrows = || println!("From closure: {:?}", list1);
only_borrows();     // list is not changed and continues to be in scope

// borrowing mutably:
let mut list2 = vec![1, 2, 3];
let mut borrows_mutably = || list2.push(7);
borrows_mutably();  // list is updated, but continues to be in scope

// taking ownership with the move keyword. This is mostly useful when passing a closure to a new thread:
let mut list3 = vec![1, 2, 3];
thread::spawn(move || {     // spawn fires up a new thread
            list3.push(4);
            println!("From thread: {:?}", list3);
        })                  // returns a JoinHandle
        .join()             // wait for the thread to finish and returns a Result<(), Error>
        .unwrap();          // unwrap Result: returns the Ok value or panics on Err

// taking ownership automatically (fails compilation):
let mut list = [(10, 1), (3, 5), (7, 12)];
let mut sort_operations = vec![];
let txt = String::from("by key called");

list.sort_by_key(|r| {
    sort_operations.push(txt);  // the closure takes ownership of txt, it can only be used once!
    r.0
});
// the code can be fixed by cloning txt: sort_operations.push(txt.clone());

let v1: Vec<i32> = vec![1, 2, 3];
// Iterator adaptors are generic, Rust cannot infer the result type, we need to declare the type:
let result: i32 = v1.iter()
    .map(|x| x + 1) // iterator adaptor
    .sum();         // consuming adaptor

// Another choice: declare the type on the adaptor:
let result = v1.iter()
    .map(|x| x + 1)
    .sum::<i32>();

// the struct fields are invisible from another module, unless they are defined public
pub struct TitleBasics {
    id: String,                     // this is a private field
    pub title_type: Option<String>, // this is a public field
    primary_title: Option<String>,
    start_year: Option<i32>,
}

// path to crate::module::type, not entirely unlike a Java import
use std::collections::HashMap;

// add methods to TitleBasics
impl TitleBasics {
    // convert a HashMap to TitleBasics
    pub fn from(fields: &HashMap<&str, &str>) -> TitleBasics {
        TitleBasics {
            id: fields["id"].to_string(), // map[key] will 'panic' if key is not found
            title_type: fields
                .get("title_type")        // map.get returns an Option<&str>
                .map(|&s| s.to_string()),
            primary_title: fields.get("primary_title").map(|&s| s.to_string()),
            start_year: fields
                .get("start_year")
                .map(|&s| s.parse::<i32>().ok()).flatten(),
        }
    }
    // get a detail
    // &self is an implicit alias of the structure data
    pub fn get_start_year(&self) -> &Option<i32> {
        &self.start_year
    }
    // set a detail
    pub fn set_start_year(&mut self, start_year: i32) {
        self.start_year = Some(start_year);
    }
}
// create a new instance, get a detail then set a detail:
fn struct_impl() {
    let map: HashMap<&str, &str> = HashMap::from([
        ("id", "tt000001"),
        ("title_type", "documentary"),
        ("primary_title", "The Blue Planet"),
        ("start_year", "1999"),
    ]);
    let mut tb = TitleBasics::from(&map);
    // {:?} instructs the println macro to call the Debug::fmt() method of the Option
    println!("start_year={:?}", tb.get_start_year());
    tb.set_start_year(1998);
    println!("start_year={:?}", tb.get_start_year());
}

trait Animal {
    fn name(&self) -> String;
    fn species(&self) -> String;
}

struct Fox(String);

struct Chicken(String);

impl Animal for Fox {
    fn name(&self) -> String {
        self.0.clone()
    }
    fn species(&self) -> String {
        "Fox".to_string()
    }
}

impl Animal for Chicken {
    fn species(&self) -> String {
        "Chicken".to_string()
    }
    fn name(&self) -> String {
        self.0.clone()
    }
}

// &dyn indicates that the type is a trait, not an object type
// the trait is implemented by Fox and Chicken trait objects
fn assert_animal(animal: &dyn Animal, name: &str, species: &str) {
    assert!(animal.name() == name);
    assert!(animal.species() == species);
}

fn test_animals() {
    let chicken = Chicken("Jenny".to_string());
    let fox = Fox("Joe".to_string());

    assert_animal(&chicken, "Jenny", "chicken");
    assert_animal(&fox, "Joe", "Fox");
}

// the following trait abstracts the access to a database row.
// It may be implemented for different databases or for unit testing without a database.
pub trait DbRow {
    fn opt_string(&self, column: &str) -> Option<String>;
    fn opt_i32(&self, column: &str) -> Option<i32>;
}

// add a from_db_row method to TitleBasics
impl TitleBasics {
    pub fn from_db_row(r: &dyn DbRow) -> TitleBasics {
        TitleBasics {
            id: r.opt_string("tconst").unwrap(),
            title_type: r.opt_string("titletype"),
            primary_title: r.opt_string("primarytitle"),
            start_year: r.opt_i32("startyear"),
        }
    }
}

// Implement DbRow for Postgres
// Although PgRow is coming from an external library, we can extend it,
// a bit like implicit classes in Scala2
use rocket_db_pools::sqlx::{Row, postgres::PgRow};
impl DbRow for PgRow {
    fn opt_string(&self, column: &str) -> Option<String> {
        self.try_get::<String, &str>(column).ok()
    }
    fn opt_i32(&self, column: &str) -> Option<i32> {
        self.try_get::<i32, &str>(column).ok()
    }
}

// Use DB row for querying a DB table, with the rocket_db_pools library
// "async" is an asynchronous function, practically meaning it returns a Future
use rocket_db_pools::sqlx;
use rocket_db_pools::sqlx::{Error, PgPool, postgres::PgRow};
pub async fn query_title_basics(db_pool: &PgPool, id: &str) -> Result<TitleBasics, Error> {
    sqlx::query("SELECT * FROM title_basics WHERE tconst = $1")
        .bind(id)
        .fetch_one(db_pool)
        .await
        .and_then(|row: PgRow| Ok(TitleBasics::from_db_row(&row)))
}


// A mock DB row used for unit testing
struct TestDbRow<'r> {
    map: HashMap<&'static str, &'r str>,
}

// Implement DbRow for the mock DB row
impl<'r> DbRow for TestDbRow<'r> {
    fn opt_string(&self, column: &str) -> Option<String> {
        self.map.get(column).map(|x| x.to_string())
    }
    fn opt_i32(&self, column: &str) -> Option<i32> {
        self.map.get(column).map(|x| x.parse::<i32>().unwrap())
    }
}

// Test TitleBasics::from_db_row() without a database:
// #[test] is an annotation macro
#[test]
fn test_title_basics_from_db_row() {
    let values = HashMap::from([("tconst", "abcd")]);
    let test_row = TestDbRow { map: values };
    let title_basics = TitleBasics::from_db_row(&test_row);

    assert!(title_basics.id == "abcd");
    // ...
}

use std::ops::Add;

// #[derive] is an annotation macro, it will auto-generate the implementation
// for the traits Debug, Copy, Clone and PartialEq
#[derive(Debug, Copy, Clone, PartialEq)]
struct Point {
    x: i32,
    y: i32,
}

impl Add for Point {
    type Output = Point;

    fn add(self, other: Point) -> Point {
        Point {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}

fn foo() {
    assert_eq!(Point { x: 1, y: 0 } + Point { x: 2, y: 3 }, Point { x: 3, y: 3 });
}