Rustで条件分岐を活用してプログラムのパフォーマンスを最適化する方法

let number = 5;

if number > 0 {
    println!("Positive number");
} else if number == 0 {
    println!("Zero");
} else {
    println!("Negative number");
}

match number {
    1 => println!("One"),
    2..=4 => println!("Between two and four"),
    _ => println!("Other number"),
}

   let condition = true;
   let number = if condition { 5 } else { 10 };
   println!("{}", number); // 5

   for i in 0..100 {
       if i % 2 == 0 {
           println!("Even");
       }
   }

   // 統合前
   if x > 0 { ... }
   if x > 0 && y > 0 { ... }

   // 統合後（コンパイラ最適化により）
   if x > 0 {
       ...
       if y > 0 {
           ...
       }
   }

   let flag = false;
   if flag {
       println!("This code will be eliminated.");
   }

if x > 0 {
    // 長い処理
}
if x > 0 {
    // 別の長い処理
}

if x > 0 {
    // 長い処理
    // 別の長い処理
}

   // 非効率な例
   if (x > 0 && y > 0) || (x > 0 && z > 0) {
       ...
   }

   // 効率的な例
   if x > 0 {
       if y > 0 || z > 0 {
           ...
       }
   }

   // 頻出条件を先に配置
   if x == 0 {
       ...
   } else if y > 10 {
       ...
   }

   // ネストが深い例
   if x > 0 {
       if y > 0 {
           if z > 0 {
               ...
           }
       }
   }

   // ネストを浅くした例
   if x <= 0 || y <= 0 || z <= 0 {
       return;
   }
   ...

   match x {
       0 => println!("Zero"),
       1..=10 => println!("Between 1 and 10"),
       _ => println!("Greater than 10"),
   }

   let values = vec![1, 2, 3, 4, 5];
   let result: Vec<_> = values.iter()
                              .filter(|&&x| x > 2)
                              .collect();
   println!("{:?}", result); // [3, 4, 5]

   enum Status {
       Active,
       Inactive,
       Pending,
   }

   let status = Status::Active;

   match status {
       Status::Active => println!("Active"),
       Status::Inactive => println!("Inactive"),
       Status::Pending => println!("Pending"),
   }

  let condition = expensive_calculation();
  if condition {
      ...
  }
  if condition {
      ...
  }

let number = 5;

if number > 0 {
    println!("Positive");
} else if number == 0 {
    println!("Zero");
} else {
    println!("Negative");
}

let number = 3;

match number {
    1 => println!("One"),
    2..=4 => println!("Between Two and Four"),
    _ => println!("Other"),
}

let temperature = 25;

if temperature > 30 {
    println!("Hot");
} else if temperature >= 15 {
    println!("Warm");
} else {
    println!("Cold");
}

enum Weather {
    Sunny,
    Rainy,
    Cloudy,
}

let today = Weather::Rainy;

match today {
    Weather::Sunny => println!("It's sunny!"),
    Weather::Rainy => println!("Bring an umbrella!"),
    Weather::Cloudy => println!("It might rain later."),
}

let value = Some(10);

if let Some(x) = value {
    match x {
        1 => println!("One"),
        2..=9 => println!("Between Two and Nine"),
        _ => println!("Greater than Nine"),
    }
} else {
    println!("No value");
}

fn simple_if_branching(x: i32) -> i32 {
    if x > 50 {
        100
    } else {
        0
    }
}

fn complex_match_branching(x: i32) -> i32 {
    match x {
        0 => 0,
        1..=50 => 50,
        51..=100 => 100,
        _ => -1,
    }
}

fn optimized_branching(x: i32) -> i32 {
    if x < 0 {
        -1
    } else if x <= 50 {
        50
    } else if x <= 100 {
        100
    } else {
        -1
    }
}

#[bench]
fn bench_simple_if(b: &mut Bencher) {
    b.iter(|| simple_if_branching(black_box(75)));
}

#[bench]
fn bench_complex_match(b: &mut Bencher) {
    b.iter(|| complex_match_branching(black_box(75)));
}

#[bench]
fn bench_optimized(b: &mut Bencher) {
    b.iter(|| optimized_branching(black_box(75)));
}

fn validate_input(input: i32) -> Result<(), &'static str> {
    if input < 0 {
        Err("Input must be non-negative")
    } else if input > 100 {
        Err("Input must be less than or equal to 100")
    } else {
        Ok(())
    }
}

fn main() {
    match validate_input(150) {
        Ok(_) => println!("Input is valid"),
        Err(e) => println!("Error: {}", e),
    }
}

enum AppError {
    NotFound,
    InvalidInput(String),
    Unknown,
}

fn handle_error(error: AppError) {
    match error {
        AppError::NotFound => println!("Error: Resource not found"),
        AppError::InvalidInput(reason) => println!("Error: Invalid input - {}", reason),
        AppError::Unknown => println!("Error: Unknown error occurred"),
    }
}

fn main() {
    let error = AppError::InvalidInput("Invalid data format".to_string());
    handle_error(error);
}

   fn process_data(data: Option<i32>) -> Result<i32, &'static str> {
       let value = data.ok_or("Data is missing")?;
       if value < 0 {
           return Err("Value must be non-negative");
       }
       Ok(value * 2)
   }

   fn parse_input(input: &str) -> Result<i32, AppError> {
       input.parse::<i32>().map_err(|_| AppError::InvalidInput(input.to_string()))
   }

   use std::fs;

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

enum NetworkError {
    Timeout,
    ConnectionRefused,
    ProtocolError,
}

fn handle_network_response(response: Result<String, NetworkError>) {
    match response {
        Ok(data) => println!("Data received: {}", data),
        Err(NetworkError::Timeout) => println!("Error: Request timed out"),
        Err(NetworkError::ConnectionRefused) => println!("Error: Connection refused"),
        Err(NetworkError::ProtocolError) => println!("Error: Protocol error"),
    }
}

fn classify_data(data: Vec<i32>) -> (Vec<i32>, Vec<i32>) {
    let mut positives = Vec::new();
    let mut negatives = Vec::new();

    for &value in &data {
        if value > 0 {
            positives.push(value);
        } else if value < 0 {
            negatives.push(value);
        }
    }

    (positives, negatives)
}

fn main() {
    let data = vec![-10, 15, -20, 30, 0];
    let (positives, negatives) = classify_data(data);
    println!("Positives: {:?}", positives);
    println!("Negatives: {:?}", negatives);
}

use rayon::prelude::*;

fn sum_even_numbers(data: Vec<i32>) -> i32 {
    data.par_iter() // 並列イテレータを使用
        .filter(|&&x| x % 2 == 0)
        .sum()
}

fn main() {
    let data = (1..=1_000_000).collect();
    let sum = sum_even_numbers(data);
    println!("Sum of even numbers: {}", sum);
}

use std::collections::HashMap;

fn factorial(n: u32, cache: &mut HashMap<u32, u32>) -> u32 {
    if let Some(&result) = cache.get(&n) {
        return result;
    }

    let result = if n <= 1 { 1 } else { n * factorial(n - 1, cache) };
    cache.insert(n, result);
    result
}

fn main() {
    let mut cache = HashMap::new();
    let result = factorial(10, &mut cache);
    println!("Factorial of 10: {}", result);
}

fn process_data(data: Vec<i32>) -> Result<Vec<i32>, &'static str> {
    if data.is_empty() {
        return Err("Data is empty");
    }

    let filtered: Vec<i32> = data.into_iter().filter(|&x| x >= 0).collect();
    Ok(filtered)
}

fn main() {
    let data = vec![10, -5, 20, -10];
    match process_data(data) {
        Ok(result) => println!("Processed data: {:?}", result),
        Err(e) => println!("Error: {}", e),
    }
}

enum Command {
    Print(String),
    Repeat(String, u32),
    Exit,
}

process_command(Command::Print("Hello".to_string())); // Hello
process_command(Command::Repeat("Hi".to_string(), 3)); // Hi Hi Hi
process_command(Command::Exit); // Exiting...

average_of_evens(vec![1, 3, 5]); // Err("No even numbers found")
average_of_evens(vec![]); // Err("Input list is empty")
average_of_evens(vec![2, 4, 6]); // Ok(4.0)