Remove 'static constraint from block_on

Factor out `spawn` into an unsafe helper `spawn_unchecked` where
`block_on` can allow a non-static future and output to execute because
dataflow ensures the Task does not outlive the future.

Fixes #107

Author: pchickey

src/runtime/block_on.rs

@@ -7,8 +7,7 @@ use std::task::{Context, Poll, Waker};
 /// Start the event loop. Blocks until the future
 pub fn block_on<F>(fut: F) -> F::Output
 where
-    F: Future + 'static,
-    F::Output: 'static,
+    F: Future,
 {
     // Construct the reactor
     let reactor = Reactor::new();
@@ -19,7 +18,11 @@ where
     }
 
     // Spawn the task onto the reactor.
-    let root_task = reactor.spawn(fut);
+    // Safety: The execution loop below, concluding with pulling the Ready out
+    // of the root_task, ensures that it does not outlive the Future or its
+    // output.
+    #[allow(unsafe_code)]
+    let root_task = unsafe { reactor.spawn_unchecked(fut) };
 
     loop {
         match reactor.pop_ready_list() {

src/runtime/reactor.rs

@@ -258,11 +258,17 @@ impl Reactor {
         ready
     }
 
-    /// Spawn a `Task` on the `Reactor`.
-    pub fn spawn<F, T>(&self, fut: F) -> Task<T>
+    /// We need an unchecked spawn for implementing `block_on`, where the
+    /// implementation does not expose the resulting Task and does not return
+    /// until all tasks have finished execution.
+    ///
+    /// # Safety
+    /// Caller must ensure that the Task<T> does not outlive the Future F or
+    /// F::Output T.
+    #[allow(unsafe_code)]
+    pub(crate) unsafe fn spawn_unchecked<F, T>(&self, fut: F) -> Task<T>
     where
-        F: Future<Output = T> + 'static,
-        T: 'static,
+        F: Future<Output = T>,
     {
         let this = self.clone();
         let schedule = move |runnable| this.inner.ready_list.lock().unwrap().push_back(runnable);
@@ -278,6 +284,19 @@ impl Reactor {
         task
     }
 
+    /// Spawn a `Task` on the `Reactor`.
+    pub fn spawn<F, T>(&self, fut: F) -> Task<T>
+    where
+        F: Future<Output = T> + 'static,
+        T: 'static,
+    {
+        // Safety: 'static constraints satisfy the lifetime requirements
+        #[allow(unsafe_code)]
+        unsafe {
+            self.spawn_unchecked(fut)
+        }
+    }
+
     pub(super) fn pop_ready_list(&self) -> Option<Runnable> {
         self.inner.ready_list.lock().unwrap().pop_front()
     }