今年の言語はRust その２５


# 今年の言語はRust その２５


Rustを学びます


Rustの日本語ドキュメント 2nd Edition
https://doc.rust-jp.rs/book/second-edition/

オリジナル(英語)
https://doc.rust-lang.org/book/



#### 実行環境

```sh
$ cargo -V
cargo 1.33.0 (f099fe94b 2019-02-12)
$ rustup -V
rustup 1.17.0 (069c88ed6 2019-03-05)
$ rustc --version
rustc 1.33.0 (2aa4c46cf 2019-02-28)

$  cat /proc/version
Linux version 4.14.97-74.72.amzn1.x86_64 (mockbuild@gobi-build-64002) (gcc version 7.2.1 20170915 (Red Hat 7.2.1-2) (GCC)) #1 SMP Tue Feb 5 20:59:30 UTC 2019

$ uname -a
Linux ip-10-100-0-8 4.14.97-74.72.amzn1.x86_64 #1 SMP Tue Feb 5 20:59:30 UTC 2019 x86_64 x86_64 x86_64 GNU/Linux

$ cat /etc/\*release
NAME="Amazon Linux AMI"
VERSION="2018.03"
ID="amzn"
ID_LIKE="rhel fedora"
VERSION_ID="2018.03"
PRETTY_NAME="Amazon Linux AMI 2018.03"
ANSI_COLOR="0;33"
CPE_NAME="cpe:/o:amazon:linux:2018.03:ga"
HOME_URL="http://aws.amazon.com/amazon-linux-ami/"
Amazon Linux AMI release 2018.03

```


## 10. ジェネリック

### 10.3 ライフタイムで参照を検証する

### ライフタイムの観点で思考する

常にxの値を返したい場合, __y__ に__ライフタイム引数を指定__ する必要はなくなる
それは、__yのライフタイム__ はxや戻り値のライフタイムとは何も__関係がない__からである


```rust
fn longest<'a>(s: &'a str, y: &str) -> &'a str {
  x
}
```

ここで、他のエラーの発生する実験をして、理解を深めよう。
ここでは、引数に関係なく、__関数内で生成された値に対する参照__ を返すことにします。
もちろんエラーが発生します。

関数内で生成された__result__ は関数末端でスコープを抜けて片付けられてしまいます。
返り値に指定されたライフタイム引数'bよりもライフタイムが短くなってしまいました。ゆえにエラー。


```rust
fn longest<'a>(x: &'a str, y: & str) -> &'a str {
    
    let result = String::from("really long string");
    result.as_str()
    
}

~~~
4 |     result.as_str()
  |     ------^^^^^^^^^
  |     |
  |     returns a value referencing data owned by the current function
  |     `result` is borrowed here
  (注釈: 借用された値は、関数本体1行目1文字目で定義されているようにライフタイム'aに対して有効でなければなりません)

```

>最善の修正案は、 呼び出し元の関数が値の片付けに責任を持てるよう、参照ではなく所有されたデータ型を返すことでしょう。



#### 構造体定義のライフタイム注釈

構造体に__ジェネリックなライフタイム引数の名前を宣言<'a>__ することで、構造体内でライフタイム引数が使用できる。
この注釈はImportantExcerptのインスタンスが、 __partフィールドに保持している参照__ よりも__長生きしない__ ことを意味します。



```rust
struct ImportantExcerpt<'a> {
  part: &'a str,
}

fn main() {



    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.')
                              .next()
                              .expect("Could not find a '.'");
    let i = ImportantExcerpt { part: first_sentence };
    println!("{}",i.part);
}

===
Call me Ishmael
```

#### ライフタイム省略

```rust

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();
    
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    
    &s[..]
}



```

コンパイラによってライフタイム引数を推定することで、プログラマはすべてのライフタイム引数を書かなくてもよくなった

```rust
fn first_word(s: &str) -> &str {

↓ 1番目の規則: 1引数の関数は、1つのライフタイム引数を得る

fn first_word<'a>(s: &'a str) -> & str {

↓ 2番目の規則: 1つだけ入力ライフタイム引数があるなら、そのライフタイムが全ての出力ライフタイム引数に代入される

fn first_word<'a>(s: &'a str) -> &'a str {

```

```rust
fn longest(x: &str, y: &str) -> &str {

↓ 1番目の規則: 2つ引数のある関数は、2つの個別のライフタイム引数を得る

fn longest<'a, 'b>(x: &'a str, y: &'b str) -> &str{

```

>最初の規則は、参照である各引数は、独自のライフタイム引数を得るというものです。

>2番目の規則は、1つだけ入力ライフタイム引数があるなら、そのライフタイムが全ての出力ライフタイム引数に代入されるというものです

>3番目の規則は、複数の入力ライフタイム引数があるけれども、メソッドでそのうちの一つが&selfや&mut selfだったら、 selfのライフタイムが全出力ライフタイム引数に代入されるというものです。

#### メソッド定義におけるライフタイム注釈

3番目の規則を説明しよう

以下のような実装があった場合 __level__ メソッドのライフタイム引数はどうなるか

```rust
impl<メソッド用> ImportantExcerpt<フィールド用> {}
```

1. 引数が一つの場合は、引数と出力はおなじライフタイム


```rust
impl<'a> ImportantExcerpt<'a> {

    fn level(&self) -> i32 {
      3
    }
}

↓ 引数に独自のライフタイムがつけられている

impl<'a, 'b> ImportantExcerpt<'a> {

    fn level(&'b self) -> i32 {
      3
    }
}
```

```Rust
impl<'a> ImportantExcerpt<'a> {
    fn announce_and_return_part(&self, announcement: &str) -> &str {
        println!("Attention please: {}", announcement);
        self.part
    }
}

↓ たぶんこういうことだろう : 3番目の規則: 出力のライフタイムは、selfのライフタイムが優先

impl<'a, 'b> ImportantExcerpt<'a> {
    fn announce_and_return_part(&'b self, announcement: & str) -> &'b str {
        println!("Attention please: {}", announcement);
        self.part
    }
}

```

#### 静的ライフタイム

特殊ライフタイム__'static__ であり、プログラム全体の期間をしめす。
文字列リテラルはすべて__'static__になり、 __バイナリに直接格納される__


```rust

let s: &'static str = "I have a static lifetime.";
```

#### ジェネリックな型引数、トレイト協会、ライフタイムを一度に

```rust

use std::fmt::Display;

fn longest_with_an_announcement<'a, T>(x: &'a str, y: &'a str, ann: T) -> &'a str
    where T: Display
{
    println!("Announcement! {}", ann);
    
    if x.len() > y.len() {
        x
    }else{
        y
    }
}


fn main(){
    let string1 = String::from("short message");
    let string2 = String::from("long long long message");
    
    let announce = String::from("Hello World!");
    
    let result = longest_with_an_announcement(string1.as_str(), string2.as_str(), announce);
    
    println!("Longest: {}", result);
    
}
```

ながかったぞ！ジェネリック！

長かったぞライフタイム！

昨日はまったく分からなかったが、手を動かしまくったおかげで、余裕になった！



次回はやっとテスト!!


イエス！