fn main() {
  let s1 = String::from("Hello, Rust!");
  
  // Ownership of the String is transferred from s1 to s2
  let s2 = s1;
  
  // This results in a compilation
  println!("s1: {}", s1);
} // s2 goes out of scope and memory is freed

fn take_ownership(some_string: String) {
  // The ownership of the String is transferred to some_string
  println!("Got ownership: {}", some_string);
}  // some_string goes out of scope and the memory is freed

fn main() {
  let my_string = String::from("Hello, ownership!");

  // Ownership is transferred to the function and my_string is
  // no longer valid
  take_ownership(my_string);

  // This results in a compilation error as my_string is no
  // longer the owner of the String.
  println!("my_string: {}", my_string);
} // my_string is no longer valid here, as it was moved to take_ownership

fn main() {
  // s is the owner of the mutable String
  let mut s = String::from("Hello, Rust!");

  let r1 = &s;  // Immutable borrow
  let r2 = &s;  // Another immutable borrow

  println!("r1: {}, r2: {}", r1, r2);

  let r3 = &mut s;  // Mutable borrow
  r3.push_str(", and Pythonista!"); // Modifying the borrowed value

  println!("r3: {}", r3);
} // r1, r2, r3, and s go out of scope and memory is automagically freed

struct Quote<'a> {
  part: &'a str,
}  // We annotated this Struct such that its lifetime is linked to part

fn main() {
  let novel = String::from("Do or do not. There is not try.");

  // We split novel on the period but split returns borrows.
  // This means that if novel goes out of scope, so does first_sentence.
  let first_sentence = novel.split('.')
          .next().expect("No period detected!");
   
  // We have annotated the lifetime to be dependent of part.
  // If first_sentence goes out of scope, so does quote.
  let quote = Quote {
    part: first_sentence,
  };
}  // All will be deallocated

fn divide(x: f64, y: f64) -> Option<f64> {
  if y == 0.0 {
    None
  } else {
    Some(x / y)
  }
}
  
fn main() {
  let result = divide(10.0, 2.0);
  
  match result {
    Some(value) => println!("Result: {}", value),
    None => println!("Cannot divide by zero!"),
  }
}

fn divide(x: f64, y: f64) -> Result<f64, &'static str> {
  if y == 0.0 {
    Err("Cannot divide by zero!")
  } else {
    Ok(x / y)
  }
}
  
fn main() {
  let result = divide(10.0, 0.0);
  
  match result {
    Ok(value) => println!("Result: {}", value),
    Err(err) => println!("Error: {}", err),
  }
}

let mut values = vec![Some(1), Some(2), None, Some(3)];

while let Some(value) = values.pop() {
  if let Some(inner_value) = value {
    println!("Popped: {}", inner_value);
  } else {
    println!("Found None");
  }
}

class A:
    def method(self):
        print("Method in class A")

class B(A):
    def method(self):
        print("Method in class B")

class C(A):
    def method(self):
        print("Method in class C")
        
class D(B, C):
    pass

obj = D()
obj.method()  # Ambiguity arises here

// Define a trait for characters that can speak
trait Speaker {
    fn speak(&self);
}

// Implement the Speaker trait for a Jedi
struct Jedi {
    name: String,
}

impl Speaker for Jedi {
    fn speak(&self) {
        println!("{} says: May the Force be with you.", self.name);
    }
}

// Implement the Speaker trait for a Droid
struct Droid {
    model: String,
}

impl Speaker for Droid {
    fn speak(&self) {
        println!("{} says: Beep boop beep.", self.model);
    }
}

// Function that takes any type implementing the Speaker trait
fn introduce(character: &dyn Speaker) {
    character.speak();
}

fn main() {
    let obi_wan = Jedi {
        name: String::from("Obi-Wan Kenobi"),
    };

    let r2d2 = Droid {
        model: String::from("R2-D2"),
    };

    // Call the introduce function with instances of Jedi and Droid
    introduce(&obi_wan);
    introduce(&r2d2);
}