#[macro_use]
extern crate my_macros;

fn main() {
    my_macro!(); // Using a macro from the `my_macros` crate
}

pub struct MyError {
    field1: u32,
    field2: String,
}

pub trait Iterator {
    type Item;

    fn next(&mut self) -> Option<Self::Item>;
}

// ジェネリクスでの定義
pub trait Iterator<T> {
    fn next(&mut self) -> Option<T>;
}

// ジェネリクスでは以下のように複数の型で実装できてしまうが、
impl Iterator<String> for Counter {...
impl Iterator<u32> for Counter {...

// Associate TypeならばCounter構造体のIterator実装は1つの型に絞ることができる。
impl Iterator for Counter {
    type Item = u32;

    fn next(&mut self) -> Option<Self::Item> {
        // --snip--

error[E0004]: non-exhaustive patterns: `XXX` not covered

let PATTERN = EXPRESSION;

let (x, y) = (3, 4, 5); // mismatched types ← (_, _) タプル型に合っていない

let Some(x) = Some(5); //  refutable pattern in local binding ← Noneのパターンがサポートされていない(と論破可能)

    // コンパイルは通る
    if let Some(x) = Some(5) {
        println!("{}", x); // 5
    }

trait Shape {
    fn area(&self) -> f64;
}

// trait object (動的ディスパッチ)
fn print_area(shape: &dyn Shape) {
    println!("Area: {}", shape.area());
}

// generics (静的ディスパッチ)
fn print_area<T: Shape>(shape: T) {
    println!("Area: {}", shape.area());
}

fn main() {
    // 動的ディスパッチ呼び出し
    print_area(&rectangle);

    // 静的ディスパッチ呼び出し
    print_area(rectangle);
}

use std::sync::{Arc, Mutex, Condvar};
use std::thread;

let pair = Arc::new((Mutex::new(false), Condvar::new()));
let pair2 = Arc::clone(&pair); // 【重要】Arc::clone によって作られるpair2はpairと同じ実態(同メモリ上)を参照する

// Inside of our lock, spawn a new thread, and then wait for it to start.
thread::spawn(move|| {
    let (lock, cvar) = &*pair2;
    let mut started = lock.lock().unwrap(); // 【重要】Mutex (ここでは`lock`)はある値がそのとき1スレッドのみから変更される制御のためのもの
    *started = true;
    // We notify the condvar that the value has changed.
    cvar.notify_one(); // 【重要】Condvarはスレッド間でno CPU時間で"待ち"→"開始OK"を伝達させるためのもの。
});

// Wait for the thread to start up.
let (lock, cvar) = &*pair; // 上記別スレッドでの&*pair2と同じ実態(同メモリ上)である。
let mut started = lock.lock().unwrap();
while !*started {
    started = cvar.wait(started).unwrap(); // 【重要】ここで一時的にstartedのLockを解除し、cvar.notify_one() を待つ。
    // 【重要】この Condvar.wait(&self, MutexGuard) は引数のMutexのLockを外して待ち通知が来てwaitがreturnを返すときには"再度Lockを取得する"
}

fn read_username_from_file() -> Result<String, io::Error> {
    let mut username_file = File::open("hello.txt")?;
.
.
    Ok(something)
}

fn read_username_from_file() -> Result<String, io::Error> {
    let mut username_file = match File::open("hello.txt") {
        Ok(file) => file,
        Err(e) => { return Err(e); }
    }
.
.
    Ok(username)
}

error[E0277]: the `?` operator can only be used in a function that returns `Result`

use moduleA::moduleB::moduleC::MethodD;

pub use self::kinds::SecondaryColor;

use art::PrimaryColor;