MENU
  1. ホーム
  2. Rust
  3. RustとTokioで非同期処理を組み込んだCLIツールを作成する完全ガイド

RustとTokioで非同期処理を組み込んだCLIツールを作成する完全ガイド

Rust

RustとTokioを使用することで、高速で効率的な非同期処理を持つCLIツールを開発できます。非同期処理は、長時間かかるI/O操作（ファイル読み込み、ネットワーク通信など）を待つ間に他のタスクを実行できるため、パフォーマンスが向上します。

Rustは安全性とパフォーマンスを両立するシステムプログラミング言語として人気があり、Tokioはその非同期ランタイムとして広く利用されています。本記事では、RustとTokioを組み合わせて非同期処理を取り入れたCLIツールを開発する手順を詳しく解説します。

非同期処理の基本概念から始め、Tokioの導入方法、非同期関数の書き方、並行処理の実装、さらにはパフォーマンス向上のテクニックまで順を追って説明します。RustでCLIツールを開発する際に非同期処理を組み込むことで、効率的でレスポンスの良いアプリケーションを作成できるでしょう。

目次

Rustの非同期処理とTokioの概要

Rustはシステムプログラミング言語でありながら、非同期処理を安全かつ効率的にサポートする特徴があります。非同期処理を導入することで、ブロッキングI/Oを回避し、タスクの並行実行が可能になります。

非同期処理とは

非同期処理とは、あるタスクを待機している間に他のタスクを同時に実行する処理方法です。例えば、ネットワークからデータを取得する間に、別の計算タスクを進めることができます。これにより、アプリケーションの応答性が向上し、リソースの効率的な利用が可能になります。

Tokioとは

Tokioは、Rust用の非同期ランタイムライブラリです。非同期タスクのスケジューリング、I/O操作、タイマー、ネットワーク通信などを提供します。Tokioはasync/await構文と組み合わせることで、非同期コードを簡潔に書くことができます。

Tokioの主な特徴

  1. マルチスレッド対応
    Tokioは複数のスレッドでタスクを並行実行し、システムのパフォーマンスを最大限に引き出します。
  2. 豊富な機能
    非同期I/O、TCP/UDP通信、タイマー、タスクのスケジューリングなど、非同期プログラミングに必要な機能を網羅しています。
  3. 高いパフォーマンス
    非同期タスクを効率的に処理するため、リソースの無駄を最小限に抑えます。

非同期処理の基本構文

Rustで非同期処理を行うには、asyncとawaitのキーワードを使用します。

use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
    println!("開始");
    sleep(Duration::from_secs(2)).await;
    println!("2秒待機後に実行");
}

このコードでは、sleep関数が2秒間待機し、その間に他のタスクを実行できる状態になります。非同期処理を効率的に利用することで、CLIツールの応答性を高めることが可能です。

非同期CLIツール開発の準備

Rustで非同期処理を組み込んだCLIツールを開発するには、いくつかのステップで環境構築と必要なクレートの導入を行う必要があります。以下の手順に従って準備を進めましょう。

1. Rustのインストール

まずはRustをインストールします。Rustの公式ツールチェーン管理ツールであるrustupを使用します。以下のコマンドを実行してください。

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

インストールが完了したら、Rustのバージョンを確認します。

rustc --version

2. プロジェクトの作成

Cargoを使って新しいRustプロジェクトを作成します。

cargo new async_cli_tool
cd async_cli_tool

3. 必要なクレートの追加

Cargo.tomlにTokioを追加し、非同期ランタイムとして設定します。Cargo.tomlを以下のように編集します。

[dependencies]
tokio = { version = "1", features = ["full"] }
clap = { version = "4", features = ["derive"] }
  • Tokio：非同期ランタイムで、I/Oやタスクスケジューリングをサポートします。
  • Clap：CLI引数をパースするためのライブラリです。

4. #[tokio::main]の確認

非同期関数のエントリーポイントを指定するために、#[tokio::main]アトリビュートを使用します。src/main.rsを以下のように書き換えます。

use clap::Parser;

/// 非同期CLIツールの説明
#[derive(Parser)]
struct Args {
    /// サンプル引数
    #[arg(short, long)]
    input: String,
}

#[tokio::main]
async fn main() {
    let args = Args::parse();
    println!("入力値: {}", args.input);
}

5. プロジェクトのビルドと実行

以下のコマンドでプロジェクトをビルドし、実行します。

cargo run -- --input "テストデータ"

開発準備の確認

上記の手順が完了すれば、非同期処理を組み込んだCLIツールを開発するための基本的な環境が整いました。次のステップでは、Tokioを使った具体的な非同期処理の実装を進めていきます。

Tokioのインストールと設定

Tokioを使用してRustで非同期処理を行うためには、プロジェクトにTokioクレートをインストールし、適切に設定する必要があります。以下の手順で進めましょう。

1. Cargo.tomlにTokioを追加

Cargo.tomlファイルにTokioクレートを追加します。fullフィーチャーを指定することで、Tokioが提供するすべての機能を利用できます。

[dependencies]
tokio = { version = "1", features = ["full"] }

フィーチャーの概要

  • full：Tokioのすべての機能（I/O、マルチスレッド、タイマー、ネットワークなど）を含みます。
  • カスタムフィーチャー：必要に応じて、個別にフィーチャーを指定することも可能です。例えば、シンプルな用途にはrt（ランタイム）やmacros（マクロサポート）だけを追加することができます。

2. 非同期ランタイムの設定

main関数でTokioのランタイムを使うために、#[tokio::main]アトリビュートを追加します。これにより、非同期関数をエントリーポイントとして使えるようになります。

src/main.rsの例

use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
    println!("非同期処理を開始します...");
    sleep(Duration::from_secs(2)).await;
    println!("2秒後に処理が完了しました。");
}

3. #[tokio::main]の動作説明

  • #[tokio::main]は、非同期関数を同期関数として実行できるようにします。
  • 非同期処理がエントリーポイントの中で記述されている場合、Tokioが非同期タスクを管理し、実行します。

4. ビルドと実行

以下のコマンドでビルドし、非同期処理が正しく動作するか確認します。

cargo run

出力結果の例

非同期処理を開始します...
（2秒待機）
2秒後に処理が完了しました。

5. その他のTokioランタイムアトリビュート

用途に応じて、以下のような異なるランタイムアトリビュートも使用できます。

  • #[tokio::main(flavor = "multi_thread")]
    マルチスレッドランタイムでタスクを並行処理します。
  • #[tokio::main(flavor = "current_thread")]
    シングルスレッドランタイムでタスクを順次実行します。

まとめ

これでTokioをインストールし、Rustプロジェクトで非同期ランタイムを設定する準備が整いました。次のステップでは、非同期関数やawaitの具体的な使い方を解説します。

非同期関数とawaitの使い方

Rustにおける非同期プログラミングでは、asyncキーワードを使って非同期関数を定義し、awaitキーワードで非同期タスクの完了を待つことができます。ここでは、非同期関数の定義方法とawaitの基本的な使い方を解説します。

非同期関数の定義

非同期関数を定義するには、asyncキーワードを関数の前に付けます。

async fn fetch_data() {
    println!("データを取得しています...");
}

この関数は即座に結果を返さず、非同期タスクとして処理をスケジュールします。

awaitで非同期関数を呼び出す

非同期関数を呼び出す際は、awaitキーワードを使ってその完了を待ちます。awaitを使うことで、タスクの結果が返るまで他の処理を並行して実行できます。

以下は、fetch_data関数を呼び出し、awaitで待つ例です。

use tokio::time::{sleep, Duration};

async fn fetch_data() {
    println!("データ取得開始...");
    sleep(Duration::from_secs(2)).await;
    println!("データ取得完了！");
}

#[tokio::main]
async fn main() {
    println!("処理開始");
    fetch_data().await;
    println!("処理終了");
}

出力結果

処理開始
データ取得開始...
（2秒待機）
データ取得完了！
処理終了

非同期ブロックの使い方

asyncブロックを使用することで、関数内で非同期処理を手軽に記述できます。

use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
    let handle = tokio::spawn(async {
        println!("非同期タスク開始...");
        sleep(Duration::from_secs(3)).await;
        println!("非同期タスク完了！");
    });

    println!("メイン関数の処理中...");
    handle.await.unwrap();
    println!("すべての処理が完了しました。");
}

出力結果

メイン関数の処理中...
非同期タスク開始...
（3秒待機）
非同期タスク完了！
すべての処理が完了しました。

非同期関数の返り値

非同期関数はResultやOption型の値を返すことができます。以下は、非同期関数がResultを返す例です。

use tokio::time::{sleep, Duration};

async fn fetch_data() -> Result<String, &'static str> {
    sleep(Duration::from_secs(2)).await;
    Ok("データ取得成功".to_string())
}

#[tokio::main]
async fn main() {
    match fetch_data().await {
        Ok(data) => println!("{}", data),
        Err(e) => eprintln!("エラー: {}", e),
    }
}

出力結果

データ取得成功

まとめ

  • 非同期関数はasyncキーワードで定義します。
  • awaitで非同期関数の完了を待ちます。
  • 非同期ブロックを使うことで、関数内でも非同期処理を書けます。
  • 非同期関数は通常の関数と同じように、値を返すことが可能です。

非同期処理を理解することで、RustのCLIツールに効率的な並行処理を組み込めるようになります。次は、簡単な非同期CLIツールの実装例を紹介します。

簡単な非同期CLIツールの実装例

ここでは、Tokioを使用して簡単な非同期処理を持つCLIツールを実装します。ツールの目的は、複数のURLから並行してデータを取得するシンプルなHTTPクライアントです。これにより、Rustの非同期処理とCLI引数のパース方法を学べます。

プロジェクトの準備

Cargo.tomlに必要な依存関係を追加します。

[dependencies]
tokio = { version = "1", features = ["full"] }
reqwest = { version = "0.11", features = ["json"] }
clap = { version = "4", features = ["derive"] }
  • Tokio：非同期ランタイム
  • Reqwest：HTTPクライアントライブラリ
  • Clap：CLI引数をパースするライブラリ

CLIツールのコード

以下のコードは、複数のURLを並行して取得し、レスポンスのステータスを表示する非同期CLIツールです。

src/main.rs

use clap::Parser;
use reqwest;
use tokio;
use std::time::Instant;

/// 簡単な非同期HTTPクライアントツール
#[derive(Parser)]
struct Args {
    /// 取得するURLリスト（スペース区切り）
    urls: Vec<String>,
}

#[tokio::main]
async fn main() {
    let args = Args::parse();
    let start_time = Instant::now();

    if args.urls.is_empty() {
        eprintln!("エラー: 少なくとも1つのURLを指定してください。");
        return;
    }

    let handles: Vec<_> = args.urls.into_iter().map(|url| {
        tokio::spawn(async move {
            match reqwest::get(&url).await {
                Ok(response) => println!("{}: {}", url, response.status()),
                Err(e) => eprintln!("{}: エラー - {}", url, e),
            }
        })
    }).collect();

    // すべてのタスクが完了するのを待つ
    for handle in handles {
        let _ = handle.await;
    }

    let duration = start_time.elapsed();
    println!("処理時間: {:.2?}", duration);
}

コードの解説

  1. CLI引数のパース
  • Args構造体でURLリストを受け取ります。clapで自動的に引数を解析します。
  1. 非同期HTTPリクエスト
  • reqwest::getを使用して各URLに非同期リクエストを送信します。
  1. 並行処理
  • tokio::spawnで複数の非同期タスクを並行して実行します。
  • 各タスクは独立して動作し、レスポンスが取得でき次第、ステータスを表示します。
  1. 処理時間の計測
  • std::time::Instantを使用して、全体の処理時間を計測します。

ビルドと実行

以下のコマンドでツールをビルドし、複数のURLを指定して実行します。

cargo run -- https://example.com https://httpbin.org/status/200 https://httpbin.org/status/404

出力例

https://example.com: 200 OK
https://httpbin.org/status/200: 200 OK
https://httpbin.org/status/404: 404 Not Found
処理時間: 1.23s

まとめ

この簡単な非同期CLIツールの例では、複数のHTTPリクエストを並行して処理し、各URLのステータスを表示しました。非同期処理を活用することで、効率的なCLIツールを開発できます。

次のステップでは、エラーハンドリングの方法について詳しく解説します。

エラーハンドリングの実装

非同期処理を伴うCLIツールでは、エラーハンドリングが重要です。ネットワーク通信の失敗や無効な入力に対して適切に対処することで、ツールの信頼性が向上します。ここでは、RustとTokioを使用した非同期処理におけるエラーハンドリングの方法を解説します。

基本的なエラーハンドリングの方法

Rustでは、エラーを処理するためにResult型やOption型を使用します。非同期関数でも同様に、Result型を使ってエラーを伝播できます。

非同期関数でResultを返す例

use tokio::time::{sleep, Duration};

async fn fetch_data(url: &str) -> Result<String, &'static str> {
    println!("{} からデータを取得中...", url);
    sleep(Duration::from_secs(2)).await;

    if url == "https://example.com" {
        Ok("データ取得成功！".to_string())
    } else {
        Err("データ取得に失敗しました")
    }
}

#[tokio::main]
async fn main() {
    match fetch_data("https://example.com").await {
        Ok(data) => println!("成功: {}", data),
        Err(e) => eprintln!("エラー: {}", e),
    }
}

非同期HTTPリクエストのエラーハンドリング

reqwestを使ったHTTPリクエストでは、ネットワークエラーやサーバーエラーが発生する可能性があります。以下の例では、reqwestでHTTPリクエストを行い、エラーを適切に処理します。

エラーハンドリング付きのHTTPリクエスト

use reqwest;
use tokio;

async fn fetch_url(url: &str) -> Result<(), reqwest::Error> {
    match reqwest::get(url).await {
        Ok(response) => {
            println!("{}: ステータスコード {}", url, response.status());
            Ok(())
        }
        Err(e) => {
            eprintln!("{}: リクエストエラー - {}", url, e);
            Err(e)
        }
    }
}

#[tokio::main]
async fn main() {
    let urls = vec![
        "https://example.com",
        "https://invalid-url.xyz",
    ];

    for url in urls {
        if let Err(e) = fetch_url(url).await {
            eprintln!("エラーが発生しました: {}", e);
        }
    }
}

エラーをthiserrorでカスタムエラー型にする

カスタムエラー型を使うと、エラーの種類に応じた処理がしやすくなります。thiserrorクレートを使用して、エラー型を定義しましょう。

Cargo.tomlに依存関係を追加

[dependencies]
thiserror = "1.0"
reqwest = { version = "0.11", features = ["json"] }
tokio = { version = "1", features = ["full"] }

カスタムエラー型の定義と使用

use reqwest;
use thiserror::Error;
use tokio;

#[derive(Error, Debug)]
enum FetchError {
    #[error("HTTPリクエストエラー: {0}")]
    RequestError(#[from] reqwest::Error),

    #[error("無効なURL: {0}")]
    InvalidUrl(String),
}

async fn fetch_data(url: &str) -> Result<(), FetchError> {
    if url.is_empty() {
        return Err(FetchError::InvalidUrl("URLが空です".to_string()));
    }

    let response = reqwest::get(url).await?;
    println!("{}: ステータスコード {}", url, response.status());
    Ok(())
}

#[tokio::main]
async fn main() {
    let url = "https://example.com";

    match fetch_data(url).await {
        Ok(_) => println!("データ取得成功！"),
        Err(e) => eprintln!("エラー: {}", e),
    }
}

ベストプラクティス

  1. 具体的なエラーメッセージ
    ユーザーにわかりやすいエラーメッセージを提供しましょう。
  2. エラーのログ出力
    重要なエラーはeprintln!やログクレートを使ってログに記録します。
  3. 適切なリトライ処理
    ネットワークエラー時には、リトライ処理を実装することで信頼性を向上させます。
  4. エラーの種類に応じた処理
    エラーの種類によって異なる対処を行うことで、柔軟なエラーハンドリングが可能になります。

まとめ

非同期CLIツールでのエラーハンドリングは、Result型やカスタムエラー型を活用することで効率的に実装できます。これにより、エラーが発生してもツールが適切に動作し、ユーザーに有用な情報を提供できるようになります。次は、非同期タスクの管理と並行処理について解説します。

非同期タスクの管理と並行処理

RustとTokioを使えば、非同期タスクを効率的に管理し、並行処理を行うことができます。非同期タスクを適切にスケジューリングすることで、複数の処理を同時に実行し、パフォーマンスを向上させることが可能です。

非同期タスクの生成とtokio::spawn

非同期タスクを生成するには、tokio::spawnを使います。これにより、新しいタスクが並行して実行されます。

基本例

use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
    let task1 = tokio::spawn(async {
        sleep(Duration::from_secs(2)).await;
        println!("タスク1が完了しました");
    });

    let task2 = tokio::spawn(async {
        sleep(Duration::from_secs(1)).await;
        println!("タスク2が完了しました");
    });

    task1.await.unwrap();
    task2.await.unwrap();

    println!("すべてのタスクが完了しました");
}

出力結果

タスク2が完了しました
タスク1が完了しました
すべてのタスクが完了しました

並行処理とjoin!

複数の非同期タスクを並行して実行し、それらがすべて完了するのを待つには、tokio::join!を使用します。

join!の例

use tokio::{time::{sleep, Duration}, join};

async fn task1() {
    sleep(Duration::from_secs(2)).await;
    println!("タスク1が完了しました");
}

async fn task2() {
    sleep(Duration::from_secs(1)).await;
    println!("タスク2が完了しました");
}

#[tokio::main]
async fn main() {
    join!(task1(), task2());
    println!("すべてのタスクが完了しました");
}

出力結果

タスク2が完了しました
タスク1が完了しました
すべてのタスクが完了しました

タスクのキャンセル

タスクの実行を途中でキャンセルしたい場合は、tokio::select!を使用します。

タスクキャンセルの例

use tokio::{time::{sleep, Duration}, select};

async fn long_task() {
    sleep(Duration::from_secs(5)).await;
    println!("長時間タスクが完了しました");
}

#[tokio::main]
async fn main() {
    let long_task_handle = tokio::spawn(long_task());

    select! {
        _ = long_task_handle => println!("タスクが完了しました"),
        _ = sleep(Duration::from_secs(2)) => println!("タイムアウト: タスクをキャンセルしました"),
    }
}

出力結果

タイムアウト: タスクをキャンセルしました

タスクのエラーハンドリング

非同期タスク内でエラーが発生する可能性がある場合、Result型でエラー処理を行います。

エラーハンドリング付きタスク

use tokio::fs::File;
use tokio::io::{self, AsyncReadExt};

async fn read_file(path: &str) -> io::Result<String> {
    let mut file = File::open(path).await?;
    let mut contents = String::new();
    file.read_to_string(&mut contents).await?;
    Ok(contents)
}

#[tokio::main]
async fn main() {
    match read_file("example.txt").await {
        Ok(contents) => println!("ファイル内容:\n{}", contents),
        Err(e) => eprintln!("エラー: {}", e),
    }
}

ベストプラクティス

  1. 適切な並行処理
  • 不必要にタスクを並行実行しないように注意しましょう。並行処理はリソースを効率よく使うために有効ですが、過剰な並行実行はパフォーマンス低下を招きます。
  1. エラーハンドリング
  • 非同期タスク内で発生するエラーを適切に処理し、パニックを避けましょう。
  1. タスクのキャンセルとタイムアウト
  • 長時間かかるタスクにはキャンセルやタイムアウト処理を導入して、システムの応答性を維持しましょう。
  1. リソース管理
  • ファイルやネットワークリソースを使用する場合は、タスク完了時に適切にリソースを解放するように心がけましょう。

まとめ

非同期タスクの管理と並行処理を理解することで、Rustで効率的なCLIツールを構築できます。次のステップでは、パフォーマンス向上のテクニックについて解説します。

パフォーマンス向上のテクニック

非同期処理を組み込んだRustのCLIツールで効率的なパフォーマンスを実現するには、いくつかの最適化テクニックがあります。Tokioを活用しつつ、リソース管理やタスクの最適化を行うことで、より高速で信頼性の高いツールを構築できます。

1. 非同期タスクの適切な並行処理

大量のタスクを並行実行する場合、リソースの枯渇を防ぐためにタスクの数を制限します。

tokio::sync::Semaphoreを使った並行タスクの制限

use tokio::sync::Semaphore;
use tokio::time::{sleep, Duration};
use std::sync::Arc;

#[tokio::main]
async fn main() {
    let semaphore = Arc::new(Semaphore::new(3)); // 最大3つのタスクを同時実行
    let urls = vec![
        "https://example.com",
        "https://rust-lang.org",
        "https://tokio.rs",
        "https://github.com",
        "https://crates.io",
    ];

    let handles: Vec<_> = urls.into_iter().map(|url| {
        let permit = semaphore.clone().acquire_owned();
        tokio::spawn(async move {
            let _permit = permit.await;
            println!("{} の取得開始", url);
            sleep(Duration::from_secs(2)).await;
            println!("{} の取得完了", url);
        })
    }).collect();

    for handle in handles {
        handle.await.unwrap();
    }

    println!("すべてのタスクが完了しました");
}

2. タイムアウトの設定

タスクが長時間ブロックしないように、タイムアウトを設定します。

tokio::time::timeoutの使用

use tokio::time::{timeout, Duration, sleep};

#[tokio::main]
async fn main() {
    let result = timeout(Duration::from_secs(3), async {
        sleep(Duration::from_secs(5)).await;
        "処理完了"
    }).await;

    match result {
        Ok(message) => println!("{}", message),
        Err(_) => println!("タイムアウトしました"),
    }
}

3. バッチ処理の活用

大量のタスクを1つずつ処理するのではなく、バッチ処理でまとめて処理することで効率を向上させます。

use tokio::time::{sleep, Duration};

async fn process_batch(batch: Vec<&str>) {
    for item in batch {
        println!("{} を処理中...", item);
        sleep(Duration::from_secs(1)).await;
    }
}

#[tokio::main]
async fn main() {
    let items = vec!["タスク1", "タスク2", "タスク3", "タスク4"];
    let batch_size = 2;

    for batch in items.chunks(batch_size) {
        process_batch(batch.to_vec()).await;
    }

    println!("すべてのバッチ処理が完了しました");
}

4. 効率的なI/O処理

非同期I/O処理を行う際は、ブロッキングI/Oを避け、非同期I/Oを利用しましょう。reqwestやtokio::fsを使うことで非同期I/Oが可能です。

非同期ファイル読み書き

use tokio::fs::File;
use tokio::io::{self, AsyncWriteExt};

#[tokio::main]
async fn main() -> io::Result<()> {
    let mut file = File::create("output.txt").await?;
    file.write_all(b"非同期ファイル書き込み").await?;
    println!("ファイル書き込みが完了しました");
    Ok(())
}

5. タスクのリトライ処理

ネットワークエラーなど一時的な問題に対応するため、リトライ処理を実装します。

リトライの例

use tokio::time::{sleep, Duration};

async fn fetch_with_retry(retries: u32) {
    for attempt in 1..=retries {
        println!("試行 {}...", attempt);
        if attempt == retries {
            println!("最終試行に失敗しました");
            return;
        }
        sleep(Duration::from_secs(2)).await;
    }
}

#[tokio::main]
async fn main() {
    fetch_with_retry(3).await;
}

6. ログの導入

パフォーマンスの問題を特定するために、logやenv_loggerを使ってログを記録します。

Cargo.tomlに追加

[dependencies]
log = "0.4"
env_logger = "0.10"

コード例

use log::{info, warn};
use env_logger;

fn main() {
    env_logger::init();
    info!("アプリケーションを開始しました");
    warn!("警告: 何か問題が発生する可能性があります");
}

まとめ

非同期CLIツールのパフォーマンスを向上させるためには、タスクの並行処理、タイムアウトの設定、バッチ処理、効率的なI/O、リトライ処理、そしてログの活用が重要です。これらのテクニックを組み合わせることで、高速かつ信頼性のあるツールを開発できます。

次は、本記事の内容をまとめます。

まとめ

本記事では、RustとTokioを使って非同期処理を組み込んだCLIツールを開発する方法について解説しました。導入から始まり、非同期処理の基本概念、非同期関数とawaitの使い方、簡単な非同期CLIツールの実装、エラーハンドリング、タスクの管理と並行処理、そしてパフォーマンス向上のテクニックまで網羅しました。

非同期処理を活用することで、CLIツールはより効率的でレスポンスの良いアプリケーションになります。Tokioの強力なランタイムを活かし、タスクの並行実行やエラー処理を適切に行うことで、安定性とパフォーマンスを両立したツールを構築できるでしょう。

これらの知識を活用し、ぜひ実践的な非同期CLIツール開発に挑戦してみてください。

Rust
プログラミング 非同期処理 CLIツール Rust Tokio

コメント

コメントする

目次