fix: docs and tests

Author: NthTensor

src/lib.rs

@@ -42,6 +42,18 @@ mod signal;
 mod thread_pool;
 mod unwind;
 
+// -----------------------------------------------------------------------------
+// Type markers
+
+#[doc(hidden)]
+pub struct FnOnceMarker;
+
+#[doc(hidden)]
+pub struct FutureMarker;
+
+#[doc(hidden)]
+pub struct AsyncMarker;
+
 // -----------------------------------------------------------------------------
 // Top-level exports
 

src/scope.rs

@@ -15,6 +15,9 @@ use crate::job::JobRef;
 use crate::platform::*;
 use crate::signal::Signal;
 use crate::thread_pool::Worker;
+use crate::AsyncMarker;
+use crate::FnOnceMarker;
+use crate::FutureMarker;
 
 // -----------------------------------------------------------------------------
 // Scope
@@ -148,14 +151,18 @@ impl Drop for Scope<'_> {
 // -----------------------------------------------------------------------------
 // Generalized scoped spawn trait
 
-pub trait ScopedSpawn<'scope, T> {
+/// Logic for spawning scoped work onto a thread pool.
+///
+/// This trait defines the behavor of [`Scope::spawn`] for various types.
+pub trait ScopedSpawn<'scope, M> {
+    /// The output returned by the spawn operation. This is usually either the
+    /// empty type `()` or a `Task<T>`.
     type Output;
 
+    /// Spawns scoped work onto the thread pool.
     fn spawn(self, scope: &Scope<'scope>) -> Self::Output;
 }
 
-struct FnOnceMarker;
-
 impl<'scope, F> ScopedSpawn<'scope, FnOnceMarker> for F
 where
     F: FnOnce(&Scope<'scope>) + Send + 'scope,
@@ -191,8 +198,6 @@ where
     }
 }
 
-struct FutureMarker;
-
 impl<'scope, Fut, T> ScopedSpawn<'scope, FutureMarker> for Fut
 where
     Fut: Future<Output = T> + Send + 'scope,
@@ -207,8 +212,6 @@ where
     }
 }
 
-struct AsyncMarker;
-
 impl<'scope, Fn, Fut, T> ScopedSpawn<'scope, AsyncMarker> for Fn
 where
     Fn: FnOnce(&Scope<'scope>) -> Fut + Send + 'scope,
@@ -225,7 +228,11 @@ where
         // scope is via `Scope::new` and that function requires the caller pin
         // the scope before using it.
         let scope_ptr = unsafe { ScopePtr::new(scope) };
-        let future = async move { scope_ptr.run(self).await };
+        let future = async move {
+            let result = scope_ptr.run(self).await;
+            drop(scope_ptr);
+            result
+        };
 
         // The schedule function will turn the future into a job when woken.
         let schedule = move |runnable: Runnable| {

src/thread_pool.rs

@@ -31,6 +31,9 @@ use crate::platform::*;
 use crate::scope::Scope;
 use crate::signal::Signal;
 use crate::unwind;
+use crate::AsyncMarker;
+use crate::FnOnceMarker;
+use crate::FutureMarker;
 
 // -----------------------------------------------------------------------------
 // Thread pool worker leases
@@ -491,22 +494,26 @@ impl ThreadPool {
 // -----------------------------------------------------------------------------
 // Generalized spawn trait
 
-pub trait Spawn<T> {
+/// Logic for spawning work onto a thread pool.
+///
+/// This trait defines the behavior of [`ThreadPool::spawn`] for various types.
+pub trait Spawn<M> {
+    /// The output returned by the spawn operation. This is usually either the
+    /// empty type `()` or a `Task<T>`.
     type Output;
 
+    /// Spawns work onto the thread pool.
     fn spawn(self, thread_pool: &'static ThreadPool, worker: Option<&Worker>) -> Self::Output;
 }
 
-struct FnOnceMarker;
-
 impl<F> Spawn<FnOnceMarker> for F
 where
     F: FnOnce(&Worker) + Send + 'static,
 {
     type Output = ();
 
     #[inline]
-    fn spawn(self, _thread_pool: &'static ThreadPool, worker: Option<&Worker>) {
+    fn spawn(self, thread_pool: &'static ThreadPool, worker: Option<&Worker>) {
         // Allocate a new job on the heap to store the closure.
         let job = HeapJob::new(self);
 
@@ -523,13 +530,12 @@ where
         if let Some(worker) = worker {
             worker.queue.push_back(job_ref);
         } else {
-            todo!();
+            let mut state = thread_pool.state.lock().unwrap();
+            state.shared_jobs.push_back(job_ref);
         }
     }
 }
 
-struct FutureMarker;
-
 impl<Fut, T> Spawn<FutureMarker> for Fut
 where
     Fut: Future<Output = T> + Send + 'static,
@@ -588,8 +594,6 @@ where
     }
 }
 
-struct AsyncMarker;
-
 impl<Fn, Fut, T> Spawn<AsyncMarker> for Fn
 where
     Fn: FnOnce() -> Fut + Send + 'static,
@@ -613,7 +617,7 @@ impl ThreadPool {
     ///
     /// See also: [`Worker::spawn`] and [`spawn`].
     #[inline]
-    pub fn spawn<T, S: Spawn<T>>(&'static self, work: S) -> <S as Spawn<T>>::Output {
+    pub fn spawn<M, S: Spawn<M>>(&'static self, work: S) -> <S as Spawn<M>>::Output {
         work.spawn(self, None)
     }
 
@@ -955,7 +959,7 @@ impl Worker {
     /// If you do not have access to a [`Worker`], you may call
     /// [`ThreadPool::spawn`] or simply [`spawn`].
     #[inline]
-    pub fn spawn<T, S: Spawn<T>>(&self, work: S) -> <S as Spawn<T>>::Output {
+    pub fn spawn<M, S: Spawn<M>>(&self, work: S) -> <S as Spawn<M>>::Output {
         work.spawn(self.lease.thread_pool, Some(self))
     }
 
@@ -1104,7 +1108,7 @@ impl Worker {
 /// If there is no current thread pool, this panics.
 ///
 /// See also: [`Worker::spawn`] and [`ThreadPool::spawn`].
-pub fn spawn<T, S: Spawn<T>>(work: S) -> <S as Spawn<T>>::Output {
+pub fn spawn<M, S: Spawn<M>>(work: S) -> <S as Spawn<M>>::Output {
     Worker::with_current(|worker| {
         worker
             .expect("attempt to call `forte::spawn` from outside a thread pool")
@@ -1353,7 +1357,7 @@ mod tests {
 
         THREAD_POOL.scope(|scope| {
             for _ in 0..NUM_JOBS {
-                scope.spawn(|_| {
+                scope.spawn(|_: &Scope<'_>| {
                     THREAD_POOL.join(
                         |_| a.fetch_add(1, Ordering::Relaxed),
                         |_| b.fetch_add(1, Ordering::Relaxed),