Mastering Async Blocks in Rust

This challenge focuses on understanding and utilizing asynchronous programming constructs in Rust, specifically async blocks. You'll learn how to define and execute small, self-contained asynchronous operations within your Rust code, enabling more efficient and responsive applications.

Problem Description

Your task is to create a Rust program that demonstrates the use of an async block to perform a simulated, time-consuming operation. This operation should involve a short delay to mimic asynchronous work. You will then need to execute this async block and print its result to the console.

Key Requirements:

1. Define an async block: Create an async block that encapsulates a piece of asynchronous code.
2. Simulate asynchronous work: Inside the async block, use a function like tokio::time::sleep to introduce a small delay (e.g., 100 milliseconds).
3. Return a value: The async block should return a simple value (e.g., a string or an integer) after the delay.
4. Execute the async block: Use an asynchronous runtime (like Tokio) to run the async block and await its completion.
5. Print the result: Display the value returned by the async block to standard output.

Expected Behavior:

When the program is run, it should print the returned value from the async block. There should be a noticeable, albeit brief, pause before the output appears due to the simulated delay.

Edge Cases:

• Consider what happens if the delay is set to 0.
• Ensure proper handling of the asynchronous runtime initialization.

Examples

Example 1:

Input: No specific input needed, program runs directly.
Output:
Async operation completed!
Explanation: The program defines an async block that sleeps for a short duration and then returns a string. The async block is executed using Tokio, and the returned string is printed to the console.

Example 2:

Input: No specific input needed.
Output:
123
Explanation: The async block sleeps and returns an integer. The integer is then printed.

Constraints

• You must use the tokio runtime for executing asynchronous code.
• The simulated delay should be between 50 and 200 milliseconds.
• The async block must return a value.
• Your solution should be a single executable Rust program.

Notes

• You will need to add the tokio crate as a dependency to your Cargo.toml file.
• Remember to mark your main function with #[tokio::main] to enable the Tokio runtime.
• Think about how to "unwrap" the result from the Future returned by the async block.