MENU
  1. ホーム
  2. Rust
  3. Rustで複数のコレクションの共通部分を取得する方法を徹底解説

Rustで複数のコレクションの共通部分を取得する方法を徹底解説

Rust

Rustのプログラミングでは、効率的なデータ操作が重要な要素の一つです。特に、複数のコレクション間の共通部分を取得する操作は、データのフィルタリングや分析においてよく利用されます。本記事では、Rustの標準ライブラリを活用したintersectionメソッドの基本から、カスタム実装を通じた高度なテクニックまでを徹底解説します。また、実用例やパフォーマンス向上のためのヒントも紹介します。この記事を通じて、Rustを使ったデータ操作の理解を深め、効率的なプログラムを書くためのスキルを習得しましょう。

目次

コレクションの共通部分とは


コレクションの共通部分とは、複数のデータ集合の中で、すべてのコレクションに共通して存在する要素を指します。たとえば、[1, 2, 3]と[2, 3, 4]という2つのコレクションがある場合、その共通部分は[2, 3]です。

Rustにおける共通部分の活用場面


Rustでは、以下のような場面でコレクションの共通部分を取得する操作が有用です：

  • データのフィルタリング: 必要なデータだけを抽出する際に利用できます。
  • 重複データの確認: 異なるコレクション間の重複要素を検出するために役立ちます。
  • 検索結果の精査: 複数条件を満たすデータを絞り込む場面で使用します。

コレクションの種類と共通部分操作


Rustでは、以下のようなコレクションに対して共通部分を求めることが可能です：

  • ハッシュセット: 高速で効率的な共通部分計算が可能です。
  • ベクトル: よりカスタマイズされた操作が必要な場合に便利です。
  • バイナリツリーやマップ: より高度なデータ構造にも対応できます。

Rustの標準ライブラリは、このような共通部分操作を簡単に実現するためのメソッドやトレイトを提供しており、効率的なデータ処理をサポートしています。

`intersection`メソッドの基本構文


Rustでは、intersectionメソッドを使用することで、簡単にコレクションの共通部分を取得することができます。このメソッドは主にHashSet型に実装されており、複数のセット間の共通要素を効率的に取得できます。

`intersection`の基本構文


以下は、intersectionメソッドの基本的な構文です：

use std::collections::HashSet;

fn main() {
    let set1: HashSet<_> = [1, 2, 3].iter().cloned().collect();
    let set2: HashSet<_> = [2, 3, 4].iter().cloned().collect();

    let intersection: HashSet<_> = set1.intersection(&set2).cloned().collect();
    println!("{:?}", intersection); // 出力: {2, 3}
}

構文の詳細

  1. intersection(&other):
    &otherには、共通部分を求めたいもう一つのHashSetを渡します。このメソッドはイテレータを返します。
  2. cloned():
    イテレータの値をコピーします。これにより、所有権を持った値の集合を生成できます。
  3. collect():
    イテレータを収集し、新しいHashSetや他のコレクションに変換します。

イミュータブルな操作


intersectionは元のコレクションを変更しないため、イミュータブルなデータ操作として利用できます。この特性により、安全性とデータの再利用性が向上します。

適用範囲

  • 集合演算: 共通部分、和集合、差集合などの基本操作。
  • フィルタリング: 必要な要素のみを抽出するための手段。

このように、intersectionはRustの標準ライブラリが提供する強力なメソッドの一つであり、効率的なデータ操作を可能にします。

ハッシュセットで共通部分を取得する方法


Rustでは、HashSetを用いることで効率的にコレクションの共通部分を取得できます。HashSetは、要素の重複を排除し、高速な集合演算を可能にするデータ構造です。ここでは、HashSetを活用した共通部分の取得方法を詳しく解説します。

基本例: ハッシュセットの作成と共通部分の取得


以下は、HashSetを使って2つのコレクションの共通部分を取得する例です：

use std::collections::HashSet;

fn main() {
    let set1: HashSet<_> = [1, 2, 3, 4].iter().cloned().collect();
    let set2: HashSet<_> = [3, 4, 5, 6].iter().cloned().collect();

    let common_elements: HashSet<_> = set1.intersection(&set2).cloned().collect();
    println!("{:?}", common_elements); // 出力: {3, 4}
}

コードの解説

  1. HashSet::new()またはcollect()によるセット作成:
    スライスからHashSetを生成します。iter()で参照を作成し、cloned()で値をコピーします。
  2. intersectionメソッド:
    共通部分を取得するために使用します。このメソッドはイテレータを返し、collect()で新しいコレクションに変換します。
  3. 効率性:
    ハッシュセットの内部構造（ハッシュテーブル）により、要素の探索が高速です。

実用例: 複数のセットを扱う場合


複数のHashSetの共通部分を取得するには、foldを活用します：

fn main() {
    let sets = vec![
        [1, 2, 3].iter().cloned().collect::<HashSet<_>>(),
        [2, 3, 4].iter().cloned().collect::<HashSet<_>>(),
        [3, 4, 5].iter().cloned().collect::<HashSet<_>>(),
    ];

    let common_elements = sets
        .iter()
        .skip(1)
        .fold(sets[0].clone(), |acc, set| {
            acc.intersection(set).cloned().collect()
        });

    println!("{:?}", common_elements); // 出力: {3}
}

複数セット処理のポイント

  1. foldの利用:
    初期値として最初のセットを指定し、他のセットと逐次比較します。
  2. 効率性の確保:
    最初のセットを小さいものにすると、比較回数が減少して効率が向上します。

利点と適用場面

  • データ分析: 共通の要素を特定してフィルタリングを行う。
  • 条件検索: 複数条件に一致するデータを抽出。
  • セット演算: 他の集合操作（和集合、差集合）との組み合わせ。

HashSetを使った共通部分の取得は、シンプルかつ高性能な方法であり、多くの場面で有用です。Rustの標準ライブラリを活用することで、効率的な集合演算を実現できます。

ベクトル同士の共通部分を取得するカスタム方法


RustのVec型は一般的に使われるコレクションですが、HashSetのような共通部分取得メソッドを直接持っていません。そのため、ベクトル同士の共通部分を取得するには、カスタムロジックを実装する必要があります。ここでは、Vec型での共通部分の取得方法をいくつか紹介します。

方法1: ハッシュセットを活用して効率化


ベクトルをHashSetに変換し、intersectionメソッドを使用して共通部分を取得する方法です：

use std::collections::HashSet;

fn main() {
    let vec1 = vec![1, 2, 3, 4];
    let vec2 = vec![3, 4, 5, 6];

    let set1: HashSet<_> = vec1.iter().cloned().collect();
    let set2: HashSet<_> = vec2.iter().cloned().collect();

    let common_elements: Vec<_> = set1.intersection(&set2).cloned().collect();
    println!("{:?}", common_elements); // 出力: [3, 4]
}

メリット

  • 重複を排除した上で効率的に共通部分を計算できます。
  • 簡潔で読みやすいコード。

方法2: イテレータを用いた手動フィルタリング


Vec同士で直接共通部分を取得する方法です：

fn main() {
    let vec1 = vec![1, 2, 3, 4];
    let vec2 = vec![3, 4, 5, 6];

    let common_elements: Vec<_> = vec1
        .iter()
        .filter(|&item| vec2.contains(item))
        .cloned()
        .collect();

    println!("{:?}", common_elements); // 出力: [3, 4]
}

メリット

  • HashSetを使わずに簡単なロジックで実現可能。

デメリット

  • containsが線形探索のため、コレクションが大きくなるとパフォーマンスが低下する。

方法3: ソートされたベクトルを用いた高速取得


事前にソートされたベクトルを使用すると、共通部分を効率的に取得できます：

fn main() {
    let mut vec1 = vec![1, 2, 3, 4];
    let mut vec2 = vec![3, 4, 5, 6];

    vec1.sort();
    vec2.sort();

    let mut common_elements = Vec::new();
    let mut iter1 = vec1.iter();
    let mut iter2 = vec2.iter();

    let mut item1 = iter1.next();
    let mut item2 = iter2.next();

    while let (Some(v1), Some(v2)) = (item1, item2) {
        if v1 == v2 {
            common_elements.push(*v1);
            item1 = iter1.next();
            item2 = iter2.next();
        } else if v1 < v2 {
            item1 = iter1.next();
        } else {
            item2 = iter2.next();
        }
    }

    println!("{:?}", common_elements); // 出力: [3, 4]
}

メリット

  • ソート済みデータを使用することで効率的（線形時間で処理可能）。

デメリット

  • 元のベクトルをソートする必要がある（元データの順序を保持する場合は注意）。

用途に応じた選択

  • データが大規模で重複を無視してもよい場合は、HashSetの活用が最適。
  • 小規模データで単純な操作を行いたい場合は、手動フィルタリングが適切。
  • 大規模データかつ順序を考慮する場合は、ソートを活用した高速取得が推奨されます。

このように、Vec型の共通部分取得には複数の方法があり、目的に応じて最適な手法を選択できます。Rustの柔軟な標準ライブラリを活用して効率的なコードを構築しましょう。

ライフタイムを考慮した共通部分の取得


Rustでは、所有権とライフタイムの管理が重要です。特に、複数のコレクションから共通部分を取得する際に、ライフタイムを適切に考慮することで、安全で効率的なコードを実現できます。ここでは、ライフタイムに関する基本知識を復習しつつ、実際にライフタイムを考慮した共通部分取得の方法を解説します。

ライフタイムとは


ライフタイムは、Rustのコンパイラが参照の有効期間を追跡する仕組みです。これにより、メモリの安全性を保証します。以下はライフタイムの基本ルールです：

  1. すべての参照にはライフタイムが存在する。
  2. ライフタイムは省略可能な場合もあるが、複雑なケースでは明示する必要がある。
  3. 参照が無効になる前に、その参照を使い終わる必要がある。

共通部分取得でのライフタイムの考慮


共通部分を取得する際、元のコレクションから参照を保持する場合、ライフタイムを明示することが求められる場合があります。以下の例を見てみましょう。

ライフタイムを明示した共通部分の取得


以下の例では、intersectionメソッドを利用して、元のデータを参照したまま共通部分を取得します：

use std::collections::HashSet;

fn find_intersection<'a>(set1: &'a HashSet<i32>, set2: &'a HashSet<i32>) -> HashSet<&'a i32> {
    set1.intersection(set2).collect()
}

fn main() {
    let set1: HashSet<_> = [1, 2, 3, 4].iter().cloned().collect();
    let set2: HashSet<_> = [3, 4, 5, 6].iter().cloned().collect();

    let common_elements = find_intersection(&set1, &set2);
    for &item in &common_elements {
        println!("{}", item); // 出力: 3, 4
    }
}

コードの解説

  1. 'aライフタイムの指定:
    set1とset2の参照、および返される要素のライフタイムを一致させています。これにより、元のコレクションが有効な間だけ共通部分が参照可能になります。
  2. 所有権の維持:
    このアプローチでは、元のデータの所有権を保持したまま共通部分を取得できます。

所有権の移動とライフタイムの違い


ライフタイムを考慮せず、所有権を移動することで共通部分を取得する場合もあります：

fn find_intersection_owned(set1: HashSet<i32>, set2: HashSet<i32>) -> HashSet<i32> {
    set1.intersection(&set2).cloned().collect()
}

この方法では、ライフタイムを気にする必要はありませんが、元のセットが無効になるため再利用はできません。

ライフタイムを活用した設計の利点

  • メモリ効率: 参照を使うことで不要なデータのコピーを避ける。
  • 安全性: Rustのライフタイムシステムによって、無効な参照を防ぐ。
  • 柔軟性: 元のコレクションが必要な間、有効な共通部分を操作可能。

実用例: データベースやキャッシュのフィルタリング


参照を使った共通部分取得は、データベースやキャッシュシステムでの効率的なデータフィルタリングに役立ちます。ライフタイムを適切に設計することで、大規模なデータセットでも高いパフォーマンスを維持できます。

ライフタイムを明示的に管理することで、Rustのメモリ安全性を最大限に活用しながら、効率的なコレクション操作を実現できます。

実用例：データフィルタリングへの応用


Rustで複数のコレクションの共通部分を取得する機能は、データフィルタリングの場面で非常に役立ちます。たとえば、ユーザーの行動データやログデータを絞り込む際、共通する項目を効率的に特定できます。ここでは具体例を挙げて説明します。

例1: ユーザーのアクセスログのフィルタリング


複数の条件に一致するユーザーを特定する例を見てみましょう：

use std::collections::HashSet;

fn main() {
    let users_visited_page_a: HashSet<_> = ["Alice", "Bob", "Charlie"].iter().cloned().collect();
    let users_visited_page_b: HashSet<_> = ["Bob", "Charlie", "Dave"].iter().cloned().collect();

    let common_users: HashSet<_> = users_visited_page_a.intersection(&users_visited_page_b).cloned().collect();

    println!("Users who visited both pages: {:?}", common_users); 
    // 出力: {"Bob", "Charlie"}
}

コードの解説

  1. 条件ごとのセット作成:
    それぞれのページを訪れたユーザーをHashSetとして定義します。
  2. 共通部分の取得:
    intersectionメソッドを利用して、両方のページを訪れたユーザーを特定します。

例2: 商品リストのフィルタリング


複数の条件を満たす商品を絞り込む例です：

fn main() {
    let products_in_category_a: HashSet<_> = ["Laptop", "Smartphone", "Tablet"].iter().cloned().collect();
    let products_in_category_b: HashSet<_> = ["Smartphone", "Tablet", "Smartwatch"].iter().cloned().collect();

    let filtered_products: HashSet<_> = products_in_category_a.intersection(&products_in_category_b).cloned().collect();

    println!("Products in both categories: {:?}", filtered_products);
    // 出力: {"Smartphone", "Tablet"}
}

応用ポイント

  • カテゴリやフィルタ条件をセットで定義することで、簡単に共通部分を抽出可能。
  • 他のフィルタ条件との組み合わせも容易。

例3: データ分析のサブセット抽出


以下の例では、複数の属性を持つデータポイントのサブセットを抽出します：

fn main() {
    let dataset_a: HashSet<_> = [1, 2, 3, 4, 5].iter().cloned().collect();
    let dataset_b: HashSet<_> = [3, 4, 5, 6, 7].iter().cloned().collect();

    let subset: HashSet<_> = dataset_a.intersection(&dataset_b).cloned().collect();

    println!("Common elements in datasets: {:?}", subset);
    // 出力: {3, 4, 5}
}

実用性

  • 分析対象のデータを条件に基づいて絞り込み。
  • 大規模データセットの高速処理が可能。

実用例の利点

  • 効率的なデータ操作: HashSetやintersectionメソッドを活用することで、高速かつ簡潔なコードを実現。
  • 再利用性: 条件を変更するだけで、異なるデータセットに適用可能。
  • 可読性: メソッドのチェーンや直感的な構文により、コードの理解が容易。

Rustの共通部分取得を応用することで、複雑なデータフィルタリングの要件にも柔軟に対応できます。実際の開発現場では、これらの例を基にさらに高度な操作を実装することができます。

エラーハンドリングの注意点


Rustで複数のコレクションの共通部分を取得する際、エラーハンドリングは重要な要素です。特に、データ型のミスマッチや欠損値が含まれる場合には、適切なエラー処理を実装することでプログラムの安定性を向上させることができます。ここでは、エラーハンドリングの注意点とその実践方法について解説します。

注意点1: データ型の不一致


Rustは静的型付け言語ですが、異なる型のコレクション間で共通部分を取得しようとすると、コンパイルエラーが発生します。以下は型ミスマッチを回避する方法です：

use std::collections::HashSet;

fn main() {
    let set1: HashSet<i32> = [1, 2, 3].iter().cloned().collect();
    let set2: HashSet<i32> = [2, 3, 4].iter().cloned().collect();

    // 型が一致しているのでエラーは発生しない
    let common_elements: HashSet<_> = set1.intersection(&set2).cloned().collect();
    println!("{:?}", common_elements); // 出力: {2, 3}
}

対策

  • コレクションを扱う前に型を明示する。
  • 型が異なる場合はinto()やmap()を利用して型変換を行う。

注意点2: 空のコレクションの処理


共通部分を求めるコレクションが空の場合、結果も空になります。これを適切に処理することで、予期しない動作を防ぎます：

fn main() {
    let set1: HashSet<i32> = HashSet::new();
    let set2: HashSet<i32> = [2, 3, 4].iter().cloned().collect();

    let common_elements: HashSet<_> = set1.intersection(&set2).cloned().collect();
    if common_elements.is_empty() {
        println!("No common elements found.");
    } else {
        println!("Common elements: {:?}", common_elements);
    }
}

対策

  • 共通部分を求める前にコレクションが空かどうかを確認する。
  • 結果のコレクションが空の場合のロジックを実装する。

注意点3: ライフタイム関連のエラー


共通部分の取得において参照を利用する場合、ライフタイムに関するエラーが発生する可能性があります：

fn find_intersection<'a>(set1: &'a HashSet<i32>, set2: &'a HashSet<i32>) -> HashSet<&'a i32> {
    set1.intersection(set2).collect()
}

fn main() {
    let set1: HashSet<_> = [1, 2, 3].iter().cloned().collect();
    let set2: HashSet<_> = [2, 3, 4].iter().cloned().collect();

    let result = find_intersection(&set1, &set2);
    println!("{:?}", result); // 出力: {2, 3}
}

対策

  • ライフタイムを明示して参照の有効期間をコンパイラに伝える。
  • 必要に応じて所有権を移動し、ライフタイムエラーを回避する。

注意点4: データ欠損や不正値の処理


データに欠損値や不正値が含まれる場合、これを適切に処理することでプログラムの誤動作を防ぎます：

fn main() {
    let set1: HashSet<_> = [1, 2, 3, 0].iter().cloned().collect();
    let set2: HashSet<_> = [0, 3, 4, 5].iter().cloned().collect();

    let common_elements: HashSet<_> = set1
        .intersection(&set2)
        .filter(|&&x| x != 0) // 0を不正値として排除
        .cloned()
        .collect();

    println!("Filtered common elements: {:?}", common_elements);
    // 出力: {3}
}

対策

  • 欠損値や不正値をフィルタリングするロジックを追加する。
  • データの前処理を徹底し、不正値の混入を防ぐ。

適切なエラーハンドリングで信頼性を向上


エラーハンドリングを考慮したコレクション操作により、信頼性の高いプログラムを構築できます。Rustの静的型付けと所有権システムを活用し、エラーを未然に防ぐ設計を心掛けましょう。

パフォーマンスを向上させるためのベストプラクティス


Rustで複数のコレクションの共通部分を効率的に取得するには、パフォーマンスを考慮した設計が欠かせません。ここでは、計算コストを削減し、処理を高速化するためのベストプラクティスを紹介します。

1. 小さいコレクションを基準にする


共通部分の計算では、最も小さいコレクションを基準にすることで、反復回数を最小限に抑えることができます：

use std::collections::HashSet;

fn main() {
    let small_set: HashSet<_> = [1, 2].iter().cloned().collect();
    let large_set: HashSet<_> = (1..=100).collect();

    let common_elements: HashSet<_> = small_set.intersection(&large_set).cloned().collect();
    println!("{:?}", common_elements); // 出力: {1, 2}
}

ポイント

  • 最小のコレクションをintersectionの基準にすることで計算量を削減。
  • 大規模データセットの処理速度を向上。

2. 適切なデータ構造を選択する


コレクションの種類に応じた適切なデータ構造を使用することで、効率的な共通部分の取得が可能です：

  • HashSet: 高速な集合演算に適している。
  • BTreeSet: 要素がソートされている場合に有効。

例：BTreeSetを利用した共通部分の取得

use std::collections::BTreeSet;

fn main() {
    let set1: BTreeSet<_> = [1, 2, 3, 4].iter().cloned().collect();
    let set2: BTreeSet<_> = [3, 4, 5, 6].iter().cloned().collect();

    let common_elements: BTreeSet<_> = set1.intersection(&set2).cloned().collect();
    println!("{:?}", common_elements); // 出力: {3, 4}
}

3. データの重複を事前に排除する


重複が多いデータを処理する場合、事前に重複を排除してから共通部分を計算すると、処理速度が向上します：

fn main() {
    let vec1 = vec![1, 2, 2, 3, 4];
    let vec2 = vec![3, 3, 4, 5, 6];

    let set1: HashSet<_> = vec1.into_iter().collect();
    let set2: HashSet<_> = vec2.into_iter().collect();

    let common_elements: HashSet<_> = set1.intersection(&set2).cloned().collect();
    println!("{:?}", common_elements); // 出力: {3, 4}
}

メリット

  • データ量の削減による計算コストの低減。
  • メモリ使用量の最適化。

4. 並列処理の活用


データが大規模な場合、並列処理を導入することで計算時間を短縮できます。rayonクレートを利用した例：

use rayon::prelude::*;
use std::collections::HashSet;

fn main() {
    let set1: HashSet<_> = (1..=10_000).collect();
    let set2: HashSet<_> = (5_000..=15_000).collect();

    let common_elements: HashSet<_> = set1
        .par_iter()
        .filter(|&&x| set2.contains(&x))
        .cloned()
        .collect();

    println!("Number of common elements: {}", common_elements.len());
}

メリット

  • 複数のスレッドを活用することで計算時間を大幅に短縮。
  • CPUリソースを有効活用。

5. メモリと速度のトレードオフを考慮する


メモリ効率と速度のバランスを考慮し、必要に応じて一時的なコレクションを作成しない方法を選ぶ。例えば、iter()やfilter()を利用してイテレータを直接処理する方法が適しています。

例：イテレータを使った共通部分取得

fn main() {
    let vec1 = vec![1, 2, 3, 4];
    let vec2 = vec![3, 4, 5, 6];

    let common_elements: Vec<_> = vec1
        .iter()
        .filter(|&&x| vec2.contains(&x))
        .cloned()
        .collect();

    println!("{:?}", common_elements); // 出力: [3, 4]
}

まとめ

  • データ量や構造に応じて適切な手法を選択する。
  • 小さいコレクションを基準にし、必要に応じて並列処理を導入する。
  • データ前処理やイテレータの活用により、パフォーマンスを最大化する。

これらのベストプラクティスを活用することで、Rustで効率的な共通部分取得を実現できます。

Rustにおけるコレクション操作の今後の展望

Rustのエコシステムは活発に進化しており、コレクション操作に関する新しい機能やツールの導入が期待されています。以下では、Rustのコレクション操作が向かう可能性のある方向性について考察します。

1. 標準ライブラリのさらなる拡充


Rustの標準ライブラリは、既に効率的なコレクション操作を提供していますが、以下のような改善が進む可能性があります：

  • 新しい集合演算メソッド: 現在のintersectionやunionに加えて、より高度な集合操作が追加される。
  • カスタムデータ構造のサポート: 高度なフィルタリングや検索に特化したデータ構造が標準化される。

2. 並列処理の標準化


現状ではrayonのような外部クレートが並列処理を提供していますが、将来的には標準ライブラリで並列処理が可能になるかもしれません。これにより、大規模データセットの共通部分取得がさらに効率化されるでしょう。

3. WASMやクラウド向け最適化


RustはWebAssemblyやクラウド開発での利用が拡大しています。コレクション操作がこれらの環境に最適化されることで、分散システムやサーバレスアーキテクチャでも効率的なデータ処理が可能になると期待されます。

4. コンパイラによるさらなる最適化


Rustのコンパイラ（rustc）は、コレクション操作のコードを効率的にコンパイルするための最適化が進んでいます。特に、以下のような最適化が期待されています：

  • ループのアンローリング: 繰り返し処理を高速化。
  • 条件分岐の効率化: フィルタリングロジックの性能向上。

5. より柔軟なエラーハンドリング


Rustのエラー処理は強力ですが、さらに簡潔で柔軟なコレクション操作が可能になるよう、メソッドチェーン内でのエラー処理の改善が進む可能性があります。

6. クレートエコシステムの進化

  • 人気クレートの統合: rayonやserdeのようなクレートが、標準ライブラリに統合される可能性。
  • 新しいクレートの登場: 特定のユースケースに特化したコレクション操作を提供するクレートの登場。

まとめ


Rustのコレクション操作は現在でも強力ですが、標準ライブラリの進化やエコシステムの拡充によって、さらに便利で効率的になることが期待されます。これにより、より複雑なデータ処理を簡単に実現できる未来が訪れるでしょう。Rustのエコシステムの進展を注視しつつ、現行のツールを活用して効率的なコレクション操作を行いましょう。

まとめ


本記事では、Rustで複数のコレクションの共通部分を取得する方法について解説しました。intersectionメソッドの基本から、HashSetやVecを使った実装方法、ライフタイムの考慮、データフィルタリングの実用例、さらにパフォーマンス向上のためのベストプラクティスまで幅広く紹介しました。

Rustの型安全性や効率性を活かせば、データ処理の複雑な課題もシンプルかつ安全に解決できます。この記事を参考に、さらに高度なコレクション操作に挑戦し、Rustを用いた開発スキルを磨いていきましょう。

Rust
プログラミング コレクション Rust

コメント

コメントする

目次