Rustでループ処理を抽象化する関数設計のポイントと実践例

for i in 0..5 {
    println!("i: {}", i);
}

let mut count = 0;
while count < 5 {
    println!("count: {}", count);
    count += 1;
}

let mut count = 0;
loop {
    if count == 5 {
        break;
    }
    println!("count: {}", count);
    count += 1;
}

(0..5).for_each(|i| println!("i: {}", i));

fn filter_elements<T, F>(data: &[T], condition: F) -> Vec<T>
where
    T: Clone,
    F: Fn(&T) -> bool,
{
    data.iter().cloned().filter(condition).collect()
}

fn filter_even_numbers(data: &[i32]) -> Vec<i32> {
    filter_elements(data, |&x| x % 2 == 0)
}

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

let add = |a: i32, b: i32| -> i32 { a + b };
println!("{}", add(2, 3)); // 出力: 5

fn process_elements<T, F>(data: &[T], operation: F) -> Vec<T>
where
    T: Clone,
    F: Fn(&T) -> bool,
{
    data.iter().cloned().filter(operation).collect()
}

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

    // クロージャで偶数をフィルタリング
    let evens = process_elements(&numbers, |&x| x % 2 == 0);
    println!("Even numbers: {:?}", evens);

    // クロージャで奇数をフィルタリング
    let odds = process_elements(&numbers, |&x| x % 2 != 0);
    println!("Odd numbers: {:?}", odds);
}

fn transform_elements<T, U, F>(data: &[T], transform: F) -> Vec<U>
where
    F: Fn(&T) -> U,
{
    data.iter().map(transform).collect()
}

fn main() {
    let numbers = vec![1, 2, 3];
    let squares = transform_elements(&numbers, |&x| x * x);
    println!("Squares: {:?}", squares);
}

fn apply_with_state<F>(mut operation: F)
where
    F: FnMut() -> (),
{
    operation();
    operation();
}

fn main() {
    let mut count = 0;
    apply_with_state(|| {
        count += 1;
        println!("Count: {}", count);
    });
}

fn generic_function<T>(value: T) {
    println!("{:?}", value);
}

fn filter_generic<T, F>(data: &[T], condition: F) -> Vec<T>
where
    T: Clone,
    F: Fn(&T) -> bool,
{
    data.iter().cloned().filter(condition).collect()
}

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    let even_numbers = filter_generic(&numbers, |&x| x % 2 == 0);
    println!("Even numbers: {:?}", even_numbers);

    let words = vec!["apple", "banana", "cherry"];
    let long_words = filter_generic(&words, |word| word.len() > 5);
    println!("Long words: {:?}", long_words);
}

use std::fmt::Display;

fn print_elements<T>(data: &[T])
where
    T: Display,
{
    for item in data {
        println!("{}", item);
    }
}

fn main() {
    let numbers = vec![1, 2, 3];
    print_elements(&numbers);

    let words = vec!["Rust", "is", "great"];
    print_elements(&words);
}

fn combine<T, U>(a: T, b: U) -> String
where
    T: Display,
    U: Display,
{
    format!("{}{}", a, b)
}

fn main() {
    let result = combine(42, " is the answer");
    println!("{}", result);
}

fn filter_with_error<T, F, E>(data: &[T], condition: F) -> Result<Vec<T>, E>
where
    T: Clone,
    F: Fn(&T) -> Result<bool, E>,
{
    let mut results = Vec::new();
    for item in data {
        match condition(item)? {
            true => results.push(item.clone()),
            false => {}
        }
    }
    Ok(results)
}

fn main() -> Result<(), String> {
    let numbers = vec![1, 2, 3, 4, 5];

    // クロージャでエラーを模擬
    let filtered = filter_with_error(&numbers, |&x| {
        if x == 3 {
            Err("Value 3 is not allowed".to_string())
        } else {
            Ok(x % 2 == 0)
        }
    });

    match filtered {
        Ok(values) => println!("Filtered values: {:?}", values),
        Err(e) => println!("Error: {}", e),
    }

    Ok(())
}

#[derive(Debug)]
enum MyError {
    InvalidValue,
    CalculationError,
}

fn process_element(value: i32) -> Result<i32, MyError> {
    if value < 0 {
        Err(MyError::InvalidValue)
    } else {
        Ok(value * 2)
    }
}

fn process_numbers(data: &[i32]) -> Result<Vec<i32>, MyError> {
    data.iter().map(|&x| process_element(x)).collect()
}

fn filter_elements<T, F>(data: &[T], condition: F) -> Vec<T>
where
    T: Clone,
    F: Fn(&T) -> bool,
{
    data.iter().cloned().filter(condition).collect()
}

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

    // 偶数をフィルタリング
    let evens = filter_elements(&numbers, |&x| x % 2 == 0);
    println!("Even numbers: {:?}", evens);

    // 3より大きい数をフィルタリング
    let greater_than_three = filter_elements(&numbers, |&x| x > 3);
    println!("Numbers greater than 3: {:?}", greater_than_three);
}

fn multi_condition_filter<T, F>(data: &[T], conditions: Vec<F>) -> Vec<T>
where
    T: Clone,
    F: Fn(&T) -> bool,
{
    data.iter()
        .cloned()
        .filter(|item| conditions.iter().all(|cond| cond(item)))
        .collect()
}

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

    // 偶数かつ3より大きい数をフィルタリング
    let conditions: Vec<Box<dyn Fn(&i32) -> bool>> = vec![
        Box::new(|&x| x % 2 == 0),
        Box::new(|&x| x > 3),
    ];
    let result = multi_condition_filter(&numbers, conditions);
    println!("Filtered numbers: {:?}", result);
}

#[derive(Clone, Debug)]
struct Product {
    name: String,
    price: f64,
}

fn main() {
    let products = vec![
        Product {
            name: "Apple".to_string(),
            price: 1.2,
        },
        Product {
            name: "Banana".to_string(),
            price: 0.8,
        },
        Product {
            name: "Cherry".to_string(),
            price: 2.0,
        },
    ];

    // 価格が1ドル以上の商品のフィルタリング
    let filtered_products = filter_elements(&products, |p| p.price >= 1.0);
    println!("Filtered products: {:?}", filtered_products);
}

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

#[tokio::main]
async fn main() {
    for i in 1..=5 {
        println!("Processing item {}", i);
        sleep(Duration::from_secs(1)).await;
    }
    println!("All items processed.");
}

use tokio::time::{sleep, Duration};
use std::future::Future;

async fn process_items<T, F>(items: Vec<T>, process: F)
where
    F: Fn(T) -> Box<dyn Future<Output = ()> + Send>,
    T: Send + 'static,
{
    for item in items {
        process(item).await;
    }
}

#[tokio::main]
async fn main() {
    let items = vec![1, 2, 3, 4, 5];

    process_items(items, |item| {
        Box::new(async move {
            println!("Processing item {}", item);
            sleep(Duration::from_secs(1)).await;
        })
    })
    .await;
}

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

async fn process_item(item: i32) {
    println!("Processing item {}", item);
    sleep(Duration::from_secs(1)).await;
}

#[tokio::main]
async fn main() {
    let items = vec![1, 2, 3, 4, 5];
    let tasks: Vec<_> = items.into_iter().map(|item| process_item(item)).collect();
    futures::future::join_all(tasks).await;
    println!("All items processed.");
}

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

async fn process_item_with_error(item: i32) -> Result<(), String> {
    if item == 3 {
        Err("Error processing item 3".to_string())
    } else {
        println!("Processing item {}", item);
        sleep(Duration::from_secs(1)).await;
        Ok(())
    }
}

#[tokio::main]
async fn main() {
    let items = vec![1, 2, 3, 4, 5];
    for item in items {
        match process_item_with_error(item).await {
            Ok(_) => println!("Item {} processed successfully", item),
            Err(e) => println!("Error: {}", e),
        }
    }
}