Rust から Misskey を扱うためのライブラリを書いた

なぜ Rust で書くのか

というわけで動機の一部に Rust を使ってもらいたいというのがあるので、ここで Rust の宣伝を挟みます⁸。Rust とはどういうプログラミング言語なのか、公式の本の日本語訳から引用してみます。

Rust プログラミング言語は、高速で信頼できるソフトウェアを書く手助けをしてくれます。 高レベルのエルゴノミクス(訳注: ergonomics とは、人間工学的という意味。砕いて言えば、人間に優しいということ)と低レベルの制御は、 しばしばプログラミング言語の設計においてトレードオフの関係になります; Rust は、その衝突に挑戦しています。バランスのとれた強力な技術の許容量と素晴らしい開発者経験を通して、 Rust は伝統的にそれらの制御と紐付いていた困難全てなしに低レベルの詳細(メモリ使用など)を制御する選択肢を与えてくれます。

https://doc.rust-jp.rs/book-ja/ch00-00-introduction.html

Rust はしばしば書いていてしんどい⁹んじゃあないかとか、学習が大変¹⁰そうだとかいう認識を持たれます。 しかし実際のところ、上に書いてあるとおり Rust の大きな特徴は人間に優しい点にあります。

Rust の Web サイトで「パフォーマンス」と「信頼性」に並んで掲げられているのが「生産性」です。

Rust には優れたドキュメント、有用なエラーメッセージを備えた使いやすいコンパイラ、および統合されたパッケージマネージャとビルドツール、多数のエディタに対応するスマートな自動補完と型検査機能、自動フォーマッタといった一流のツール群が数多く揃っています。

https://www.rust-lang.org/ja/

開発者体験を上げることが、Rust の目的の 1 つとして強く意識されています。

Rust の特徴としてよく知られている信頼性や速度というのは Misskey の bot には必要ない場合がほとんどです。 正直なところ Misskey の bot を書くのに最適なプログラミング言語が Rust かと言われれば微妙なのです。 しかし最適ではなくても Rust で書こうとする理由はここにあって¹¹、Rust はとことん人に優しい作りをしているのでコードを書いている体験が非常に良い。

たとえば Rust のコンパイラ rustc はエラーメッセージが非常に親切です。 よく難しいと言われる所有権に関係するエラーを出させてみるとこんな感じ:

error[E0382]: borrow of moved value: `x`
 --> src/main.rs:5:20
  |
2 |     let x = "hello".to_string();
  |         - move occurs because `x` has type `String`, which does not implement the `Copy` trait
3 |     println!("{}", x);
4 |     let y = x;
  |             - value moved here
5 |     println!("{}", x);
  |                    ^ value borrowed here after move

どうですか？ 用語の意味はともかくめちゃめちゃ丁寧に説明してくれるし、直し方を考えるための手がかりもたくさんあります。 少なくとも「moved な値を borrow するのはエラーで、ここでは四行目で move された x を五行目で利用しようとしたがそれはできない」までは容易に読み取れると思います。なので対策としては四行目で move しないようにする…！と進んでいけるわけです。

もっと簡単な例だと、直し方を教えてくれることがあります。

error[E0596]: cannot borrow `x` as mutable, as it is not declared as mutable
 --> src/main.rs:3:5
  |
2 |     let x = vec![1];
  |         - help: consider changing this to be mutable: `mut x`
3 |     x.push(1);
  |     ^ cannot borrow as mutable

help: consider changing this to be mutable として直し方を教えてくれています。優しい…

別の例として、Clippy というツールがあります。 新しいプログラミング言語を学ぶ際、コード規約とか文化とかを理解するのには時間がかかるのでしんどいですよね。 Clippy はそういうのを自動で見つけて指摘・たまに自動修正してくれるツールです。 と書いたのですがつまりは少し頭のよい linter です… しかし、こういうものを公式が開発しているというのはおそらく特筆すべき点で、開発者体験を向上しようとする姿勢がよく表れていると思います。

それに、見方を変えれば Rust の「信頼性」というのも人間への優しさなのです。 Rust の信頼性というのが何を言っているかというと「コンパイルが通ったプログラムはある程度よい振る舞いをする」みたいなもので、よい振る舞いというのは具体的にはデータ競合が起きないとかヌルポが起きないとかそういうやつです。 つまり言い方を変えると、よくない振る舞いをするプログラムはコンパイルさせない¹²というわけです。 人がミスをしてしまってもコンパイラがミスを見つけてくれるのは優しさっぽいですね。 テストを書くまでもなく¹³コンパイルする時点で様々なバグが見つかるなら、それはとてもいいことだと思いませんか？

Rust の学習を始めるための資料を付録１に置いたので、興味を持ってくれたらぜひそちらも見てみてくださいね！

タイムラインを流す

まず、最初にやったみたいに Cargo.toml の [dependencies] セクションに下の行を追加します。

futures = "0.3"

futures は Rust の非同期エコシステムの中心にいるクレートで、今回はストリームを扱うために必要となります。

use futures::stream::TryStreamExt;
use misskey::prelude::*;
use misskey::WebSocketClient;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = WebSocketClient::builder("wss://your.instance.example/streaming")
        .token("API_TOKEN")
        .connect()
        .await?;

    let mut notes = client.home_timeline().await?;

    while let Some(note) = notes.try_next().await? {
        if let Some(text) = &note.text {
            println!("@{}: {}", note.user.username, text);
        }
    }

    Ok(())
}

実行して待っていると、ホームタイムラインの投稿がターミナルに流れてくるはずです 🎉

さて、今回も少しづつ紐解いていきます。 main まではさっきまでとほぼ同じなので大丈夫ですね。

let client = WebSocketClient::builder("wss://your.instance.example/streaming")
    .token("API_TOKEN")
    .connect()
    .await?;

う〜ん。さっきの例と違って WebSocketClient を使っています。 WebSocketClient は先程登場した HttpClient と違ってリアルタイムでイベントを受信するような使い方ができます。 ストリーミングと言うとわかりやすいかもしれません。 今回の例はタイムラインの投稿をリアルタイムで取得するのが目的なので、WebSocketClient を使う必要があります³⁸。

WebSocketClient はその名前の通り WebSocket という技術³⁹で Misskey インスタンスと通信を行います。 さっき使った HttpClient は「必要になったときに接続する」スタイルだったのに対し、WebSocketClient（というか WebSocket）は「最初に接続してその接続をずっと使う」スタイルを取ります。 そのため WebSocketClient を作る段階で接続をやる必要があり、ここでさっきと違って connect だとか await だとかがあるのはそれです。 connect で接続をし、接続は非同期関数なので await し、接続は失敗しうるので ? でエラーだったら返します。

let mut notes = client.home_timeline().await?;

ここでは home_timeline メソッド⁴⁰を使い、ホームタイムラインの投稿をリアルタイムに取得するストリームを作っています。 正確にはこのメソッドはホームタイムラインに接続して⁴¹おり、その接続というのは時間がかかるので非同期関数です。 なので await しており、接続は失敗する可能性があるので例のごとく ? でエラーを返してやります。

これで notes 変数がホームタイムラインのストリームになりました。 let mut の mut は今後 notes 変数の状態を変更しうるという印です。 ストリームから値を取り出すのはストリームの状態を変更することになるため、あとで値を取り出すためにここでは mut にしてあります^{42 43}。

while let Some(note) = notes.try_next().await? {
  ...
}

なんか難しい風ですね。実際これはちょっと深いことを言っている。

右にいる notes.try_next().await? から見ていきましょうか。 これは notes の try_next というメソッドを呼んでいる。 あれっ notes の型ってなんだっけ…いままで「ストリーム」という曖昧な呼び方をしていましたが、これは Stream トレイトを実装している型⁴⁴です。 いやトレイトってなんやねんというのはいったん置いておいてその事実だけを書いておき、実用上の問題としては notes には TryStreamExt と StreamExt に書いてあるメソッドが使えます⁴⁵。 そして try_next は TryStreamExt のメソッドです。なるほど！

try_next はストリームから次の要素を取り出す非同期関数で、これまた Result を返します。 なのでまた await して ? でエラーを剥ぐ…このパターンが定番になってきましたね。 これで右側 notes.try_next().await? が何をやっているかはわかったと思います。

さて、一般的にストリームというのは終わることがあって⁴⁶、そのため try_next ももしかしたら返す値がない可能性があります。 他の言語ではこういう“ない”可能性がある値を nullable だとか optional みたいに呼ばれる概念で扱うことがありますが、Rust では Option<T> という普通の型を持つ普通の値で、こういった“ない”可能性がある値を表します。 そういうわけで notes.try_next().await? は Option<Note> という型を持っています。Note がある場合とない場合があるといった感じです。

次の while let Some(note) = ... の部分はこの“あるかないか型” Option と密接に関わってきます。 まず皆さんおなじみ、JavaScript などで while (<なんか式>) { <たくさんの文> } と書くと <なんか式> が true ⁴⁷である間ずっと <たくさんの文> を繰り返し実行するという意味合いになるという認識があると思います。 Rust の while もほとんど同じです。しかし while let は実行を続ける条件が少し普通の while と違います。 Rust で while let <パターン> = <なんか式> { <たくさんの文> } と書くと、<なんか式> が⁴⁸ <パターン> にマッチする間ずっと <たくさんの文> を繰り返します。 ここでは <パターン> の部分に Some(note) というのがありますね。Some というのは“ある”場合のことで、あるので Note 型の note が取り出せています。 一方で“ない”場合は None というの⁴⁹になり、その場合はこの Some(note) というパターンにマッチしない。 なので while let のループはそこで終了…という理屈で、「notes ストリームが値を返す間ずっと繰り返す」になっています。

う〜んとはいえパターンマッチとかの説明はここでカバーするにはデカすぎる。 釈然としない場合は本の該当章とか Option について書いてある部分を見てもらえると理解が深まると思います。

では次に進みます。 理解を深めなくても次に進むことはできるので次に進んでしまいましょう。

if let Some(text) = &note.text {
  ...
}

if let はさっき出てきた while let の if 版みたいな感じで、パターンにマッチした場合実行するといった感じでしょうか。 右側ではまずノートのテキストを note.text で取ってきます。 note は Note 型です。いろいろなフィールドがありますね。text もその 1 つです。 ノートにはテキストがない場合があり⁵⁰、そのため note.text は Option<String> 型、すなわち実際にはテキストが入っていない場合 None と入っている場合 Some(text) の二通りがあります。 ここでは if let で Some(text) だった場合にのみ中身を実行しています。

&note.text の & は、note の所有権を奪わないようにつけています。出たよ所有権。 Rust の世界ではそれぞれの値に所有権を持つ変数がただ 1 つ存在することになっています。 そして値を渡すようなこと（代入とか関数の引数に渡すとか、ここではパターンマッチ）を普通にやると（ここでは text に、部分的に note の）所有権を渡すことになります。 しかし「所有権を持つ変数がただ 1 つ」だったので、所有権を渡してしまったらその後で元の変数（ここでは note）はもはや所有権を失い使うことができなくなってしまいます。 もう一度使うためには所有権を返してもらう必要がありますが、毎回渡して返してをやるのは面倒なので Rust には借用という概念があります。 これは所有権を渡さずにもとの値へのアクセスを得るための方法で、借用を渡せば所有権は元の変数に残り続けます。 一方で借用の側からも値にアクセスすることができて、いい話という感じですね。 その借用を作るために & を使っています。 つまり今回の例では note を今後も使いたいので note の借用に対してパターンマッチをすることで note の所有権を奪われないようにしているためにこういう書き方になっており、なので text 変数は note の中のテキストを借りているという状態になっています。

println!("@{}: {}", note.user.username, text);

さて、中身です。 println! は何？println はターミナルに文字列を出力します。 ここではノートを投稿した人のユーザーネームとさっき取り出したテキストを出力しています。 println! の記法は左の文字列の {} の部分が順番に右の引数で埋められていく感じです⁵¹。

自動フォローバック

ひえ〜大変だ、なんだか説明がたいへんに長くなってしまった…でもあとはほとんど同じ概念の使い回し！

今度は bot 定番のフォローされたら自動でフォロバする機能を実装してみます。

use futures::stream::TryStreamExt;
use misskey::prelude::*;
use misskey::streaming::channel::main::MainStreamEvent;
use misskey::WebSocketClient;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = WebSocketClient::builder("wss://your.instance.example/streaming")
        .token("API_TOKEN")
        .connect()
        .await?;

    let mut stream = client.main_stream().await?;

    while let Some(event) = stream.try_next().await? {
        if let MainStreamEvent::Followed(user) = event {
            println!("followed from @{}", user.username);

            if !client.is_following(&user).await? {
                client.follow(&user).await?;
            }
        }
    }

    Ok(())
}

さっきと雰囲気が似ていますね！

let mut stream = client.main_stream().await?;

ふむ、今度は main_stream 関数で “main stream” というやつのストリームを取ってきているらしい… “main stream” というのが何なのか僕も正直詳しくは知らないんですが、ここにはアカウントに関するイベント⁵²が流れてきます。

while let Some(event) = stream.try_next().await? {
  ...
}

これはさっきとほぼ同じです。 取ってきているものがノートではなくて main stream に流れてくるイベントなので変数名を event にしてみました。 event の型は MainStreamEvent で、そのドキュメントにはどんなイベントが発生しうるのかが列挙されています。

if let MainStreamEvent::Followed(user) = event {
  ...
}

今回はフォローされたときに反応したいので、Followed イベントに注目します。 先程出てきた if let を用いて、 event が Followed だったときのみ中身を実行するようにしています。

println!("followed from @{}", user.username);

中身その１。フォローされましたっていうログを出しています。（ログを出すのが好きなので）

if !client.is_following(&user).await? {
    client.follow(&user).await?;
}

中身その２。 ClientExt の is_following 関数でフォローしてきたユーザー user を自分がフォローしているかどうかを判定しています。 & をつけて借用を渡しているのは今後も user を使いたいからです。 もしフォローしていなかったら、次に follow 関数で user をフォローします。 これでフォローバック完了です。

チャットボット

勢いがついてきましたか？私は勢いがついています！ 今度はメンションに反応して返信する簡単なチャットボットを作ってみます！よろしくおねがいします！よろしくおねがいします！

use futures::stream::TryStreamExt;
use misskey::prelude::*;
use misskey::streaming::channel::main::MainStreamEvent;
use misskey::WebSocketClient;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = WebSocketClient::builder("wss://your.instance.example/streaming")
        .token("API_TOKEN")
        .connect()
        .await?;

    let mut stream = client.main_stream().await?;

    while let Some(event) = stream.try_next().await? {
        if let MainStreamEvent::Mention(note) = event {
            let text = match &note.text {
                Some(text) => text,
                None => continue,
            };

            if !text.contains("ping") {
                continue;
            }

            println!("got ping from @{}", note.user.username);
            client.reply(&note, "pong").await?;
        }
    }

    Ok(())
}

ワクワク！

if let MainStreamEvent::Mention(note) = event {
  ...
}

メンションされたときに反応したいので今回は Mention イベントだったときに中身を実行するようにしています。 note 変数にはメンションしてきたノートが Note 型で入っています。

let text = match &note.text {
    Some(text) => text,
    None => continue,
};

エッこれは何…⁵³ match は JavaScript とかの switch がすごく強力になった感じのもので、この例では note.text が取りうるパターン（つまり Some(text) か None の二通り）の全てに対して分岐を書いています。 そして Some(text) だったら text を返しそれが左側にいる let text = ... によって text 変数に代入される… None だったら continue、すなわち while の条件に戻って次のイベントを待ちます。

if !text.contains("ping") {
    continue;
}

文字列に対する⁵⁴ contains メソッドでノートが "ping" という文字列を含んでいなかったら continue するようにしています。 つまり "ping" を含むメンションが来たら continue せずに次に進みます。

println!("got ping from @{}", note.user.username);
client.reply(&note, "pong").await?;

次です。 まずログを出した後⁵⁵、reply 関数を使って "pong" を返信しています。

やったー！

同時に動かす

いくつか個別に機能ができたら、それをたくさん組み合わせたくなりますね！ 今回作ってみた３つ、すなわち

• ホームタイムラインのノートをターミナルに出力
• フォローされたら自動フォローバック
• "ping" を含むリプライに "pong" を返す

を同時に動かしてみます。

その前段階として、それぞれの処理を関数に切り分けます。流石に全てが 1 つに入っているとデカすぎて大変なので… しかし様々な理由から同じクライアントで二度 main_stream や home_timeline を呼ぶことができないので^{56 57 58}、main_stream を使っている 2 つは同じ関数にまとめてやります。つまり、こう:

async fn events(client: &WebSocketClient) -> anyhow::Result<()> {
    let mut stream = client.main_stream().await?;

    while let Some(event) = stream.try_next().await? {
        match event {
            MainStreamEvent::Followed(user) => {
                println!("followed from @{}", user.username);

                if !client.is_following(&user).await? {
                    client.follow(&user).await?;
                }
            }
            MainStreamEvent::Mention(note) => {
                let text = match &note.text {
                    Some(text) => text,
                    None => continue,
                };

                if !text.contains("ping") {
                    continue;
                }

                println!("got ping from @{}", note.user.username);
                client.reply(&note, "pong").await?;
            }
            _ => {}
        }
    }

    Ok(())
}

ちょっと大きめですが⁵⁹、どうでしょうか。 いままで if let でやっていた部分を match で分岐して、 Followed だった場合と Mention だった場合にそれぞれ先程説明した処理を書いています。 最後の _ => {} で、その他の（Followed でも Mention でもない）イベントが飛んできたときに⁶⁰それを無視しています。 match は if let と違って event が取りうる全てのパターンを列挙する必要があるので、こうやって追加のケースが必要になる場合があります。

そしてもう 1 つ、ホームタイムラインのノートを出力するやつはこう:

async fn timeline(client: &WebSocketClient) -> anyhow::Result<()> {
    let mut notes = client.home_timeline().await?;

    while let Some(note) = notes.try_next().await? {
        if let Some(text) = &note.text {
            println!("@{}: {}", note.user.username, text);
        }
    }

    Ok(())
}

うん、こちらはスッキリしていますね。 2 つの関数で client は共有したいので引数で受け取るようになっています。なお、ここで WebSocketClient ではなくて &WebSocketClient を受け取っているのは、クライアントの所有権を渡したくないからです。この 2 つは同時に実行したいので、両方に所有権を渡そうとすると所有者が二人いることになってしまいそれは不可能です。しかしこのように & で借用を受け取ることによって複数の場所から同時に参照することができています⁶¹。

では events 関数と timeline 関数を呼び出しましょう！！ワクワク！ しかし、かなしいことにこれらを順番に呼び出しても予期した動作になりません。

// これはうまく行かないコード
#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = WebSocketClient::builder("wss://your.instance.example/streaming")
        .token("API_TOKEN")
        .connect()
        .await?;

    // ↓これは終わらないので…
    events(&client).await?;
    // ↓ここには到達しない！
    timeline(&client).await?;

    Ok(())
}

このように書いても events は終わらない⁶²（イベントが来なくなるということはないので、ずっとイベントを待ち続ける）ので、events は実行されますが timeline は実行されることはありません！そんな…

ということで今私たちがほしいのは、2 つの非同期関数を同時に await する機能です。それは join と呼ばれていて、futures クレートに実装されています！ 具体的には、こう:

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = WebSocketClient::builder("wss://your.instance.example/streaming")
        .token("API_TOKEN")
        .connect()
        .await?;

    // 同時に await！
    futures::try_join!(main_stream(&client), timeline(&client))?;

    Ok(())
}

ここでは try_join を使っています。 単純に join をすると両方の処理が終わるまで待機ということになるのですが、実際に欲しい挙動は「両方の処理が正常に終わるかどちらかがエラーを返したら終了」です。 try_join はまさにその挙動を実現してくれます。 そしてどちらかがエラーを返したときのためにこれは Result を返すため、最後に ? をつけています。 なお try_join はマクロで⁶³、マクロは引数の数が決まっていないので⁶⁴他に同時にやりたい非同期関数が出てきても引数に追加していけば動きます。