lol no futures

src/main.rs

@@ -10,65 +10,59 @@ impl<T> Project for FutResult<T> {
     type Assoc = Result<T, ()>;
 }
 
-mod fut {
+use crate::Project;
-    use std::future::Future;
 
-    use crate::Project;
+pub trait Stream {
-
-    pub trait Stream {
     type Item;
 
-        fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F>
+    fn for_each<Fut, F>(self, f: F) -> ForEach<Self, F>
     where
         F: FnMut(Self::Item) -> Fut,
-            Fut: Future<Output = ()>,
         Self: Sized,
     {
         loop {}
     }
-    }
+}
 
-    pub fn map<T, F>(f: F) -> Map<F>
+pub fn map<T, F>(f: F) -> Map<F>
-    where
+where
     F: FnMut(String) -> T,
-    {
+{
     loop {}
-    }
+}
 
-    pub struct Map<F>(F);
+pub struct Map<F>(F);
 
-    pub trait FnOnce1<A> {
+pub trait FnOnce1<A> {
     type Output;
     fn call_once(self, arg: A) -> Self::Output;
-    }
+}
 
-    impl<T, A, R> FnOnce1<A> for T
+impl<T, A, R> FnOnce1<A> for T
-    where
+where
     T: FnOnce(A) -> R,
-    {
+{
     type Output = R;
     fn call_once(self, arg: A) -> R {
         loop {}
     }
-    }
+}
 
-    impl<F> Stream for Map<F>
+impl<F> Stream for Map<F>
-    where
+where
     F: FnOnce1<String>,
     F::Output: Project,
-    {
+{
     type Item = <F::Output as Project>::Assoc;
-    }
+}
 
-    pub struct ForEach<St, Fut, F> {
+pub struct ForEach<St, F> {
     stream: St,
     f: F,
-        future: Fut,
-    }
 }
 
 fn main() {
-    let bodies = fut::map(|url| FutResult(Result::Ok(url)));
+    let bodies = map(|url| FutResult(Result::Ok(url)));
 
     bodies.for_each(|b| async {
         match b {