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 {
+    type Item;
 
-    pub trait Stream {
+    fn for_each<Fut, F>(self, f: F) -> ForEach<Self, F>
-        type Item;
-
-        fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F>
-        where
-            F: FnMut(Self::Item) -> Fut,
-            Fut: Future<Output = ()>,
-            Self: Sized,
-        {
-            loop {}
-        }
-    }
-
-    pub fn map<T, F>(f: F) -> Map<F>
     where
-        F: FnMut(String) -> T,
+        F: FnMut(Self::Item) -> Fut,
+        Self: Sized,
     {
         loop {}
     }
+}
 
-    pub struct Map<F>(F);
+pub fn map<T, F>(f: F) -> Map<F>
+where
+    F: FnMut(String) -> T,
+{
+    loop {}
+}
 
-    pub trait FnOnce1<A> {
+pub struct Map<F>(F);
-        type Output;
-        fn call_once(self, arg: A) -> Self::Output;
-    }
 
-    impl<T, A, R> FnOnce1<A> for T
+pub trait FnOnce1<A> {
-    where
+    type Output;
-        T: FnOnce(A) -> R,
+    fn call_once(self, arg: A) -> Self::Output;
-    {
+}
-        type Output = R;
-        fn call_once(self, arg: A) -> R {
-            loop {}
-        }
-    }
 
-    impl<F> Stream for Map<F>
+impl<T, A, R> FnOnce1<A> for T
-    where
+where
-        F: FnOnce1<String>,
+    T: FnOnce(A) -> R,
-        F::Output: Project,
+{
-    {
+    type Output = R;
-        type Item = <F::Output as Project>::Assoc;
+    fn call_once(self, arg: A) -> R {
-    }
+        loop {}
-
-    pub struct ForEach<St, Fut, F> {
-        stream: St,
-        f: F,
-        future: Fut,
     }
 }
 
+impl<F> Stream for Map<F>
+where
+    F: FnOnce1<String>,
+    F::Output: Project,
+{
+    type Item = <F::Output as Project>::Assoc;
+}
+
+pub struct ForEach<St, F> {
+    stream: St,
+    f: F,
+}
+
 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 {