Rust で GraphQL サーバーを建ててみた

# はじめに

普段のお仕事では JavaJava してる筆者です。
Rust が旬らしいので、試しに簡単な GraphQL サーバーを建ててみました。
基本的な機能はライブラリに頼りましたが、Rust の文法を一通り確認するにはちょうどいいように感じました。
~~GraphQL サーバー建てたいだけなら他の言語の方がいい。~~

最終的なコードは[こちら](https://github.com/igm50/rust-graphql-sample)。

## この記事の内容

- 開発環境構築(Docker)
- 開発中に引っかかった文法
- 使ってみた所感

## 開発環境構築(Docker)

ローカル死んでも汚したくないマンなので、Docker を使います。ちなみに筆者は MacBook Pro をそのまま使用しています。
普通にローカルのディレクトリをマウントすると、ビルドが死ぬほど遅くなります。ビルド時のファイル同期処理がボトルネックになっているようです。
Rust のビルドディレクトリは、デフォルト設定だとルートディレクトリ直下に置かれます。[噂によると](https://qiita.com/yuki_ycino/items/cb21cf91a39ddd61f484)Docker for Mac の場合、マウントしたファイルの同期がかなり遅いんだとか。

というわけで、[こちらの記事](https://qiita.com/yagince/items/077d209ecca644398ea3)を参考に Dockerfile を作成しましょう。

```dockerfile
FROM rust:1.41-buster

WORKDIR /usr/src/app

RUN USER=root cargo init --bin

ENV CARGO_TARGET_DIR=/tmp/target

COPY ./Cargo.toml Cargo.toml
COPY ./Cargo.lock Cargo.lock

RUN cargo build \
  && rm src/main.rs

EXPOSE 8000
```

`CARGO_TARGET_DIR`でビルドディレクトリを指定しています。ファイル同期を行わないディレクトリを指定してあげましょう。これだけで(対策前に比べると)かなりサクサクになります。
他にもいろいろ書いていますが、だいたい初回ビルドを行うためのものです。初回ビルドは依存ライブラリの影響でどうしても重くなるので、先にやっておこうということですね。

## 開発中に引っかかった文法

[TRPL](https://doc.rust-jp.rs/book/second-edition/)をしっかり読んでいれば引っかかることはないでしょう。

### サイズ不明なトレイトはスマートポインタに格納する

[TRPL のこのページ](https://doc.rust-jp.rs/book/second-edition/ch15-01-box.html)に書かれている内容です。

Rust では一部の文脈において、対象のサイズをコンパイル時に特定できている必要があります。
具体的に言うと、以下の記述は怒られます。

```rust
trait Shape {
    fn area(&self) -> f32;
}

fn print_area(s: dyn Shape) { // `s` doesn't have a size known at compile-time
    println!("{}", s.area());
}
```

`Shape`は[トレイト(Java でいうインターフェースのようなもの)](https://doc.rust-jp.rs/book/second-edition/ch10-02-traits.html)なので、定義した段階ではそのサイズは不明です。底辺と高さをフィールドに持つ三角形かもしれませんし、半径のみを持つ円形かもしれません。
そのため、コンパイル時にはサイズが判断できず、エラーとなります。

というわけで、[Box](https://doc.rust-lang.org/std/boxed/struct.Box.html)を使いましょう。

```rust
trait Shape {
    fn area(&self) -> f32;
}

fn print_area(s: Box<dyn Shape>) {
    println!("{}", s.area());
}
```

Box に格納されたデータはヒープに配置されます。Box 自身はシンプルなスマートポインタなので、格納するデータに寄らず、サイズは常に一定です。
また、Box には[`Deref`トレイト](https://doc.rust-jp.rs/book/second-edition/ch15-02-deref.html)が実装されているため、普通の参照と変わらない感覚で操作することができます。

このように、サイズ不定なトレイトはスマートポインタに格納することで疑似的にサイズ特定可能になります。
Box 以外にも Rc や [Arc](https://qiita.com/qnighy/items/4bbbb20e71cf4ae527b9)等があるため、そちらもチェックしておくといいでしょう。

### ?演算子

[TRPL のこのページ](https://doc.rust-jp.rs/book/second-edition/ch09-02-recoverable-errors-with-result.html)に書かれている内容です。

Rust には[Result 型](https://doc.rust-lang.org/std/result/enum.Result.html)があります。他の言語では Either とか呼ばれているやつですね。
失敗する可能性のある関数を定義するとき、正常なら戻り値を格納した`Ok`を、異常ならエラーなどを格納した`Err`を返却するようにしてあげる、等の使い方をします。
呼び出し側は Ok のときと Err のときの 2 通りを想定してあげなければなりません。

例えば、以下のようなコードがあるとします。

```rust
// a / b
fn div(a: f32, b: f32) -> Result<f32, String> {
    match b != 0.0 {
        true => Ok(a / b),
        false => Err(String::from("Divided by zero.")), // ゼロ除算はエラー
    }
}

// (a / b) + c
fn calculate(a: f32, b: f32, c: f32) -> Result<f32, String> {
    let rd = div(a, b);

    match rd {
        Ok(d) => Ok(d + c),
        Err(e) => Err(e), // ゼロ除算によるエラーはそのまま呼び出し元に渡す
    }
}
```

`div`は失敗するかもしれない関数であるため、結果に応じて処理を分岐させる必要があります。
必要な処理ではありますが、冗長に感じますね。

ここで`?`演算子を使ってあげましょう。`calculate`に注目です。

```rust
// a / b
fn div(a: f32, b: f32) -> Result<f32, String> {
    match b != 0.0 {
        true => Ok(a / b),
        false => Err(String::from("Divided by zero.")), // ゼロ除算はエラー
    }
}

// (a / b) + c
fn calculate(a: f32, b: f32, c: f32) -> Result<f32, String> {
    let d = div(a, b)?; // エラーの場合はここで処理を終了し、呼び出し元に渡す
    Ok(d + c)
}
```

一気に簡単になりましたね。
`?`演算子は Result 型が返り値である関数を呼び出す際に使えます。
呼び出した関数の戻り値がエラーだった場合、呼び出し元に返してくれます。正常だった場合はResult型を取っ払ってくれます。
エラーのもつ型と返却すべき型が異なる場合は、`from`トレイトが実装されている場合に限り自動で変換してくれます。

この通り、失敗するかもしれない関数を連続して呼び出すときには非常に便利です。
エラー時に内包する型は`std::error:Error`トレイトである場合が多いです。
トレイトのままでは扱いにくいので Box に格納します(`Result<Any, Box<Error>>`)。が、`Error -> Box<Error>`は`from`トレイトが実装されているため自動で行われます。超便利。

## 使ってみた所感

### コンパイラが厳格

Rust の開発ではものすごくコンパイラに怒られます。やれ所有権がおかしいだのサイズがわからんだの`dyn`つけ忘れてるだの……
一方で、実行時エラーはあまり起きませんでした（無いわけではない）。
コンパイラが厳格な分、実行がスムーズにいくのはありがたいですね。筆者のようにコンパイラと殴りあうのが楽しいエンジニアには向いているかと思います。

### 基本的なツールがそろっている

`Option`型や`Result`型が基本ライブラリとして実装されており、サポートする機能も備わっています。
また、ユニットテストについても追加のライブラリ無しに実行できるため、いちいちライブラリの選定や管理などに頭を使わずに済みます。
必要なものは最初から入っているのがとても便利に感じます。

### マクロはさっぱりわからない

Rust にはマクロの機能があります。今回利用した`actix-web`や`juniper`などのライブラリでも利用されていますね。
このマクロですが、中で何をやっているのか非常にわかりにくく感じました。

例えば[`juniper::graphql_object`](https://docs.rs/juniper/0.14.2/juniper/macro.graphql_object.html)マクロを見てみましょう。

<details><summary>juniper::graphql_object</summary><div>

```rust
macro_rules! graphql_object {
    (
        @generate,
        meta = {
            lifetimes = [$($lifetimes:tt,)*],
            name = $name: ty,
            ctx = $ctx: ty,
            main_self = $main_self: ident,
            outname = {$($outname: tt)*},
            scalar = {$($scalar:tt)*},
            $(description = $desciption: expr,)*
            $(additional = {
                $(interfaces = [$($interface:ty,)*],)*
            },)*
        },
        items = [$({
            name = $fn_name: ident,
            body = $body: block,
            return_ty = $return_ty: ty,
            args = [$({
                arg_name = $arg_name : ident,
                arg_ty = $arg_ty: ty,
                $(arg_default = $arg_default: expr,)*
                $(arg_description = $arg_description: expr,)*
                $(arg_docstring = $arg_docstring: expr,)*
            },)*],
            $(decs = $fn_description: expr,)*
            $(docstring = $docstring: expr,)*
            $(deprecated = $deprecated: expr,)*
            $(executor_var = $executor: ident,)*
        },)*],
    ) => { ... };
    (
        @parse_interfaces,
        success_callback = $success_callback: ident,
        additional_parser = {$($additional:tt)*},
        meta = {
            lifetimes = [$($lifetime:tt,)*],
            name = $name:ty,
            ctx = $ctxt: ty,
            main_self = $mainself: ident,
            outname = {$($outname:tt)*},
            scalar = {$($scalar:tt)*},
            $(description = $desciption: tt,)*
            $(additional = {
                $(interfaces = [$($_interface:ty,)*],)*
            },)*

        },
        items = [$({$($items: tt)*},)*],
        rest = [$($interface: ty),+]  $($rest:tt)*
    ) => { ... };
    (
        @parse_interfaces,
        success_callback = $success_callback: ident,
        additional_parser = {$($additional:tt)*},
        meta = { $($meta:tt)* },
        items = [$({$($items: tt)*},)*],
        rest = interfaces: $($rest:tt)*
    ) => { ... };
    (
        @parse,
        meta = {$($meta:tt)*},
        rest = $($rest:tt)*
    ) => { ... };
    (@$($stuff:tt)*) => { ... };
    (
        $($rest:tt)*
    ) => { ... };
}
```

えっと……何この……なに？

</div></details>

筆者のマクロ知識がひよこ未満なのが主原因ですが、難解ですね。
とはいえ、`vec!`をはじめとして上手くマクロを使えれば便利なことは間違いないようです。

## おわりに

Rust を触ったことで、ポインタやスタック・ヒープについて意識する機会ができ、勉強になりました。
また、コンパイラと殴り合うのは楽しいと再認識できました。~~たまに心折れるけど。~~

## 参考資料

[The Rust Programming Language](https://doc.rust-jp.rs/book/second-edition/)
[[Rust] docker コンテナにマウントしたディレクトリで build すると遅かった話し](https://qiita.com/yagince/items/077d209ecca644398ea3)
[DX を大幅に低下させる Docker for Mac を捨てて Mac 最速の Docker 環境を手に入れる](https://qiita.com/yuki_ycino/items/cb21cf91a39ddd61f484)
[Rust で DI(依存注入)する](https://qiita.com/tmtmtoo/items/5ce0166f09150d78c9ff)
[Rust の所有権まわりの基礎まとめ](https://qiita.com/koheimiya/items/f85d7fce21b37e593309)
[Rust チートシート](https://cheats.rs/)
[Rust のエラーまわりの変遷](https://qiita.com/legokichi/items/d4819f7d464c0d2ce2b8)
[Rust で Option 値や Result 値を上手に扱う](https://qiita.com/tatsuya6502/items/cd41599291e2e5f38a4a)
[Rust の?演算子](https://qiita.com/kanna/items/a0c10a0563573d5b2ed0)
[Rust の `Arc` を読む(1): Arc/Rc の基本](https://qiita.com/qnighy/items/4bbbb20e71cf4ae527b9)
[Rust のマクロを覚える](https://qiita.com/k5n/items/758111b12740600cc58f)
[実践クリーンアーキテクチャ](https://nrslib.com/clean-architecture/)