mirror of
https://github.com/rust-lang/rustlings.git
synced 2025-12-28 06:49:19 +00:00
38 lines
1.6 KiB
Rust
38 lines
1.6 KiB
Rust
// This program demonstrates the transformation of a synchronous function into an asynchronous one.
|
|
// The original function performs a time-consuming operation, which we'll simulate with a sleep.
|
|
// You need to convert this function to use async/await syntax and understand how it improves the responsiveness of the application.
|
|
|
|
use std::time::Duration;
|
|
use futures::executor::block_on; // This is for running the async main function in this educational context.
|
|
use tokio; // We use tokio for the async sleep functionality.
|
|
|
|
// Synchronous version of a function that simulates a long-running operation
|
|
fn calculate_value_synchronously() -> i32 {
|
|
println!("Starting synchronous calculation...");
|
|
std::thread::sleep(Duration::from_secs(2)); // Simulating a long-running task
|
|
println!("Synchronous calculation done.");
|
|
42 // returns a computed value
|
|
}
|
|
|
|
// Converted to async version
|
|
async fn calculate_value_asynchronously() -> i32 {
|
|
println!("Starting asynchronous calculation...");
|
|
tokio::time::sleep(Duration::from_secs(2)).await; // Using Tokio's async sleep
|
|
println!("Asynchronous calculation done.");
|
|
42 // returns a computed value
|
|
}
|
|
|
|
async fn main_async() {
|
|
println!("Calling synchronous function:");
|
|
let sync_result = calculate_value_synchronously();
|
|
println!("Result from synchronous function: {}", sync_result);
|
|
|
|
println!("Calling asynchronous function:");
|
|
let async_result = calculate_value_asynchronously().await;
|
|
println!("Result from asynchronous function: {}", async_result);
|
|
}
|
|
|
|
fn main() {
|
|
block_on(main_async());
|
|
}
|