tokio: update threaded runtime to std::future (#1280)

re-enables the threaded runtime and sets it (again) as the default.

tokio/examples/echo-udp.rs

@@ -50,12 +50,12 @@ impl Server {
 }
 
 #[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
+async fn main() {
     let addr = env::args().nth(1).unwrap_or("127.0.0.1:8080".to_string());
-    let addr = addr.parse::<SocketAddr>()?;
+    let addr = addr.parse::<SocketAddr>().unwrap();
 
-    let socket = UdpSocket::bind(&addr)?;
-    println!("Listening on: {}", socket.local_addr()?);
+    let socket = UdpSocket::bind(&addr).unwrap();
+    println!("Listening on: {}", socket.local_addr().unwrap());
 
     let server = Server {
         socket: socket,
@@ -64,6 +64,5 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     };
 
     // This starts the server task.
-    server.run().await?;
-    Ok(())
+    server.run().await.unwrap();
 }

tokio/examples/hello_world.rs

@@ -19,16 +19,14 @@ use tokio::io::AsyncWriteExt;
 use tokio::net::TcpStream;
 
 #[tokio::main]
-pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let addr = "127.0.0.1:6142".parse()?;
+pub async fn main() {
+    let addr = "127.0.0.1:6142".parse().unwrap();
 
     // Open a TCP stream to the socket address.
     //
     // Note that this is the Tokio TcpStream, which is fully async.
-    let mut stream = TcpStream::connect(&addr).await?;
+    let mut stream = TcpStream::connect(&addr).await.unwrap();
     println!("created stream");
     let result = stream.write(b"hello world\n").await;
     println!("wrote to stream; success={:?}", result.is_ok());
-
-    Ok(())
 }

tokio/examples/udp-client.rs

@@ -41,29 +41,32 @@ fn get_stdin_data() -> Result<Vec<u8>, Box<dyn std::error::Error>> {
 }
 
 #[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
+async fn main() {
     let remote_addr: SocketAddr = env::args()
         .nth(1)
         .unwrap_or("127.0.0.1:8080".into())
-        .parse()?;
+        .parse()
+        .unwrap();
+
     // We use port 0 to let the operating system allocate an available port for us.
     let local_addr: SocketAddr = if remote_addr.is_ipv4() {
         "0.0.0.0:0"
     } else {
         "[::]:0"
     }
-    .parse()?;
-    let mut socket = UdpSocket::bind(&local_addr)?;
+    .parse()
+    .unwrap();
+
+    let mut socket = UdpSocket::bind(&local_addr).unwrap();
     const MAX_DATAGRAM_SIZE: usize = 65_507;
-    socket.connect(&remote_addr)?;
-    let data = get_stdin_data()?;
-    socket.send(&data).await?;
+    socket.connect(&remote_addr).unwrap();
+    let data = get_stdin_data().unwrap();
+    socket.send(&data).await.unwrap();
     let mut data = vec![0u8; MAX_DATAGRAM_SIZE];
-    let len = socket.recv(&mut data).await?;
+    let len = socket.recv(&mut data).await.unwrap();
     println!(
         "Received {} bytes:\n{}",
         len,
         String::from_utf8_lossy(&data[..len])
     );
-    Ok(())
 }