Sync bound

[planetoryd]

pub type FutSet<'f> =
    FuturesUnordered<Pin<Box<dyn Future<Output = Result<()>> + marker::Send + Sync + 'f>>>;

assert_impl_all!(FutSet: marker::Send, Sync);

impl Listener {
    // #[async_recursion]
    // async fn sock_accept(sock: UnixListener, set: &FutSet) -> Result<()> {
    //     if let Result::Ok((ux, _anon)) = sock.accept().await {
    //         let fds = ux.recv_stream().await?;
    //         let f: Framed<UnixStream, LengthDelimitedCodec> =
    //             Framed::new(ux, LengthDelimitedCodec::new());
    //         let f = FramedUS(f);
    //         let mut k = Server(f, FDStream(fds));
    //         let id = try_session(
    //             &mut k,
    //             async move |proto: <SubIdentify<'_, Client> as PartialDual<
    //                 '_,
    //                 Client,
    //                 Server,
    //             >>::Dual<End<'_, _>>| { proto.receive().await },
    //         )
    //         .await?;
    //         set.push(Self::sock_accept(sock, set))
    //     }
    //     Ok(())
    // }
    fn sock_accept<'life0, 'async_recursion>(
        sock: UnixListener,
        set: &'life0 FutSet,
    ) -> ::core::pin::Pin<
        Box<dyn ::core::future::Future<Output = Result<()>> + 'async_recursion + ::core::marker::Send + Sync>,
    >
    where
        'life0: 'async_recursion,
    {
        Box::pin(async move {
            if let Result::Ok((ux, _anon)) = sock.accept().await {
                let fds = ux.recv_stream().await?;
                let f: Framed<UnixStream, LengthDelimitedCodec> =
                    Framed::new(ux, LengthDelimitedCodec::new());
                let f = FramedUS(f);
                let mut k = Server(f, FDStream(fds));
                let id = try_session(
                    &mut k,
                    async move |proto: <SubIdentify<'_, Client> as PartialDual<
                        '_,
                        Client,
                        Server,
                    >>::Dual<End<'_, _>>| { proto.receive().await },
                )
                .await?;
                set.push(Self::sock_accept(sock, set))
            }
            Ok(())
        })
    }

I came across the above use case in my project. It requires Sync.

[planetoryd]

Not over yet. In my code I have to remove async-recursion's lifetime bounds to make it work. Maybe I should just give up using macros. oh, I can get around it.

[BigBadE]

+1, I've implemented this myself for async-recursion and async-trait

[dcchut]

Sorry for taking so long to get to this @planetoryd - I've been quite busy.

A few thoughts:

• Instead of using space as a separator, could you use a comma? e.g. Sync, ?Send and Sync,?Send. (unless there's a technical reason preventing this)
• Could you add a test where the order of Send + Sync are reversed:

#[async_recursion(Sync, ?Send)]

• Could you also add some expand tests in tests/expand? These basically test what output the macro is producing - you should be able to see the Sync bound in there.

If you don't particularly feel like working on this let me know and I'll branch off your changes.

[planetoryd]

I'm busy medmaxxing RN, and it's gonna take a lot of time to familiarize with your project. It's cheaper for both of us if you do it.

[dcchut]

Fixed in #40, released in v1.1.0.