add prelude. make tests compile but crash

Author: pchickey

Cargo.toml

@@ -15,6 +15,7 @@ authors = [
 [features]
 
 [dependencies]
+async-channel.workspace = true
 futures-core.workspace = true
 http.workspace = true
 pin-project-lite.workspace = true
@@ -24,6 +25,7 @@ wstd-macro.workspace = true
 
 [dev-dependencies]
 anyhow.workspace = true
+futures-lite.workspace = true
 serde_json.workspace = true
 test-programs-artifacts.workspace = true
 wasmtime.workspace = true
@@ -47,8 +49,10 @@ repository = "https://github.com/yoshuawuyts/wstd"
 
 [workspace.dependencies]
 anyhow = "1"
+async-channel = "1.6.1"
 cargo_metadata = "0.18.1"
 futures-core = "0.3.19"
+futures-lite = "1.12.0"
 heck = "0.5"
 http = "1.1"
 pin-project-lite = "0.2.8"

src/lib.rs

@@ -1,4 +1,8 @@
 #![allow(async_fn_in_trait)]
+#![warn(future_incompatible, unreachable_pub)]
+//#![deny(missing_debug_implementations)]
+//#![warn(missing_docs)]
+//#![forbid(rustdoc::missing_doc_code_examples)]
 
 //! An async standard library for Wasm Components and WASI 0.2
 //!
@@ -53,3 +57,28 @@ pub mod runtime;
 pub mod time;
 
 pub use wstd_macro::attr_macro_main as main;
+
+pub mod prelude {
+    pub use crate::http::Body as _;
+    pub use crate::io::AsyncRead as _;
+    pub use crate::io::AsyncWrite as _;
+    pub use crate::time::future::FutureExt as _;
+    pub use crate::time::future::Timer as _;
+    pub use crate::time::stream::IntoStream as _;
+    pub use crate::time::stream::StreamExt as _;
+    pub use std::future::IntoFuture as _;
+}
+
+/// An async multi-producer multi-consumer channel.
+pub mod channel {
+    /// Suspend or resume execution of a future.
+    #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+    pub enum Parker {
+        /// Put the future into a suspended state.
+        Park,
+        /// Put the future into an active state.
+        Unpark,
+    }
+    #[doc(inline)]
+    pub use async_channel::*;
+}

src/time/mod.rs

@@ -38,6 +38,7 @@ pub fn interval(duration: Duration) -> Interval {
 /// An async iterator representing notifications at fixed interval.
 ///
 /// See the [`interval`] function for more.
+#[derive(Debug)]
 pub struct Interval {
     duration: Duration,
 }

src/time/stream/buffer.rs

@@ -107,12 +107,12 @@ mod test {
 
     #[test]
     fn buffer_all_values() {
-        async_io::block_on(async {
+        crate::runtime::block_on(async {
             let interval = Duration::from_millis(5);
             let buffer = Duration::from_millis(20);
 
             let mut counter = 0;
-            crate::stream::interval(interval)
+            crate::time::stream::interval(interval)
                 .take(10)
                 .buffer(buffer)
                 .for_each(|buf| counter += buf.len())
@@ -124,12 +124,12 @@ mod test {
 
     #[test]
     fn no_debounces_hit() {
-        async_io::block_on(async {
+        crate::runtime::block_on(async {
             let interval = Duration::from_millis(20);
             let buffer = Duration::from_millis(10);
 
             let mut counter = 0;
-            crate::stream::interval(interval)
+            crate::time::stream::interval(interval)
                 .take(10)
                 .buffer(buffer)
                 .for_each(|buf| counter += buf.len())

src/time/stream/debounce.rs

@@ -111,12 +111,12 @@ mod test {
 
     #[test]
     fn all_values_debounce() {
-        async_io::block_on(async {
+        crate::runtime::block_on(async {
             let interval = Duration::from_millis(10);
             let debounce = Duration::from_millis(20);
 
             let mut counter = 0;
-            crate::stream::interval(interval)
+            crate::time::stream::interval(interval)
                 .take(10)
                 .debounce(debounce)
                 .for_each(|_| counter += 1)
@@ -128,12 +128,12 @@ mod test {
 
     #[test]
     fn no_debounces_hit() {
-        async_io::block_on(async {
+        crate::runtime::block_on(async {
             let interval = Duration::from_millis(40);
             let debounce = Duration::from_millis(10);
 
             let mut counter = 0;
-            crate::stream::interval(interval)
+            crate::time::stream::interval(interval)
                 .take(10)
                 .debounce(debounce)
                 .for_each(|_| counter += 1)

src/time/stream/sample.rs

@@ -106,15 +106,15 @@ mod test {
 
     #[test]
     fn smoke() {
-        async_io::block_on(async {
+        crate::runtime::block_on(async {
             let interval = Duration::from_millis(100);
             let throttle = Duration::from_millis(200);
 
             let take = 4;
             let expected = 2;
 
             let mut counter = 0;
-            crate::stream::interval(interval)
+            crate::time::stream::interval(interval)
                 .take(take)
                 .sample(throttle)
                 .for_each(|_| counter += 1)

src/time/stream/throttle.rs

@@ -109,15 +109,15 @@ mod test {
 
     #[test]
     fn smoke() {
-        async_io::block_on(async {
+        crate::runtime::block_on(async {
             let interval = Duration::from_millis(100);
             let throttle = Duration::from_millis(300);
 
             let take = 4;
             let expected = 2;
 
             let mut counter = 0;
-            crate::stream::interval(interval)
+            crate::time::stream::interval(interval)
                 .take(take)
                 .throttle(throttle)
                 .for_each(|_| counter += 1)