[Breaking] Remove Async trait and Send bounds in async functions

Cargo.toml

@@ -6,9 +6,7 @@ members = [
     "crates/cgp",
     "crates/cgp-core",
     "crates/cgp-extra",
-    "crates/cgp-async",
     "crates/cgp-async-macro",
-    "crates/cgp-sync",
     "crates/cgp-component",
     "crates/cgp-macro",
     "crates/cgp-macro-lib",
@@ -42,9 +40,7 @@ keywords        = ["cgp"]
 cgp                         = { path = "./crates/cgp" }
 cgp-core                    = { path = "./crates/cgp-core" }
 cgp-extra                   = { path = "./crates/cgp-extra" }
-cgp-async                   = { path = "./crates/cgp-async" }
 cgp-async-macro             = { path = "./crates/cgp-async-macro" }
-cgp-sync                    = { path = "./crates/cgp-sync" }
 cgp-component               = { path = "./crates/cgp-component" }
 cgp-macro                   = { path = "./crates/cgp-macro" }
 cgp-macro-lib               = { path = "./crates/cgp-macro-lib" }

crates/cgp-async-macro/Cargo.toml

@@ -5,7 +5,7 @@ license      = { workspace = true }
 repository   = { workspace = true }
 authors      = { workspace = true }
 rust-version = { workspace = true }
-version      = "0.4.2"
+version      = "0.5.0-alpha"
 keywords     = { workspace = true }
 description  = """
     Context-generic programming async macros

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

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

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

@@ -10,40 +10,16 @@ extern crate proc_macro;
 use proc_macro::TokenStream;
 
 mod impl_async;
-mod strip_async;
-
-/**
-   This macro can be used in place of the [`macro@native_async`] macro
-   to strip away all use of `async` and `.await` syntax. This helps emulate
-   async-generic by turnining async functions into sync functions.
-*/
-#[proc_macro_attribute]
-pub fn strip_async(_attr: TokenStream, stream: TokenStream) -> TokenStream {
-    strip_async::strip_async(stream.into()).into()
-}
 
 /**
     The `#[async_trait]` macro is used to desugar async functions in traits
-    to return `impl Future + Send`.
+    to return `impl Future`.
 
     This macro is required mainly to get around the current limitation of
     [async functions in traits](https://blog.rust-lang.org/2023/12/21/async-fn-rpit-in-traits/),
     which would produce a lint warning for `async_fn_in_trait` if bare async
     functions are defined in a trait.
 
-    The default approach adopted by CGP is to always include a `Send` bound
-    on the desugared `Future`, so that any async function that indirectly calls
-    the method can still implement `Send` be be used with libraries such as `tokio::spawn`.
-
-    It is possible to remove default `Send` by deactivating the `send` feature in the `cgp-async`
-    crate. However, the removal may be unreliable, as the feature flag could still be accidentally
-    enabled by one of the dependencies.
-
-    Note that although the macro shares the same name as the
-    [`async-trait`](https://docs.rs/async-trait) crate, it is implemented very differently.
-    The other crate with the same name returns a `Pin<Box<dyn Future + Send>>`, while
-    this macro returns a `impl Future + Send`.
-
     ## Example
 
     Given the following trait definition:
@@ -59,11 +35,11 @@ pub fn strip_async(_attr: TokenStream, stream: TokenStream) -> TokenStream {
 
     ```rust,ignore
     pub trait CanRun {
-        fn run(&self) -> impl Future<Output = ()> + Send;
+        fn run(&self) -> impl Future<Output = ()>;
     }
     ```
 */
 #[proc_macro_attribute]
-pub fn native_async(_attr: TokenStream, stream: TokenStream) -> TokenStream {
+pub fn async_trait(_attr: TokenStream, stream: TokenStream) -> TokenStream {
     impl_async::impl_async(stream.into()).into()
 }