Rust ハンズオン

資料の使い方

• 資料はスライド形式になっています
• 横方向に進んでいけば、自分なりの grep を実装できます
• 縦方向にも進める場合もあります

縦方向のスライドは補足です

• 縦方向のスライドには、補足や詳細な情報がのっています

Rust とは

• システムプログラミング用の言語としてスタートしました
• 信頼性が高く、性能の良いプログラムを書けるように設計されています
• 組み込みからWeb まで、さまざまな場面で利用されています

Rust の採用例

• Friends of Rust / Production
• Awesome Rust
• 日本の例：LINE、Voyage group、CADDi、Cookpad、Dwango、Forcia、etc

ドキュメント

• The book / 日本語版
• Rust by Example / 日本語版
• Command Line Applications in Rust
• Rust Design Patterns
• This week in Rust

Playground

• https://play.rust-lang.org/
• オンラインで Rust の挙動を確認できます
• gist 上のコードを読み込ませることもできます：例 / gist

Rust Search Extenstion

• Rust のドキュメント検索が楽になるブラウザ拡張
• rs キーワード と URL バーに入力すると、適切な文書を表示します
• Web サイト

プロジェクトの作成

• Rust のプロジェクトの操作には、cargo コマンドを使います
• cargo new を実行すると、プロジェクトが作成されます

% cargo new fizzbuzz
     Created binary (application) `fizzbuzz` package

プロジェクトのフォルダ構成

fizzbuzz
├── Cargo.toml
└── src
   └── main.rs

イテレーターを使った書き換え

• 0..10 は 0 以上 10 未満の範囲を表すオブジェクトを定義します
• このオブジェクトは、イテレーターとしての性質を持っています
• そのため for 文で範囲に含まれる整数を列挙できます
• 下記では、列挙された値を使わないので、変数名に _ を利用しています

fn main() {
  for _ in 0..10{
    println!("Hello, world!");
  }
}

列挙された値を利用する場合

• for の後に記述された変数で、列挙された値を参照できます
• 次の例では、列挙された値を埋め込んだ文字列を出力しています
• Playground で試す

fn main() {
  for iteration in 0..10{
    println!("Hello, world! (iteration #{})", iteration);
  }
}

条件分岐：if 式

• Rust での if は式です。つまり評価値を持ちます
• 実行したブロックで最後に評価した式の値が、if 式の評価値となります
• ブロックの最後の式に ; がついていないことがポイントです

fn main() {
  for n in 0..10{
    let output = if n % 15 == 0{
      "FizzBuzz"
    }else{
      format!("{}", n)
    };
    println!("{}", output);
  }
}

format

• format は書式つき文字列を処理するマクロです
• 第 1 引数に指定した書式に、第 2 引数以降の値を埋め込みます
• 第 1 引数にある {} は値を埋め込むプレースホルダーを意味します
• 次の例では、Hello, {} の {} 部分に、name の値が埋め込まれます

fn main(){
  let name = "World";
  let output = format!("Hello, {}!", name);
  println!("{}", output);
}

マクロの利用

• マクロを利用する時は、名前の後に ! をつけます
• 下記の例にある format や println はマクロです
• なお ! をつけない場合、関数呼び出しとして解釈されます

fn main(){
  let name = "World";
  let output = format!("Hello, {}!", name);
  println!("{}", output);
}

コンパイル時の型チェック

• コンパイル時には型チェックが行われます
• 次の例では、if 節の評価値が str 型なのに対し、else の評価値が String 型であることが原因でコンパイルエラーとなっています
• "FizzBuzz" に対して、to_string メソッドを呼ぶように変更することで修正できます

error[E0308]: `if` and `else` have incompatible types
 --> src/main.rs:6:9
  |
3 |         let output = if n % 15 == 0{
  |  ____________________-
4 | |         "FizzBuzz"
  | |         ---------- expected because of this
5 | |       }else{
6 | |         format!("{}", n)
  | |         ^^^^^^^^^^^^^^^^ expected `&str`, found struct `String`
7 | |       };
  | |_______- `if` and `else` have incompatible types
  |

String と str

• String は文字列を表すオブジェクトです
• str は文字列のスライスを表す値です
• to_string メソッドで、String オブジェクトへ変換できます

let name = "World";
let message = format!("Hello, {}!", name);
println!("{}", message);
   
let slice_of_message = &message[0..5];
println!("{}", slice_of_message);

let another_string = slice_of_message.to_string();
println!("{}", another_string);

スライス から String への変換（つづき）

• format マクロを使って変換する場合も多く見られます
• スライスである文字列リテラルを変換する場合にも多用されます

let a_str = "Hello, world!";
let converted_string = format!("{}", a_str);

let a_string = format!("Hello, world!");

コンパイルエラーの修正方法

• if 節の評価値の型が String となるように修正します
• スライスを String 型に変換することで、if 節のエラーが修正できます

fn main() {
  for n in 0..10{
    let output = if n % 15 == 0{
      format!("FizzBuzz")
    }else{
      format!("{}", n)
    };
    println!("{}", output);
  }
}

さらに別のコンパイルエラーの修正方法

• String::from で String オブジェクトを作ることもできます

fn main() {
  for n in 0..10{
    let output = if n % 15 == 0{
      String::from("FizzBuzz")
    }else{
      format!("{}", n)
    };
    println!("{}", output);
  }
}

関数への切り出し

• fn キーワード で関数を定義できます
• () 内に引数のリストを、-> の後に返り値の型を書きます
• 下記は、FizzBuzz の数値から文字列への変換を、関数に切り出した例です
• u32 を String への変換として実装しています

fn fizzbuzz(n: u32) -> String{
  if n % 15 == 0{
    format!("FizzBuzz")
  }else if n % 5 == 0{
    format!("Buzz")
  }else if n % 3 == 0{
    format!("Fizz")
  }else{
    format!("{}", n)
  }
}

関数呼び出し

• 実引き数をを与えて関数を呼びます
• 下記の例では、output や n に型が明記されていません
• これはコンパイラーが型推論を行うためです

fn main() {
  for n in 1..20{
    let output = fizzbuzz(n);
    println!("{}", output);
  }
}

FizzBuzz：関数プログラミング的なアプローチ

• FizzBuzz はデータ変換を行う関数として捉えることもできます
• 例：数値の範囲 -> 文字列
• 一つ一つの数値を、文字列に変換する関数は fizzbuzz として用意されています
• これを使って、関数プログラミング的なアプローチで FizzBuzz を書き直します

FizzBuzz: map メソッド

• コレクション中の要素一つ一つに関数を適用して、別のコレクションを作る map と呼ばれる操作は、関数プログラミングで良く利用されます
• Rust のイテレーターにも map メソッドは用意されています
• このメソッドは、各要素に、引数に与えた関数を適用した結果を持つイテレーターを返します

fn main() {
  for output in (1..20).map(fizzbuzz){
    println!("{}", output);
 }
}

クロージャー：関数の一種

• クロージャーは関数の一種で、定義された時にアクセス可能な変数であれば関数本体内で利用できる、という点が特徴です
• 無名関数やラムダ、といった名前でクロージャーを提供している言語もあります
• Rust でもクロージャーは利用できます。下記の例では、 fold メソッドの第 2 引数でクロージャーを定義しています
• 仮引数リストは | と | の間に記述します

fn main() {
  let output = (1..20).map(fizzbuzz)
      .fold(format!(""), |accum, line|{
    format!("{}\n{}", accum, line)
  });
  println!("{}", output);
}

単体テスト

• #[test] とアノテーションされた関数は、テスト用の関数として処理されます
• 次の例は、fizzbuzz の振る舞いをテストする関数です
• cargo test でテストを実行できます

#[test]
fn test_fizzbuzz_returns_fizzbuzz() {
    let expected = format!("FizzBuzz");
    let actual = fizzbuzz(15);
    assert_eq!(expected, actual);
}

アサーション

• アサーションが満たされるかどうかで、テストの成否がきまります
• アサーションは assert、assert_eq、assert_ne マクロで記述します
• 次の例では、fizzbuzz の返り値に関する期待を assert_eq で記述しています

#[test]
fn test_fizzbuzz_returns_fizzbuzz() {
    let expected = format!("FizzBuzz");
    let actual = fizzbuzz(15);
    assert_eq!(expected, actual);
}

テストの実行と、その結果

• cargo test でテストが実行されます
• 定義されたテストを全て実行し、結果を次のように表示します
• 次の例では、4 つのテストが全て成功していることがわかります

% cargo test
（中略）
running 4 tests
test test_fizzbuzz_returns_buzz ... ok
test test_fizzbuzz_returns_fizz ... ok
test test_fizzbuzz_returns_fizzbuzz ... ok
test test_fizzbuzz_returns_number_string ... ok

test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

テストコードの例

#[test]
fn test_fizzbuzz_returns_fizzbuzz() {
  let expected = format!("FizzBuzz");
  let actual = fizzbuzz(15);
  assert_eq!(expected, actual);
}

#[test]
fn test_fizzbuzz_returns_fizz() {
  let expected = format!("Fizz");
  let actual = fizzbuzz(6);
  assert_eq!(expected, actual);
}

#[test]
fn test_fizzbuzz_returns_buzz() {
  let expected = format!("Buzz");
  let actual = fizzbuzz(10);
  assert_eq!(expected, actual);
}

#[test]
fn test_fizzbuzz_returns_number_string() {
  let number = 4;
  let expected = format!("{}", number);
  let actual = fizzbuzz(number);
  assert_eq!(expected, actual);
}

ファイル読み込みには失敗がつきもの

• Rust では、ある操作の成否を Result を使って表現します
• Result は Ok もしくは Err を値に持つ列挙型です
• Ok か Err かは、is_ok メソッドで判別できます

fn main() {
  let result: Result<u32, String> = Ok(1);
  let message = if result.is_ok(){
    "Success"
  }else{
    "Fail"
  };
  println!("{}", message);
}

Result<T, E>

• Result は Ok と Err を値に持つ列挙型です
• Ok は処理の成果物を、Err はエラー値を内部に持っています
• 成果物 / エラー値の型は自由に変えられるようになっています

enum Result<T, E> {
   Ok(T),
   Err(E),
}

成果物 / エラーの型の指定

• 成果物やエラーの表現は、プログラムによって異なります
• そのため成果物のデータ型とエラーを表すデータ型もあわせて指定します
• 次の例では、成果物は u32 であり、エラーは String で表現されます

let result: Result<u32, String> = Ok(1);

成果物の取り出し方（unwrap を使う場合）

• unwrap メソッドを使って、成果物（もしくはエラーの理由）を取り出せます
• 次の例では、成功した場合に unwrap メソッドを使って成果物を取り出しています

fn main() {
  let result: Result<u32, String> = Ok(1);
  let message = if result.is_ok(){
    format!("Result = {}", result.unwrap())
  }else{
    format!("Fail")
  };
  println!("{}", message);
}

成果物の取り出し方（パターンマッチを使う場合）

• 条件分岐と unwrap との組み合わは、パターンマッチを使って簡略化できます
• パターンマッチは match 式 として記述できます
• パターンの一部分を、変数に束縛することで、Ok / Err から値を取り出せます

fn main() {
  let result: Result<u32, String> = Ok(1);
  let message = match result {
    Ok(value) => format!("Result = {}", value),
    Err(_) => format!("Fail")
  };
  println!("{}", message);
}

成果物の取り出し方（if let を使う場合）

• if let という構文でも、成果物を取得できます
• ある処理が成功した場合にのみ続きを実行したい、という時によく使われます

fn main() {
  let result: Result<u32, String> = Ok(1);
  if let Ok(value) = result {
    println!("Result = {}", value);
  }
}

? 演算子を利用したアーリーリターン

• その場でエラーを返して関数から脱出することはよくあります
• ? 演算子を利用することで、アーリーリターンをシンプルに記述できます
• 次の例では main 関数でアーリーリターンしています（Playground で試す）
• これにあわせて main 関数に返り値を設定しています

fn accept_only_even_number(value: u32) -> Result<u32, String>{
  if value % 2 == 0{
    Ok(value)
  }else{
    Err(format!("Odd number is given"))
  }
}

fn main() -> Result<(), String>{
  let value = accept_only_even_number(2)?;
  println!("Result = {}", value);

  let value = accept_only_even_number(3)?;
  println!("Result = {}", value);
  
  Ok(())
}

Result のエイリアス：std::io::Result

• エラーの理由を表す型が決まっている、といった理由で Result のエイリアスが作られることは良くあります
• 代表例は、std::io::Result です
• 次のように、エラーを std::io::Error で表すと定めています

type Result<T> = Result<T, std::io::Error>;

Option: null かもしれない値の表現

• Option は存在するかもしれないし、しないかもしれないといった値を表現します
• 下記の例では、1 番目のコマンドライン引数を取得しています
• この値が存在するかどうかは、ユーザーの入力に依存します

fn main() {
  let arguments = std::env::args();
  match arguments.nth(1){
    Some(path) => run(path),
    None => println!("No path is specified"),
  }  
}

Option の値：Some と None

• Option は Result と良く似た性質をしています
• 公式ドキュメントでは、Result はリッチな Option として紹介されています
• 値が存在する場合、Option の値は Some となります。
• 値が存在しない場合の値は None です

fn main() {
  let arguments = std::env::args();
  match arguments.nth(1){
    Some(path) => run(path),
    None => println!("No path is specified"),
  }  
}

Option からの値取得

• Some は、実際の値を内部に保持しています
• Option は Result と同様に、unwrap メソッドを持っています
• またパターンマッチや、if let、? 演算子も利用できます

fn main() {
  let arguments = std::env::args();
  match arguments.nth(1){
    Some(path) => run(path),
    None => println!("No path is specified"),
  }  
}

コマンドラインオプションに対応しよう

• grep は -n オプションをつけると、結果に行番号をつけて結果を出力します
• この機能を mygrep にも実装します
• オプションの解析には、ライブラリを利用することします

package と crate

• ライブラリやバイナリのことを、Rust では crate（クレート）と呼びます
• 1 つ以上の crate を取りまとめたものを package と呼びます
• package は必ず Cargo.toml を持っています
• このハンズオンでは、mygrep パッケージを操作しています

% cargo new mygrep
  Created binary (application) `mygrep` package

crates.io：crate レポジトリ

• Cargo は 3rd party ライブラリ（crate）のインストールや管理を行えます
• レポジトリに公開されている crate は、cargo コマンドでインストールできます
• crates.io が標準のレポジトリとして利用されます

ここまでの状態（main.rs）

• MyGrep::new は使わなくなったので、削除しました

use structopt::StructOpt;

#[derive(StructOpt)]
#[structopt(name="mygrep")]
struct MyGrep{
  #[structopt(name = "PATTERN")]
  pattern: String,
  #[structopt(name = "FILE")]
  path: String,
}

fn grep(content: String, pattern: String){
  for line in content.lines(){
    if line.contains(pattern.as_str()){
      println!("{}", line);
    }
  }
}

fn run(mygrep: MyGrep){
  match std::fs::read_to_string(mygrep.path) {
    Ok(content) => grep(content, mygrep.pattern),
    Err(reason) => println!("{}", reason)
  }  
}

fn main(){
  let mygrep = MyGrep::from_args();
  run(mygrep);
}

Trait：データ構造の満たす性質の定義

• Rust は型を、そのデータ構造が満たす性質で区別します
• データ構造の満たす性質は、インタフェースの集まりとして定義されます
• インタフェースの集まりのことを、Rust では trait と呼びます
• 次の例では、i32 と Vec は、ともに Zero という trait を実装しているため、同じ型として扱えます

trait Zero {
    fn is_zero(&self) -> bool;
}

impl Zero for i32 {
    fn is_zero(&self) -> bool {　*self == 0　}
}

impl<T> Zero for Vec<T>{
    fn is_zero(&self) -> bool{ self.len() == 0 }
}

Derive アトリビュート：コードの自動的な追加

• Derive アトリビュート は、指定した trait の持つインタフェースを実装します
• 次の例では、Foo に PartialEq と Clone を実装しています
• 実装方法はマクロによって定められています
• マクロが用意されていない trait を Derive アトリビュートを使って実装できません

#[derive(PartialEq, Clone)]
struct Foo<T> {
    a: i32,
    b: T,
}

use：名前空間へのシンボルの追加

• use は、別のファイルで定義されているシンボルを、そのファイルの名前空間に追加でき、シンボルを省略して記述できるようになります
• 次の例では、structopt::StructOpt を、そのファイルの名前空間に追加したため、StructOpt trait を StructOpt で参照できています
• 仮に名前空間に追加しなかった場合、StructOpt を解決できず、コンパイルエラーとなります

use structopt::StructOpt;

#[derive(StructOpt)]
#[structopt(name="mygrep")]
struct MyGrep{
  #[structopt(name = "PATTERN")]
  pattern: String,
  #[structopt(name = "FILE")]
  path: String,
}

所有権の移動に伴うコンパイルエラー

• mygrep.path の値は read_to_string の引数に所有権が移動しています
• 所有権が移動したフィールドをもつオブジェクトを利用しているので、コンパイルエラーがおきます
• 所有権は代入や、関数呼び出しによって移動します

error[E0382]: use of partially moved value: `mygrep`
  --> src/main.rs:68:25
   |
67 |   match std::fs::read_to_string(mygrep.path) {
   |                                 ----------- value partially moved here
68 |     Ok(content) => grep(mygrep, content),
   |                         ^^^^^^ value used here after partial move
   |
   = note: partial move occurs because `mygrep.path` has type `String`, which does not implement the `Copy` trait

error: aborting due to previous error

For more information about this error

名前と値

• Rust では = で行う行為を束縛と呼びます
• let で宣言するのは名前です。
• = は値に変数を結びつけると考えるため束縛と呼ばれます
• 下記の例では、chiko と another_chiko は異なる値に束縛されています

struct Person{
  name: String
}

let chiko = Person{name: "Chiko".to_string()};
let another_chiko = Person{name: "Chiko".to_string()};

所有権の移動

• Rust で値に束縛される名前は 1 つまでとなっています
• ある値が他の名前に束縛された時、元の名前はその値に束縛されなくなります
• このことを所有権の移動（move）と呼びます
• 下記のコードは、chiko に束縛されていた値を、所有権の移動後に参照するためコンパイルエラーとなります

let chiko = Person{name: "Chiko".to_string()};
let another_chiko = chiko;

println!("{}", chiko.name);

所有権の移動と関数呼び出し

• 所有権の移動は関数呼び出しでも起こります
• それは関数の仮引数（名前）が、実引数（値）に束縛されるためです
• 次の例では、do_somthing 呼び出しに chiko から所有権が移動します

let chiko = Person{name: "Chiko".to_string()};
do_somthing(chiko);
let message = format!("Hello, {}", chiko.name);

参照と借用

• 所有権を渡す代わりに、一時的に値を貸し出すこともできます
• 貸し出す場合は、値は参照という形で渡します
• 変数名の前に & をつけることで、値への参照を取得します

fn run(mygrep: MyGrep){
  match std::fs::read_to_string(&mygrep.path) {
    Ok(content) => grep(mygrep, content),
    Err(reason) => println!("{}", reason)
  }  
}

参照

• Rust には参照という概念があります
• 参照とは、ある値を指す値とでも呼ぶもので、値へ間接的にアクセスするために利用します
• & を変数につけることで、それを束縛する値への参照を取得できます

let chiko = Person{name: format!("Chiko")};
let reference = &chiko;

参照と所有権の移動

• 参照を取得した時に、値の所有権は移動しません
• 次の例では、reference へ値の所有権は移動していません
• そのため、コンパイルエラーとはなりません

let chiko = Person{name: format!("Chiko")};
let reference = &chiko;
let message = format!("{}", chiko.name);

借用：borrowing

• 関数が参照を引数とすることを「借用（borrowing）」と呼びます
• 次の do_something は参照を引数として受け取ります
• この関数を呼び出した時、chiko を束縛する値の所有権は移動しません
• そのため、最後の行はコンパイルエラーとはなりません

fn do_something(person: &Person){
  println!("Hello, {}!", person.name);
}

fn main(){
  let chiko = Person{name: format!("Chiko")};
  do_something(&chiko);
  let message = format!("Hello, {}!", chiko.name);
}

所有権が移動した後の借用

• 次の例では greet を呼び出し時に所有権が移動します
• 所有権が移動した値は、関数呼び出し後に消滅します
• 消滅後 reference 経由で値を参照しているので、コンパイルエラーとなります

fn greet(person: Person){
  println!("Hello, {}", person.name);
}

fn main() {
  let chiko = Person{name: format!("Chiko")};
  let reference = &chiko;
  greet(chiko);
  println!("{}", reference.name);
}

所有権移動後の借用によるエラーメッセージ

error[E0505]: cannot move out of `chiko` because it is borrowed
  --> src/main.rs:13:11
   |
11 |     let reference = &chiko;
   |                     ------ borrow of `chiko` occurs here
12 |     println!("{}", reference.name);
13 |     greet(chiko);
   |           ^^^^^ move out of `chiko` occurs here
14 |     println!("{}", reference.name);
   |                    -------------- borrow later used here

self を引数にとる関数

• self を引数にとる関数をデータ構造に実装することで、そのデータ構造にメソッドを追加できます
• メソッド呼び出し時、self はメソッドのレシーバーに束縛されます
• 次の例では、Peano という構造体に succ というメソッドを追加しています

struct Peano{
  value: u32
}
impl Peano{
  fn zero() -> Peano{ 
    Peano{value: 0}
  }
  fn succ(&self) -> Peano{
    Peano{value: self.value + 1}
  }
}
fn main(){
  let zero = Peano::zero();
  let one = zero.succ();
  println!("zero = {}, one = {}", zero.value, one.value);
}

self か &self か

• メソッドの第 1 引数は、self もしくは &self となります
• 前者ではメソッド呼び出し時に、自身の所有権が仮引数に移動します。後者では、所有権が移動しません

struct Peano{
  value: u32
}
impl Peano{
  fn zero() -> Peano{ 
    Peano{value: 0}
  }
  fn succ(self) -> Peano{
    Peano{value: self.value + 1}
  }
}
fn main(){
  let zero = Peano::zero();
  let one = zero.succ();
}

メソッド呼び出しによる所有権の移動

• succ を呼び出した時点で zero に束縛されていた値の所有権が移動しています
• 一方 println! では所有権の移動した値を参照しています
• そのため以下の例は、コンパイルエラーとなります

struct Peano{
  value: u32
}
impl Peano{
  fn zero() -> Peano{ 
    Peano{value: 0}
  }
  fn succ(self) -> Peano{
    Peano{value: self.value + 1}
  }
}
fn main(){
  let zero = Peano::zero();
  let one = zero.succ();
  println!("zero = {}, one = {}", zero.value, one.value);
}