Blowing in the wind

#[derive(Debug)]
struct Foo;

let x = Foo;

let y = x;

// `x` has moved into `y`, and so cannot be used

// println!("{x:?}"); // error: use of moved value

// We can derive a `Copy` implementation. `Clone` is also required, as it's
// a supertrait of `Copy`.
#[derive(Debug, Copy, Clone)]
struct Foo;

let x = Foo;

let y = x;

// `y` is a copy of `x`

println!("{x:?}"); // A-OK!

// A unit struct without resources
// Clone must also have to be derived when you use Copy
#[derive(Debug, Clone, Copy)]
struct Unit;

// A tuple struct with resources that implements the `Clone` trait
// Copy can not be applied to Pair struct
#[derive(Clone, Debug)]
struct Pair(Box, Box);

fn main() {
    // Instantiate `Unit`
    let unit = Unit;
    // Copy `Unit`, there are no resources to move
    let copied_unit = unit;

    // Both `Unit`s can be used independently
    println!("original: {:?}", unit);
    println!("copy: {:?}", copied_unit);


    // ----------- from here, Pair is handled -----------
    // Instantiate `Pair`
    let pair = Pair(Box::new(1), Box::new(2));
    println!("original: {:?}", pair);

    // Move `pair` into `moved_pair`, moves resources
    let moved_pair = pair;
    println!("moved: {:?}", moved_pair);

    // Error! `pair` has lost its resources
    //println!("original: {:?}", pair);
    // TODO ^ Try uncommenting this line

    // Clone `moved_pair` into `cloned_pair` (resources are included)
    let cloned_pair = moved_pair.clone();
    println!("cloned original: {:?}", moved_pair);
    // Drop the original pair using std::mem::drop
    drop(moved_pair);

    // Error! `moved_pair` has been dropped
    //println!("copy: {:?}", moved_pair);
    // TODO ^ Try uncommenting this line

    // The result from .clone() can still be used!
    println!("clone: {:?}", cloned_pair);
}

// imple "Trait" is static, so you don't need to use "Box dyn"
fn main() {

    fn returns_closure(y: i32) -> impl Fn(i32) -> i32 {
        move |x| x + y
    }

    fn returns_closure0(y: i32) -> Box<dyn fn(i32) -> i32> {
        Box::new(move |x| x + y)
    }

    println!("{}", returns_closure0(50)(10));
    println!("{}", returns_closure(50)(20));
}

fn double_positives<'a>(numbers: &'a Vec) -> impl Iterator + 'a {
    numbers
        .iter()
        .filter(|x| x > &&0)
        .map(|x| x * 2)
}

fn main() {
    let singles = vec![-3, -2, 2, 3];
    let doubles = double_positives(&singles);
    assert_eq!(doubles.collect::<Vec<i32>>(), vec![4, 6]);
}

struct Sheep {}
struct Cow {}

trait Animal {
    // Instance method signature
    fn noise(&self) -> &'static str;
}

// Implement the `Animal` trait for `Sheep`.
impl Animal for Sheep {
    fn noise(&self) -> &'static str {
        "baaaaah!"
    }
}

// Implement the `Animal` trait for `Cow`.
impl Animal for Cow {
    fn noise(&self) -> &'static str {
        "moooooo!"
    }
}

// Returns some struct that implements Animal, but we don't know which one at compile time.
fn random_animal(random_number: f64) -> Box<dyn Animal> {
    if random_number < 0.5 {
        Box::new(Sheep {})
    } else {
        Box::new(Cow {})
    }
}

fn main() {
    let random_number = 0.234;
    let animal = random_animal(random_number);
    println!("You've randomly chosen an animal, and it says {}", animal.noise());
}

// A struct with annotation of lifetimes.
// ライフタイムのアノテーションつき構造体。
#[derive(Debug)]
struct Borrowed<'a> {
    x: &'a i32,
}

// Annotate lifetimes to impl.
// ライフタイムのアノテーションつきimpl。
impl<'a> Default for Borrowed<'a> {
    fn default() -> Self {
        Self {
            x: &10,
        }
    }
}

fn main() {
    let b: Borrowed = Default::default();
    println!("b is {:?}", b);
}

// A struct with annotation of lifetimes.
// ライフタイムのアノテーションつき構造体。
#[derive(Debug, Default)]
struct Borrowed {
    x: i32,
}

// Annotate lifetimes to impl.
// ライフタイムのアノテーションつきimpl。
/*
impl<'a> Default for Borrowed<'a> {
    fn default() -> Self {
        Self {
            x: &10,
        }
    }
}
*/

fn main() {
    let b: Borrowed = Borrowed{x: 5,};
    println!("b is {:?}", b.x);
}

fn main() {
    // associated types
    //
    let point = Point(x, y);

    println!("Point X:{}, Y:{}", &x, &y);
    println!("Exist?:{}", point.exist(&x, &y));

    println!("Point-X:{}", point.v_axis());
    println!("Point-X:{}", point.h_axis());

    new_point(&point);
}

struct Point(i32, i32);

trait Position {
    type X;         // to use associated types
    type Y;

    fn exist(&self, _: &Self::X, _: &Self::Y) -> bool;
    fn h_axis(&self) -> i32;
    fn v_axis(&self) -> i32;
}

impl Position for Point {
    type X = i32;
    type Y = i32;

    fn exist(&self, x: &Self::X, y: &Self::Y) -> bool {
        (&self.0 == x) && (&self.1 == y)
    }

    fn h_axis(&self) -> Self::X {
        self.0
    }

    fn v_axis(&self) -> Self::Y {
        self.1
    }
}

fn new_point<Z: Position>(point: &Z) {                          // you don't need specify X and Y anymore
    println!("POINT:({},{})", point.v_axis(), point.h_axis())   // like "fn new_point<X, Y, Z>(point: &Z) where Z: Position<X, Y>"
}