Support async-generic feature flags in cgp-async (#37)

* Add cargo feature flags for cgp-async

* Propagate default features for cgp-async

* Add full feature to cgp and cgp-core

* Fix cgp-error-eyre when default-features = false

* Add changelog

Author: soareschen

.github/workflows/tests.yml

@@ -46,6 +46,11 @@ jobs:
           name: clippy-all-features
           token: ${{ secrets.GITHUB_TOKEN }}
           args: --all-features --all-targets -- -D warnings
+      - uses: actions-rs/clippy-check@v1
+        with:
+          name: clippy-no-default-features
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --no-default-features --all-targets -- -D warnings
 
   test:
     runs-on: ubuntu-latest

CHANGELOG.md

@@ -2,7 +2,26 @@
 
 ## Pre-Release
 
-- Introduce new cgp-field constructs [#36](https://github.com/contextgeneric/cgp/pull/36)
+- Support async-generic feature flags in cgp-async - [#37](https://github.com/contextgeneric/cgp/pull/37)
+    - Introduce the following feature flags to `cgp-async`:
+    - `async`
+    - `send`
+    - `sync`
+    - `static`
+    - `full` - default feature with all enabled
+    - Introduce the following traits in `cgp-async`:
+    - `MaybeSend` - alias to `Send` when the `send` feature is enabled, otherwise nothing.
+    - `MaybeSync` - alias to `Sync` when the `sync` feature is enabled, otherwise nothing.
+    - `MaybeStatic` - alias to `'static` when the `static` feature is enabled, otherwise nothing.
+    - Update the `Async` trait from `Sized + Send + Sync + 'static` to `MaybeSend + MaybeSync + MaybeStatic`.
+    - The `Sized` constraint is removed from `Async` to allow use inside `dyn` traits.
+    - Update the `#[async_trait]` macro to desugar async functions to return `impl Future<Output: MaybeSend>`.
+    - Use of `#[async_trait]` now requires import of `cgp::prelude::*` to allow `MaybeSend` to be auto imported.
+    - `cgp-async` now re-exports `cgp_sync::strip_async` if the `async` feature is not enabled.
+    - i.e. async functions are desugared into sync functions if the `async` feature is disabled.
+    - Crates such as `cgp` and `cgp-core` offers the `full` feature, which can be disabled to disable the indirect default features in `cgp-async`.
+
+- Introduce new cgp-field constructs - [#36](https://github.com/contextgeneric/cgp/pull/36)
     - Introduce the product type constructs `Cons` and `Nil`.
     - Introduce the sum type constructs `Either` and `Void`.
     - Introduce the `Field` type for tagged field value.

Cargo.lock

@@ -15,7 +15,7 @@ pub fn impl_async(item: TokenStream) -> TokenStream {
                     };
 
                     let impl_return: ReturnType = parse_quote! {
-                        -> impl ::core::future::Future<Output = #return_type> + Send
+                        -> impl ::core::future::Future<Output = #return_type> + MaybeSend
                     };
 
                     trait_fn.sig.output = impl_return;

crates/cgp-async-macro/src/impl_async.rs

@@ -11,5 +11,19 @@ description  = """
     Async-generic primitives to support both sync/async in context-generic programming
 """
 
+[features]
+default = [ "full" ]
+full = [
+    "async",
+    "send",
+    "sync",
+    "static",
+]
+async = []
+send = [ "async" ]
+sync = [ "async" ]
+static = [ "async" ]
+
 [dependencies]
 cgp-async-macro = { version = "0.1.0" }
+cgp-sync = { version = "0.1.0" }

crates/cgp-async/Cargo.toml

@@ -1,29 +1,9 @@
-pub use cgp_async_macro::native_async as async_trait;
-
-/**
-   This is defined as a convenient constraint alias to
-   `Sized + Send + Sync + 'static`.
+pub mod traits;
 
-   This constraint is commonly required to be present in almost all associated
-   types. The `Sized` constraint is commonly required for associated types to be
-   used as generic parameters. The `Send + Sync + 'static` constraints are
-   important for the use of async functions inside traits.
+pub use traits::{Async, MaybeSend, MaybeStatic, MaybeSync};
 
-   Because Rust do not currently natively support the use of async functions
-   in traits, we use the [`async_trait`] crate to desugar async functions
-   inside traits into functions returning
-   `Pin<Box<dyn Future + Send>>`. Due to the additional `Send` and lifetime
-   trait bounds inside the returned boxed future, almost all values that are
-   used inside the async functions are required to have types that implement
-   `Send` and `Sync`.
-
-   It is also common to require the associated types to have the `'static`
-   lifetime for them to be used inside async functions, because Rust would
-   otherwise infer a more restrictive lifetime that does not outlive the
-   async functions. The `'static` lifetime constraint here really means
-   that the types implementing `Async` must not contain any lifetime
-   parameter.
-*/
-pub trait Async: Send + Sync + 'static {}
+#[cfg(feature = "async")]
+pub use cgp_async_macro::native_async as async_trait;
 
-impl<A> Async for A where A: Send + Sync + 'static {}
+#[cfg(not(feature = "async"))]
+pub use cgp_sync::async_trait;

crates/cgp-async/src/lib.rs

@@ -0,0 +1,31 @@
+use crate::traits::r#static::MaybeStatic;
+use crate::traits::send::MaybeSend;
+use crate::traits::sync::MaybeSync;
+
+/**
+   This is defined as a convenient constraint alias to
+   `Sized + Send + Sync + 'static`.
+
+   This constraint is commonly required to be present in almost all associated
+   types. The `Sized` constraint is commonly required for associated types to be
+   used as generic parameters. The `Send + Sync + 'static` constraints are
+   important for the use of async functions inside traits.
+
+   Because Rust do not currently natively support the use of async functions
+   in traits, we use the [`async_trait`] crate to desugar async functions
+   inside traits into functions returning
+   `Pin<Box<dyn Future + Send>>`. Due to the additional `Send` and lifetime
+   trait bounds inside the returned boxed future, almost all values that are
+   used inside the async functions are required to have types that implement
+   `Send` and `Sync`.
+
+   It is also common to require the associated types to have the `'static`
+   lifetime for them to be used inside async functions, because Rust would
+   otherwise infer a more restrictive lifetime that does not outlive the
+   async functions. The `'static` lifetime constraint here really means
+   that the types implementing `Async` must not contain any lifetime
+   parameter.
+*/
+pub trait Async: MaybeSend + MaybeSync + MaybeStatic {}
+
+impl<A> Async for A where A: MaybeSend + MaybeSync + MaybeStatic {}

crates/cgp-async/src/traits/async.rs

@@ -0,0 +1,9 @@
+pub mod r#async;
+pub mod send;
+pub mod r#static;
+pub mod sync;
+
+pub use r#async::Async;
+pub use r#static::MaybeStatic;
+pub use send::MaybeSend;
+pub use sync::MaybeSync;

crates/cgp-async/src/traits/mod.rs

@@ -0,0 +1,8 @@
+#[cfg(feature = "send")]
+pub use core::marker::Send as MaybeSend;
+
+#[cfg(not(feature = "send"))]
+pub trait MaybeSend {}
+
+#[cfg(not(feature = "send"))]
+impl<T> MaybeSend for T {}

crates/cgp-async/src/traits/send.rs

@@ -0,0 +1,11 @@
+#[cfg(feature = "static")]
+pub trait MaybeStatic: 'static {}
+
+#[cfg(feature = "static")]
+impl<T: 'static> MaybeStatic for T {}
+
+#[cfg(not(feature = "static"))]
+pub trait MaybeStatic {}
+
+#[cfg(not(feature = "static"))]
+impl<T> MaybeStatic for T {}