Remove async runtime requirement from examples

7 files changed, 41 insertions, 58 deletions

diff --git a/docs/pages/1-get-started.md b/docs/pages/1-get-started.md
index f4edfc0..b05e72b 100644
--- a/docs/pages/1-get-started.md
+++ b/docs/pages/1-get-started.md
@@ -9,24 +9,10 @@ cargo add mingling
 Or add the following to your `Cargo.toml`:
 ```toml
 [dependencies]
-mingling = "0.1.5"
+mingling = "0.1.6"
 ```
 
-> **Mingling** is an **async program**, so please use `async-std`, `tokio`, or another async runtime.
-
-2. This article assumes you are using the `tokio` async runtime. Add the following to your `Cargo.toml`:
-```toml
-tokio = { 
-    version = "1", 
-    features = [
-        "macros", 
-        "rt", 
-        "rt-multi-thread"
-    ] 
-}
-```
-
-3. Write the basic code in your `main.rs` or other program entry point.
+2. Write the basic code in your `main.rs` or other program entry point.
 ```rust
 use mingling::macros::{dispatcher, gen_program, r_println, renderer};
  
@@ -55,7 +41,7 @@ fn render_hello(_prev: HelloEntry) {
 gen_program!();
 ```
 
-4. Install your command-line program and run it.
+3. Install your command-line program and run it.
 ```bash
 cargo install --path ./
 your_bin hello
@@ -65,5 +51,17 @@ Result:
 Hello, World!
 ```
 
+## About Async Runtime
+
+**Mingling** supports **async runtime**, you can enable the `async` feature to activate it.
+
+After enabling it, **Mingling** will have the following changes:
+
+- The `Chain` trait and `chain!` macro will require you to use **async functions**
+- `Program::exec` will become an async function
+- The `gen_program!` macro will generate async functions
+
+**Mingling** does not depend on any specific asynchronous runtime internally, which means you can freely choose a suitable asynchronous runtime for your program (such as `async-std`, `tokio`)
+
 ## 💡 Next Steps
 > **Mingling**'s basic components [Go](./pages/2-basic)
diff --git a/docs/pages/2-basic/1-program.md b/docs/pages/2-basic/1-program.md
index fd8e986..ae22896 100644
--- a/docs/pages/2-basic/1-program.md
+++ b/docs/pages/2-basic/1-program.md
@@ -45,12 +45,11 @@ use mingling::{
     setup::BasicProgramSetup
 };
 
-#[tokio::main]
-async fn main() {
+fn main() {
     let mut program = ThisProgram::new();
     // Add `BasicProgramSetup`
     program.with_setup(BasicProgramSetup);
-    program.exec().await;
+    program.exec();
 }
 
 // Generate `ThisProgram`
@@ -68,8 +67,7 @@ dispatcher!("member.add",
 dispatcher!("member.rm", 
     RemoveMemberCommand => RemoveMemberEntry);
 
-#[tokio::main]
-async fn main() {
+fn main() {
     let mut program = ThisProgram::new();
 
     // Register Dispatchers
@@ -82,7 +80,7 @@ async fn main() {
         RemoveMemberCommand
     ));
 
-    program.exec().await;
+    program.exec();
 }
 ```
 
@@ -91,8 +89,7 @@ async fn main() {
 You can extract global arguments before the program runs to control the global state of the `Program`:
 
 ```rust
-#[tokio::main]
-async fn main() {
+fn main() {
     let mut program = ThisProgram::new();
 
     let mut output = current_dir().unwrap();
@@ -109,7 +106,7 @@ async fn main() {
         |_, v| output = PathBuf::from(v)
     );
 
-    program.exec().await;
+    program.exec();
 }
 ```
 
diff --git a/docs/pages/2-basic/2-setup.md b/docs/pages/2-basic/2-setup.md
index 8dbdd76..c80b91e 100644
--- a/docs/pages/2-basic/2-setup.md
+++ b/docs/pages/2-basic/2-setup.md
@@ -38,11 +38,10 @@ use mingling::{
 static OUTPUT_PATH: std::sync::OnceLock<PathBuf> 
     = std::sync::OnceLock::new();
 
-#[tokio::main]
-async fn main() {
+fn main() {
     let mut program = ThisProgram::new();
     program.with_setup(MySetup);
-    program.exec().await;
+    program.exec();
 }
 
 // Define two Dispatchers using `dispatcher!`
diff --git a/docs/pages/2-basic/3-dispatcher.md b/docs/pages/2-basic/3-dispatcher.md
index d0858d2..66e5c90 100644
--- a/docs/pages/2-basic/3-dispatcher.md
+++ b/docs/pages/2-basic/3-dispatcher.md
@@ -45,13 +45,12 @@ dispatcher!(MyProgram, "hello",
 **Tips:** Finally, add the `Dispatcher` you created to the [Program](pages/2-basic/1-program):
 
 ```rust
-#[tokio::main]
-async fn main() {
+fn main() {
     let mut program = ThisProgram::new();
     program.with_dispatcher(HelloCommand);
     program.with_dispatcher(SubFooCommand);
     program.with_dispatcher(SubBarCommand);
-    program.exec().await;
+    program.exec();
 }
 ```
 
diff --git a/docs/pages/2-basic/4-chain.md b/docs/pages/2-basic/4-chain.md
index 87a50f2..0fd375a 100644
--- a/docs/pages/2-basic/4-chain.md
+++ b/docs/pages/2-basic/4-chain.md
@@ -19,7 +19,7 @@ pack!(ParsedHello = String);
 // Define chain parse_hello (expands to ParseHello)
 // Declare conversion from HelloEntry
 #[chain]
-async fn parse_hello(prev: HelloEntry) -> NextProcess {
+fn parse_hello(prev: HelloEntry) -> NextProcess {
     // Take the inner reference of HelloEntry
     let args = &*prev;
 
@@ -41,10 +41,6 @@ async fn parse_hello(prev: HelloEntry) -> NextProcess {
 
 ## Manual Impl
 
-> ⚠️ WARNING
->
-> The following content is not yet fully implemented; currently, only the `chain!` macro is allowed for implementation.
-
 You can also manually implement the basic `Chain` for finer control.
 
 However, please note that within the `chain!` macro, a `register_type!` macro is executed. This macro does not expand to any content; it only informs the `gen_program` context that this type exists.
@@ -58,7 +54,7 @@ pack!(ParsedHello = String);
 struct ParseHello;
 impl Chain<ThisProgram> for ParseHello {
     type Previous = HelloEntry;
-    async fn proc(prev: Self::Previous) 
+    fn proc(prev: Self::Previous) 
         -> ChainProcess<ThisProgram> 
     {
         let args = &*prev;
@@ -72,9 +68,8 @@ impl Chain<ThisProgram> for ParseHello {
     }
 }
  
-// Register HelloEntry to the context and 
-//   assign an ID for it
-register_type!(HelloEntry);
+// Register chain to the context
+register_chain!(HelloEntry);
 ```
 
 ## 💡 Next Page
diff --git a/docs/pages/2-basic/5-renderer.md b/docs/pages/2-basic/5-renderer.md
index 1f566f2..12ac00f 100644
--- a/docs/pages/2-basic/5-renderer.md
+++ b/docs/pages/2-basic/5-renderer.md
@@ -21,7 +21,7 @@ pack!(ParsedHello = String);
 
 // It's the Chain defined in the Dispatcher chapter
 #[chain]
-async fn parse_hello(prev: HelloEntry) -> NextProcess {
+fn parse_hello(prev: HelloEntry) -> NextProcess {
     let args = &*prev;
     let first = args
         .first()
@@ -53,10 +53,6 @@ fn render_hello(prev: ParsedHello) {
 
 ## Manual Impl
 
-> ⚠️ WARNING
->
-> The following content is not yet fully implemented; currently, only the `renderer!` macro is allowed for implementation.
-
 Similarly, you can also manually implement `Renderer`,
 
 but note that inside the `renderer!` macro, a `register_type!` macro is executed. This macro itself does not expand into any content; it is only used to inform the `gen_program` context that the type exists:
@@ -73,5 +69,6 @@ impl Renderer for RenderHello {
     }
 }
  
-register_type!(ParsedHello);
+// Register renderer to the context
+register_renderer!(ParsedHello);
 ```
diff --git a/docs/pages/3-features/1-parser.md b/docs/pages/3-features/1-parser.md
index 2ebe31c..f89091b 100644
--- a/docs/pages/3-features/1-parser.md
+++ b/docs/pages/3-features/1-parser.md
@@ -25,7 +25,7 @@ The following demonstrates the parsing approach without using a `Picker`:
 
 ```rust
 #[chain]
-async fn parse_hello(prev: HelloEntry) -> NextProcess {
+fn parse_hello(prev: HelloEntry) -> NextProcess {
     let args = &*prev;
     let first = args.first().cloned().unwrap_or_else(|| "World".to_string());
     ParsedHello::new(first).to_render()
@@ -36,7 +36,7 @@ This is how it looks when using `Picker`:
 
 ```rust
 #[chain]
-async fn parse_hello(prev: HelloEntry) -> NextProcess {
+fn parse_hello(prev: HelloEntry) -> NextProcess {
     // Create Picker
     let picker = Picker::<ThisProgram>::new(prev.inner);
 
@@ -102,11 +102,10 @@ use mingling::{
     parser::PickableEnum,
 };
 
-#[tokio::main]
-async fn main() {
+fn main() {
     let mut program = ThisProgram::new();
     program.with_dispatcher(FruitEatCommand);
-    program.exec().await;
+    program.exec();
 }
 
 dispatcher!("eat",
@@ -131,7 +130,7 @@ enum Fruit {
 impl PickableEnum for Fruit {}
 
 #[chain]
-async fn parse_fruit_eat(prev: FruitEatEntry) -> NextProcess {
+fn parse_fruit_eat(prev: FruitEatEntry) -> NextProcess {
     // ...
 }
 
@@ -197,7 +196,7 @@ Now start writing the logic:
 
 ```rust
 #[chain]
-async fn parse_fruit_eat(prev: FruitEatEntry) -> NextProcess {
+fn parse_fruit_eat(prev: FruitEatEntry) -> NextProcess {
     let picker = Picker::new(prev.inner);
     let mut min_weight: i16 = 0;
     let parsed = picker
@@ -247,11 +246,10 @@ use mingling::{
     parser::{PickableEnum, Picker},
 };
 
-#[tokio::main]
-async fn main() {
+fn main() {
     let mut program = ThisProgram::new();
     program.with_dispatcher(FruitEatCommand);
-    program.exec().await;
+    program.exec();
 }
 
 dispatcher!("eat",
@@ -277,7 +275,7 @@ impl PickableEnum for Fruit {}
 pack!(MinGreaterThanMax = ());
 
 #[chain]
-async fn parse_fruit_eat(prev: FruitEatEntry) -> NextProcess {
+fn parse_fruit_eat(prev: FruitEatEntry) -> NextProcess {
     let picker = Picker::new(prev.inner);
     let mut min_weight: i16 = 0;
     let parsed = picker