From f37d00762dd93a574acd4c0c13e3670ef7f0e2a3 Mon Sep 17 00:00:00 2001
From: Jon Heinritz <jon.heinritz@protonmail.com>
Date: Fri, 14 Mar 2025 16:05:37 +0100
Subject: [PATCH 1/5] Give type access to manually implemented notifier futures

---
 src/prod_cons/framed.rs      | 36 +++++++++++++++++++-
 src/prod_cons/stream.rs      | 45 ++++++++++++++++++++++++-
 src/traits/notifier/mod.rs   |  1 +
 src/traits/notifier/typed.rs | 65 ++++++++++++++++++++++++++++++++++++
 4 files changed, 145 insertions(+), 2 deletions(-)
 create mode 100644 src/traits/notifier/typed.rs

diff --git a/src/prod_cons/framed.rs b/src/prod_cons/framed.rs
index 6347c36..399e35a 100644
--- a/src/prod_cons/framed.rs
+++ b/src/prod_cons/framed.rs
@@ -9,7 +9,10 @@ use crate::{
     traits::{
         bbqhdl::BbqHandle,
         coordination::Coord,
-        notifier::{AsyncNotifier, Notifier},
+        notifier::{
+            typed::{AsyncNotifierTyped, ConstrFnMut, ConstrFut, TypedWrapper},
+            AsyncNotifier, Notifier,
+        },
         storage::Storage,
     },
 };
@@ -134,6 +137,22 @@ where
     }
 }
 
+impl<Q, S, C, N, H> TypedWrapper<FramedProducer<Q, S, C, N, H>>
+where
+    S: Storage,
+    C: Coord,
+    N: AsyncNotifierTyped,
+    Q: BbqHandle<S, C, N>,
+    H: LenHeader,
+{
+    pub fn wait_grant(
+        &self,
+        sz: H,
+    ) -> <N as ConstrFut>::NotFull<impl ConstrFnMut<Out = FramedGrantW<Q, S, C, N, H>>> {
+        self.bbq.not.wait_for_not_full(move || self.grant(sz).ok())
+    }
+}
+
 pub struct FramedConsumer<Q, S, C, N, H = u16>
 where
     S: Storage,
@@ -210,6 +229,21 @@ where
     }
 }
 
+impl<Q, S, C, N, H> TypedWrapper<FramedConsumer<Q, S, C, N, H>>
+where
+    S: Storage,
+    C: Coord,
+    N: AsyncNotifierTyped,
+    Q: BbqHandle<S, C, N>,
+    H: LenHeader,
+{
+    pub fn wait_read(
+        &self,
+    ) -> <N as ConstrFut>::NotEmpty<impl ConstrFnMut<Out = FramedGrantR<Q, S, C, N, H>>> {
+        self.bbq.not.wait_for_not_empty(move || self.read().ok())
+    }
+}
+
 pub struct FramedGrantW<Q, S, C, N, H = u16>
 where
     S: Storage,
diff --git a/src/prod_cons/stream.rs b/src/prod_cons/stream.rs
index e944e3a..a9316fc 100644
--- a/src/prod_cons/stream.rs
+++ b/src/prod_cons/stream.rs
@@ -9,7 +9,10 @@ use crate::{
     traits::{
         bbqhdl::BbqHandle,
         coordination::Coord,
-        notifier::{AsyncNotifier, Notifier},
+        notifier::{
+            typed::{AsyncNotifierTyped, ConstrFnMut, ConstrFut, TypedWrapper},
+            AsyncNotifier, Notifier,
+        },
         storage::Storage,
     },
 };
@@ -118,6 +121,32 @@ where
     }
 }
 
+impl<Q, S, C, N> TypedWrapper<StreamProducer<Q, S, C, N>>
+where
+    S: Storage,
+    C: Coord,
+    N: AsyncNotifierTyped,
+    Q: BbqHandle<S, C, N>,
+{
+    pub fn wait_grant_max_remaining(
+        &self,
+        max: usize,
+    ) -> <N as ConstrFut>::NotFull<impl ConstrFnMut<Out = StreamGrantW<Q, S, C, N>> + '_> {
+        self.bbq
+            .not
+            .wait_for_not_full(move || self.grant_max_remaining(max).ok())
+    }
+
+    pub fn wait_grant_exact(
+        &self,
+        sz: usize,
+    ) -> <N as ConstrFut>::NotFull<impl ConstrFnMut<Out = StreamGrantW<Q, S, C, N>> + '_> {
+        self.bbq
+            .not
+            .wait_for_not_full(move || self.grant_exact(sz).ok())
+    }
+}
+
 pub struct StreamConsumer<Q, S, C, N>
 where
     S: Storage,
@@ -164,6 +193,20 @@ where
     }
 }
 
+impl<Q, S, C, N> TypedWrapper<StreamConsumer<Q, S, C, N>>
+where
+    S: Storage,
+    C: Coord,
+    N: AsyncNotifierTyped,
+    Q: BbqHandle<S, C, N>,
+{
+    pub fn wait_read(
+        &self,
+    ) -> <N as ConstrFut>::NotEmpty<impl ConstrFnMut<Out = StreamGrantR<Q, S, C, N>> + '_> {
+        self.bbq.not.wait_for_not_empty(move || self.read().ok())
+    }
+}
+
 pub struct StreamGrantW<Q, S, C, N>
 where
     S: Storage,
diff --git a/src/traits/notifier/mod.rs b/src/traits/notifier/mod.rs
index cd63a21..9d76b71 100644
--- a/src/traits/notifier/mod.rs
+++ b/src/traits/notifier/mod.rs
@@ -2,6 +2,7 @@
 pub mod maitake;
 
 pub mod blocking;
+pub mod typed;
 
 pub trait Notifier {
     const INIT: Self;
diff --git a/src/traits/notifier/typed.rs b/src/traits/notifier/typed.rs
new file mode 100644
index 0000000..f5ef5f9
--- /dev/null
+++ b/src/traits/notifier/typed.rs
@@ -0,0 +1,65 @@
+use crate::traits::notifier::{AsyncNotifier, Notifier};
+use core::{future::Future, ops::Deref};
+
+pub trait AsyncNotifierTyped: Notifier {
+    type FutNotEmpty<F, T>: Future<Output = T>;
+    type FutNotFull<F, T>: Future<Output = T>;
+
+    fn wait_for_not_empty<T, F: FnMut() -> Option<T>>(&self, f: F) -> Self::FutNotEmpty<F, T>;
+    fn wait_for_not_full<T, F: FnMut() -> Option<T>>(&self, f: F) -> Self::FutNotFull<F, T>;
+}
+
+impl<N> AsyncNotifier for N
+where
+    N: AsyncNotifierTyped,
+{
+    async fn wait_for_not_empty<T, F: FnMut() -> Option<T>>(&self, f: F) -> T {
+        self.wait_for_not_empty(f).await
+    }
+
+    async fn wait_for_not_full<T, F: FnMut() -> Option<T>>(&self, f: F) -> T {
+        self.wait_for_not_full(f).await
+    }
+}
+
+pub trait Typed: Sized {
+    fn typed(self) -> TypedWrapper<Self> {
+        TypedWrapper(self)
+    }
+}
+
+impl<T> Typed for T {}
+
+pub struct TypedWrapper<T>(T);
+
+impl<T> Deref for TypedWrapper<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+pub trait ConstrFnMut<'a>: FnMut() -> Option<Self::Out> {
+    type Out;
+}
+
+impl<F, Out> ConstrFnMut<'_> for F
+where
+    F: FnMut() -> Option<Out>,
+{
+    type Out = Out;
+}
+
+pub trait ConstrFut<'a>: AsyncNotifierTyped {
+    type NotFull<F: ConstrFnMut<'a>>;
+    type NotEmpty<F: ConstrFnMut<'a>>;
+}
+
+impl<'a, N> ConstrFut<'a> for N
+where
+    N: AsyncNotifierTyped,
+{
+    type NotFull<F: ConstrFnMut<'a>> = <N as AsyncNotifierTyped>::FutNotFull<F, F::Out>;
+    type NotEmpty<F: ConstrFnMut<'a>> = <N as AsyncNotifierTyped>::FutNotEmpty<F, F::Out>;
+}

From c304fe7b3030df63d4d9c582f4a56f84fbb29eaf Mon Sep 17 00:00:00 2001
From: Jon Heinritz <jon.heinritz@protonmail.com>
Date: Sun, 16 Mar 2025 02:31:38 +0100
Subject: [PATCH 2/5] Only implement `Typed` for types that actually use it

---
 src/prod_cons/framed.rs      | 21 ++++++++++++++++++++-
 src/prod_cons/stream.rs      | 20 +++++++++++++++++++-
 src/traits/notifier/typed.rs |  2 --
 3 files changed, 39 insertions(+), 4 deletions(-)

diff --git a/src/prod_cons/framed.rs b/src/prod_cons/framed.rs
index 399e35a..29af839 100644
--- a/src/prod_cons/framed.rs
+++ b/src/prod_cons/framed.rs
@@ -10,7 +10,7 @@ use crate::{
         bbqhdl::BbqHandle,
         coordination::Coord,
         notifier::{
-            typed::{AsyncNotifierTyped, ConstrFnMut, ConstrFut, TypedWrapper},
+            typed::{AsyncNotifierTyped, ConstrFnMut, ConstrFut, Typed, TypedWrapper},
             AsyncNotifier, Notifier,
         },
         storage::Storage,
@@ -137,6 +137,15 @@ where
     }
 }
 
+impl<Q, S, C, N> Typed for FramedProducer<Q, S, C, N>
+where
+    S: Storage,
+    C: Coord,
+    N: Notifier,
+    Q: BbqHandle<S, C, N>,
+{
+}
+
 impl<Q, S, C, N, H> TypedWrapper<FramedProducer<Q, S, C, N, H>>
 where
     S: Storage,
@@ -229,6 +238,16 @@ where
     }
 }
 
+impl<Q, S, C, N, H> Typed for FramedConsumer<Q, S, C, N, H>
+where
+    S: Storage,
+    C: Coord,
+    N: AsyncNotifier,
+    Q: BbqHandle<S, C, N>,
+    H: LenHeader,
+{
+}
+
 impl<Q, S, C, N, H> TypedWrapper<FramedConsumer<Q, S, C, N, H>>
 where
     S: Storage,
diff --git a/src/prod_cons/stream.rs b/src/prod_cons/stream.rs
index a9316fc..5d04627 100644
--- a/src/prod_cons/stream.rs
+++ b/src/prod_cons/stream.rs
@@ -10,7 +10,7 @@ use crate::{
         bbqhdl::BbqHandle,
         coordination::Coord,
         notifier::{
-            typed::{AsyncNotifierTyped, ConstrFnMut, ConstrFut, TypedWrapper},
+            typed::{AsyncNotifierTyped, ConstrFnMut, ConstrFut, Typed, TypedWrapper},
             AsyncNotifier, Notifier,
         },
         storage::Storage,
@@ -121,6 +121,15 @@ where
     }
 }
 
+impl<S, C, N, Q> Typed for StreamProducer<Q, S, C, N>
+where
+    S: Storage,
+    C: Coord,
+    N: Notifier,
+    Q: BbqHandle<S, C, N>,
+{
+}
+
 impl<Q, S, C, N> TypedWrapper<StreamProducer<Q, S, C, N>>
 where
     S: Storage,
@@ -193,6 +202,15 @@ where
     }
 }
 
+impl<S, C, N, Q> Typed for StreamConsumer<Q, S, C, N>
+where
+    S: Storage,
+    C: Coord,
+    N: Notifier,
+    Q: BbqHandle<S, C, N>,
+{
+}
+
 impl<Q, S, C, N> TypedWrapper<StreamConsumer<Q, S, C, N>>
 where
     S: Storage,
diff --git a/src/traits/notifier/typed.rs b/src/traits/notifier/typed.rs
index f5ef5f9..d9e9bde 100644
--- a/src/traits/notifier/typed.rs
+++ b/src/traits/notifier/typed.rs
@@ -28,8 +28,6 @@ pub trait Typed: Sized {
     }
 }
 
-impl<T> Typed for T {}
-
 pub struct TypedWrapper<T>(T);
 
 impl<T> Deref for TypedWrapper<T> {

From 284e2ed942714fd7c3750d62405688964eeac6c4 Mon Sep 17 00:00:00 2001
From: Jon Heinritz <jon.heinritz@protonmail.com>
Date: Mon, 17 Mar 2025 03:14:06 +0100
Subject: [PATCH 3/5] dev

---
 src/prod_cons/framed.rs      | 23 +++++-----------------
 src/traits/notifier/typed.rs | 38 +++++++++++++++++++++++++++++++++++-
 2 files changed, 42 insertions(+), 19 deletions(-)

diff --git a/src/prod_cons/framed.rs b/src/prod_cons/framed.rs
index 29af839..7f661f9 100644
--- a/src/prod_cons/framed.rs
+++ b/src/prod_cons/framed.rs
@@ -10,7 +10,7 @@ use crate::{
         bbqhdl::BbqHandle,
         coordination::Coord,
         notifier::{
-            typed::{AsyncNotifierTyped, ConstrFnMut, ConstrFut, Typed, TypedWrapper},
+            typed::{AsyncNotifierTyped, BbqSync, ConstrFnMut, ConstrFut, Typed, TypedWrapper},
             AsyncNotifier, Notifier,
         },
         storage::Storage,
@@ -88,22 +88,16 @@ impl<S: Storage, C: Coord, N: Notifier> crate::queue::ArcBBQueue<S, C, N> {
 
 pub struct FramedProducer<Q, S, C, N, H = u16>
 where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
+    Self: BbqSync<Q, S, C, N>,
     H: LenHeader,
 {
-    bbq: Q::Target,
+    bbq: <Q as BbqHandle<S, C, N>>::Target,
     pd: PhantomData<(S, C, N, H)>,
 }
 
 impl<Q, S, C, N, H> FramedProducer<Q, S, C, N, H>
 where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
+    Self: BbqSync<Q, S, C, N>,
     H: LenHeader,
 {
     pub fn grant(&self, sz: H) -> Result<FramedGrantW<Q, S, C, N, H>, ()> {
@@ -137,14 +131,7 @@ where
     }
 }
 
-impl<Q, S, C, N> Typed for FramedProducer<Q, S, C, N>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-{
-}
+impl<Q, S, C, N> Typed for FramedProducer<Q, S, C, N> where Self: BbqSync<Q, S, C, N> {}
 
 impl<Q, S, C, N, H> TypedWrapper<FramedProducer<Q, S, C, N, H>>
 where
diff --git a/src/traits/notifier/typed.rs b/src/traits/notifier/typed.rs
index d9e9bde..45eb4e1 100644
--- a/src/traits/notifier/typed.rs
+++ b/src/traits/notifier/typed.rs
@@ -1,4 +1,9 @@
-use crate::traits::notifier::{AsyncNotifier, Notifier};
+use crate::traits::{
+    bbqhdl::BbqHandle,
+    coordination::Coord,
+    notifier::{AsyncNotifier, Notifier},
+    storage::Storage,
+};
 use core::{future::Future, ops::Deref};
 
 pub trait AsyncNotifierTyped: Notifier {
@@ -49,6 +54,37 @@ where
     type Out = Out;
 }
 
+#[allow(private_bounds)]
+pub trait BbqSync<Q, S, C, N>
+where
+    Self: Imply<S, Is: Storage>,
+    Self: Imply<C, Is: Coord>,
+    Self: Imply<N, Is: Notifier>,
+    Self: Imply<Q, Is: BbqHandle<S, C, N>>,
+{
+}
+
+impl<T, Q, S, C, N> BbqSync<Q, S, C, N> for T
+where
+    Self: Imply<S, Is: Storage>,
+    Self: Imply<C, Is: Coord>,
+    Self: Imply<N, Is: Notifier>,
+    Self: Imply<Q, Is: BbqHandle<S, C, N>>,
+{
+}
+
+pub(crate) trait Imply<T>: ImplyInner<T, Is = T> {}
+
+impl<S, T> Imply<T> for S {}
+
+pub(crate) trait ImplyInner<T> {
+    type Is;
+}
+
+impl<S, T> ImplyInner<T> for S {
+    type Is = T;
+}
+
 pub trait ConstrFut<'a>: AsyncNotifierTyped {
     type NotFull<F: ConstrFnMut<'a>>;
     type NotEmpty<F: ConstrFnMut<'a>>;

From 79b0083feebc6ada2e5884a84301a76dc0c91aab Mon Sep 17 00:00:00 2001
From: Jon Heinritz <jon.heinritz@protonmail.com>
Date: Mon, 17 Mar 2025 03:15:34 +0100
Subject: [PATCH 4/5] fix: add required `FnMut` bound to the associated types
 as well

---
 src/traits/notifier/typed.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/traits/notifier/typed.rs b/src/traits/notifier/typed.rs
index 45eb4e1..8fc538e 100644
--- a/src/traits/notifier/typed.rs
+++ b/src/traits/notifier/typed.rs
@@ -7,8 +7,8 @@ use crate::traits::{
 use core::{future::Future, ops::Deref};
 
 pub trait AsyncNotifierTyped: Notifier {
-    type FutNotEmpty<F, T>: Future<Output = T>;
-    type FutNotFull<F, T>: Future<Output = T>;
+    type FutNotEmpty<F: FnMut() -> Option<T>, T>: Future<Output = T>;
+    type FutNotFull<F: FnMut() -> Option<T>, T>: Future<Output = T>;
 
     fn wait_for_not_empty<T, F: FnMut() -> Option<T>>(&self, f: F) -> Self::FutNotEmpty<F, T>;
     fn wait_for_not_full<T, F: FnMut() -> Option<T>>(&self, f: F) -> Self::FutNotFull<F, T>;

From 512c7695a3272009095f0c76312a2ade7bfb36e8 Mon Sep 17 00:00:00 2001
From: Jon Heinritz <jon.heinritz@protonmail.com>
Date: Tue, 18 Mar 2025 15:08:21 +0100
Subject: [PATCH 5/5] feat: refactor `BbqHandle` to use associated types
 instead of generics

---
 src/prod_cons/framed.rs      | 200 ++++++--------------------------
 src/prod_cons/stream.rs      | 216 +++++++----------------------------
 src/traits/bbqhdl.rs         |  39 ++++++-
 src/traits/notifier/typed.rs |  38 +-----
 4 files changed, 112 insertions(+), 381 deletions(-)

diff --git a/src/prod_cons/framed.rs b/src/prod_cons/framed.rs
index 7f661f9..2871651 100644
--- a/src/prod_cons/framed.rs
+++ b/src/prod_cons/framed.rs
@@ -10,7 +10,7 @@ use crate::{
         bbqhdl::BbqHandle,
         coordination::Coord,
         notifier::{
-            typed::{AsyncNotifierTyped, BbqSync, ConstrFnMut, ConstrFut, Typed, TypedWrapper},
+            typed::{AsyncNotifierTyped, ConstrFnMut, ConstrFut, Typed, TypedWrapper},
             AsyncNotifier, Notifier,
         },
         storage::Storage,
@@ -54,14 +54,14 @@ unsafe impl LenHeader for usize {
 }
 
 impl<S: Storage, C: Coord, N: Notifier> BBQueue<S, C, N> {
-    pub fn framed_producer(&self) -> FramedProducer<&'_ Self, S, C, N> {
+    pub fn framed_producer(&self) -> FramedProducer<&'_ Self> {
         FramedProducer {
             bbq: self.bbq_ref(),
             pd: PhantomData,
         }
     }
 
-    pub fn framed_consumer(&self) -> FramedConsumer<&'_ Self, S, C, N> {
+    pub fn framed_consumer(&self) -> FramedConsumer<&'_ Self> {
         FramedConsumer {
             bbq: self.bbq_ref(),
             pd: PhantomData,
@@ -71,14 +71,14 @@ impl<S: Storage, C: Coord, N: Notifier> BBQueue<S, C, N> {
 
 #[cfg(feature = "std")]
 impl<S: Storage, C: Coord, N: Notifier> crate::queue::ArcBBQueue<S, C, N> {
-    pub fn framed_producer(&self) -> FramedProducer<std::sync::Arc<BBQueue<S, C, N>>, S, C, N> {
+    pub fn framed_producer(&self) -> FramedProducer<Self> {
         FramedProducer {
             bbq: self.0.bbq_ref(),
             pd: PhantomData,
         }
     }
 
-    pub fn framed_consumer(&self) -> FramedConsumer<std::sync::Arc<BBQueue<S, C, N>>, S, C, N> {
+    pub fn framed_consumer(&self) -> FramedConsumer<Self> {
         FramedConsumer {
             bbq: self.0.bbq_ref(),
             pd: PhantomData,
@@ -86,21 +86,13 @@ impl<S: Storage, C: Coord, N: Notifier> crate::queue::ArcBBQueue<S, C, N> {
     }
 }
 
-pub struct FramedProducer<Q, S, C, N, H = u16>
-where
-    Self: BbqSync<Q, S, C, N>,
-    H: LenHeader,
-{
-    bbq: <Q as BbqHandle<S, C, N>>::Target,
-    pd: PhantomData<(S, C, N, H)>,
+pub struct FramedProducer<Q: BbqHandle, H = u16> {
+    bbq: Q::Target,
+    pd: PhantomData<H>,
 }
 
-impl<Q, S, C, N, H> FramedProducer<Q, S, C, N, H>
-where
-    Self: BbqSync<Q, S, C, N>,
-    H: LenHeader,
-{
-    pub fn grant(&self, sz: H) -> Result<FramedGrantW<Q, S, C, N, H>, ()> {
+impl<Q: BbqHandle, H: LenHeader> FramedProducer<Q, H> {
+    pub fn grant(&self, sz: H) -> Result<FramedGrantW<Q, H>, ()> {
         let (ptr, cap) = self.bbq.sto.ptr_len();
         let needed = sz.into() + core::mem::size_of::<H>();
 
@@ -118,58 +110,30 @@ where
     }
 }
 
-impl<Q, S, C, N, H> FramedProducer<Q, S, C, N, H>
-where
-    S: Storage,
-    C: Coord,
-    N: AsyncNotifier,
-    Q: BbqHandle<S, C, N>,
-    H: LenHeader,
-{
-    pub async fn wait_grant(&self, sz: H) -> FramedGrantW<Q, S, C, N, H> {
+impl<Q: BbqHandle<Notifier: AsyncNotifier>, H: LenHeader> FramedProducer<Q, H> {
+    pub async fn wait_grant(&self, sz: H) -> FramedGrantW<Q, H> {
         self.bbq.not.wait_for_not_full(|| self.grant(sz).ok()).await
     }
 }
 
-impl<Q, S, C, N> Typed for FramedProducer<Q, S, C, N> where Self: BbqSync<Q, S, C, N> {}
+impl<Q: BbqHandle, H: LenHeader> Typed for FramedProducer<Q, H> {}
 
-impl<Q, S, C, N, H> TypedWrapper<FramedProducer<Q, S, C, N, H>>
-where
-    S: Storage,
-    C: Coord,
-    N: AsyncNotifierTyped,
-    Q: BbqHandle<S, C, N>,
-    H: LenHeader,
-{
+impl<Q: BbqHandle<Notifier: AsyncNotifierTyped>, H: LenHeader> TypedWrapper<FramedProducer<Q, H>> {
     pub fn wait_grant(
         &self,
         sz: H,
-    ) -> <N as ConstrFut>::NotFull<impl ConstrFnMut<Out = FramedGrantW<Q, S, C, N, H>>> {
-        self.bbq.not.wait_for_not_full(move || self.grant(sz).ok())
+    ) -> <Q::Notifier as ConstrFut>::NotFull<impl ConstrFnMut<Out = FramedGrantW<Q, H>>> {
+        AsyncNotifierTyped::wait_for_not_full(&self.bbq.not, move || self.grant(sz).ok())
     }
 }
 
-pub struct FramedConsumer<Q, S, C, N, H = u16>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-    H: LenHeader,
-{
+pub struct FramedConsumer<Q: BbqHandle, H: LenHeader = u16> {
     bbq: Q::Target,
-    pd: PhantomData<(S, C, N, H)>,
+    pd: PhantomData<H>,
 }
 
-impl<Q, S, C, N, H> FramedConsumer<Q, S, C, N, H>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-    H: LenHeader,
-{
-    pub fn read(&self) -> Result<FramedGrantR<Q, S, C, N, H>, ()> {
+impl<Q: BbqHandle, H: LenHeader> FramedConsumer<Q, H> {
+    pub fn read(&self) -> Result<FramedGrantR<Q, H>, ()> {
         let (ptr, _cap) = self.bbq.sto.ptr_len();
         let (offset, grant_len) = self.bbq.cor.read()?;
 
@@ -212,65 +176,29 @@ where
     }
 }
 
-impl<Q, S, C, N, H> FramedConsumer<Q, S, C, N, H>
-where
-    S: Storage,
-    C: Coord,
-    N: AsyncNotifier,
-    Q: BbqHandle<S, C, N>,
-    H: LenHeader,
-{
-    pub async fn wait_read(&self) -> FramedGrantR<Q, S, C, N, H> {
+impl<Q: BbqHandle<Notifier: AsyncNotifier>, H: LenHeader> FramedConsumer<Q, H> {
+    pub async fn wait_read(&self) -> FramedGrantR<Q, H> {
         self.bbq.not.wait_for_not_empty(|| self.read().ok()).await
     }
 }
 
-impl<Q, S, C, N, H> Typed for FramedConsumer<Q, S, C, N, H>
-where
-    S: Storage,
-    C: Coord,
-    N: AsyncNotifier,
-    Q: BbqHandle<S, C, N>,
-    H: LenHeader,
-{
-}
+impl<Q: BbqHandle, H: LenHeader> Typed for FramedConsumer<Q, H> {}
 
-impl<Q, S, C, N, H> TypedWrapper<FramedConsumer<Q, S, C, N, H>>
-where
-    S: Storage,
-    C: Coord,
-    N: AsyncNotifierTyped,
-    Q: BbqHandle<S, C, N>,
-    H: LenHeader,
-{
+impl<Q: BbqHandle<Notifier: AsyncNotifierTyped>, H: LenHeader> TypedWrapper<FramedConsumer<Q, H>> {
     pub fn wait_read(
         &self,
-    ) -> <N as ConstrFut>::NotEmpty<impl ConstrFnMut<Out = FramedGrantR<Q, S, C, N, H>>> {
-        self.bbq.not.wait_for_not_empty(move || self.read().ok())
+    ) -> <Q::Notifier as ConstrFut>::NotEmpty<impl ConstrFnMut<Out = FramedGrantR<Q, H>>> {
+        AsyncNotifierTyped::wait_for_not_empty(&self.bbq.not, move || self.read().ok())
     }
 }
 
-pub struct FramedGrantW<Q, S, C, N, H = u16>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-    H: LenHeader,
-{
+pub struct FramedGrantW<Q: BbqHandle, H: LenHeader = u16> {
     bbq: Q::Target,
     base_ptr: NonNull<u8>,
     hdr: H,
 }
 
-impl<Q, S, C, N, H> Deref for FramedGrantW<Q, S, C, N, H>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-    H: LenHeader,
-{
+impl<Q: BbqHandle, H: LenHeader> Deref for FramedGrantW<Q, H> {
     type Target = [u8];
 
     fn deref(&self) -> &Self::Target {
@@ -283,14 +211,7 @@ where
     }
 }
 
-impl<Q, S, C, N, H> DerefMut for FramedGrantW<Q, S, C, N, H>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-    H: LenHeader,
-{
+impl<Q: BbqHandle, H: LenHeader> DerefMut for FramedGrantW<Q, H> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         let len = self.hdr.into();
         let body_ptr = unsafe {
@@ -301,14 +222,7 @@ where
     }
 }
 
-impl<Q, S, C, N, H> Drop for FramedGrantW<Q, S, C, N, H>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-    H: LenHeader,
-{
+impl<Q: BbqHandle, H: LenHeader> Drop for FramedGrantW<Q, H> {
     fn drop(&mut self) {
         // Default drop performs an "abort"
         let (_ptr, cap) = self.bbq.sto.ptr_len();
@@ -318,14 +232,7 @@ where
     }
 }
 
-impl<Q, S, C, N, H> FramedGrantW<Q, S, C, N, H>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-    H: LenHeader,
-{
+impl<Q: BbqHandle, H: LenHeader> FramedGrantW<Q, H> {
     pub fn commit(self, used: H) {
         let (_ptr, cap) = self.bbq.sto.ptr_len();
         let hdrlen: usize = const { core::mem::size_of::<H>() };
@@ -351,27 +258,13 @@ where
     }
 }
 
-pub struct FramedGrantR<Q, S, C, N, H = u16>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-    H: LenHeader,
-{
+pub struct FramedGrantR<Q: BbqHandle, H: LenHeader> {
     bbq: Q::Target,
     body_ptr: NonNull<u8>,
     hdr: H,
 }
 
-impl<Q, S, C, N, H> Deref for FramedGrantR<Q, S, C, N, H>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-    H: LenHeader,
-{
+impl<Q: BbqHandle, H: LenHeader> Deref for FramedGrantR<Q, H> {
     type Target = [u8];
 
     fn deref(&self) -> &Self::Target {
@@ -380,42 +273,21 @@ where
     }
 }
 
-impl<Q, S, C, N, H> DerefMut for FramedGrantR<Q, S, C, N, H>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-    H: LenHeader,
-{
+impl<Q: BbqHandle, H: LenHeader> DerefMut for FramedGrantR<Q, H> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         let len: usize = self.hdr.into();
         unsafe { core::slice::from_raw_parts_mut(self.body_ptr.as_ptr(), len) }
     }
 }
 
-impl<Q, S, C, N, H> Drop for FramedGrantR<Q, S, C, N, H>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-    H: LenHeader,
-{
+impl<Q: BbqHandle, H: LenHeader> Drop for FramedGrantR<Q, H> {
     fn drop(&mut self) {
         // Default behavior is "keep" - release zero bytes
         self.bbq.cor.release_inner(0);
     }
 }
 
-impl<Q, S, C, N, H> FramedGrantR<Q, S, C, N, H>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-    H: LenHeader,
-{
+impl<Q: BbqHandle, H: LenHeader> FramedGrantR<Q, H> {
     pub fn release(self) {
         let len: usize = self.hdr.into();
         let hdrlen: usize = const { core::mem::size_of::<H>() };
diff --git a/src/prod_cons/stream.rs b/src/prod_cons/stream.rs
index 5d04627..5cf60de 100644
--- a/src/prod_cons/stream.rs
+++ b/src/prod_cons/stream.rs
@@ -1,11 +1,10 @@
 use core::{
-    marker::PhantomData,
     ops::{Deref, DerefMut},
     ptr::NonNull,
 };
 
 use crate::{
-    queue::BBQueue,
+    queue::{ArcBBQueue, BBQueue},
     traits::{
         bbqhdl::BbqHandle,
         coordination::Coord,
@@ -18,57 +17,39 @@ use crate::{
 };
 
 impl<S: Storage, C: Coord, N: Notifier> BBQueue<S, C, N> {
-    pub fn stream_producer(&self) -> StreamProducer<&'_ Self, S, C, N> {
+    pub fn stream_producer(&self) -> StreamProducer<&Self> {
         StreamProducer {
             bbq: self.bbq_ref(),
-            pd: PhantomData,
         }
     }
 
-    pub fn stream_consumer(&self) -> StreamConsumer<&'_ Self, S, C, N> {
+    pub fn stream_consumer(&self) -> StreamConsumer<&Self> {
         StreamConsumer {
             bbq: self.bbq_ref(),
-            pd: PhantomData,
         }
     }
 }
 
-#[cfg(feature = "std")]
-impl<S: Storage, C: Coord, N: Notifier> crate::queue::ArcBBQueue<S, C, N> {
-    pub fn stream_producer(&self) -> StreamProducer<std::sync::Arc<BBQueue<S, C, N>>, S, C, N> {
+impl<S: Storage, C: Coord, N: Notifier> ArcBBQueue<S, C, N> {
+    pub fn stream_producer(&self) -> StreamProducer<Self> {
         StreamProducer {
-            bbq: self.0.bbq_ref(),
-            pd: PhantomData,
+            bbq: self.bbq_ref(),
         }
     }
 
-    pub fn stream_consumer(&self) -> StreamConsumer<std::sync::Arc<BBQueue<S, C, N>>, S, C, N> {
+    pub fn stream_consumer(&self) -> StreamConsumer<Self> {
         StreamConsumer {
-            bbq: self.0.bbq_ref(),
-            pd: PhantomData,
+            bbq: self.bbq_ref(),
         }
     }
 }
 
-pub struct StreamProducer<Q, S, C, N>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-{
+pub struct StreamProducer<Q: BbqHandle> {
     bbq: Q::Target,
-    pd: PhantomData<(S, C, N)>,
 }
 
-impl<Q, S, C, N> StreamProducer<Q, S, C, N>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-{
-    pub fn grant_max_remaining(&self, max: usize) -> Result<StreamGrantW<Q, S, C, N>, ()> {
+impl<Q: BbqHandle> StreamProducer<Q> {
+    pub fn grant_max_remaining(&self, max: usize) -> Result<StreamGrantW<Q>, ()> {
         let (ptr, cap) = self.bbq.sto.ptr_len();
         let (offset, len) = self.bbq.cor.grant_max_remaining(cap, max)?;
         let ptr = unsafe {
@@ -83,7 +64,7 @@ where
         })
     }
 
-    pub fn grant_exact(&self, sz: usize) -> Result<StreamGrantW<Q, S, C, N>, ()> {
+    pub fn grant_exact(&self, sz: usize) -> Result<StreamGrantW<Q>, ()> {
         let (ptr, cap) = self.bbq.sto.ptr_len();
         let offset = self.bbq.cor.grant_exact(cap, sz)?;
         let ptr = unsafe {
@@ -99,21 +80,15 @@ where
     }
 }
 
-impl<Q, S, C, N> StreamProducer<Q, S, C, N>
-where
-    S: Storage,
-    C: Coord,
-    N: AsyncNotifier,
-    Q: BbqHandle<S, C, N>,
-{
-    pub async fn wait_grant_max_remaining(&self, max: usize) -> StreamGrantW<Q, S, C, N> {
+impl<Q: BbqHandle<Notifier: AsyncNotifier>> StreamProducer<Q> {
+    pub async fn wait_grant_max_remaining(&self, max: usize) -> StreamGrantW<Q> {
         self.bbq
             .not
             .wait_for_not_full(|| self.grant_max_remaining(max).ok())
             .await
     }
 
-    pub async fn wait_grant_exact(&self, sz: usize) -> StreamGrantW<Q, S, C, N> {
+    pub async fn wait_grant_exact(&self, sz: usize) -> StreamGrantW<Q> {
         self.bbq
             .not
             .wait_for_not_full(|| self.grant_exact(sz).ok())
@@ -121,60 +96,32 @@ where
     }
 }
 
-impl<S, C, N, Q> Typed for StreamProducer<Q, S, C, N>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-{
-}
+impl<Q: BbqHandle> Typed for StreamProducer<Q> {}
 
-impl<Q, S, C, N> TypedWrapper<StreamProducer<Q, S, C, N>>
-where
-    S: Storage,
-    C: Coord,
-    N: AsyncNotifierTyped,
-    Q: BbqHandle<S, C, N>,
-{
+impl<Q: BbqHandle<Notifier: AsyncNotifierTyped>> TypedWrapper<StreamProducer<Q>> {
     pub fn wait_grant_max_remaining(
         &self,
         max: usize,
-    ) -> <N as ConstrFut>::NotFull<impl ConstrFnMut<Out = StreamGrantW<Q, S, C, N>> + '_> {
-        self.bbq
-            .not
-            .wait_for_not_full(move || self.grant_max_remaining(max).ok())
+    ) -> <Q::Notifier as ConstrFut>::NotFull<impl ConstrFnMut<Out = StreamGrantW<Q>> + '_> {
+        AsyncNotifierTyped::wait_for_not_full(&self.bbq.not, move || {
+            self.grant_max_remaining(max).ok()
+        })
     }
 
     pub fn wait_grant_exact(
         &self,
         sz: usize,
-    ) -> <N as ConstrFut>::NotFull<impl ConstrFnMut<Out = StreamGrantW<Q, S, C, N>> + '_> {
-        self.bbq
-            .not
-            .wait_for_not_full(move || self.grant_exact(sz).ok())
+    ) -> <Q::Notifier as ConstrFut>::NotFull<impl ConstrFnMut<Out = StreamGrantW<Q>> + '_> {
+        AsyncNotifierTyped::wait_for_not_full(&self.bbq.not, move || self.grant_exact(sz).ok())
     }
 }
 
-pub struct StreamConsumer<Q, S, C, N>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-{
+pub struct StreamConsumer<Q: BbqHandle> {
     bbq: Q::Target,
-    pd: PhantomData<(S, C, N)>,
 }
 
-impl<Q, S, C, N> StreamConsumer<Q, S, C, N>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-{
-    pub fn read(&self) -> Result<StreamGrantR<Q, S, C, N>, ()> {
+impl<Q: BbqHandle> StreamConsumer<Q> {
+    pub fn read(&self) -> Result<StreamGrantR<Q>, ()> {
         let (ptr, _cap) = self.bbq.sto.ptr_len();
         let (offset, len) = self.bbq.cor.read()?;
         let ptr = unsafe {
@@ -190,61 +137,30 @@ where
     }
 }
 
-impl<Q, S, C, N> StreamConsumer<Q, S, C, N>
-where
-    S: Storage,
-    C: Coord,
-    N: AsyncNotifier,
-    Q: BbqHandle<S, C, N>,
-{
-    pub async fn wait_read(&self) -> StreamGrantR<Q, S, C, N> {
+impl<Q: BbqHandle<Notifier: AsyncNotifier>> StreamConsumer<Q> {
+    pub async fn wait_read(&self) -> StreamGrantR<Q> {
         self.bbq.not.wait_for_not_empty(|| self.read().ok()).await
     }
 }
 
-impl<S, C, N, Q> Typed for StreamConsumer<Q, S, C, N>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-{
-}
+impl<Q: BbqHandle> Typed for StreamConsumer<Q> {}
 
-impl<Q, S, C, N> TypedWrapper<StreamConsumer<Q, S, C, N>>
-where
-    S: Storage,
-    C: Coord,
-    N: AsyncNotifierTyped,
-    Q: BbqHandle<S, C, N>,
-{
+impl<Q: BbqHandle<Notifier: AsyncNotifierTyped>> TypedWrapper<StreamConsumer<Q>> {
     pub fn wait_read(
         &self,
-    ) -> <N as ConstrFut>::NotEmpty<impl ConstrFnMut<Out = StreamGrantR<Q, S, C, N>> + '_> {
-        self.bbq.not.wait_for_not_empty(move || self.read().ok())
+    ) -> <Q::Notifier as ConstrFut>::NotEmpty<impl ConstrFnMut<Out = StreamGrantR<Q>>> {
+        AsyncNotifierTyped::wait_for_not_empty(&self.bbq.not, move || self.read().ok())
     }
 }
 
-pub struct StreamGrantW<Q, S, C, N>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-{
+pub struct StreamGrantW<Q: BbqHandle> {
     bbq: Q::Target,
     ptr: NonNull<u8>,
     len: usize,
     to_commit: usize,
 }
 
-impl<Q, S, C, N> Deref for StreamGrantW<Q, S, C, N>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-{
+impl<Q: BbqHandle> Deref for StreamGrantW<Q> {
     type Target = [u8];
 
     fn deref(&self) -> &Self::Target {
@@ -252,25 +168,13 @@ where
     }
 }
 
-impl<Q, S, C, N> DerefMut for StreamGrantW<Q, S, C, N>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-{
+impl<Q: BbqHandle> DerefMut for StreamGrantW<Q> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         unsafe { core::slice::from_raw_parts_mut(self.ptr.as_ptr(), self.len) }
     }
 }
 
-impl<Q, S, C, N> Drop for StreamGrantW<Q, S, C, N>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-{
+impl<Q: BbqHandle> Drop for StreamGrantW<Q> {
     fn drop(&mut self) {
         let StreamGrantW {
             bbq,
@@ -288,13 +192,7 @@ where
     }
 }
 
-impl<Q, S, C, N> StreamGrantW<Q, S, C, N>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-{
+impl<Q: BbqHandle> StreamGrantW<Q> {
     pub fn commit(self, used: usize) {
         let (_, cap) = self.bbq.sto.ptr_len();
         let used = used.min(self.len);
@@ -306,26 +204,14 @@ where
     }
 }
 
-pub struct StreamGrantR<Q, S, C, N>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-{
+pub struct StreamGrantR<Q: BbqHandle> {
     bbq: Q::Target,
     ptr: NonNull<u8>,
     len: usize,
     to_release: usize,
 }
 
-impl<Q, S, C, N> Deref for StreamGrantR<Q, S, C, N>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-{
+impl<Q: BbqHandle> Deref for StreamGrantR<Q> {
     type Target = [u8];
 
     fn deref(&self) -> &Self::Target {
@@ -333,25 +219,13 @@ where
     }
 }
 
-impl<Q, S, C, N> DerefMut for StreamGrantR<Q, S, C, N>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-{
+impl<Q: BbqHandle> DerefMut for StreamGrantR<Q> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         unsafe { core::slice::from_raw_parts_mut(self.ptr.as_ptr(), self.len) }
     }
 }
 
-impl<Q, S, C, N> Drop for StreamGrantR<Q, S, C, N>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-{
+impl<Q: BbqHandle> Drop for StreamGrantR<Q> {
     fn drop(&mut self) {
         let StreamGrantR {
             bbq,
@@ -368,13 +242,7 @@ where
     }
 }
 
-impl<Q, S, C, N> StreamGrantR<Q, S, C, N>
-where
-    S: Storage,
-    C: Coord,
-    N: Notifier,
-    Q: BbqHandle<S, C, N>,
-{
+impl<Q: BbqHandle> StreamGrantR<Q> {
     pub fn release(self, used: usize) {
         let used = used.min(self.len);
         self.bbq.cor.release_inner(used);
diff --git a/src/traits/bbqhdl.rs b/src/traits/bbqhdl.rs
index 2ce17e4..6c35d35 100644
--- a/src/traits/bbqhdl.rs
+++ b/src/traits/bbqhdl.rs
@@ -1,29 +1,56 @@
 use core::ops::Deref;
+use std::sync::Arc;
 
-use crate::queue::BBQueue;
+use crate::queue::{ArcBBQueue, BBQueue};
 
 use super::{coordination::Coord, notifier::Notifier, storage::Storage};
 
-pub trait BbqHandle<S: Storage, C: Coord, N: Notifier> {
-    type Target: Deref<Target = BBQueue<S, C, N>> + Clone;
+pub trait BbqHandle {
+    type Target: Deref<Target = BBQueue<Self::Storage, Self::Coord, Self::Notifier>> + Clone;
     fn bbq_ref(&self) -> Self::Target;
+
+    type Storage: Storage;
+    type Coord: Coord;
+    type Notifier: Notifier;
 }
 
-impl<'a, S: Storage, C: Coord, N: Notifier> BbqHandle<S, C, N> for &'a BBQueue<S, C, N> {
+impl<S: Storage, C: Coord, N: Notifier> BbqHandle for &BBQueue<S, C, N> {
     type Target = Self;
 
     #[inline(always)]
     fn bbq_ref(&self) -> Self::Target {
         *self
     }
+
+    type Storage = S;
+    type Coord = C;
+    type Notifier = N;
+}
+
+#[cfg(feature = "std")]
+impl<S: Storage, C: Coord, N: Notifier> BbqHandle for ArcBBQueue<S, C, N> {
+    type Target = Arc<BBQueue<S, C, N>>;
+
+    #[inline(always)]
+    fn bbq_ref(&self) -> Self::Target {
+        self.0.clone()
+    }
+
+    type Storage = S;
+    type Coord = C;
+    type Notifier = N;
 }
 
 #[cfg(feature = "std")]
-impl<S: Storage, C: Coord, N: Notifier> BbqHandle<S, C, N> for std::sync::Arc<BBQueue<S, C, N>> {
-    type Target = std::sync::Arc<BBQueue<S, C, N>>;
+impl<S: Storage, C: Coord, N: Notifier> BbqHandle for Arc<BBQueue<S, C, N>> {
+    type Target = Self;
 
     #[inline(always)]
     fn bbq_ref(&self) -> Self::Target {
         self.clone()
     }
+
+    type Storage = S;
+    type Coord = C;
+    type Notifier = N;
 }
diff --git a/src/traits/notifier/typed.rs b/src/traits/notifier/typed.rs
index 8fc538e..678ad8f 100644
--- a/src/traits/notifier/typed.rs
+++ b/src/traits/notifier/typed.rs
@@ -1,9 +1,4 @@
-use crate::traits::{
-    bbqhdl::BbqHandle,
-    coordination::Coord,
-    notifier::{AsyncNotifier, Notifier},
-    storage::Storage,
-};
+use crate::traits::notifier::{AsyncNotifier, Notifier};
 use core::{future::Future, ops::Deref};
 
 pub trait AsyncNotifierTyped: Notifier {
@@ -54,37 +49,6 @@ where
     type Out = Out;
 }
 
-#[allow(private_bounds)]
-pub trait BbqSync<Q, S, C, N>
-where
-    Self: Imply<S, Is: Storage>,
-    Self: Imply<C, Is: Coord>,
-    Self: Imply<N, Is: Notifier>,
-    Self: Imply<Q, Is: BbqHandle<S, C, N>>,
-{
-}
-
-impl<T, Q, S, C, N> BbqSync<Q, S, C, N> for T
-where
-    Self: Imply<S, Is: Storage>,
-    Self: Imply<C, Is: Coord>,
-    Self: Imply<N, Is: Notifier>,
-    Self: Imply<Q, Is: BbqHandle<S, C, N>>,
-{
-}
-
-pub(crate) trait Imply<T>: ImplyInner<T, Is = T> {}
-
-impl<S, T> Imply<T> for S {}
-
-pub(crate) trait ImplyInner<T> {
-    type Is;
-}
-
-impl<S, T> ImplyInner<T> for S {
-    type Is = T;
-}
-
 pub trait ConstrFut<'a>: AsyncNotifierTyped {
     type NotFull<F: ConstrFnMut<'a>>;
     type NotEmpty<F: ConstrFnMut<'a>>;