Complete code of multi-parameter Hook mechanism using enum in Rust

In Rust, if you want to implement a Hook mechanism with multiple parameters for enum, you can combine pattern matching and enumeration to handle it. This approach can be extended to support different types of input parameters and logic processing.

Here is a complete example of a multi-parameter mechanism that implements enum and Hook:

Define enumeration and Hook types

use std::sync::{Arc, Mutex};
// Define a multi-parameter enumenum HookInput {
    Add(i32, i32),
    Multiply(i32, i32),
    Concat(String, String),
}
// Define a multiple return value enumenum HookOutput {
    Sum(i32),
    Product(i32),
    Combined(String),
    None,
}
// Define the Hook typetype HookFn = Arc&lt;dyn Fn(HookInput) -&gt; HookOutput + Send + Sync&gt;;
// Hook Managerstruct HookManager {
    hooks: Mutex&lt;Vec&lt;HookFn&gt;&gt;,
}
impl HookManager {
    fn new() -&gt; Self {
        Self {
            hooks: Mutex::new(Vec::new()),
        }
    }
    // Add a Hook function    fn add_hook&lt;F&gt;(&amp;self, hook: F)
    where
        F: Fn(HookInput) -&gt; HookOutput + Send + Sync + 'static,
    {
        ().unwrap().push(Arc::new(hook));
    }
    // Execute all Hooks    fn execute_hooks(&amp;self, input: HookInput) -&gt; Vec&lt;HookOutput&gt; {
        let hooks = ().unwrap();
        ().map(|hook| hook(())).collect()
    }
}
// Implement Clone's support for HookInputimpl Clone for HookInput {
    fn clone(&amp;self) -&gt; Self {
        match self {
            HookInput::Add(a, b) =&gt; HookInput::Add(*a, *b),
            HookInput::Multiply(a, b) =&gt; HookInput::Multiply(*a, *b),
            HookInput::Concat(a, b) =&gt; HookInput::Concat((), ()),
        }
    }
}

Using the Hook Manager

fn main() {
    let manager = HookManager::new();
    // Add the first Hook: Process Add    manager.add_hook(|input| match input {
        HookInput::Add(a, b) =&gt; {
            println!("Adding: {} + {}", a, b);
            HookOutput::Sum(a + b)
        }
        _ =&gt; HookOutput::None,
    });
    // Add a second Hook: Handle Multiply    manager.add_hook(|input| match input {
        HookInput::Multiply(a, b) =&gt; {
            println!("Multiplying: {} * {}", a, b);
            HookOutput::Product(a * b)
        }
        _ =&gt; HookOutput::None,
    });
    // Add a third Hook: Process Concat    manager.add_hook(|input| match input {
        HookInput::Concat(a, b) =&gt; {
            println!("Concatenating: {} + {}", a, b);
            HookOutput::Combined(format!("{}{}", a, b))
        }
        _ =&gt; HookOutput::None,
    });
    // Execute Hook: Add    let add_results = manager.execute_hooks(HookInput::Add(3, 4));
    println!("Results for Add: {:?}", add_results);
    // Execute Hook: Multiply    let multiply_results = manager.execute_hooks(HookInput::Multiply(5, 6));
    println!("Results for Multiply: {:?}", multiply_results);
    // Execute Hook: Concat    let concat_results = manager.execute_hooks(HookInput::Concat(
        "Hello".to_string(),
        "World".to_string(),
    ));
    println!("Results for Concat: {:?}", concat_results);
}

Sample running results

Adding: 3 + 4
Results for Add: [Sum(7), None, None]

Multiplying: 5 * 6
Results for Multiply: [None, Product(30), None]

Concatenating: Hello + World
Results for Concat: [None, None, Combined("HelloWorld")]

Code parsing

Multi-parameter processing:

• HookInput uses enumeration to define different input types (such as Add(i32, i32), Multiply(i32, i32), Concat(String, String)).
• Each variant represents a different logical branch that can be expanded to more operation types.

Multiple return value processing:
• HookOutput uses enumeration to define different output types (such as Sum(i32), Product(i32), Combined(String)).
• Each variant corresponds to a different return value logic.

Hook Manager:
• HookManager uses Vec to store all registered Hook functions.
• execute_hooks traverses all Hooks and calls the corresponding logic based on the input to collect the return value.

Scalability:
• New HookInput and HookOutput enumeration variants can be easily added to extend new logic.
• The new Hook function only needs to match the newly added variant.

Optimization direction

Parallel execution:
If multiple Hooks can be executed in parallel, parallel iteration tools such as rayon can be introduced.

use rayon::prelude::*;
hooks.par_iter().map(|hook| hook(())).collect()

Dynamic dispatch:
If you need to dynamically register more types of operations, you can define the input parameters as Box and use them in conjunction with downcast. Return value filtering:
The results of HookOutput::None can be filtered out in execute_hooks to simplify result processing.

Summarize

• Core idea:
Use enum to express multiple input and output types, and implement a Hook mechanism with multi-parameter and multi-logical branches in conjunction with pattern matching.
• Strong scalability:
With the addition of new enumeration variants, more input and return value types can be easily supported.
• Applicable scenarios:
• Plug-in system
• Event-driven architecture
• Dynamic business logic processing

This is the end of this article about using enum to implement the multi-parameter Hook mechanism in Rust. For more related contents of the Rust enum multi-parameter Hook mechanism, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!