fn double(xs: &mut [u64]) {
    for x in xs {
        *x *= 2;
    }
}

fn fib(n: i32) -> u64 {
    if n <= 1 {
        return 1;
    }
    fib(n-1) + fib(n-2)
}

#[derive(Debug)]
struct P {
    x: i32,
    y: i32,
}

impl P {
    pub fn new() -> P {
        P { x: 0, y: 0 }
    }

    fn update_x(&mut self) {
        self.x += 1;
    }

    fn double(&self, i: &mut i32) {
        *i *= 2;
    }

    fn update(&mut self) {
        self.update_x();
        self.update_x();

        let mut i = &mut self.x;
        // ^^^ ここでmutable borrowしている
        // vvv ここでimmutable borrowだめでしょ
        self.double(i);

        /*
        borrow規約
        - リソース渡しすると、所有権が移る
        - borrowのスコープは、所有者よりも短くないとダメ
            - なんなら {}で囲む
        - 以下は **排他**
            - 1以上のimmutable borrow (let x = &T)
            - ただ1つのmutable borrrow (let y = &mut T)
        */
    }
}

fn main() {
/*
    {
        let mut a = vec![1, 2, 3];
        println!("{:?}", a);

        for _i in 0..20 {
            double(&mut a);
            println!("{:?}", a);
        }
    }
    {
        for n in 0..20 {
            println!("{}: {}", n, fib(n));
        }
    }
*/
    {
        let a = (1..10).collect::<Vec<i32>>();
        println!("{:?}", a);
    }

    {
        let mut p = P::new();
        println!("{:?}", p);

        p.update();
        println!("{:?}", p);
    }
}