Rustハンズオン第3回基礎文法編

Slide 1

Slide 1 text

Rust ハンズオン第 3 回中級編 1

Slide 2

Slide 2 text

⽬次 . cat を実装する（ Option や Result を使ってみる） . 所有権、借⽤、ライフタイムのエクササイズ 2

Slide 3

Slide 3 text

今⽇のゴール Option 型と Result 型の使い⽅を知る。所有権、借⽤、ライフタイム関連のコンパイルエラーの直し⽅を知る。 3

Slide 4

Slide 4 text

gist ⻑めのソースコードはコピー＆ペーストできるように、gist に貼りました。エクササイズのときなどにご利⽤ください。 https://gist.github.com/yuk1ty/5a9c686d9ec9031d0c4bd95a00bdf5b6 4

Slide 5

Slide 5 text

cat を実装する 5

Slide 6

Slide 6 text

プロジェクトの作成新しくプロジェクトを作りましょう。「Hello, World」できることを確認します。 $ cargo new grep-rs $ cd grep-rs $ cargo run 6

Slide 7

Slide 7 text

cat プログラムの⼿順 . まず指定したパスのファイルを読み込みます。 . ファイルの中⾝を⽂字列で取得します。 . 成功した場合は、内容をすべて標準出⼒します。 7

Slide 8

Slide 8 text

指定したパスのファイルを読み込む std::fs::read_to_string という関数を使うと、引数で指定したパスから⽂字列として内容を読み込みます。 Ok や Err という⾒慣れない⽂字が出てきましたね。 fn main() { let path = "./src/main.rs"; match std::fs::read_to_string(path) { Ok(content) => print!("{}", content), Err(why) => println!("{}", why), } } 8

Slide 9

Slide 9 text

Result : エラーハンドリングを⾏う Rust では Result 型を⽤いてエラーハンドリングをします。正常系だった場合は Ok で囲んで返します。エラーが送出したい場所に対して、 Err で囲んで返します。 fn division(dividened: i32, divisor: i32) -> Result { if divisor == 0 { return Err(CalcError::DividedByZero); } if dividened < 0 { return Err(CalcError::DetectedNegative(dividened)); } if divisor < 0 { return Err(CalcError::DetectedNegative(divisor)); } Ok(dividened / divisor) } 9

Slide 10

Slide 10 text

Result : エラーハンドリングを⾏うエラー型⾃体も enum で記述することが多いです。実運⽤では anyhow と thiserror というクレートを組み合わせて作ります。 enum CalcError { // ゼロ除算を⾏った場合に返すエラー DividedByZero, // 負の数が⼊っていた場合に返すエラー。中にその数値を⼊れる。 DetectedNegative(i32), } 10

Slide 11

Slide 11 text

Result : エラーハンドリングを⾏う Result は enum なので、match 式で分岐を記述できます。 fn main() { let answer = division(4, 2); match answer { Ok(value) => println!("answer is {}", value), Err(err) => match err { // eprintln! マクロはエラー出⼒をできる。 CalcError::DividedByZero => eprintln!(" ゼロ除算です"), CalcError::DetectedNegative(num) => { eprintln!("{} は負の数です。負の数は⼊れられません。", num) } }, } } 11

Slide 12

Slide 12 text

ファイルを読み込んだ際のエラーハンドリングというわけで、 Ok や Err でエラーハンドリングをしていることがわかります。たとえばファイルが⾒つからなかった場合には、 Err 側に⼊ってきます。 fn main() { let path = "./src/main.rs"; match std::fs::read_to_string(path) { Ok(content) => print!("{}", content), Err(why) => println!("{}", why), } } 12

Slide 13

Slide 13 text

急いでいるときに使える unwrap コードを書いていると、急いでいる場⾯があると思います。プロダクションではできるかぎりエラーハンドリングをするべきですが、急ぎのときは unwrap という関数を使⽤できます。あるいは、絶対にエラーにならないはずの場所であえて unwrap を使っておくこともあります。エラーだった場合は、その時点でパニック（プログラムが強制的に異常終了）します。 fn main() { let path = "./src/main.rs"; let content = std::fs::read_to_string(path).unwrap(); print!("{}", content); } 13

Slide 14

Slide 14 text

ファイルパスは実⾏時の引数から渡せるようにするさきほどの例では、ファイルパスはハードコーディングでした。実⾏時に引数で渡せるようにすると、柔軟になるでしょう。 std::env::args という関数を使うと、実⾏時引数を取得できます。 nth という関数を実⾏すると、何番⽬の引数を取るかを取得できます。 fn main() { let mut args = std::env::args(); match args.nth(1) { Some(path) => match std::fs::read_to_string(path) { Ok(content) => print!("{}", content), Err(why) => println!("{}", why), }, None => println!("1 つ⽬の実⾏時引数にファイルパスを⼊れる必要があります。") } } 14

Slide 15

Slide 15 text

⼊れ⼦はちょっと読みにくいので、関数を出すネストが発⽣しました。好みの問題ではありますが、ネストは⼀般に読みにくさを増します。ファイルの読み込み処理を関数に切り出しましょう。ところで、 Some や None という⾒慣れない⽂字が出てきています。 fn run(path: String) { match std::fs::read_to_string(path) { Ok(content) => print!("{}", content), Err(why) => println!("{}", why), } } fn main() { let mut args = std::env::args(); match args.nth(1) { Some(path) => run(path), None => println!("1 つ⽬の実⾏時引数にファイルパスを⼊れる必要があります。") } } 15

Slide 16

Slide 16 text

「ない」を⽰す Option null あるいは「ないこと」を⽰すには Option 型を使います。 Option も enum なので、match 式で分岐を記述できます。 fn find(source: Vec, target: i32) -> Option { for s in source.into_iter() { if s == target { return Some(s) } } None } fn main() { let vec = vec![1, 2, 3, 4]; match find(vec, 3) { Some(value) => println!("value: {}", value), None => println!("not found!") } } 16

Slide 17

Slide 17 text

急いでいるときに使える unwrap Result と同様に unwrap 関数が⽤意されています。 None に対して unwrap が⾏われるとパニックします。 fn find(source: Vec, target: i32) -> Option { for s in source.into_iter() { if s == target { return Some(s) } } None } fn main() { let vec = vec![1, 2, 3, 4]; let value = find(vec, 3).unwrap(); println!("value: {}", value); } 17

Slide 18

Slide 18 text

実⾏してみよう cargo run [ 読み込んでみたいパス] で実⾏できます。 fn run(path: String) { match std::fs::read_to_string(path) { Ok(content) => print!("{}", content), Err(why) => println!("{}", why), } } fn main() { let mut args = std::env::args(); match args.nth(1) { Some(path) => run(path), None => println!("1 つ⽬の実⾏時引数にファイルパスを⼊れる必要があります。") } } 18

Slide 19

Slide 19 text

なぜ Result ？ Either のほうが好きなんだけど？諦めましょう。Rust は昔 Result 型も Either 型をもっていましたが、エラーハンドリングという⽤途で使われるはずの Either はユーザーにはほぼ使われず、 Result 型のみが残ったという経緯があります。まとめた: https://zenn.dev/helloyuki/scraps/e5af11fecac719 ちなみに Scala と Rust を⾏き来すると、エラーを⼊れる側を間違えてよく怒られます。 19

Slide 20

Slide 20 text

所有権、借⽤、ライフタイム 20

Slide 21

Slide 21 text

所有権 Rust では、値には所有者がかならず⼀⼈います。関数を呼び出したり、別の変数に値を格納したりすると、値の所有者が移ります。これをムーブするといいます。 21

Slide 22

Slide 22 text

値と変数 let s = "this is a value".to_string(); ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 変数値 22

Slide 23

Slide 23 text

値の所有者がだんだん移っていく例⼀度変数に束縛した値を、別の変数に再代⼊するとまずは起こります。 // 下記は main 関数内に書いているイメージ。 // 変数 `s` に値を紐付けた。 let s: String = "this is a value".to_string(); // 以下の⾏で、`s` の値は `t` に所有権が移る。 let t = s; // `s` はもう使⽤できないので、コンパイルエラー。 println!("{}", s); 23

Slide 24

Slide 24 text

Slide 25

Slide 25 text

Slide 26

Slide 26 text

Slide 27

Slide 27 text

値の所有者がだんだん移っていく例関数に値を⼊れても、同様に所有権の移動が起こります。 fn print_something(s: String) { println!("{}", s); } // s はここで解放される。 // 下記は main 関数に書いてあるイメージ。 // 変数 `s` に値を紐付けた。 let s = "this is a value".to_string(); // 以下の⾏で、`s` の値の所有権は `print_something` 関数に移る。 print_something(s); // `s` はもう使⽤できないので、コンパイルエラー。 println!("{}", s); 27

Slide 28

Slide 28 text

コピーセマンティクス先ほどまで紹介したものを「ムーブセマンティクス」といいます。⼀⽅で、数値型など軽めのものまでムーブしていては、正直だるいです。 i32 や f64 などのプリミティブ型は Copy トレイトが実装されていて、⾃動でコピーを⾏ってくれます。これをコピーセマンティクスと呼びます。⾃分で Copy トレイトを実装すれば、独⾃のデータ型に対してコピーセマンティクスを適⽤できます。 28

Slide 29

Slide 29 text

コピーセマンティクスの例下記はコピーセマンティクスなので、裏で⾃動でコピーが⾛ります。 fn main() { let a: i32 = 1; let b = a; // この時点で、a は b にコピーされる。 println!("{}", a); // ムーブセマンティクスならコンパイルエラーだが、通る。 } 29

Slide 30

Slide 30 text

所有権を毎度移していると⼤変なので、貸し出ししよう⼀度使ってしまうと消えてばかりでは、正直不便ですよね。借⽤という機能があって、それを利⽤すると所有権を貸し出すことができます。借⽤は、実質的には参照になっています。 30

Slide 31

Slide 31 text

先ほどの例を完全に動くようにしてみるあまり旨味を感じられないが、変数に所有権を移していた例のコンパイルを通るようにします。 // 下記は main 関数内に書いているイメージ。 // 変数 `s` に値を紐付けた。 let s = "this is a value".to_string(); // 以下の⾏では、`t` は `s` を借⽤する。 let t = &s; // `s` の所有権はまだなくなっていないので、標準出⼒できる。 println!("{}", s); 31

Slide 32

Slide 32 text

先ほどの例を完全に動くようにしてみるこちらはよくやる、関数に所有権を移してしまっていた例。仮引数は s の参照を受け取るようにし、実引数は s の借⽤を渡すようにします。 // `s` は参照を受け取る。 fn print_something(s: &str) { println!("{}", s); } // 下記は main 関数に書いてあるイメージ。 // 変数 `s` に値を紐付けた。 let s = "this is a value".to_string(); // 以下の⾏で、`s` の値を借⽤して渡す。 print_something(&s); // `s` は解放されていないので、標準出⼒できる。 println!("{}", s); 32

Slide 33

Slide 33 text

エクササイズ 1 下記のコードのコンパイルエラーを通せるようにしてみましょう。 struct User { tag: i32 } impl User { fn new(num: i32) -> User { User { tag: num } } fn print_tag(self) -> i32 { self.tag } } fn main() { let mut user = User::new(1); assert_eq!(user.print_tag(), 1); user.tag = 2; assert_eq!(user.print_tag(), 2); } 33

Slide 34

Slide 34 text

解説: エクササイズ 1 main 関数内で束縛している user の所有権が問題になっている。 1 回⽬の assert_eq! にて、 print_tag メソッドが呼ばれるが、これに所有権が移る。次の⾏に⾏くまでに所有権が解放されてしまう。 print_tag メソッドは借⽤を利⽤するように修正する。 34

Slide 35

Slide 35 text

解答: エクササイズ 2 struct User { tag: i32 } impl User { fn new(num: i32) -> User { User { tag: num } } fn print_tag(&self) -> i32 { self.tag } } fn main() { let mut user = User::new(1); assert_eq!(user.print_tag(), 1); user.tag = 2; assert_eq!(user.print_tag(), 2); } 35

Slide 36

Slide 36 text

エクササイズ 2 ちょっと難問。時間がなかったら⾶ばすかも。下記のコードのコンパイルエラーを通せるようにしてみましょう。 fn main() { let mut list = vec![]; add_elem(list, 1); add_elem(list, 2); add_elem(list, 3); assert_eq!(list, vec![1, 2, 3]); } fn add_elem(mut target: Vec, elem: i32) { target.push(elem); } 36

Slide 37

Slide 37 text

解説: エクササイズ 2 add_elem が問題。呼び出すと list の所有権が add_elem 関数に移る。 2 回⽬以降は呼び出せない。なので、 add_elem が受け取るリストは &mut にする必要がある。可変参照を関数の実引数として渡すには、 &mut を先頭につける必要がある。 37

Slide 38

Slide 38 text

解答: エクササイズ 2 fn main() { let mut list = vec![]; add_elem(&mut list, 1); add_elem(&mut list, 2); add_elem(&mut list, 3); assert_eq!(list, vec![1, 2, 3]); } fn add_elem(target: &mut Vec, elem: i32) { target.push(elem); } 38

Slide 39

Slide 39 text

ライフタイム⼀度借⽤したものをプログラムが終わるまでいかしておくと、2 重解放などの脆弱性の温床になってしまいます。参照と、参照をもつもの（参照をもつ構造体や、参照をもつ enum など）は、ライフタイムが適⽤されます。その参照が⽣存できるスコープのようなものです。初⼼者のうちは、コンパイラが怒るまでは⾃分でがんばらないようにしましょう。 39

Slide 40

Slide 40 text

ライフタイムはブロック（スコープ）単位で識別される fn main() { let r; // r ----------------------- { // | // x のスコープはこのブロック内まで。 // | let x = 1; // | x -------------- r = &x; // | | } // x が解放される // | + -------------- // | // * は参照外し。 // | // &x で &i32 型だったが、それを i32 型にしている。 // この時点で x は破棄されている // | // が、x を使おうとしている // | println!("{}", *r); // | <-- ここで使⽤ } // + ------------------------ 40

Slide 41

Slide 41 text

ライフタイムはブロック（スコープ）単位で識別される fn main() { let r; // r --------------------- { // | let x = 1; // | x ------------- r = &x; // | | // ブロック内で print するようにしたので、// | | // x が残った状態で使⽤できている。 // | | println!("{}", *r); // | <- 使⽤ + ------------- } // | } // + --------------------- 41

Slide 42

Slide 42 text

ライフタイム識別⼦ 'a , 'b といったように書かれます。("tick a", "tick b" と読みます) // 関数の場合 fn lifetime_string<'a>() -> &'a str { "lifetime string" } // 構造体の場合 struct LifetimeString<'a> { value: &'a str } 42

Slide 43

Slide 43 text

書き⽅: 参照を引数として渡したとき普段は省略されていますが、実は関数を何も省略せずに定義すると下記のようになります。関数に渡した s という仮引数のライフタイムと、返り値の &str のライフタイムが同じになるということです。 // 下記は fn g(p: i32) { ... } とも書ける fn g<'a>(p: &'a i32) { ... } let x = 10; g(x); 43

Slide 44

Slide 44 text

書き⽅: 構造体の参照構造体に参照をもたせることもできる。その際にはライフタイム識別⼦が必要になる。 struct S<'a> { r: &'a i32 } 44

Slide 45

Slide 45 text

書き⽅: 構造体の構造体さらに新しい構造体 T を定義し、 S をもたせたいとします。その際には T のライフタイム識別⼦と紐付けておく必要があります。 struct T<'a> { s: S<'a> } 45

Slide 46

Slide 46 text

最初のうちは… 関数では、実体または参照を仮引数に⼊れ、実体を返すようにしてもよいと思っています。参照を関数が返してしまうと、ライフタイムの管理が⼀気に⼤変になります。構造体では、参照を無理して持たせるのではなく、実体をまずはもたせてみましょう。慣れてきたら、参照にする必要な箇所を徐々に参照にしていくようにしましょう。e.g. 巨⼤なオブジェクトを持っていて、コピーコストが⼤きい物など。 46

Slide 47

Slide 47 text

エクササイズ 1 下記コードのコンパイルを通してみましょう。 fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { if x.len() > y.len() { x } else { y } } fn main() { let string1 = String::from("long string is long"); let result; { let string2 = String::from("xyz"); result = longest(string1.as_str(), string2.as_str()); } println!("The longest string is {}", result); } 47

Slide 48

Slide 48 text

解説: エクササイズ 1 string1 は {} で囲まれたブロック外まで有効。 string2 は {} で囲まれたブロック内でのみ有効。 println! した時点では、 string2 のライフタイムが切れてしまっている。 48

Slide 49

Slide 49 text

解説: エクササイズ 1 fn main() { let string1 = String::from("long string is long"); let result; { let string2 = String::from("xyz"); result = longest(string1.as_str(), string2.as_str()); } // `string2` のライフタイムがここで切れてしまう。 // ⽚⽅のライフタイムが切れている `result` を使⽤しようとするので、コンパイルエラー // `string2` がダングリングポインタになってしまっている。 println!("The longest string is {}", result); } 49

Slide 50

Slide 50 text

解説: エクササイズ 1 fn main() { let string1 = String::from("long string is long"); // string1 -------------- let result; // | { // | let string2 = String::from("xyz"); // | string 2 ---- result = longest(string1.as_str(), string2.as_str()); // | | } // | + ----------- // | println!("The longest string is {}", result); // + -------------------- } 50

Slide 51

Slide 51 text

解答: エクササイズ 1 fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { if x.len() > y.len() { x } else { y } } fn main() { let string1 = String::from("long string is long"); let result; { let string2 = String::from("xyz"); result = longest(string1.as_str(), string2.as_str()); println!("The longest string is {}", result); } } 51

Slide 52

Slide 52 text

解説: エクササイズ 1 fn main() { let string1 = String::from("long string is long"); // string1 -------------- let result; // | { // | let string2 = String::from("xyz"); // | string 2 ---- result = longest(string1.as_str(), string2.as_str()); // | | println!("The longest string is {}", result); // | | } // | +------------ } // + -------------------- 52

Slide 53

Slide 53 text

エクササイズ 2 下記コードに適切にライフタイム識別⼦を付与し、コンパイルを通してみましょう。 struct User { id: UserId, user_name: UserName } impl User { fn new(user_name: &str) -> Self { User { id: UserId(1), user_name: UserName(user_name), } } } struct UserId(i32); struct UserName(&str); fn main() { let user = User::new("namae"); assert_eq!(user.user_name.0, "namae"); } 53

Slide 54

Slide 54 text

解説: エクササイズ 2 コンパイルエラーに従いながら、順番にライフタイムパラメータを付与していく。 impl まで込みで必要になる。参照をもつもののみつければよい。 UserId には不要。 54

Slide 55

Slide 55 text

解答: エクササイズ 2 struct User<'a> { id: UserId, user_name: UserName<'a> } impl<'a> User<'a> { fn new(user_name: &'a str) -> Self { User { id: UserId(1), user_name: UserName(user_name), } } } struct UserId(i32); struct UserName<'a>(&'a str); fn main() { let user = User::new("namae"); assert_eq!(user.user_name.0, "namae"); } 55

Slide 56

Slide 56 text

所有権にもっと慣れるために https://aloso.github.io/2021/03/09/creating-an-iterator 56

Slide 57

Slide 57 text

ライフタイムについての深い話 https://doc.rust-jp.rs/book-ja/ch10-03-lifetime-syntax.html https://github.com/pretzelhammer/rust-blog/blob/master/posts/common-rust- lifetime-misconceptions.md 57

Slide 58

Slide 58 text

もっとエクササイズしたい Rustlings: https://github.com/rust-lang/rustlings 58