MENU
  1. ホーム
  2. Rust
  3. Rust条件分岐のベストプラクティスと避けるべきアンチパターン

Rust条件分岐のベストプラクティスと避けるべきアンチパターン

Rust

Rustは、安全性と高性能を両立するプログラミング言語として注目されています。その中で、条件分岐は、プログラムのロジックを構築する上で欠かせない要素です。しかし、書き方次第では、意図が伝わりにくいコードやエラーを引き起こす原因にもなります。本記事では、Rustにおける条件分岐の基本から、効率的かつ読みやすいコードを書くためのベストプラクティス、そして避けるべきアンチパターンを詳しく解説します。これにより、Rust初心者から中級者まで、誰もが適切な条件分岐を書けるようになることを目指します。

目次

Rustにおける条件分岐の基本構文


Rustでは、条件分岐を記述するための主な構文としてif文とmatch式があります。これらはシンプルかつ表現力が豊かで、さまざまなロジックを実現するのに役立ちます。

if文の基本構文


Rustのif文は以下のように記述します。

fn main() {
    let number = 7;

    if number < 10 {
        println!("number is less than 10");
    } else {
        println!("number is 10 or greater");
    }
}


この例では、if文で条件を評価し、結果に応じて異なる処理を行います。

ポイント

  • 条件は必ずbool型でなければなりません。他の型（例えばint型）を使うとコンパイルエラーになります。
  • 波括弧{}は省略できません。Rustではコードの明確性を重視するため、必須とされています。

match式の基本構文


Rustのmatch式は、複数の条件を効率的に処理するための構文です。

fn main() {
    let number = 7;

    match number {
        1 => println!("one"),
        2 => println!("two"),
        3..=9 => println!("number between 3 and 9"),
        _ => println!("something else"),
    }
}


この例では、変数numberの値に応じて異なる分岐が実行されます。

ポイント

  • 各分岐はパターン => 処理の形式で記述します。
  • _はデフォルト分岐を表し、他のどのパターンにも一致しない場合に実行されます。
  • パターンは非常に強力で、リテラル値、範囲、タプルなどを含めた柔軟な記述が可能です。

if文とmatch式の違い

  • if文: シンプルな条件評価に向いています。
  • match式: 複雑な条件分岐や複数のケースが必要な場合に適しています。

Rustではこれらの構文を使い分けることで、意図が明確で効率的な条件分岐を実現できます。

if文の使い方と注意点

Rustのif文は、シンプルな条件分岐を記述するのに適しています。しかし、書き方や使い方を誤ると、コードが冗長になったり、意図が伝わりにくくなる場合があります。ここでは、効率的なif文の使い方と注意点を解説します。

if文の基本的な使い方


if文は条件がtrueの場合に特定の処理を実行します。また、else ifやelseを用いることで、複数の条件を評価することができます。

fn main() {
    let number = 15;

    if number % 2 == 0 {
        println!("number is even");
    } else if number % 3 == 0 {
        println!("number is divisible by 3");
    } else {
        println!("number is neither even nor divisible by 3");
    }
}


この例では、if文で複数の条件を順次チェックしています。

if文を式として利用する


Rustでは、if文は「式」として利用でき、値を返すことができます。これにより、変数への代入や関数内での値の生成が簡潔になります。

fn main() {
    let condition = true;
    let number = if condition { 5 } else { 10 };

    println!("The value of number is: {}", number);
}


この例では、if文の結果が直接numberに代入されます。

ポイント

  • if文が式として使われる場合、すべての分岐で返す型が一致している必要があります。型が一致しない場合、コンパイルエラーになります。
  let number = if true { 5 } else { "ten" }; // エラー: 型が一致しない

冗長なif文の改善方法


条件が増えると、if文が冗長になる場合があります。この場合、以下の改善が有効です。

  1. match式の利用: 複数の条件を整理するためにmatch式を使う。
  2. 関数の抽出: 条件分岐が複雑な場合、ロジックを関数に分割する。
   fn is_even(num: i32) -> bool {
       num % 2 == 0
   }

   fn main() {
       let number = 10;
       if is_even(number) {
           println!("number is even");
       }
   }

注意点

  • 過剰なネストを避ける
    条件分岐が多段階でネストする場合、コードが読みにくくなります。早期リターンやmatch式を活用して改善します。
  // 悪い例
  if condition1 {
      if condition2 {
          println!("Nested condition met");
      }
  }

  // 良い例
  if !condition1 {
      return;
  }
  if condition2 {
      println!("Condition met");
  }
  • 明確で簡潔な条件を心がける
    条件の中に論理演算子を多用すると意図が分かりにくくなります。必要に応じて条件を変数に分割しましょう。

Rustのif文は、コードの簡潔さと可読性を保つ重要なツールです。正しい使い方を心がけることで、効率的で明確なコードを書くことができます。

match式の活用と効果的な使用例

Rustのmatch式は、複数の条件を分岐させる場合に特に便利な構文です。シンプルな値の比較から複雑なパターンマッチングまで対応可能で、条件分岐を効率的かつ可読性高く記述できます。ここでは、match式の活用方法と効果的な使用例を紹介します。

match式の基本


match式は、値とパターンを照合して対応する処理を実行します。

fn main() {
    let number = 5;

    match number {
        1 => println!("One"),
        2 | 3 => println!("Two or Three"),
        4..=6 => println!("Between Four and Six"),
        _ => println!("Something else"),
    }
}

ポイント

  • パターンはリテラル値、範囲（4..=6）、論理OR（2 | 3）、およびワイルドカード（_）を利用できます。
  • _は他のすべてのケースに一致するデフォルトパターンです。

多重条件を整理する


match式は、if-else文を連続して記述する場合の代替として優れています。

fn check_grade(score: u8) {
    match score {
        90..=100 => println!("Excellent"),
        75..=89 => println!("Good"),
        50..=74 => println!("Pass"),
        _ => println!("Fail"),
    }
}


このように、複数の条件を整理して書けるため、コードが読みやすくなります。

match式を使った列挙型の処理


Rustの列挙型（enum）とmatch式を組み合わせると、より表現力豊かなコードが書けます。

enum TrafficLight {
    Red,
    Yellow,
    Green,
}

fn action(light: TrafficLight) {
    match light {
        TrafficLight::Red => println!("Stop"),
        TrafficLight::Yellow => println!("Slow down"),
        TrafficLight::Green => println!("Go"),
    }
}

fn main() {
    let light = TrafficLight::Green;
    action(light);
}


この例では、TrafficLightの各バリアントに応じた動作を記述しています。

条件に応じた値の生成


match式は「式」として値を生成することができます。

fn main() {
    let x = 10;

    let result = match x {
        1 => "one",
        2 | 3 => "two or three",
        _ => "something else",
    };

    println!("Result: {}", result);
}


この例では、match式の結果を直接変数resultに代入しています。

注意点とアンチパターン

  1. すべてのケースを網羅する
    match式はすべての可能なパターンを扱う必要があります。網羅していない場合、コンパイルエラーが発生します。列挙型のすべてのバリアントを列挙するか、ワイルドカード_を追加して対応しましょう。
  2. 冗長なパターンを避ける
    パターンが複雑で冗長になる場合、コードの再利用性や可読性が低下します。共通する処理を関数に分割するなどの工夫が必要です。
  3. ネストの深さに注意
    ネストしたmatch式は読みにくくなります。関数分割や構造体・列挙型の活用で整理しましょう。

まとめ


Rustのmatch式は、条件分岐を効率化し、コードの可読性を向上させる強力なツールです。特に列挙型やパターンマッチングを活用した例では、その柔軟性と表現力が際立ちます。適切に使用することで、簡潔でメンテナンス性の高いコードを実現できます。

式としての条件分岐のメリット

Rustの条件分岐は「式」として扱われるため、他の多くのプログラミング言語と異なり、値を返して直接利用できます。この特性により、コードの簡潔さや柔軟性が大幅に向上します。ここでは、式としての条件分岐のメリットと具体例を紹介します。

if文が値を返す


Rustでは、if文は値を返すため、変数の初期化や関数の戻り値として直接利用できます。

fn main() {
    let condition = true;

    let number = if condition { 5 } else { 10 };
    println!("The value of number is: {}", number);
}

ポイント

  • 各分岐で返される型は一致している必要があります。一致しない場合、コンパイルエラーになります。
  let number = if true { 5 } else { "ten" }; // エラー: 型が一致しない
  • if文を式として利用することで、冗長な代入コードを削減できます。

match式が値を返す


同様に、match式も値を返すため、より複雑な条件分岐でも簡潔に値を生成できます。

fn main() {
    let number = 3;

    let result = match number {
        1 => "one",
        2 | 3 => "two or three",
        _ => "something else",
    };

    println!("Result: {}", result);
}

メリット

  • 複数の条件分岐を一つの式としてまとめられるため、処理がシンプルになります。
  • 値を返す処理とロジックの分岐を統一的に記述できるため、コードの意図が明確になります。

関数や式内で条件分岐を使う


条件分岐を式として扱うことで、関数の戻り値や式の一部として自然に利用できます。

fn get_status_code(is_success: bool) -> u16 {
    if is_success { 200 } else { 500 }
}

fn main() {
    let success = true;
    let code = get_status_code(success);
    println!("Status code: {}", code);
}

また、複雑なロジックでもmatch式を活用して値を生成できます。

fn get_message(code: u16) -> &'static str {
    match code {
        200 => "OK",
        404 => "Not Found",
        500 => "Internal Server Error",
        _ => "Unknown",
    }
}

注意点

  1. 型を統一する
    式としての条件分岐を利用する際、すべての分岐が同じ型を返すようにする必要があります。これにより、型エラーを防ぎ、コードの予測可能性が向上します。
  2. 複雑なロジックを避ける
    式としての条件分岐を過剰に使用すると、意図が伝わりにくいコードになる可能性があります。複雑なロジックは関数に分割して整理しましょう。

まとめ


Rustの条件分岐を式として活用することで、簡潔かつ直感的なコードが実現します。if文やmatch式を値を返す形で利用することで、冗長な記述を減らし、コードの可読性と保守性を向上させることが可能です。適切に活用することで、Rustの強力な特性を最大限に引き出せます。

条件分岐におけるアンチパターン

Rustの条件分岐は強力ですが、誤った使い方をすると、可読性が低下したり、バグの原因になる可能性があります。ここでは、条件分岐で避けるべきアンチパターンと、その改善方法を解説します。

冗長なif-elseの連続


複数の条件をif-else文で繰り返し記述するのは、コードの可読性とメンテナンス性を損ないます。

// 悪い例
fn get_status_description(status: u16) -> &'static str {
    if status == 200 {
        "OK"
    } else if status == 404 {
        "Not Found"
    } else if status == 500 {
        "Internal Server Error"
    } else {
        "Unknown"
    }
}


改善方法
複数の条件を整理する場合、match式を使用すると読みやすくなります。

// 良い例
fn get_status_description(status: u16) -> &'static str {
    match status {
        200 => "OK",
        404 => "Not Found",
        500 => "Internal Server Error",
        _ => "Unknown",
    }
}

過剰にネストした条件分岐


深くネストされた条件分岐は、コードの意図を読み取るのが困難になります。

// 悪い例
fn validate_input(value: i32) {
    if value > 0 {
        if value < 100 {
            if value % 2 == 0 {
                println!("Valid input");
            }
        }
    }
}


改善方法
早期リターンを利用し、ネストを減らします。

// 良い例
fn validate_input(value: i32) {
    if value <= 0 || value >= 100 {
        return;
    }

    if value % 2 == 0 {
        println!("Valid input");
    }
}

条件式の複雑化


条件式に多くの論理演算子を含めると、意図が不明瞭になりやすいです。

// 悪い例
fn is_valid_user(age: u8, active: bool) -> bool {
    age > 18 && age < 65 && active
}


改善方法
条件をわかりやすくするために、意味のある変数や関数に分割します。

// 良い例
fn is_valid_user(age: u8, active: bool) -> bool {
    let is_age_valid = age > 18 && age < 65;
    is_age_valid && active
}

無意味なワイルドカードの使用


match式で、すべてのケースをワイルドカード_で処理すると、予期せぬ動作を招くことがあります。

// 悪い例
fn get_day_name(day: u8) -> &'static str {
    match day {
        1 => "Monday",
        2 => "Tuesday",
        _ => "Invalid", // 他のケースもすべて"Invalid"になる
    }
}


改善方法
明示的にすべてのケースを列挙し、対応しきれない場合のみ_を使います。

// 良い例
fn get_day_name(day: u8) -> &'static str {
    match day {
        1 => "Monday",
        2 => "Tuesday",
        3 => "Wednesday",
        4 => "Thursday",
        5 => "Friday",
        6 => "Saturday",
        7 => "Sunday",
        _ => "Invalid",
    }
}

複数箇所で同じ条件を記述


条件分岐が複数箇所に重複して記述されると、変更が難しくなります。

// 悪い例
fn process_value(value: i32) {
    if value > 0 {
        println!("Positive value");
    }

    if value > 0 {
        println!("Value is greater than zero");
    }
}


改善方法
条件を関数化して再利用します。

// 良い例
fn is_positive(value: i32) -> bool {
    value > 0
}

fn process_value(value: i32) {
    if is_positive(value) {
        println!("Positive value");
        println!("Value is greater than zero");
    }
}

まとめ


Rustで条件分岐を適切に扱うには、コードの可読性とメンテナンス性を考慮することが重要です。過剰なネストや冗長なコードを避け、適切なmatch式や早期リターンを活用することで、より簡潔で理解しやすいコードを実現できます。

エラーハンドリングにおける条件分岐

Rustは、安全性を重視する設計思想から、エラーハンドリングを非常に重要視しています。条件分岐を活用したエラーハンドリングは、エラーを的確に検出し、適切に対処するための基本です。ここでは、Rustにおけるエラーハンドリングのベストプラクティスを解説します。

Option型を使ったエラーハンドリング


Option<T>は、値が存在する場合（Some）と存在しない場合（None）を明示的に表現するために使われます。

fn find_even_number(numbers: &[i32]) -> Option<i32> {
    for &num in numbers {
        if num % 2 == 0 {
            return Some(num);
        }
    }
    None
}

fn main() {
    let numbers = vec![1, 3, 5, 8, 9];
    match find_even_number(&numbers) {
        Some(num) => println!("Found even number: {}", num),
        None => println!("No even number found"),
    }
}

ポイント

  • Some(value)とNoneをmatch式で分岐させて処理を記述します。
  • Optionを活用することで、存在しない可能性のある値を安全に扱えます。

Result型を使ったエラーハンドリング


Result<T, E>は、操作が成功した場合（Ok）と失敗した場合（Err）を表現します。

fn divide(a: i32, b: i32) -> Result<i32, &'static str> {
    if b == 0 {
        Err("Division by zero")
    } else {
        Ok(a / b)
    }
}

fn main() {
    let result = divide(10, 2);
    match result {
        Ok(value) => println!("Result: {}", value),
        Err(error) => println!("Error: {}", error),
    }
}

ポイント

  • Resultを返す関数で、エラーを適切に報告できます。
  • 呼び出し側でmatch式を使い、成功と失敗の処理を分岐させます。

エラーを簡潔に扱う?演算子


エラーを呼び出し元にそのまま伝播させたい場合、?演算子を使用できます。

fn read_file(file_path: &str) -> Result<String, std::io::Error> {
    let content = std::fs::read_to_string(file_path)?;
    Ok(content)
}

fn main() {
    match read_file("example.txt") {
        Ok(content) => println!("File content: {}", content),
        Err(error) => println!("Error reading file: {}", error),
    }
}

メリット

  • ?演算子を使うことで、エラー伝播コードを簡潔に記述できます。
  • 関数がResult型を返す場合に特に有効です。

カスタムエラーの実装


アプリケーション固有のエラーを表現するために、カスタムエラー型を作成できます。

use std::fmt;

#[derive(Debug)]
enum AppError {
    NotFound,
    PermissionDenied,
}

impl fmt::Display for AppError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            AppError::NotFound => write!(f, "Not Found"),
            AppError::PermissionDenied => write!(f, "Permission Denied"),
        }
    }
}

fn example_function() -> Result<(), AppError> {
    Err(AppError::NotFound)
}

fn main() {
    match example_function() {
        Ok(_) => println!("Operation succeeded"),
        Err(e) => println!("Operation failed: {}", e),
    }
}

ポイント

  • カスタムエラー型を導入することで、エラーの種類を明確にできます。
  • DisplayやDebugトレイトを実装することで、エラーメッセージをカスタマイズできます。

注意点

  1. エラーメッセージの明確化
    ユーザーや開発者がエラーの原因を特定しやすいよう、明確で具体的なメッセージを記述します。
  2. 不要なエラー伝播の防止
    すべてのエラーを伝播するのではなく、適切に処理を行い、可能な限りアプリケーション内で対処します。

まとめ


Rustの条件分岐を活用したエラーハンドリングは、安全性を保ちながら柔軟にエラーを処理できます。OptionやResultを効果的に使い分けることで、堅牢で分かりやすいエラーハンドリングを実現できます。適切なエラー処理を行い、予期せぬ問題に強いプログラムを構築しましょう。

コードの読みやすさを向上させる分岐の工夫

条件分岐は、コードのロジックを構築する重要な要素ですが、書き方によっては可読性を損ねることがあります。ここでは、Rustにおける条件分岐をわかりやすく設計するための工夫を紹介します。

早期リターンの活用


不要なネストを防ぐために、条件が満たされた場合に早期リターンを使用します。これにより、コードが平坦化され、意図が明確になります。

// 悪い例
fn process_value(value: i32) {
    if value > 0 {
        if value % 2 == 0 {
            println!("Positive even number");
        }
    }
}

// 良い例
fn process_value(value: i32) {
    if value <= 0 {
        return;
    }
    if value % 2 == 0 {
        println!("Positive even number");
    }
}

条件を関数に分割


複雑な条件をそのまま記述すると、意図がわかりにくくなる場合があります。条件を関数化することで、条件そのものを簡潔に表現できます。

// 悪い例
fn is_eligible(age: u32, employed: bool) -> bool {
    age >= 18 && age <= 65 && employed
}

// 良い例
fn is_valid_age(age: u32) -> bool {
    age >= 18 && age <= 65
}

fn is_eligible(age: u32, employed: bool) -> bool {
    is_valid_age(age) && employed
}

match式を活用


複数の条件がある場合は、match式を使用することで分岐を整理できます。

// 悪い例
fn get_day_name(day: u8) -> &'static str {
    if day == 1 {
        "Monday"
    } else if day == 2 {
        "Tuesday"
    } else if day == 3 {
        "Wednesday"
    } else {
        "Invalid"
    }
}

// 良い例
fn get_day_name(day: u8) -> &'static str {
    match day {
        1 => "Monday",
        2 => "Tuesday",
        3 => "Wednesday",
        _ => "Invalid",
    }
}

型を活用して条件を明示


条件を直接比較するのではなく、型を活用して意図を明確化する方法も有効です。列挙型や新しい型を定義して状態を管理します。

// 列挙型を利用した例
enum Status {
    Active,
    Inactive,
}

fn print_status_message(status: Status) {
    match status {
        Status::Active => println!("The user is active."),
        Status::Inactive => println!("The user is inactive."),
    }
}

条件分岐の短縮記法を利用


単純な条件分岐には、if文を式として活用することでコードを短縮できます。

fn is_even(num: i32) -> &'static str {
    if num % 2 == 0 { "Even" } else { "Odd" }
}

コメントで意図を補足


複雑な条件が避けられない場合、コメントを活用して意図を明示します。

fn calculate_discount(price: f64, is_member: bool) -> f64 {
    if is_member && price > 100.0 {
        // 会員でかつ100ドル以上の購入の場合、20%の割引
        price * 0.8
    } else {
        price
    }
}

注意点

  1. 一貫性を保つ
    プロジェクト全体で同じスタイルの条件分岐を使用することで、チームメンバー間での理解を容易にします。
  2. 必要以上に短縮しない
    短縮記法がかえって意図を分かりにくくする場合があります。可読性を優先してください。
  3. 意図が伝わる命名
    条件に名前を付ける際、意図が明確に伝わる名前を選びます。

まとめ


条件分岐の設計次第で、コードの可読性とメンテナンス性が大きく向上します。早期リターンやmatch式の活用、条件の関数化などの工夫を取り入れることで、意図が明確で簡潔なコードを書くことが可能です。Rustの特徴を最大限に活用し、わかりやすい条件分岐を実現しましょう。

Rust条件分岐の応用例と演習問題

Rustの条件分岐をさらに深く理解するために、応用例を交えながら実践的な活用法を解説します。また、演習問題を提供することで、自身の理解度を確認できます。

応用例1: コンフィグ設定の処理


match式を活用して、アプリケーションの設定値を動的に処理します。

enum ConfigOption {
    Debug,
    Release,
    Test,
}

fn get_config_message(config: ConfigOption) -> &'static str {
    match config {
        ConfigOption::Debug => "Running in debug mode",
        ConfigOption::Release => "Running in release mode",
        ConfigOption::Test => "Running in test mode",
    }
}

fn main() {
    let config = ConfigOption::Debug;
    println!("{}", get_config_message(config));
}


この例では、列挙型を使って設定モードを明確にし、match式で処理を分岐しています。

応用例2: Webリクエストのエラーハンドリング


HTTPリクエストのステータスコードを条件分岐で処理します。

fn handle_http_status(status: u16) {
    match status {
        200 => println!("OK"),
        404 => println!("Not Found"),
        500 => println!("Internal Server Error"),
        _ => println!("Unhandled status code: {}", status),
    }
}

fn main() {
    let status_code = 404;
    handle_http_status(status_code);
}


この例では、HTTPステータスコードごとに異なる処理を実行します。

応用例3: 条件付きフィルタリング


コレクションを条件に基づいてフィルタリングする場合にも条件分岐が役立ちます。

fn filter_even_numbers(numbers: Vec<i32>) -> Vec<i32> {
    numbers.into_iter().filter(|&num| num % 2 == 0).collect()
}

fn main() {
    let numbers = vec![1, 2, 3, 4, 5, 6];
    let evens = filter_even_numbers(numbers);
    println!("Even numbers: {:?}", evens);
}


この例では、条件を満たす要素を抽出しています。

演習問題

  1. 条件分岐で合否判定を作成
    以下の関数を完成させてください。テストのスコアに基づき、以下の判定を行います。
  • 90点以上: “Excellent”
  • 75～89点: “Good”
  • 50～74点: “Pass”
  • 49点以下: “Fail”
   fn get_grade(score: u8) -> &'static str {
       // ここに条件分岐を記述
   }

   fn main() {
       let score = 85;
       println!("Grade: {}", get_grade(score));
   }
  1. 列挙型とmatch式を利用した状態管理
    列挙型TrafficLight（Red, Yellow, Greenの3つのバリアントを持つ）を作成し、以下の仕様を満たす関数を実装してください。
  • Redなら”Stop”
  • Yellowなら”Slow down”
  • Greenなら”Go”
  1. Option型を活用した安全な値の取得
    配列から偶数を最初に見つけて返す関数find_first_evenを完成させてください。見つからなければNoneを返します。
   fn find_first_even(numbers: &[i32]) -> Option<i32> {
       // ここに条件分岐を記述
   }

   fn main() {
       let numbers = vec![1, 3, 5, 8, 9];
       match find_first_even(&numbers) {
           Some(num) => println!("First even number: {}", num),
           None => println!("No even numbers found"),
       }
   }

解答例


以下は、上記演習問題の解答例です。

  1. fn get_grade(score: u8) -> &'static str { match score { 90..=100 => "Excellent", 75..=89 => "Good", 50..=74 => "Pass", _ => "Fail", } }
enum TrafficLight {
    Red,
    Yellow,
    Green,
}

fn get_action(light: TrafficLight) -> &'static str {
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Slow down",
        TrafficLight::Green => "Go",
    }
}
  1. fn find_first_even(numbers: &[i32]) -> Option<i32> { for &num in numbers { if num % 2 == 0 { return Some(num); } } None }

まとめ


応用例や演習問題を通じて、Rustの条件分岐を実践的に使うスキルを身に付けられます。if文やmatch式、OptionやResultを適切に活用し、効率的かつ安全なロジックを構築しましょう。

まとめ

本記事では、Rustにおける条件分岐の基本から応用までを解説しました。if文とmatch式の特性、式として条件分岐を活用するメリット、読みやすさを向上させる工夫、そしてエラーハンドリングや応用例まで、幅広い内容を網羅しました。また、避けるべきアンチパターンや改善方法を示し、効率的でメンテナンス性の高いコードを書くためのヒントも提供しました。

Rustの条件分岐を正しく理解し、適切に活用することで、安全性と可読性を両立したコードを構築できます。これを実践に活かし、より堅牢で表現力の高いプログラムを作成していきましょう。

Rust
プログラミング 条件分岐 ベストプラクティス Rust

コメント

コメントする

目次