adding support for no_std executor

Cargo.toml

@@ -20,9 +20,9 @@ runtime_tokio = [
     "tokio",
     "atomic_refcell"
 ]
-# runtime_nostd = [
-#     "core"
-# ]
+runtime_nostd = [
+    "executor"
+]
 
 [dependencies]
 bastion-executor = { version = "0.3", optional = true, features = [] }
@@ -31,6 +31,7 @@ tokio = { version = "0.2", optional = true, features = ["rt-core", "blocking", "
 # core = { package = "core-futures-tls", version = "0.1.0", optional = true }
 lightproc = { version = "0.3.4", optional = true }
 atomic_refcell = { version = "0.1.6", optional = true }
+executor = { version = "0.7.0", optional = true }
 
 [dev-dependencies.tokio]
 features = ["rt-core", "blocking", "time" ]

ci.sh

@@ -3,5 +3,4 @@
 cargo test --features=runtime_bastion
 cargo test --features=runtime_asyncstd
 cargo test --features=runtime_tokio
-# Disabled until we have async / await in no_std
-# cargo test --features=runtime_nostd
+cargo test --features=runtime_nostd

src/executors.rs

@@ -2,8 +2,7 @@ use crate::join_handle::{InnerJoinHandle, JoinHandle};
 use crate::AgnostikExecutor;
 #[cfg(feature = "runtime_tokio")]
 use crate::LocalAgnostikExecutor;
-use std::future::Future;
-
+use core::future::Future;
 #[cfg(feature = "runtime_asyncstd")]
 pub(crate) struct AsyncStdExecutor;
 
@@ -144,3 +143,40 @@ impl AgnostikExecutor for BastionExecutor {
         bastion_executor::run::run(future, ProcStack::default())
     }
 }
+
+#[cfg(feature = "runtime_nostd")]
+pub(crate) struct NoStdExecutor;
+
+#[cfg(feature = "runtime_nostd")]
+impl NoStdExecutor {
+    pub fn new() -> Self {
+        NoStdExecutor {}
+    }
+}
+
+#[cfg(feature = "runtime_nostd")]
+impl AgnostikExecutor for NoStdExecutor {
+    fn spawn<F>(&self, _future: F) -> JoinHandle<F::Output>
+    where
+        F: Future + Send + 'static,
+        F::Output: Send + 'static,
+    {
+        panic!("no threads on no_std environments")
+    }
+
+    fn spawn_blocking<F, T>(&self, _task: F) -> JoinHandle<T>
+    where
+        F: FnOnce() -> T + Send + 'static,
+        T: Send + 'static,
+    {
+        panic!("no threads on no_std environments")
+    }
+
+    fn block_on<F>(&self, future: F) -> F::Output
+    where
+        F: Future + Send + 'static,
+        F::Output: Send + 'static,
+    {
+        executor::block_on(future)
+    }
+}

src/join_handle.rs

@@ -1,6 +1,6 @@
 //! Generic join handle type.
 
-use std::{
+use core::{
     future::Future,
     pin::Pin,
     task::{Context, Poll},
@@ -22,13 +22,20 @@ use tokio::task::JoinHandle as TokioHandle;
 /// agnostik will panic if the task failed to execute.
 pub struct JoinHandle<R>(pub(crate) InnerJoinHandle<R>);
 
+pub struct NoStdJoinHandle<T> {
+    __phantom: core::marker::PhantomData<T>
+}
+
 pub(crate) enum InnerJoinHandle<R> {
     #[cfg(feature = "runtime_bastion")]
     Bastion(RecoverableHandle<R>),
     #[cfg(feature = "runtime_asyncstd")]
     AsyncStd(AsyncStdHandle<R>),
     #[cfg(feature = "runtime_tokio")]
     Tokio(TokioHandle<R>),
+    #[cfg(feature = "runtime_nostd")]
+    #[allow(dead_code)]
+    NoStd(NoStdJoinHandle<R>),
 }
 
 impl<R> Future for JoinHandle<R>
@@ -49,6 +56,8 @@ where
             InnerJoinHandle::Tokio(ref mut handle) => Pin::new(handle)
                 .poll(cx)
                 .map(|val| val.expect("task failed to execute")),
+            #[cfg(feature = "runtime_nostd")]
+            InnerJoinHandle::NoStd(_) => panic!("no threads on no_std environments"), 
         }
     }
 }

src/lib.rs

@@ -80,7 +80,7 @@
 //! - `Agnostik::async_std()` for async std
 //! - `Agnostik::tokio()` for tokio. **Warning:** See "How to use tokio runtime"
 //! - `Agnostik::tokio_with_runtime(runtime)` if you want to use your own `tokio::runtime::Runtime` object. **Warning:** See "How to use tokio runtime"
-//! - `Agnostik::no_std()` (coming soon) to create an exeutor that works in a nostd environment
+//! - `Agnostik::no_std()` (coming soon) to create an executor that works in a nostd environment
 //! 
 //! ### How to use tokio runtime
 //! 
@@ -125,12 +125,13 @@
 //! 
 //! You can replace 1 and 2 with `Agnostik::tokio()`, because this method call will
 //! create a Runtime object using `Runtime::new()`.
+#![cfg_attr(feature="runtime_nostd", no_std)]
 
 mod executors;
 pub mod join_handle;
 
 use join_handle::JoinHandle;
-use std::future::Future;
+use core::future::Future;
 
 /// This trait represents a generic executor that can spawn a future, spawn a blocking task,
 /// and wait for a future to finish.
@@ -221,6 +222,15 @@ impl Agnostik {
     pub fn tokio_with_runtime(runtime: tokio::runtime::Runtime) -> impl AgnostikExecutor {
         executors::TokioExecutor::with_runtime(runtime)
     }
+
+    #[cfg(feature = "runtime_nostd")]
+    /// Returns an [AgnostikExecutor], that will use a no_std executor from [executor] package
+    ///
+    /// [executor]: https://docs.rs/executor
+    /// [AgnostikExecutor]: ../trait.AgnostikExecutor.html
+    pub fn no_std() -> impl AgnostikExecutor {
+        executors::NoStdExecutor::new()
+    }
 }
 
 #[allow(unused)]

tests/no_std.rs

@@ -0,0 +1,14 @@
+pub use agnostik::prelude::*;
+
+#[cfg(feature = "runtime_nostd")]
+#[test]
+fn test_no_std() {
+    let agnostik = Agnostik::no_std();
+    agnostik.block_on(async {
+        let mut i = 0;
+        while i < 5 {
+            println!("Counting from no_std: {}", i);
+            i+=1;
+        }
+    });
+}