task::block_on -> thread::spawn_task

CHANGELOG.md

@@ -135,7 +135,7 @@ task::blocking(async {
 
 - Refactored the scheduling algorithm of our executor to use work stealing
 - Refactored the network driver, removing 400 lines of code
-- Removed the `Send` bound from `task::block_on`
+- Removed the `Send` bound from `thread::spawn_task`
 - Removed `Unpin` bound from `impl<T: futures::stream::Stream> Stream for T`
 
 # [0.99.5] - 2019-09-12

README.md

@@ -41,7 +41,7 @@ $ cargo add async-std
 use async_std::task;
 
 fn main() {
-    task::block_on(async {
+    thread::spawn_task(async {
         println!("Hello, world!");
     })
 }
@@ -72,7 +72,7 @@ async fn get() -> io::Result<Vec<u8>> {
 }
 
 fn main() {
-    task::block_on(async {
+    thread::spawn_task(async {
         let raw_response = get().await.expect("request");
         let response = String::from_utf8(raw_response)
             .expect("utf8 conversion");

benches/task_local.rs

@@ -13,7 +13,7 @@ fn get(b: &mut Bencher) {
     }
 
     let mut sum = 0;
-    task::block_on(async {
+    thread::spawn_task(async {
         b.iter(|| VAL.with(|v| sum += v));
     });
     black_box(sum);

docs/src/concepts/tasks.md

@@ -24,7 +24,7 @@ fn main() {
         }
     });
     println!("Started task!");
-    task::block_on(reader_task);
+    thread::spawn_task(reader_task);
     println!("Stopped task!");
 }
 ```
@@ -86,7 +86,7 @@ Tasks in `async_std` are one of the core abstractions. Much like Rust's `thread`
 # extern crate async_std;
 # use async_std::task;
 fn main() {
-    task::block_on(async {
+    thread::spawn_task(async {
         // this is std::fs, which blocks
         std::fs::read_to_string("test_file");
     })
@@ -107,7 +107,7 @@ In practice, that means that `block_on` propagates panics to the blocking compon
 # extern crate async_std;
 # use async_std::task;
 fn main() {
-    task::block_on(async {
+    thread::spawn_task(async {
         panic!("test");
     });
 }
@@ -128,7 +128,7 @@ task::spawn(async {
     panic!("test");
 });
 
-task::block_on(async {
+thread::spawn_task(async {
     task::sleep(Duration::from_millis(10000)).await;
 })
 ```

docs/src/tutorial/accept_loop.md

@@ -85,12 +85,12 @@ Finally, let's add main:
 // main
 fn run() -> Result<()> {
     let fut = accept_loop("127.0.0.1:8080");
-    task::block_on(fut)
+    thread::spawn_task(fut)
 }
 ```
 
 The crucial thing to realise that is in Rust, unlike other languages, calling an async function does **not** run any code.
 Async functions only construct futures, which are inert state machines.
 To start stepping through the future state-machine in an async function, you should use `.await`.
 In a non-async function, a way to execute a future is to hand it to the executor.
-In this case, we use `task::block_on` to execute a future on the current thread and block until it's done.
+In this case, we use `thread::spawn_task` to execute a future on the current thread and block until it's done.

docs/src/tutorial/all_together.md

@@ -25,7 +25,7 @@ type Receiver<T> = mpsc::UnboundedReceiver<T>;
 
 // main
 fn run() -> Result<()> {
-    task::block_on(accept_loop("127.0.0.1:8080"))
+    thread::spawn_task(accept_loop("127.0.0.1:8080"))
 }
 
 fn spawn_and_log_error<F>(fut: F) -> task::JoinHandle<()>

docs/src/tutorial/handling_disconnection.md

@@ -147,7 +147,7 @@ enum Void {}
 
 // main
 fn run() -> Result<()> {
-    task::block_on(accept_loop("127.0.0.1:8080"))
+    thread::spawn_task(accept_loop("127.0.0.1:8080"))
 }
 
 async fn accept_loop(addr: impl ToSocketAddrs) -> Result<()> {

docs/src/tutorial/implementing_a_client.md

@@ -29,7 +29,7 @@ type Result<T> = std::result::Result<T, Box<dyn std::error::Error + Send + Sync>
 
 // main
 fn run() -> Result<()> {
-    task::block_on(try_run("127.0.0.1:8080"))
+    thread::spawn_task(try_run("127.0.0.1:8080"))
 }
 
 async fn try_run(addr: impl ToSocketAddrs) -> Result<()> {

examples/a-chat/client.rs

@@ -5,13 +5,13 @@ use async_std::{
     io::{stdin, BufReader},
     net::{TcpStream, ToSocketAddrs},
     prelude::*,
-    task,
+    thread,
 };
 
 type Result<T> = std::result::Result<T, Box<dyn std::error::Error + Send + Sync>>;
 
 pub(crate) fn main() -> Result<()> {
-    task::block_on(try_main("127.0.0.1:8080"))
+    thread::spawn_task(try_main("127.0.0.1:8080"))
 }
 
 async fn try_main(addr: impl ToSocketAddrs) -> Result<()> {

examples/a-chat/server.rs

@@ -10,6 +10,7 @@ use async_std::{
     net::{TcpListener, TcpStream, ToSocketAddrs},
     prelude::*,
     task,
+    thread,
 };
 
 type Result<T> = std::result::Result<T, Box<dyn std::error::Error + Send + Sync>>;
@@ -20,7 +21,7 @@ type Receiver<T> = mpsc::UnboundedReceiver<T>;
 enum Void {}
 
 pub(crate) fn main() -> Result<()> {
-    task::block_on(accept_loop("127.0.0.1:8080"))
+    thread::spawn_task(accept_loop("127.0.0.1:8080"))
 }
 
 async fn accept_loop(addr: impl ToSocketAddrs) -> Result<()> {

examples/hello-world.rs

@@ -1,11 +1,11 @@
 //! Spawns a task that says hello.
 
-use async_std::task;
+use async_std::thread;
 
 async fn say_hi() {
     println!("Hello, world!");
 }
 
 fn main() {
-    task::block_on(say_hi())
+    thread::spawn_task(say_hi())
 }

examples/line-count.rs

@@ -5,12 +5,12 @@ use std::env::args;
 use async_std::fs::File;
 use async_std::io::{self, BufReader};
 use async_std::prelude::*;
-use async_std::task;
+use async_std::thread;
 
 fn main() -> io::Result<()> {
     let path = args().nth(1).expect("missing path argument");
 
-    task::block_on(async {
+    thread::spawn_task(async {
         let file = File::open(&path).await?;
         let mut lines = BufReader::new(file).lines();
         let mut count = 0u64;

examples/list-dir.rs

@@ -5,12 +5,12 @@ use std::env::args;
 use async_std::fs;
 use async_std::io;
 use async_std::prelude::*;
-use async_std::task;
+use async_std::thread;
 
 fn main() -> io::Result<()> {
     let path = args().nth(1).expect("missing path argument");
 
-    task::block_on(async {
+    thread::spawn_task(async {
         let mut dir = fs::read_dir(&path).await?;
 
         while let Some(res) = dir.next().await {

examples/logging.rs

@@ -1,11 +1,12 @@
 //! Prints the runtime's execution log on the standard output.
 
+use async_std::thread;
 use async_std::task;
 
 fn main() {
     femme::start(log::LevelFilter::Trace).unwrap();
 
-    task::block_on(async {
+    thread::spawn_task(async {
         let handle = task::spawn(async {
             log::info!("Hello world!");
         });

examples/print-file.rs

@@ -5,14 +5,14 @@ use std::env::args;
 use async_std::fs::File;
 use async_std::io;
 use async_std::prelude::*;
-use async_std::task;
+use async_std::thread;
 
 const LEN: usize = 16 * 1024; // 16 Kb
 
 fn main() -> io::Result<()> {
     let path = args().nth(1).expect("missing path argument");
 
-    task::block_on(async {
+    thread::spawn_task(async {
         let mut file = File::open(&path).await?;
         let mut stdout = io::stdout();
         let mut buf = vec![0u8; LEN];

examples/socket-timeouts.rs

@@ -2,7 +2,8 @@
 
 use std::time::Duration;
 
-use async_std::{io, net::TcpStream, prelude::*, task};
+use async_std::{io, net::TcpStream, prelude::*};
+use async_std::thread;
 
 async fn get() -> io::Result<Vec<u8>> {
     let mut stream = TcpStream::connect("example.com:80").await?;
@@ -20,7 +21,7 @@ async fn get() -> io::Result<Vec<u8>> {
 }
 
 fn main() {
-    task::block_on(async {
+    thread::spawn_task(async {
         let raw_response = get().await.expect("request");
         let response = String::from_utf8(raw_response).expect("utf8 conversion");
         println!("received: {}", response);

examples/stdin-echo.rs

@@ -2,10 +2,10 @@
 
 use async_std::io;
 use async_std::prelude::*;
-use async_std::task;
+use async_std::thread;
 
 fn main() -> io::Result<()> {
-    task::block_on(async {
+    thread::spawn_task(async {
         let stdin = io::stdin();
         let mut stdout = io::stdout();
         let mut line = String::new();

examples/stdin-timeout.rs

@@ -3,11 +3,11 @@
 use std::time::Duration;
 
 use async_std::io;
-use async_std::task;
+use async_std::thread;
 
 fn main() -> io::Result<()> {
     // This async scope times out after 5 seconds.
-    task::block_on(io::timeout(Duration::from_secs(5), async {
+    thread::spawn_task(io::timeout(Duration::from_secs(5), async {
         let stdin = io::stdin();
 
         // Read a line from the standard input and display it.

examples/surf-web.rs

@@ -1,10 +1,10 @@
 /* TODO: Once the next version of surf released, re-enable this example.
 //! Sends an HTTP request to the Rust website.
 
-use async_std::task;
+use async_std::thread;
 
 fn main() -> Result<(), surf::Exception> {
-    task::block_on(async {
+    thread::spawn_task(async {
         let url = "https://www.rust-lang.org";
         let mut response = surf::get(url).await?;
         let body = response.body_string().await?;

examples/task-local.rs

@@ -3,14 +3,14 @@
 use std::cell::Cell;
 
 use async_std::prelude::*;
-use async_std::task;
+use async_std::thread;
 
 task_local! {
     static VAR: Cell<i32> = Cell::new(1);
 }
 
 fn main() {
-    task::block_on(async {
+    thread::spawn_task(async {
         println!("var = {}", VAR.with(|v| v.get()));
         VAR.with(|v| v.set(2));
         println!("var = {}", VAR.with(|v| v.get()));

examples/task-name.rs

@@ -1,13 +1,14 @@
 //! Spawns a named task that prints its name.
 
 use async_std::task;
+use async_std::thread;
 
 async fn print_name() {
     println!("My name is {:?}", task::current().name());
 }
 
 fn main() {
-    task::block_on(async {
+    thread::spawn_task(async {
         task::Builder::new()
             .name("my-task".to_string())
             .spawn(print_name())

examples/tcp-client.rs

@@ -15,10 +15,10 @@
 use async_std::io;
 use async_std::net::TcpStream;
 use async_std::prelude::*;
-use async_std::task;
+use async_std::thread;
 
 fn main() -> io::Result<()> {
-    task::block_on(async {
+    thread::spawn_task(async {
         let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
         println!("Connected to {}", &stream.peer_addr()?);
 

examples/tcp-echo.rs

@@ -9,6 +9,7 @@
 use async_std::io;
 use async_std::net::{TcpListener, TcpStream};
 use async_std::prelude::*;
+use async_std::thread;
 use async_std::task;
 
 async fn process(stream: TcpStream) -> io::Result<()> {
@@ -21,7 +22,7 @@ async fn process(stream: TcpStream) -> io::Result<()> {
 }
 
 fn main() -> io::Result<()> {
-    task::block_on(async {
+    thread::spawn_task(async {
         let listener = TcpListener::bind("127.0.0.1:8080").await?;
         println!("Listening on {}", listener.local_addr()?);
 

examples/udp-client.rs

@@ -14,10 +14,10 @@
 
 use async_std::io;
 use async_std::net::UdpSocket;
-use async_std::task;
+use async_std::thread;
 
 fn main() -> io::Result<()> {
-    task::block_on(async {
+    thread::spawn_task(async {
         let socket = UdpSocket::bind("127.0.0.1:8081").await?;
         println!("Listening on {}", socket.local_addr()?);
 

examples/udp-echo.rs

@@ -8,10 +8,10 @@
 
 use async_std::io;
 use async_std::net::UdpSocket;
-use async_std::task;
+use async_std::thread;
 
 fn main() -> io::Result<()> {
-    task::block_on(async {
+    thread::spawn_task(async {
         let socket = UdpSocket::bind("127.0.0.1:8080").await?;
         let mut buf = vec![0u8; 1024];
 

src/fs/canonicalize.rs

@@ -23,7 +23,7 @@ use crate::task::blocking;
 /// # Examples
 ///
 /// ```no_run
-/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
+/// # fn main() -> std::io::Result<()> { async_std::thread::spawn_task(async {
 /// #
 /// use async_std::fs;
 ///

src/fs/copy.rs

@@ -31,7 +31,7 @@ use crate::task::blocking;
 /// # Examples
 ///
 /// ```no_run
-/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
+/// # fn main() -> std::io::Result<()> { async_std::thread::spawn_task(async {
 /// #
 /// use async_std::fs;
 ///

src/fs/create_dir.rs

@@ -25,7 +25,7 @@ use crate::task::blocking;
 /// # Examples
 ///
 /// ```no_run
-/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
+/// # fn main() -> std::io::Result<()> { async_std::thread::spawn_task(async {
 /// #
 /// use async_std::fs;
 ///