feat: add lessvec! macro

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lessvec"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2024"
 description = "A custom Vec implementation using the Rust standard library."
 authors = ["Ayush Chauhan (bakayu) <mail@ayuch.dev>"]

examples/basics.rs

@@ -1,4 +1,4 @@
-use lessvec::LessVec;
+use lessvec::prelude::*;
 
 fn main() {
     // Basic push/pop
@@ -49,4 +49,15 @@ fn main() {
     let collected: Vec<_> = v2.into_iter().collect();
     println!("into_iter collected: {:?}", collected);
     println!();
+
+    // Macro example - 1
+    println!(">>> Macro example 1 - Executing: lessvec![1, 2, 3]");
+    let v_macro = lessvec![1, 2];
+    println!("macro created: {:?}", v_macro.as_slice());
+    println!();
+
+    // Macro example - 2
+    println!(">>> Macro example 2 - Executing: lessvec![0; 2]");
+    let v_macro = lessvec![0; 2];
+    println!("macro created: {:?}", v_macro.as_slice());
 }

src/lib.rs

@@ -24,6 +24,27 @@ use std::{
     ptr::{self, NonNull},
 };
 
+mod macros;
+
+/// Re-exports a small "prelude" of the most commonly-used items.
+///
+/// The prelude provides:
+/// - `LessVec` — the vector type
+/// - `lessvec!` — the convenient macro (same syntax as `vec!`)
+///
+/// Bring them into scope with:
+///
+/// ```
+/// use lessvec::prelude::*;
+///
+/// let v = lessvec![1, 2, 3];
+/// assert_eq!(v.as_slice(), &[1, 2, 3]);
+/// ```
+pub mod prelude {
+    pub use crate::LessVec;
+    pub use crate::lessvec;
+}
+
 struct RawVec<T> {
     ptr: NonNull<T>,
     cap: usize,
@@ -645,7 +666,7 @@ impl<'a, T> Drop for Drain<'a, T> {
 
 #[cfg(test)]
 mod tests {
-    use crate::LessVec;
+    use crate::prelude::*;
 
     #[test]
     fn push_pop_roundtrip() {
@@ -720,4 +741,22 @@ mod tests {
         v.as_mut_slice()[0] = 2;
         assert_eq!(v.as_slice(), &[2]);
     }
+
+    #[test]
+    fn macro_basic() {
+        let v = lessvec![1, 2, 3];
+        assert_eq!(&*v, &[1, 2, 3]);
+    }
+
+    #[test]
+    fn macro_empty() {
+        let v: LessVec<i32> = lessvec![];
+        assert_eq!(v.len(), 0);
+    }
+
+    #[test]
+    fn macro_repeat() {
+        let v = lessvec![5; 3];
+        assert_eq!(&*v, &[5, 5, 5]);
+    }
 }

src/macros.rs

@@ -0,0 +1,43 @@
+/// Create a `LessVec` with the same syntax as the standard `vec!` macro.
+///
+/// Supported forms:
+/// - `lessvec![]` — empty `LessVec`
+/// - `lessvec![a, b, c]` — list of elements
+/// - `lessvec![elem; n]` — `n` copies of `elem` (requires `elem: Clone`)
+///
+/// # Examples
+///
+/// ```
+/// use lessvec::prelude::*;
+///
+/// let v = lessvec![1, 2, 3];
+/// assert_eq!(&*v, &[1, 2, 3]);
+///
+/// let v2: LessVec<i32> = lessvec![];
+/// assert_eq!(v2.len(), 0);
+///
+/// let v3 = lessvec![5; 4];
+/// assert_eq!(&*v3, &[5, 5, 5, 5]);
+/// ```
+#[macro_export]
+macro_rules! lessvec {
+    () => {
+        $crate::LessVec::new()
+    };
+
+    ($elem:expr; $n:expr) => {{
+        let mut v = $crate::LessVec::new();
+        let count = $n;
+        v.reserve(count);
+        for _ in 0..count {
+            v.push($elem.clone());
+        }
+        v
+    }};
+
+    ($($e:expr),+ $(,)?) => {{
+        let mut v = $crate::LessVec::new();
+        $( v.push($e); )+
+        v
+    }};
+}