let add = |x: i32, y: i32| x + y;
println!("5 + 3 = {}", add(5, 3));

fn print_items<T>(items: Vec<T>) {
    for item in items {
        println!("{:?}", item);
    }
}

fn apply_to_value<T, F>(value: T, func: F) -> T
where
    F: Fn(T) -> T,
{
    func(value)
}

fn main() {
    let multiply = |x| x * 2;

    println!("{}", apply_to_value(5, multiply)); // 整数
    println!("{}", apply_to_value(2.5, multiply)); // 浮動小数点数
}

fn apply_with_logging<T, F>(value: T, func: F) -> T
where
    T: Clone + std::fmt::Debug,
    F: Fn(T) -> T,
{
    println!("Applying function to: {:?}", value.clone());
    func(value)
}

fn filter_items<T, F>(items: Vec<T>, predicate: F) -> Vec<T>
where
    F: Fn(&T) -> bool,
{
    items.into_iter().filter(predicate).collect()
}

fn main() {
    let numbers = vec![1, 2, 3, 4, 5, 6];
    let is_even = |x: &i32| x % 2 == 0;

    let even_numbers = filter_items(numbers, is_even);
    println!("{:?}", even_numbers); // [2, 4, 6]
}

fn apply_operations<T, F>(value: T, operations: Vec<F>) -> T
where
    T: Clone,
    F: Fn(T) -> T,
{
    operations.into_iter().fold(value, |acc, op| op(acc))
}

fn main() {
    let start = 1;
    let operations = vec![
        |x| x + 1,
        |x| x * 2,
        |x| x - 3,
    ];

    let result = apply_operations(start, operations);
    println!("{}", result); // ((1 + 1) * 2) - 3 = 1
}

fn process_with_default<T, F>(value: Option<T>, default: T, operation: F) -> T
where
    F: Fn(T) -> T,
{
    match value {
        Some(v) => operation(v),
        None => default,
    }
}

fn main() {
    let value = Some(5);
    let result = process_with_default(value, 10, |x| x * 2);
    println!("{}", result); // 10

    let no_value: Option<i32> = None;
    let result = process_with_default(no_value, 10, |x| x * 2);
    println!("{}", result); // 10
}

fn apply_to_each<T, F>(values: Vec<T>, func: F) -> Vec<T>
where
    F: Fn(T) -> T,
{
    values.into_iter().map(func).collect()
}

fn main() {
    let values = vec![1, 2, 3, 4, 5];
    let square = |x| x * x;

    let squared_values = apply_to_each(values, square);
    println!("{:?}", squared_values); // [1, 4, 9, 16, 25]
}

fn filter_and_transform<T, U, F, G>(values: Vec<T>, filter: F, transform: G) -> Vec<U>
where
    F: Fn(&T) -> bool,
    G: Fn(T) -> U,
{
    values
        .into_iter()
        .filter(filter)
        .map(transform)
        .collect()
}

fn main() {
    let values = vec![1, 2, 3, 4, 5, 6];
    let is_even = |x: &i32| x % 2 == 0;
    let double = |x: i32| x * 2;

    let processed_values = filter_and_transform(values, is_even, double);
    println!("{:?}", processed_values); // [4, 8, 12]
}

fn create_pipeline<T, F1, F2>(func1: F1, func2: F2) -> impl Fn(T) -> T
where
    F

let pipeline = create_pipeline(add_one, multiply_by_two);

let result = pipeline(3); // (3 + 1) * 2 = 8
println!("{}", result); // 8

この例では、`create_pipeline`関数が2つのクロージャを組み合わせて、連続したデータ処理の流れを作成しています。これは、データ処理の段階を柔軟に構成するのに役立ちます。

<h3>実用性のポイント</h3>  
- **カスタマイズ可能**: クロージャを高階関数と組み合わせることで、処理内容を簡単に変更できます。  
- **コードの簡潔化**: 高階関数とクロージャを利用することで、冗長なコードをシンプルにまとめられます。  
- **スケーラビリティ**: 高階関数を活用することで、処理のパイプラインやフィルタリングが簡単に拡張可能です。

次章では、このような高階関数とジェネリック型クロージャを用いたエラーハンドリングの実践例について掘り下げます。
<h2>ジェネリック型クロージャを用いたエラーハンドリング</h2>  

ジェネリック型クロージャは、エラーハンドリングを柔軟かつ効率的に行うためにも利用できます。これにより、異なる型のエラーや結果を統一的に扱う仕組みを構築できます。

<h3>基本的なエラーハンドリングの仕組み</h3>  
Rustでは、エラーハンドリングに`Result`型を利用します。ジェネリック型クロージャを組み合わせることで、異なるエラー型を処理する汎用的な高階関数を作成できます。

以下は、クロージャを使ってエラー処理をカスタマイズする例です：

let handler = |err: &str| eprintln!("Error: {}", err);

if let Some(value) = handle_result(success, handler) {
    println!("Success: {}", value);
}

handle_result(failure, handler); // Prints: "Error: Something went wrong"

この例では、ジェネリック型クロージャ`handler`を使用してエラー処理のロジックをカスタマイズできます。

<h3>エラーを変換するクロージャの活用</h3>  
異なる型のエラーを統一するために、エラー変換の仕組みをジェネリック型クロージャで実装できます。

let transform = |err: &str| format!("Error occurred: {}", err);

let new_result: Result<i32, String> = map_error(result, transform);

match new_result {
    Ok(value) => println!("Value: {}", value),
    Err(err) => println!("{}", err), // Prints: "Error occurred: Invalid input"
}

このコードでは、エラー型`&str`を`String`型に変換し、扱いやすい形でエラー情報を伝達します。

<h3>ジェネリック型クロージャと`Option`の組み合わせ</h3>  
エラーハンドリングだけでなく、値が存在しない場合（`Option::None`）に特定の処理を実行するためにも利用できます。

handle_option(value, || eprintln!("No value found!")); // Prints: "No value found!"

ここでは、`on_none`クロージャが`None`の場合の処理をカスタマイズします。

<h3>実用性のポイント</h3>  
- **汎用性**: 任意のエラー型や処理に対応可能な仕組みを構築できます。  
- **再利用性**: エラー処理のロジックをクロージャとして分離することで、再利用可能なモジュールが作れます。  
- **可読性向上**: エラーハンドリングを簡潔にし、コードの可読性を向上させます。

次章では、カスタム型を使用した汎用クロージャの設計演習を通じて、さらに理解を深めていきます。
<h2>実践演習：カスタム型を使った汎用クロージャの実装</h2>  

ジェネリック型クロージャを活用することで、特定の要件を満たす柔軟なデータ処理システムを構築できます。この章では、カスタム型を利用して汎用クロージャを実装する演習を行います。

<h3>演習内容</h3>  
カスタム型`Transaction`を定義し、その処理をジェネリック型クロージャで動的に変更可能な関数を作成します。

<h3>カスタム型の定義</h3>  
以下のように、`Transaction`型を定義します：

この型は、取引のID、金額、説明文を持つ構造体です。

<h3>汎用的なクロージャを利用した処理関数</h3>  
ジェネリック型クロージャを利用して、`Transaction`型を動的に処理します。以下のような関数を作成します：

let display_transaction = |t: &Transaction| {
    println!("ID: {}, Amount: {}, Description: {}", t.id, t.amount, t.description);
};

process_transactions(transactions, display_transaction);

このコードでは、`process_transactions`関数がクロージャ`display_transaction`を用いて各取引を表示します。

<h3>演習課題1: 条件付きフィルタリング</h3>  
条件に基づいて取引をフィルタリングし、選択された取引のみを表示します。以下は解答例です：

let positive_transactions = filter_transactions(transactions, |t| t.amount > 0.0);

for t in positive_transactions {
    println!("{:?}", t);
}

<h3>演習課題2: 統計情報の算出</h3>  
取引の合計金額を計算するジェネリッククロージャを作成します：

let total = calculate_total(transactions, |acc, t| acc + t.amount);

println!("Total amount: {}", total); // 250.0

<h3>ポイント</h3>  
- **カスタム型の活用**: カスタム型を利用することで、現実的なデータ処理が可能になります。  
- **動的処理**: ジェネリック型クロージャを使うことで、異なる処理を簡単に切り替えられます。  
- **再利用性**: 汎用関数とクロージャを組み合わせることで、コードの再利用性を向上させます。

次章では、Rustにおけるクロージャとジェネリック型を使用したベストプラクティスについて詳しく解説します。
<h2>Rustにおけるクロージャとジェネリック型のベストプラクティス</h2>  

ジェネリック型クロージャを効果的に利用するためには、いくつかのベストプラクティスを押さえる必要があります。これらのポイントを活用することで、コードの保守性、効率性、可読性を向上させることができます。

<h3>1. 明確なトレイト境界の指定</h3>  
ジェネリック型を使用する際には、必要なトレイトを明確に指定することが重要です。これにより、型の制約を明示し、エラーの発生を未然に防ぐことができます。

例：

このコードでは、`T`が`Clone`と`Debug`を実装していることを保証することで、安全に関数を実行できます。

<h3>2. 冗長な型定義を避ける</h3>  
Rustは型推論が非常に優れているため、可能な限り型を明示せずにクロージャを記述することで、コードを簡潔に保つことができます。

例：

<h3>3. 高階関数と組み合わせた汎用化</h3>  
高階関数を活用することで、クロージャの汎用性をさらに高められます。例えば、`map`や`filter`のようなイテレータメソッドを使用する場合、クロージャを動的に変更することが可能です。

例：

<h3>4. エラー処理の一元化</h3>  
エラー処理をクロージャに委ねることで、コードの一貫性を保ちつつ、エラーの取り扱いを柔軟に制御できます。

例：

<h3>5. ドキュメントコメントを活用</h3>  
クロージャを用いた汎用関数は、柔軟性が高い反面、複雑になりがちです。適切なドキュメントコメントを記述することで、コードの目的や使用方法を明確に伝えることができます。

例：

<h3>6. ベンチマークとプロファイリングの実施</h3>  
ジェネリック型やクロージャは非常に効率的ですが、特定のシナリオではオーバーヘッドが生じる場合もあります。パフォーマンスを向上させるために、`cargo bench`やプロファイリングツールを活用して最適化を検討しましょう。

<h3>7. モジュール化とテストの強化</h3>  
ジェネリック型クロージャを活用したコードは、モジュールごとに分離し、ユニットテストを充実させることで保守性を高めることができます。

例：

#[test]
fn test_add_one() {
    let add_one = |x| x + 1;
    assert_eq!(add_one(5), 6);
}