Rustのborrowさっぱり分からん☆（＾～＾）何度説明されても分からんものは分からん☆（＾～＾）分からんったら分からん☆（＾～＾）

```Plain
cannot move out of type! YEAH!
```

```Plain
cannot move out of here! Are you fine!
```

さっぱり分からんので　説明もできん☆（＾～＾）　いかがでしたか？

```rust
a
&a
*a
&*a
```

なんか　いっぱいあるし、もちろん

```rust
&&a
```

とか重ねることもできる☆（＾～＾）
なんか突然　borrowed とかエラーが出てくる☆（＾～＾）
そんなときは、エラーが消えるまで

`& を付けたり外したり、 * を付けたり外したり`

する☆（＾～＾）

それでもダメなときは

```
ore.nannka_function(ore.value);

と書いているのを

let v = ore.value;
ore.nannka_function(v);
```

する☆（＾～＾）

それでもダメなときは

`.unwrap() を付けたり外したり`

する☆（＾～＾）それでもダメなときは

`{ } で挟んだり、{ } の外に出したり`

する☆（＾～＾）それでもダメなときは

```
a
b

と書いているのを

b
a
```

と並び替える☆（＾～＾） borrowed とかいうエラーが消えるまでやる☆（＾～＾）

意味☆？　知らん☆（＾～＾）

## 戦いは始まったばかり

```rust:しらｎ.rs
if let Some(banana) = self.foods[0].fruits {
    banana.change(); // I was happen!
} else {
    panic!("No banana!")
}
```

ここでも何がダメ☆（＾～＾）！？

```rust:しらｎ.rs
if let Some(ref mut banana) = self.foods[0].fruits {
    banana.change(); // Ok?
} else {
    panic!("No banana!")
}
```

`ref` とか、 `ref mut` を付けると乗り切れるときがある☆（＾～＾）　運☆（＾～＾）

## だｍ

```rust:だｍ.rs
if let Some(ref banana) = self.foods[0].fruit {
    banana.change();

    if 499 < banana.len() {
        // I was happen.
        self.food[0].fruits = Some(Apple::new());
    }
} else {
    panic!("No banana!")
}
```

これでダメなら

```rust:だｍ.rs
let mut panch = false;
if let Some(ref banana) = self.foods[0].fruit {
    banana.change();

    if 499 < banana.len() {
        panch = true; // Ok.
    }
} else {
    panic!("No banana!")
}

if panch {
    self.food[0].fruits = Some(Apple::new()); // Ok?
}
```

フラグを使ってでも　ニョロニョロ｛｝の外に出すんだ☆（＾～＾）　意味☆（＾～＾）？知らん☆（＾～＾）

## 何が起こったのか？

```rust:むｒ.rs
// fn kansu(&mut self) {

// このケースの ref mut は許されない。
if let Some(ref mut banana) = self.foods[0].fruit {
    banana.change()
} else {
    None
}
```

Oh, NO!

```rust:むｒ.rs
// fn kansu(&mut self) {

let zero_food = &mut self.foods[0];
// このケースの ref mut は許される。
if let Some(ref mut banana) = zero_food.fruit {
    banana.change()
} else {
    None
}
```

Oh, my god!

```rust:むｒ.rs
// fn kansu(&mut self) {

// このケースの ref mut は許される。
if let Some(ref mut banana) = &mut self.foods[0].fruit {
    banana.change()
} else {
    None
}
```

こんなとこに `&mut` 付けれるのか……☆（＾～＾）

## さっぱり分からんの吉

```Plain:むう.rs
Hey! cannot move out of indexed content!
```

```
pub fn get_banana(&self) -> Banana {
    self.fruits[0] // I was happen!
}
```

使いやすいと思って配列を使っているのに、なんてやつだ。

```
pub fn get_banana_color(&self) -> Color {
    self.fruits[0].color
}
```

用件を済ますラッパー・メソッドにしろということかだぜ☆（＾～＾）

## もう無理の助

```Plain
cannot move out of borrowed content! Go to hell!
```

```rust:もうｍｒ.rs
    pub fn to_banana(&self) -> Banana {
        Banana {
            sweet: self.sweet, // I was happen!
        }
    }
```

↑コピーもできないのか。

```rust:もうｍｒ.rs
    pub fn to_banana(&self) -> Banana {
        Banana {
            sweet: self.sweet.to_string(), // Ok!
        }
    }
```

↑むむう☆（＾～＾）

```rust:なんｄ.rs
pub fn get_name(&self) -> String {
    self.name // I was happen!
}
```

↑この一部の隙も無い完全無比に見えるコードの何がダメなのか☆（＾～＾）

```rust:なんｄ.rs
pub fn get_name(&self) -> String {
    self.name.to_string() // Ok!
}
```

↑……☆（＾～＾）

## ぴゅーっ！

```Plain
cannot move out of borrowed content! HAHAHA!
```

```rust
    pub fn to_basket(&self) -> Basket {
        let mut basket = Basket::new();

        // この self は許されない☆（＾～＾）
        for fruit in self.fruits {
            basket.push(fruit);
        }

        basket
    }
```

↑この簡素なコードの何がダメなのか☆（＾～＾）？

```rust
    pub fn to_basket(&self) -> Basket {
        let mut basket = Basket::new();

        // Ok!
        for fruit in &self.fruits {
            basket.push(fruit);
        }

        basket
    }
```

↑　！！！！！！！！！！！！！！！！☆（＾～＾）！！


## 太陽王

```rust:ぶｈ.rs
// fn kansu(&mut self) {

    let banana = &self.food[0].fruit;
    let sweety = self.food[0].juice.change(banana);

    // cannot borrow `self.food` as mutable because it is also borrowed as immutable
    self.food[0].drink = sweety;
```

↑びびよびよびびびびよ

```rust:ぶｈ.rs
    let zero_food = &mut self.food[0];
    let sweety = zero_food.juice.change(&zero_food.banana);

    // Ok!
    zero_food.drink = sweety;
```

↑ピカァ

## ぶおーん

```rust:もほほ.rs
cannot borrow `*basket` as mutable more than once at a time
```

```rust
basket.shuffle();

let banana = &mut basket.food[0];
banana.change();

// I was happen!
basket.shuffle();
```

↑なぜ１回切りなのか☆（＾～＾）　２回　変えたいこともあるだろ☆

```rust
basket.shuffle();

{
    let banana = &mut basket.food[0];
    banana.change();
}

// Ok!
basket.shuffle();
```

↑……☆（＾～＾）？