From 271a56606a36c68d80c870333bf5b4c6f0357efa Mon Sep 17 00:00:00 2001
From: Amjad Alsharafi <26300843+Amjad50@users.noreply.github.com>
Date: Thu, 22 Feb 2024 23:39:17 +0800
Subject: [PATCH] Remove unneeded const generic for `alloc`

Since its allocated anyway at runtime, there is no need for the extra syntax, and this makes it harder to initialize.
---
 src/alloc.rs | 61 ++++++++++++++++++++++++++--------------------------
 src/lib.rs   |  4 ++--
 src/tests.rs | 32 +++++++++++++--------------
 3 files changed, 48 insertions(+), 49 deletions(-)

diff --git a/src/alloc.rs b/src/alloc.rs
index 0a5dadb..5b519ec 100644
--- a/src/alloc.rs
+++ b/src/alloc.rs
@@ -23,7 +23,7 @@
 //! # #[cfg(not(loom))]
 //! # {
 //! use blinkcast::alloc::channel;
-//! let (sender, mut receiver) = channel::<i32, 4>();
+//! let (sender, mut receiver) = channel::<i32>(4);
 //! sender.send(1);
 //! assert_eq!(receiver.recv(), Some(1));
 //!
@@ -51,15 +51,17 @@ use alloc::sync::Arc;
 #[cfg(loom)]
 use loom::sync::Arc;
 
-struct InnerChannel<T, const N: usize> {
+struct InnerChannel<T> {
     buffer: Box<[Node<T>]>,
     head: AtomicUsize,
 }
 
-impl<T: Clone, const N: usize> InnerChannel<T, N> {
-    fn new() -> Self {
-        let mut buffer = Vec::with_capacity(N);
-        for _ in 0..N {
+impl<T: Clone> InnerChannel<T> {
+    fn new(size: usize) -> Self {
+        assert!(size <= MAX_LEN, "Exceeded the maximum length");
+
+        let mut buffer = Vec::with_capacity(size);
+        for _ in 0..size {
             buffer.push(Default::default());
         }
         let buffer = buffer.into_boxed_slice();
@@ -91,7 +93,7 @@ impl<T: Clone, const N: usize> InnerChannel<T, N> {
 /// # {
 /// use blinkcast::alloc::channel;
 ///
-/// let (sender, mut receiver) = channel::<i32, 4>();
+/// let (sender, mut receiver) = channel::<i32>(4);
 ///
 /// sender.send(1);
 /// let sender2 = sender.clone();
@@ -108,7 +110,7 @@ impl<T: Clone, const N: usize> InnerChannel<T, N> {
 /// # {
 /// use blinkcast::alloc::Sender;
 ///
-/// let sender = Sender::<i32, 4>::new();
+/// let sender = Sender::<i32>::new(4);
 ///
 /// let mut receiver = sender.new_receiver();
 ///
@@ -119,14 +121,14 @@ impl<T: Clone, const N: usize> InnerChannel<T, N> {
 /// assert_eq!(receiver.recv(), None);
 /// # }
 /// ```
-pub struct Sender<T, const N: usize> {
-    queue: Arc<InnerChannel<T, N>>,
+pub struct Sender<T> {
+    queue: Arc<InnerChannel<T>>,
 }
 
-unsafe impl<T: Clone + Send, const N: usize> Send for Sender<T, N> {}
-unsafe impl<T: Clone + Send, const N: usize> Sync for Sender<T, N> {}
+unsafe impl<T: Clone + Send> Send for Sender<T> {}
+unsafe impl<T: Clone + Send> Sync for Sender<T> {}
 
-impl<T: Clone, const N: usize> Sender<T, N> {
+impl<T: Clone> Sender<T> {
     /// Sends a message to the channel.
     /// If the channel is full, the oldest message will be overwritten.
     /// So the receiver must be quick or it will lose the old data.
@@ -136,12 +138,9 @@ impl<T: Clone, const N: usize> Sender<T, N> {
 
     /// Creates a new channel with a buffer of size `N`.
     #[allow(clippy::new_without_default)]
-    pub fn new() -> Self {
-        // TODO: use const_assert to check if N is a power of 2
-        assert!(N <= MAX_LEN, "Exceeded the maximum length");
-
+    pub fn new(size: usize) -> Self {
         Self {
-            queue: Arc::new(InnerChannel::<T, N>::new()),
+            queue: Arc::new(InnerChannel::<T>::new(size)),
         }
     }
 
@@ -153,7 +152,7 @@ impl<T: Clone, const N: usize> Sender<T, N> {
     /// # {
     /// use blinkcast::alloc::Sender;
     ///
-    /// let sender = Sender::<i32, 4>::new();
+    /// let sender = Sender::<i32>::new(4);
     ///
     /// sender.send(1);
     ///
@@ -165,7 +164,7 @@ impl<T: Clone, const N: usize> Sender<T, N> {
     /// assert_eq!(receiver.recv(), None);
     /// # }
     /// ```
-    pub fn new_receiver(&self) -> Receiver<T, N> {
+    pub fn new_receiver(&self) -> Receiver<T> {
         let head = self.queue.head.load(Ordering::Relaxed);
         let (lap, index) = unpack_data_index(head);
 
@@ -176,7 +175,7 @@ impl<T: Clone, const N: usize> Sender<T, N> {
     }
 }
 
-impl<T, const N: usize> Clone for Sender<T, N> {
+impl<T> Clone for Sender<T> {
     fn clone(&self) -> Self {
         Self {
             queue: self.queue.clone(),
@@ -198,7 +197,7 @@ impl<T, const N: usize> Clone for Sender<T, N> {
 /// # #[cfg(not(loom))]
 /// # {
 /// use blinkcast::alloc::channel;
-/// let (sender, mut receiver) = channel::<i32, 4>();
+/// let (sender, mut receiver) = channel::<i32>(4);
 /// sender.send(1);
 /// assert_eq!(receiver.recv(), Some(1));
 ///
@@ -215,15 +214,15 @@ impl<T, const N: usize> Clone for Sender<T, N> {
 /// assert_eq!(receiver2.recv(), None);
 /// # }
 /// ```
-pub struct Receiver<T, const N: usize> {
-    queue: Arc<InnerChannel<T, N>>,
+pub struct Receiver<T> {
+    queue: Arc<InnerChannel<T>>,
     reader: ReaderData,
 }
 
-unsafe impl<T: Clone + Send, const N: usize> Send for Receiver<T, N> {}
-unsafe impl<T: Clone + Send, const N: usize> Sync for Receiver<T, N> {}
+unsafe impl<T: Clone + Send> Send for Receiver<T> {}
+unsafe impl<T: Clone + Send> Sync for Receiver<T> {}
 
-impl<T: Clone, const N: usize> Receiver<T, N> {
+impl<T: Clone> Receiver<T> {
     /// Receives a message from the channel.
     ///
     /// If there is no message available, this method will return `None`.
@@ -232,7 +231,7 @@ impl<T: Clone, const N: usize> Receiver<T, N> {
     }
 }
 
-impl<T: Clone, const N: usize> Clone for Receiver<T, N> {
+impl<T: Clone> Clone for Receiver<T> {
     fn clone(&self) -> Self {
         Self {
             queue: self.queue.clone(),
@@ -252,7 +251,7 @@ impl<T: Clone, const N: usize> Clone for Receiver<T, N> {
 /// # #[cfg(not(loom))]
 /// # {
 /// use blinkcast::alloc::channel;
-/// let (sender, mut receiver) = channel::<i32, 4>();
+/// let (sender, mut receiver) = channel::<i32>(4);
 ///
 /// sender.send(1);
 /// sender.send(2);
@@ -271,8 +270,8 @@ impl<T: Clone, const N: usize> Clone for Receiver<T, N> {
 /// assert_eq!(receiver2.recv(), None);
 /// # }
 /// ```
-pub fn channel<T: Clone, const N: usize>() -> (Sender<T, N>, Receiver<T, N>) {
-    let sender = Sender::<T, N>::new();
+pub fn channel<T: Clone>(size: usize) -> (Sender<T>, Receiver<T>) {
+    let sender = Sender::<T>::new(size);
     let receiver = sender.new_receiver();
     (sender, receiver)
 }
diff --git a/src/lib.rs b/src/lib.rs
index 88bcbc0..9ba0089 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -27,7 +27,7 @@
 //! # {
 //! use blinkcast::alloc::channel;
 //!
-//! let (sender, mut receiver1) = channel::<i32, 4>();
+//! let (sender, mut receiver1) = channel::<i32>(4);
 //! sender.send(1);
 //! sender.send(2);
 //!
@@ -48,7 +48,7 @@
 //! # {
 //! use blinkcast::alloc::channel;
 //! use std::thread;
-//! let (sender1, mut receiver1) = channel::<i32, 100>();
+//! let (sender1, mut receiver1) = channel::<i32>(100);
 //! let sender2 = sender1.clone();
 //!
 //! let t1 = thread::spawn(move || {
diff --git a/src/tests.rs b/src/tests.rs
index 69ef2d7..892765c 100644
--- a/src/tests.rs
+++ b/src/tests.rs
@@ -21,14 +21,14 @@ macro_rules! loom {
 #[should_panic]
 fn test_channel_too_large() {
     loom!({
-        let _ = alloc_impl::channel::<i32, { MAX_LEN + 1 }>();
+        let _ = alloc_impl::channel::<i32>(MAX_LEN + 1);
     });
 }
 
 #[test]
 fn test_push_pop() {
     loom!({
-        let (sender, mut receiver) = alloc_impl::channel::<i32, 4>();
+        let (sender, mut receiver) = alloc_impl::channel::<i32>(4);
 
         sender.send(1);
         sender.send(2);
@@ -46,7 +46,7 @@ fn test_push_pop() {
 #[test]
 fn test_more_push_pop() {
     loom!({
-        let (sender, mut receiver) = alloc_impl::channel::<i32, 4>();
+        let (sender, mut receiver) = alloc_impl::channel::<i32>(4);
 
         sender.send(1);
         sender.send(2);
@@ -70,7 +70,7 @@ fn test_more_push_pop() {
 #[test]
 fn test_clone_send() {
     loom!({
-        let (sender, mut receiver) = alloc_impl::channel::<i32, 6>();
+        let (sender, mut receiver) = alloc_impl::channel::<i32>(6);
 
         sender.send(1);
         sender.send(2);
@@ -95,7 +95,7 @@ fn test_clone_send() {
 #[test]
 fn test_clone_recv() {
     loom!({
-        let (sender, mut receiver) = alloc_impl::channel::<i32, 4>();
+        let (sender, mut receiver) = alloc_impl::channel::<i32>(4);
 
         sender.send(1);
         sender.send(2);
@@ -120,7 +120,7 @@ fn test_clone_recv() {
 #[test]
 fn test_middle_clone() {
     loom!({
-        let (sender, mut receiver) = alloc_impl::channel::<i32, 4>();
+        let (sender, mut receiver) = alloc_impl::channel::<i32>(4);
 
         sender.send(1);
         sender.send(2);
@@ -151,7 +151,7 @@ fn test_middle_clone() {
 #[test]
 fn test_overflow() {
     loom!({
-        let (sender, mut receiver) = alloc_impl::channel::<i32, 4>();
+        let (sender, mut receiver) = alloc_impl::channel::<i32>(4);
 
         sender.send(1);
         sender.send(2);
@@ -183,7 +183,7 @@ fn test_overflow() {
 // FIXME: spin panic on loom
 #[cfg(not(loom))]
 fn test_always_overflow() {
-    let (sender, mut receiver) = alloc_impl::channel::<i32, 4>();
+    let (sender, mut receiver) = alloc_impl::channel::<i32>(4);
 
     for i in 0..100 {
         sender.send(i);
@@ -199,7 +199,7 @@ fn test_always_overflow() {
 // FIXME: spin panic on loom
 #[cfg(not(loom))]
 fn test_sender_receiver_conflict() {
-    let (sender, receiver) = alloc_impl::channel::<i32, 4>();
+    let (sender, receiver) = alloc_impl::channel::<i32>(4);
 
     let barrier = Arc::new(std::sync::Barrier::new(2));
 
@@ -241,7 +241,7 @@ fn test_sender_receiver_conflict() {
 // FIXME: too long on loom
 #[cfg(not(loom))]
 fn test_multiple_sender_conflict() {
-    let (sender, mut receiver) = alloc_impl::channel::<i32, 4>();
+    let (sender, mut receiver) = alloc_impl::channel::<i32>(4);
 
     let barrier = Arc::new(std::sync::Barrier::new(8));
 
@@ -291,7 +291,7 @@ fn test_drop() {
             }
         }
 
-        let (sender, mut receiver) = alloc_impl::channel::<DropCount, 4>();
+        let (sender, mut receiver) = alloc_impl::channel::<DropCount>(4);
 
         sender.send(DropCount);
         sender.send(DropCount);
@@ -321,7 +321,7 @@ fn test_drop() {
 #[test]
 #[cfg(not(loom))]
 fn stress_test() {
-    let (sender, receiver) = alloc_impl::channel::<i32, 40>();
+    let (sender, receiver) = alloc_impl::channel::<i32>(40);
 
     for _ in 0..4 {
         for i in 0..10 {
@@ -355,7 +355,7 @@ mod bench {
 
     #[bench]
     fn bench_push_pop(b: &mut Bencher) {
-        let (sender, mut receiver) = alloc_impl::channel::<i32, 4>();
+        let (sender, mut receiver) = alloc_impl::channel::<i32>(4);
 
         b.iter(|| {
             sender.send(1);
@@ -389,7 +389,7 @@ mod bench {
 
     #[bench]
     fn bench_push_pop_threaded(b: &mut Bencher) {
-        let (sender, receiver) = alloc_impl::channel::<i32, 4>();
+        let (sender, receiver) = alloc_impl::channel::<i32>(4);
 
         b.iter(|| {
             let sender = sender.clone();
@@ -416,7 +416,7 @@ mod bench {
 
     #[bench]
     fn bench_overflow(b: &mut Bencher) {
-        let (sender, mut receiver) = alloc_impl::channel::<i32, 4>();
+        let (sender, mut receiver) = alloc_impl::channel::<i32>(4);
 
         b.iter(|| {
             sender.send(1);
@@ -447,7 +447,7 @@ mod bench {
 
     #[bench]
     fn bench_always_overflow(b: &mut Bencher) {
-        let (sender, mut receiver) = alloc_impl::channel::<i32, 4>();
+        let (sender, mut receiver) = alloc_impl::channel::<i32>(4);
 
         b.iter(|| {
             for i in 0..50 {