// Simplified definition from std
pub trait Iterator {
    type Item;                        // associated type — fixed per implementation
    fn next(&mut self) -> Option<Self::Item>;
}

// Custom counter implementing Iterator
struct Counter {
    count: u32,
    max: u32,
}

impl Iterator for Counter {
    type Item = u32;                  // Item is now fixed as u32 for Counter

    fn next(&mut self) -> Option<u32> {
        if self.count < self.max {
            self.count += 1;
            Some(self.count)
        } else {
            None
        }
    }
}

fn main() {
    let c = Counter { count: 0, max: 3 };
    let v: Vec<u32> = c.collect();
    println!("{:?}", v);
}

use std::ops::Add;

#[derive(Debug)]
struct Millimetres(f64);

// Add<Millimetres> for Millimetres (the default Rhs)
impl Add for Millimetres {
    type Output = Millimetres;
    fn add(self, rhs: Millimetres) -> Millimetres {
        Millimetres(self.0 + rhs.0)
    }
}

// You could also impl Add<Metres> for Millimetres for cross-unit arithmetic
fn main() {
    let total = Millimetres(10.0) + Millimetres(5.5);
    println!("{:?}", total);
}

use std::ops::Add;

#[derive(Debug, Clone, Copy)]
struct Point {
    x: f64,
    y: f64,
}

// Uses the default Rhs = Self — no explicit generic argument needed
impl Add for Point {
    type Output = Point;

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

fn main() {
    let p1 = Point { x: 1.0, y: 2.0 };
    let p2 = Point { x: 3.0, y: 4.0 };
    println!("{:?}", p1 + p2);
}

use std::fmt;
use std::ops::{Add, Sub, Neg};

#[derive(Debug, Clone, Copy, PartialEq)]
struct Vec2 {
    x: f64,
    y: f64,
}

impl Vec2 {
    fn new(x: f64, y: f64) -> Self { Vec2 { x, y } }
    fn length(self) -> f64 { (self.x * self.x + self.y * self.y).sqrt() }
}

impl Add for Vec2 {
    type Output = Vec2;
    fn add(self, rhs: Vec2) -> Vec2 { Vec2::new(self.x + rhs.x, self.y + rhs.y) }
}

impl Sub for Vec2 {
    type Output = Vec2;
    fn sub(self, rhs: Vec2) -> Vec2 { Vec2::new(self.x - rhs.x, self.y - rhs.y) }
}

impl Neg for Vec2 {
    type Output = Vec2;
    fn neg(self) -> Vec2 { Vec2::new(-self.x, -self.y) }
}

impl fmt::Display for Vec2 {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "({:.2}, {:.2})", self.x, self.y)
    }
}

fn main() {
    let a = Vec2::new(3.0, 4.0);
    let b = Vec2::new(1.0, 2.0);
    println!("a     = {}", a);
    println!("b     = {}", b);
    println!("a + b = {}", a + b);
    println!("a - b = {}", a - b);
    println!("-a    = {}", -a);
    println!("|a|   = {:.2}", a.length());
}

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

trait Robot {
    fn name(&self) -> &str;
}

struct Dog;

impl Animal for Dog {
    fn name(&self) -> &str { "Buddy (animal)" }
}

impl Robot for Dog {
    fn name(&self) -> &str { "RoboDog (robot)" }
}

impl Dog {
    // Inherent method — takes priority when calling dog.name()
    fn name(&self) -> &str { "Max (inherent)" }
}

fn main() {
    let dog = Dog;

    println!("{}", dog.name());                    // inherent wins
    println!("{}", <Dog as Animal>::name(&dog));   // explicit Animal version
    println!("{}", <Dog as Robot>::name(&dog));    // explicit Robot version
}

use std::fmt;

// OutlinePrint requires Display — Display is a supertrait
trait OutlinePrint: fmt::Display {
    fn outline_print(&self) {
        // to_string() comes from Display — guaranteed to exist
        let output = self.to_string();
        let len = output.len();
        let border = "*".repeat(len + 4);

        println!("{}", border);
        println!("* {} *", output);
        println!("{}", border);
    }
}

#[derive(Debug)]
struct Point { x: f64, y: f64 }

// Must implement Display first or the compiler rejects OutlinePrint
impl fmt::Display for Point {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "({}, {})", self.x, self.y)
    }
}

// The default outline_print body is inherited automatically
impl OutlinePrint for Point {}

fn main() {
    let p = Point { x: 1.0, y: 3.0 };
    p.outline_print();
}

use std::fmt;

// Goal: implement Display for Vec<String>.
// Problem: both Vec and Display live in std — the orphan rule forbids a direct impl.
// Solution: wrap Vec<String> in a local newtype.

struct Wrapper(Vec<String>);

impl fmt::Display for Wrapper {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        // self.0 accesses the inner Vec<String>
        write!(f, "[{}]", self.0.join(", "))
    }
}

fn main() {
    let w = Wrapper(vec![
        String::from("hello"),
        String::from("world"),
    ]);
    println!("{}", w);
}

// Works for any closure that maps &str -> &str,
// regardless of the borrow's lifetime at each call site.
fn apply_transform<F>(text: &str, f: F) -> &str
where
    F: for<'a> Fn(&'a str) -> &'a str,
{
    f(text)
}

fn trim_str(s: &str) -> &str {
    s.trim()
}

fn main() {
    let owned = String::from("  hello world  ");
    let result = apply_transform(&owned, trim_str);
    println!("'{}'", result);

    let result2 = apply_transform("  rust  ", |s| s.trim());
    println!("'{}'", result2);
}

use std::thread;

// i32 is Send + Sync, so SharedData is too — automatically
#[derive(Debug)]
struct SharedData {
    value: i32,
}

fn requires_send<T: Send>(val: T) {
    thread::spawn(move || {
        println!("In thread: {:?}", val);
    }).join().unwrap();
}

// Opt into Copy — assignment copies the bits instead of moving
#[derive(Debug, Clone, Copy)]
struct Scalar(f64);

fn main() {
    let data = SharedData { value: 42 };
    requires_send(data);                      // compiles: SharedData: Send

    let s = Scalar(3.14);
    let s2 = s;                               // copy, not move
    println!("s={:?}  s2={:?}", s, s2);      // both still valid
}