mimikakimemo

自分用メモ。

Rust に付け焼き刃で入門する 5

Rust に付け焼き刃で入門する 4 の続き。

6. Enum とパターンマッチング

6.1. Enumを定義する

Enumを定義する - The Rust Programming Language 日本語版

enum IpAddrKind {
    V4,
    V6,
}

enum の定義。V4V6 を日本語ドキュメントでは列挙子と呼んでいるが、英語だと単純に variant。列挙子の名前は識別子として扱われているっぽいので、記号やスペースは含められないんだろうか? そもそも、Rust の識別子に使える文字種がどうなっているのか、まだ知らないが。

let four = IpAddrKind::V4;
let six = IpAddrKind::V6;

列挙子のインスタンスを生成する。IpAddrKind::V4IpAddrKind::V6 は値。その両方を含んだ型が IpAddrKind

:: を使っているのは、関連関数の :: と関係あるんだろうか?

enum IpAddr {
    V4(u8, u8, u8, u8),
    V6(String),
}

let home = IpAddr::V4(127, 0, 0, 1);
let loopback = IpAddr::V6(String::from("::1"));

このようにして、列挙子に具体的なデータを格納することができる。列挙型はユニオン型のようになる。

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

Move は匿名構造体をデータとして持つ列挙子。匿名構造体ってのは初めて出てきた気がする。他の箇所でも使えるんだろうか。

enumと構造体にはもう1点似通っているところがあります: implを使って構造体にメソッドを定義できるのと全く同様に、 enumにもメソッドを定義することができるのです。

なるほど。関連関数は定義できるんだろうか?と思って試してみたらいけた。

#[derive(Debug)]
enum Hoge {
    Foo(i32),
    Bar(bool),
}

impl Hoge {
    fn print(&self) {
        println!("{:?}", self);
    }
    // 関連関数を定義
    fn make_bar(value: bool) -> Hoge {
        Hoge::Bar(value)
    }
}

fn main() {
    let foo = Hoge::Foo(123);
    let bar = Hoge::make_bar(true); // 関連関数を呼び出す
    foo.print(); // → Foo(123)
    bar.print(); // → Bar(true)
}

Rustにはnullがありませんが、 値が存在するか不在かという概念をコード化するenumならあります。このenumOption<T>で、 以下のように標準ライブラリに定義されています。

Haskell でいう Maybe 的なやつ。

Option<T>は有益すぎて、初期化処理(prelude)にさえ含まれています。つまり、明示的にスコープに導入する必要がないのです。 さらに、列挙子もそうなっています: SomeNoneOption::の接頭辞なしに直接使えるわけです。

しれっと使われている SomeNone は、Option::SomeOption::Noneenum だったのか。

では、Option<T>型の値がある時、その値を使えるようにするには、どのようにSome列挙子からT型の値を取り出せばいいのでしょうか? Option<T>には様々な場面で有効に活用できる非常に多くのメソッドが用意されています; ドキュメントでそれらを確認できます。

Some(42) から値 42 を取り出す方法は、この節では濁されている。ドキュメントを見てみると、unwrap() メソッドでできるようだ。

6.2. matchフロー制御演算子

matchフロー制御演算子 - The Rust Programming Language 日本語版

パターンマッチ。説明されていないが、各アームが返す型はすべて同じでなければならないようだ。

Rustにおけるマッチは、包括的です: 全てのあらゆる可能性を網羅し尽くさなければ、コードは有効にならないのです。

これも Haskell など他の言語と同様。また、ワイルドカード的なプレースホルダとして、パターン中に _ が使える。

6.3. if letで簡潔なフロー制御

if letで簡潔なフロー制御 - The Rust Programming Language 日本語版

let some_u8_value = Some(0u8);

match some_u8_value {
    Some(3) => println!("three"),
    _ => (),
}

let some_u8_value = Some(0u8);

if let Some(3) = some_u8_value {
    println!("three");
}

は等価。if let と書かれていたので一瞬構造がよくわからなかったが、「普通の if 式の条件の部分に let Some(3) = some_u8_value が入っている」と見ればよさそう。変数定義に使う let と被っているのも紛らわしいが、パターンマッチのための「let <pattern> = <valiable>」という特別な構文、という理解でいいんだろうか。


enum とパターンマッチ。若干独特な部分はあるが、変な概念はない。

Rust に付け焼き刃で入門する 4

Rust に付け焼き刃で入門する 3 の続き。

5. 構造体を使用して関係のあるデータを構造化する

5.1. 構造体を定義し、インスタンス化する

構造体を定義し、インスタンス化する - The Rust Programming Language 日本語版

フィールドには foo.bar のようにドットでアクセス。

Rustでは、一部のフィールドのみを可変にすることはできないのです。

フィールドの値を書き換えたい場合は、構造体のインスタンス全体を可変にする。今まで見てきた変数と同じように、let mut を使う。

let mut user1 = User {
    email: String::from("someone@example.com"),
    username: String::from("someusername123"),
    active: true,
    sign_in_count: 1,
};

user1.email = String::from("anotheremail@example.com");

フィールド初期化省略記法

fn build_user(email: String, username: String) -> User {
    User {
        email, // ← これ
        username, // ← これ
        active: true,
        sign_in_count: 1,
    }
}

field init shorthand syntax。JavaScript にもあるやつ。

構造体更新記法

let user2 = User {
    email: String::from("another@example.com"),
    username: String::from("anotherusername567"),
    ..user1
};

struct update syntax。JavaScript の spreading に近いが、..foo は必ず最後に書く必要がある様子。

タプル構造体

struct Color(i32, i32, i32);
let black = Color(0, 0, 0);

型に名前をつけて区別できること以外は、普通のタプルと同じ。要素に red, green, blue など名前をつけたくなるが、それはできないようだ。

普通の構造体の定義は ; が不要だが、タプル構造体の定義は ; が必要。若干ややこしいが、VS Code の拡張を入れておけば、保存時のフォーマットでよしなに直してくれる。

ユニット様構造体

struct Foo; だけで定義できるらしい。

5.2. 構造体を使ったプログラム例

構造体を使ったプログラム例 - The Rust Programming Language 日本語版

構造体を使ったかんたんなチュートリアル。構造体の定義の直前に #[derive(Debug)] をつけると、println! 文字列に {:?} を書いていい感じに出力できるようになる。derive マクロというやつなんだろうか。

5.3 メソッド記法

メソッド記法 - The Rust Programming Language 日本語版

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

impl ブロックによって、構造体にメソッドを定義できる。fn といい mut といい struct といい、Rust のキーワードは省略形が多い。

第1引数 &self で自分自身のインスタンスを受け取るのは Python っぽい。&self には型注釈は不要。試してみたら、一応 self: &Rectangle と書くことはできるようだ。& が頭につくことに注意。可変にするなら &mut self

selfだけを第1引数にしてインスタンスの所有権を奪うメソッドを定義することは稀です; このテクニックは通常、 メソッドがselfを何か別のものに変形し、変形後に呼び出し元が元のインスタンスを使用できないようにしたい場合に使用されます。

そうなのか。

Rustには->演算子の代わりとなるようなものはありません; その代わり、Rustには、 自動参照および参照外しという機能があります。Rustにおいてメソッド呼び出しは、 この動作が行われる数少ない箇所なのです。

自動でよしなにしてくれて若干気持ち悪いが、C の .-> の使い分けもそれはそれで面倒なので、まあ。

メソッドの受け手に関して借用が明示されないというのが、 所有権を実際に使うのがRustにおいて簡単である大きな理由です。

意味がとりづらいが、「メソッドの第1引数(&self&mut selfself)を見るだけで、メソッド呼び出しによって借用が起きるかどうかをコンパイラが判断できる。なので、メソッドの受け手 reciever(そのインスタンス自体。foo.do_something()foo)に &&mut をつける必要がない(&foo.do_something()foo.do_something() か、というようなことに人間が注意しなくても良い)」ということだろうか。

implブロック内にselfを引数に取らない関数を定義できることです。 これは、構造体に関連付けられているので、関連関数と呼ばれます。

associated function。いわゆる静的メソッド。some_instance.do_something() ではなく、SomeStruct::do_something() で呼び出す。

複数のimplブロックが有用になるケースは第10章で見ますが、そこではジェネリック型と、トレイトについて議論します。

まだよくわからない。構造体自体の定義 struct とメソッド定義 impl が文法上別々のブロックに分かれているのは、これを可能にするためなんだろうか?


構造体おわり。特にはまりそうなところは無かった。

Rust に付け焼き刃で入門する 3

Rust に付け焼き刃で入門する 2 の続き。

4. 所有権を理解する

Rust 独特の機能。「Rust を手っ取り早く解説」系の記事では、あまりよく挙動がわからなかったので、しっかり理解したい。

4.1. 所有権とは

所有権とは? - The Rust Programming Language 日本語版

プログラムが動作するにつれて、 定期的に使用されていないメモリを検索するガベージコレクションを持つ言語もありますが、他の言語では、 プログラマが明示的にメモリを確保したり、解放したりしなければなりません。Rustでは第3の選択肢を取っています: メモリは、コンパイラコンパイル時にチェックする一定の規則とともに所有権システムを通じて管理されています。 どの所有権機能も、実行中にプログラムの動作を遅くすることはありません。

GC でも malloc/free でもない第3の方法が所有権 ownership システム。

この章の後半でスタックとヒープを交えて所有権の一部が解説されるので、ここでちょっと予行演習をしておきましょう。

  • スタック:高速。LIFO。既知で固定サイズのデータに限る
  • ヒープ:低速。使いたいときは領域を確保 allocate して、そのポインタを返す

いきなり結構低レベルな話になってきた。このあたりの概念は Rust に特有ということでもない。

コードが関数を呼び出すと、関数に渡された値(ヒープのデータへのポインタも含まれる可能性あり)と、 関数のローカル変数がスタックに載ります。関数の実行が終了すると、それらの値はスタックから取り除かれます。

ここも一般的なコールスタックの話。

一度所有権を理解したら、あまり頻繁にスタックとヒープに関して考える必要はなくなるでしょうが、 ヒープデータを管理することが所有権の存在する理由

なるほど。

  • Rustの各値は、所有者と呼ばれる変数と対応している。
  • いかなる時も所有者は一つである。
  • 所有者がスコープから外れたら、値は破棄される。

このルールは明快なので、「手っ取り早く解説」系の記事でも読んで覚えている。

変数は、宣言された地点から、現在のスコープの終わりまで有効になります。

よくある感じ。スコープが何を指すかの説明がないが、とりあえずは { ... } を思い描いておけばいいんだろうか。

Rustには、 2種類目の文字列型、String型があります。この型はヒープにメモリを確保するので、 コンパイル時にはサイズが不明なテキストも保持することができるのです。

ちなみに、もう一方の型(文字列リテラルの型)は &str 型のようだ。両者の名前が似ていて最初は???という感じだったが、よくある区別。

変数がスコープを抜ける時、Rustは特別な関数を呼んでくれます。[…] Rustは、閉じ波括弧で自動的にdrop関数を呼び出します。

デストラクタ的な。

他の言語を触っている間に"shallow copy"と"deep copy"という用語を耳にしたことがあるなら、 データのコピーなしにポインタと長さ、許容量をコピーするという概念は、shallow copyのように思えるかもしれません。 ですが、コンパイラは最初の変数をも無効化するので、shallow copyと呼ばれる代わりに、 ムーブとして知られているわけです。

shallow copy だけだと二重解放の問題が起きるので、shallow copy っぽいことをしつつ、古い変数の方は無効にする。これがムーブ。なるほど、そういうことか。

ムーブによって「いかなる時も所有者は一つである」というルールが満たされる。すると、後は「所有者がスコープから外れたら、値は破棄される」というルールだけ用意しておけば、二重解放や、解放し忘れに悩まされることがなくなる。

Rustでは、 自動的にデータの"deep copy"が行われることは絶対にないわけです。それ故に、あらゆる自動コピーは、実行時性能の観点で言うと、 悪くないと考えてよいことになります。

ふむ。自動コピー automatic copy ってのは後で出てくるのかな。

型がCopyトレイトに適合していれば、代入後も古い変数が使用可能になります。

ルールはそんなに単純じゃなかった。他の言語も deep copyshallow copy が混ざったりするので、それと同じだといえば同じだが。プリミティブだけでなく、例えば (i32, i32)Copy らしい。

関数に変数を渡すと、 代入のようにムーブやコピーされます。

関数に変数を渡すと関数にムーブされる、というのはなんか独特な感じ。関数にムーブされた変数は、その関数を抜けるときに drop される。変数が Copy だったら、関数に渡すとムーブではなくコピーされる。参照渡しと値渡しのようなものではあるが…。

関数から値を返した場合は、drop されずに呼び出し元(の新たな変数)にムーブされる。

4.2. 参照と借用

参照と借用 - The Rust Programming Language 日本語版

fn main() {
    let s1 = String::from("hello");
    // s1 を渡すと calculate_length にムーブしてしまうが、次の println! でもう一度使いたいので、関数から返してもらう必要がある
    let (s2, len) = calculate_length(s1);
    println!("The length of '{}' is {}.", s2, len);
}

fn calculate_length(s: String) -> (String, usize) {
    let length = s.len();
    (s, length)
}

受け取った変数をいちいち返すのは煩雑なので、参照 reference という仕組みがある。

fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1);
    println!("The length of '{}' is {}.", s2, len);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

変数名や型注釈に & をつける。C言語っぽい記法(忘れていたが、C の & はアドレス演算子という名前らしい)。

この&s1という記法により、s1の値を参照する参照を生成することができますが、これを所有することはありません。所有してないということは、指している値は、参照がスコープを抜けてもドロップされないということです。

意味の取りづらい日本語だが、原文を見てみるに、「&s1 って書くと s1 の参照を作ることができるけど、参照 &s1 は変数 s1 を所有するわけじゃないよ。参照 &s1 があるスコープを抜けたとしても、&s1 が参照している変数 s1 はドロップされないよ。&s1s1 を所有していないからね。」ということらしい。

関数の引数に参照を取ることを借用と呼びます。

borrowing。

変数が標準で不変なのと全く同様に、参照も不変なのです。

&foo は不変。&mut foo で渡せば、可変になる。

ところが、可変な参照には大きな制約が一つあります: 特定のスコープで、ある特定のデータに対しては、 一つしか可変な参照を持てないことです。

さらに不変な参照をしている間は、可変な参照をすることはできません。

競合を防ぐため。納得できる。一方で、不変な参照だけであれば、いくつも同時に作ることができる。

対照的にRustでは、コンパイラが、 参照がダングリング参照に絶対ならないよう保証してくれます

浮いた参照にならないように、コンパイルエラーにしてくれる。

4.3. スライス型

スライス型 - The Rust Programming Language 日本語版

所有権のない別のデータ型は、スライスです。

なるほど? 「別の」ということは、参照とも違う扱いなんだろうか。Python のスライスみたいなものかな?

for (i, &item) in bytes.iter().enumerate() {

このへんも Python っぽい。

let s = String::from("hello");
let slice = &s[3..]; // "lo"

sString 型のとき、文字列スライス &s[3..]&str 型。スライスとして表現することによって、元の変数に対する変更などをコンパイラでチェックすることができる。

let s = "Hello, world!";

ここでのsの型は、&strです: バイナリのその特定の位置を指すスライスです。 これは、文字列が不変である理由にもなっています。要するに、&strは不変な参照なのです。

な、なるほど…。そういう扱いなのか。


所有権まわりのメリットはだいぶ理解できた。

Rust に付け焼き刃で入門する 2

Rust に付け焼き刃で入門する 1 の続き。

3. 一般的なプログラミングの概念

3.1. 変数と可変性

変数と可変性 - The Rust Programming Language 日本語版

不変のメリットについての説明は、特に Rust に限ったことではない。

不変な変数とは別に、定数もある。型注釈は必須。

const MAX_POINTS: u32 = 100_000;

シャドーイングについては、前回見たとおり。

3.2 データ型

データ型 - The Rust Programming Language 日本語版

Rust は静的型付き言語。型推論してくれるので、型注釈は必要なところでだけで良い。

整数型や論理値型など、プリミティブな型はスカラー型と呼ぶ。整数にはサイズがある。ローレベルな感じ。迷ったら Rust のデフォルトである i32 型を使えば良いとのこと(最速なので)。浮動小数点型の方は f64。いわゆる double。演算子は普通な感じ。

bool 型は truefalse

char 型は Unicode スカラー値の一つ。'a' のようにシングルクォートで囲む。文字列 "a" とは別。

タプルの要素の型は一致しなくてよい。destructring も可能。要素には、x.0 のようにドットでアクセス。

配列 array は同じ型の要素からなり、固定長。他の言語でいうような可変長のリストは、ベクタ vector を使う。配列の要素には x[0] のようにしてアクセス。範囲外へのアクセスは実行時エラー panic になる。

3.3 関数

関数 - The Rust Programming Language 日本語版

ソースコード中でanother_functionmain関数の後に定義していることに注目してください; 勿論、main関数の前に定義することもできます。コンパイラは、関数がどこで定義されているかは気にしません。 どこかで定義されていることのみ気にします。

なるほど。JavaScript だと巻き上げ hoisting が起きるけど、Rust はどうなんだろう。

fn main() {
    println!("Hello, world!");
    another_function();
}

let num = 42;

fn another_function() {
    println!("{}", num);
}

これだとerror: expected item, found keyword `let` というエラーになった。そもそもここには let を置けないので、let と関数定義の順序を気にする必要はない様子。また、

fn main() {
    println!("Hello, world!");
    another_function();

    let num = 42;

    fn another_function() {
        println!("{}", num);
    }
}

can't capture dynamic environment in a fn item というエラーになった。関数定義の順序を気にしないといけないようなコードは、そもそも文法的に許されていないようだ。

関数シグニチャにおいて、各仮引数の型を宣言しなければなりません。

はい。

文とは、なんらかの動作をして値を返さない命令です。 式は結果値に評価されます。

変数宣言や関数定義は文。プロック {} は式。式にセミコロンをつけると文になる。

戻り値に名前を付けはしませんが、 矢印(->)の後に型を書いて確かに宣言します。Rustでは、関数の戻り値は、関数本体ブロックの最後の式の値と同義です。 returnキーワードで関数から早期リターンし、値を指定することもできますが、多くの関数は最後の式を暗黙的に返します。

Rust では、ブロックの最後の式の値を戻り値とみなす。式なのでセミコロンはつけない(つけると文になってしまう)。慣れるまではうっかりセミコロンを消したり、つけたりしてしまいそうだ。ただ、戻り値の型が食い違っていたらコンパイルエラーで気づけるので、そこまで神経質にならなくても良さそう。

戻り値なしの場合は空のタプル -> () で型を表現できるが、この場合に限って、戻り値の型注釈を省略できるっぽい。

3.4. コメント

// でコメントを書ける。

3.5. フロー制御

フロー制御 - The Rust Programming Language 日本語版

if は式なので、値を返す。条件は bool 型である必要がある。アームの {} は省略不可。else, else if も使えるが、各アームが返す型は同じでなければならない。ユニオン型にはなってくれないようだ。

各アームが返す型は同じでなければならないので、値を返す式として使う場合は else が必ず必要。

let a = if cond { 100 } else { 0 }; // OK
let a = if cond { 100 }; // NG

無限ループは loop。条件付きループは while。コレクション(イテレータ?)に対するループは for ... inbreakcontinue もある。このあたりは普通な感じ。

ループは式なんだろうか? break から値は返せるんだろうか? …特にこのページには記述がなかった。

Rust に付け焼き刃で入門する 1

数十分〜数時間で手っ取り早く掴む系

ざくっと見てみたところ、所有権・借用や、ライフタイムの扱いがややこしそうな印象。コンパイルエラーのメッセージが親切なのはとても嬉しい。Hello World を書こうとすると、いきなりマクロ println! が出てきて「!」となる。

The Rust Programming Language

公式のこのドキュメントがまずはおすすめらしいので、以降はこれに沿って勉強してみる。TRPL あるいは the book と呼ばれているとのこと。


1. 事始め

事始め - The Rust Programming Language 日本語版

1.1. インストール

普段は Homebrew を使うことが多いが、今回はとりあえず公式にしたがってインストールする。

$ curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh

デフォルトのままで動いた。

$ rustup --version
rustup 1.23.1 (3df2264a9 2020-11-30)
info: This is the version for the rustup toolchain manager, not the rustc compiler.
info: The currently active `rustc` version is `rustc 1.50.0 (cb75ad5db 2021-02-10)`

$ rustc --version
rustc 1.50.0 (cb75ad5db 2021-02-10)

$ cargo --version
cargo 1.50.0 (f04e7fab7 2021-02-04)

公式のパッケージマネージャー cargo が一緒にインストールされるのも、楽でうれしい。

1.2. Hello, World!

hello_world/main.rshello world を書く。VS Code にはデフォルトで Rust のシンタックスハイライトが入っているようだ。

rustcコンパイルしたら、実行ファイルのバイナリができた。

$ rustc main.rs
$ file main
main: Mach-O 64-bit executable x86_64
$ ./main
Hello, world!

1.3 Hello, Cargo!

  • $ cargo new プロジェクトの作成。Git リポジトリの作成までやってくれる
  • $ cargo check 検証
  • $ cargo build [--release] ビルド
  • $ cargo run (ビルド+)実行

cargo があるので、rustcコンパイルする機会はあまりなさそう?

2. 数当てゲームをプログラムする

数当てゲームをプログラムする - The Rust Programming Language 日本語版

VS Code で写経。そのままだとフォーマットや補完ができなかったので、拡張機能を入れた。

let で変数の作成。immutable の方が無標になっているのはありがたい。

::new 行にある :: という記法は、newString 型の関連関数であることを表しています。

関連関数というのは聞き慣れない言葉。英語だと associated function。スタティックメソッドと同じようなものらしい。

io::stdin().read_line(&mut guess)

read_line に、String 型の変数 guess の参照を渡している。C 言語のポインタっぽい。可変であることが &mut で明示的に示されている。

Result 型に関しては、列挙子は OkErr です。

HaskellEither など、関数型でよくあるアレ。エラー処理が書きやすくなるのでありがたい。エラー処理が漏れていると、コンパイル時に検出できるのもうれしい。

0.3.14という数字は、実際には^0.3.14の省略記法で、これは、「バージョン0.3.14と互換性のある公開APIを持つ任意のバージョン」を意味します。

Cargo の依存の指定。実際に、手元の環境では 0.3.23 がインストールされた様子。ちなみに、クレート crate というのは木箱のことらしい。

次に、別の use 行を追加しています: use rand::Rng ですね。Rng トレイトは乱数生成器が実装するメソッドを定義していて、 このトレイトがスコープにないと、メソッドを使用できないのです。

これはわかりにくい気がする。…が、試しに use rand::Rngコメントアウトしてビルドしてみたら、

help: the following trait is implemented but not in scope; perhaps add a `use` for it:
    |
4   | use crate::rand::Rng;

という親切なメッセージが出てきた。これだったら大丈夫そうだ。

match式は、複数のアーム(腕)からできています。

パターンマッチ。

Rustでは、新しい値でguessの値を覆い隠す(shadow)ことが許されているのです。 この機能は、値を別の型に変換したいシチュエーションでよく使われます。

最初はこのシャドーイングの使いみちがわからなかったけど、そういうことか。immutable な変数が基本なので、混乱も起きなさそう。

loop, continue, break については、特に変わったところはなし。

プログラミング言語Rust 公式ガイド

プログラミング言語Rust 公式ガイド