Rustの基本をPythonと比較しつつ学んでみる #3

普段Pythonなどをメインにお仕事をしていますが、Rustのごく基本的な文法や挙動などをPythonと比較しつつ学んでいってみます（前も入門書消化したタイミングで少し記事にしたりしていますが復習も兼ねて書いておきます）。

※Rust初心者なため誤解している点などがあるかもしれません。その辺はご容赦ください。

※長くなりそうなので記事を分割しています。本記事は3記事目となります（過去の記事で触れた点はスキップします）。

1記事目:

https://qiita.com/simonritchie/items/da550aa1070ca6b711a6

2記事目:

https://qiita.com/simonritchie/items/e0928e60cf959f31ddaa

# 構造体（struct）

Pythonのクラスに近いものとしてはRustでは構造体（struct）があります。

例えば以下のようなPythonのクラスで考えてみます。

```py
class Cat:

    name: str
    age: int

    def __init__(self, name: str, age: int) -> None:
        self.name = name
        self.age = age

    def increment_age(self) -> None:
        self.age += 1
```

Rustで上記のクラスに近いものを作るにはstructキーワードを使って以下のように書きます（まずは属性定義だけしています）。

```rust
struct Cat {
    name: String,
    age: i32,
}
```

メソッドを追加したい場合には以下のような記述が必要になります。

```rust
impl クラス名 {
    fn メソッド名(...) -> ...
}
```

コンストラクタの場合はPythonだと`__init__`というdunder methodsで定義しますが、これはRustでは`new`が該当するようです。ただし慣習的なもの（書籍などでは大体`new`で設定されている）のようで別に`new`ではなくともコンパイル等は通るようです。Pythonだとコンストラクタでは返却値の型アノテーションは`None`で問題無い形でしたがRustでは対象のクラス（今回の例で言うと`Cat`）を型として指定します。

また、structのインスタンスを作る際には以下のような記述になります。

```rust
struct名 {
    フィールド名: フィールドの値,
    ...
}
```

前記のPythonのコードのコンストラクタで言うとRustでは以下のようになります。

```rust
fn main() {
}

struct Cat {
    name: String,
    age: i32,
}

impl Cat {
    fn new(name: &str, age: i32) -> Cat {
        return Cat {
            name: String::from(name),
            age: age,
        }
    }
}
```

インスタンス化はPythonだと`cat: Cat = Cat(name="ミケ", age=5)`といったような記述になりますがRustだと以下のような感じになります。

```rust
fn main() {
    let cat: Cat = Cat::new("ミケ", 5);
}
```

属性に関してはドットで繋げる形でアクセスできます（例 : `cat.age`）。

```rust
fn main() {
    let cat: Cat = Cat::new("ミケ", 5);
    println!("{}", cat.age);
}

struct Cat {
    name: String,
    age: i32,
}

impl Cat {
    fn new(name: &str, age: i32) -> Cat {
        return Cat {
            name: String::from(name),
            age: age,
        }
    }
}
```

```
5
```

前記のPythonコードにある`increment_age`メソッドの追加を考えてみます。Pythonだとメソッドには`self`という引数が必要になりますが、Rustでは`&self`という引数を指定する形になります（コンストラクタの場合にはPythonと異なり引数への指定は要らないようです）。

※例外的にCopyトレイトを持っている場合などに`&self`ではなく`self`と指定するケースもあるようですが基本的には`&self`となるようです。

また、メソッド内で属性の更新を行いたい場合には引数部分を`& mut self`といったようにします。インスタンス化の際にも変数にmutの指定が必要になります。

```rust
fn main() {
    let mut cat: Cat = Cat::new("ミケ", 5);
    cat.increment_age();
    println!("{}", cat.age);
}

struct Cat {
    name: String,
    age: i32,
}

impl Cat {
    fn new(name: &str, age: i32) -> Cat {
        return Cat {
            name: String::from(name),
            age: age,
        }
    }

    fn increment_age(&mut self) {
        self.age += 1;
    }
}
```

```
6
```

# トレイトの利用

Rustにはトレイトという機能があります。これはPythonで言うところの抽象クラスによるインターフェイスと似たような挙動をします。つまりメソッド内部の処理の実装は含まないもののメソッドの引数や返却値の構造などを事前に定義しておくことができます。

Pythonだとabc（abstract base class）パッケージの`ABC`と`abstractmethod`を使って以下のように実装することができます。インターフェイス用のクラスを継承したら`@abstractmethod`のデコレーターが付いているメソッドをオーバーライドする形でメソッド内部の実装を書く必要があります。

```py
from abc import ABC, abstractmethod


class AgeInterface(ABC):
    @abstractmethod
    def increment_age(self) -> None:
        ...


class Cat(AgeInterface):

    name: str
    age: int

    def __init__(self, name: str, age: int) -> None:
        self.name = name
        self.age = age

    def increment_age(self) -> None:
        self.age += 1


cat: Cat = Cat(name="ミケ", age=5)
```

Rustのトレイトではまず定義として以下のような記述を行います。ここではメソッドの中身は記述しません。

```rust
trait AgeTrait {
    fn increment_age(&mut self);
}
```

その後に`impl 対象トレイト名 for 構造体名`といった記述を行い、その中にメソッドの実装の中身を書きます。

```rust
impl AgeTrait for Cat {
    fn increment_age(&mut self) {
        self.age += 1;
    }
}
```

コード全体としては以下のようになります。

```rust
fn main() {
    let mut cat: Cat = Cat::new("ミケ", 5);
    cat.increment_age();
    println!("{}", cat.age);
}

struct Cat {
    name: String,
    age: i32,
}

trait AgeTrait {
    fn increment_age(&mut self);
}

impl Cat {
    fn new(name: &str, age: i32) -> Cat {
        return Cat {
            name: String::from(name),
            age: age,
        }
    }
}

impl AgeTrait for Cat {
    fn increment_age(&mut self) {
        self.age += 1;
    }
}
```

```
6
```

特定の関数やメソッドの引数や返却の型の指定でこのトレイトを指定することもできます。こうすることによって対象のトレイトを持っている構造体であればなんでも指定できるようになります。例えば以下のような関数を定義することができます（引数の型の部分にimplなどの記述が必要なようです）。

```rust
fn increment_age_10(animal: &mut impl AgeTrait) {
    for _ in 0..10 {
        animal.increment_age();
    }
}
```

呼び出し元では以下のような記述になります。

```rust
fn main() {
    let mut cat: Cat = Cat::new("ミケ", 5);
    increment_age_10(&mut cat);
    println!("{}", cat.age);
}
```

```
15
```

# Rustとマクロ

今までもRustの記事を書く際にもマクロを使ってきました（末尾に`!`が付くものですね）。特に`println!`のマクロは多く利用してきました。

少々他の言語ではRustのマクロ風な機能に慣れていなかったので少々とっつきにくいとは感じていますが軽くだけ触れておきます。

今までもマクロを使ってきてとりあえず`println!`マクロのように関数のように使えるということは感じていましたが、まずは関数とマクロの違いについて触れていきます。

関数はお馴染みで引数を受け取って必要な場合は結果の返却値を返します。一方でマクロはRustの構文を受け取ってそしてRustの構文を返却します。また、プログラム実行中に呼ばれるのではなくコンパイル時に展開される（関数のように残らず、マクロの内容が該当の処理の箇所に展開される）ようです。そのため内容によっては関数などよりもコンパイル後のサイズが大きくなるケースもあるようです（マクロによって生成されるRustの構文が多い場合など）。

また、各所の記事を読んだ感じでは基本的にはマクロは必要なければ使わなくて良さそう・・・ただし向いているケースもあるのでそういった際には使っていくと色々便利そう・・・という印象を受けました。

基本的な書き方としては以下のような感じになります。

```rust
macro_rules! マクロ名 {
    (引数として指定するRustの構文) => {
        展開する構文内容
    }
}
```

例えば雑ですが引数に指定された構文を参照して内容を出力する`print_value`というマクロを考えてみます。以下のような記述になります。

```rust
macro_rules! print_value {
    ($x: expr) => {
        println!("value is: {}", $x);
    }
}

fn main() {
    let int_value: i32 = 42;
    print_value!(int_value);
}
```

`expr`部分は型の指定のようなもので、構文解析に使われるようです。`expr`は式のリテラルや変数、関数呼び出しなどの表現の構文が該当するようです。他にも識別子の`ident`とかステートメントの`stmt`など様々なものが存在するようです。

前述のコードのマクロでは`print_value!(int_value);`部分がコンパイル時にマクロ側で定義されている構文が使われて`println!("value is: {}", int_value);`という構文に展開される・・・という具合に動作します。

結果として関数を呼び出すのと同じような感覚で結果が出力されます。

```
value is: 42
```

また、関数などは呼び出し元よりも後に書いても動作しますがマクロでは前に書かないと弾かれる？ようです。これは構文展開の都合でしょうか？

例えば以下のようなコードではコンパイルエラーとなります。

```rust
fn main() {
    let int_value: i32 = 42;
    print_value!(int_value);
}

macro_rules! print_value {
    ($x: expr) => {
        println!("value is: {}", $x);
    }
}
```

```
error: cannot find macro `print_value` in this scope
 --> src\main.rs:3:5
  |
3 |     print_value!(int_value);
  |     ^^^^^^^^^^^
  |
  = help: have you added the `#[macro_use]` on the module/import?
```

その他本記事では詳しくは触れませんがマクロではPythonのデコレーターのような使い方もできるようです。こちらは属性マクロなどといった呼ばれ方をしている？ようです。

例えば整数などの数値はCopyトレイトを持っているので別の変数をアサインするとコピーが走ってそれぞれの変数の更新などは所有権をあまり意識せずに操作することができるのは前記事などで触れましたが、一方てstructなどの構造体はCopyトレイトを持っておらず記述によってはエラーになります。

```rust:エラーになる例
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let mut point_1: Point = Point { x: 100, y: 200 };
    let mut point_2: Point = point_1;
    point_1.x = 300;
}
```

```
error[E0382]: assign to part of moved value: `point_1`
 --> src\main.rs:9:5
  |
7 |     let mut point_1: Point = Point { x: 100, y: 200 };
  |         ----------- move occurs because `point_1` has type `Point`, which does not implement the `Copy` trait
8 |     let mut point_2: Point = point_1;
  |                              ------- value moved here
9 |     point_1.x = 300;
  |     ^^^^^^^^^^^^^^^ value partially assigned here after move
```

こういったケースに`#[derive(Clone, Copy)]`という記述をデコレーターのようにstructに追加することでCopyトレイトを持つ形となってエラー無く扱うことができます。

```rust
#[derive(Clone, Copy)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let mut point_1: Point = Point { x: 100, y: 200 };
    let mut point_2: Point = point_1;
    point_1.x = 300;
    println!("{}", point_1.x);
    println!("{}", point_2.x);
}
```

```
300
100
```

`derive`マクロはRustの標準ライブラリのCopyなどのトレイトの実装を自動生成する属性マクロ・・・といった挙動をするようです。Pythonのデコレーターも最初とっつきにくかったですが慣れたら非常に便利だったため、この辺のマクロも将来必要になってきたら深堀りして勉強していこうと思います。

# 参考文献・参考サイトなど

https://www.amazon.com/Speed-Your-Python-Rust-performance/dp/180181144X/

https://keens.github.io/blog/2018/02/17/makurokurabu_rustshibu/

https://zenn.dev/a24k/articles/20221113-wasmple-define-macros

https://qiita.com/k5n/items/758111b12740600cc58f