Implement vec! macro

src/lib.rs

@@ -2,6 +2,9 @@
 #![deny(missing_docs)]
 #![doc = include_str!("../README.md")]
 
+#[macro_use]
+mod macros;
+
 use core::mem::MaybeUninit;
 use core::{cmp, error, fmt, slice};
 
@@ -60,7 +63,7 @@ impl<T, const CAPACITY: usize> Vec<T, CAPACITY> {
     pub const fn new() -> Self {
         assert!(CAPACITY > 0, "CAPACITY must be greater than 0");
 
-        // SAFETY: The elements in the array are not accessed before beign initialized.
+        // SAFETY: The elements in the array are not accessed before being initialized.
         let data = unsafe { MaybeUninit::<[MaybeUninit<T>; CAPACITY]>::uninit().assume_init() };
         Self { data, length: 0 }
     }

src/macros.rs

@@ -0,0 +1,56 @@
+/// Creates new vector.
+///
+/// # Forms
+///
+/// - `vec![T; CAPACITY]`: Creates a new empty `Vec<T, CAPACITY>` with maximum `CAPACITY` elements of type `T`.
+/// - `vec![x, y, z]`: Creates a `Vec` initialized with the given values. The capacity is inferred from the number of elements.
+///
+/// # Examples
+///
+/// Create an empty vector with capacity:
+///
+/// ```rust
+/// let vec = static_vector::vec![i32; 10];
+/// assert!(vec.is_empty());
+/// ```
+///
+/// Create a vector from elements:
+///
+/// ```rust
+/// let vec = static_vector::vec![1, 2, 3];
+/// assert_eq!(vec.as_slice(), &[1, 2, 3]);
+/// ```
+#[macro_export]
+macro_rules! vec {
+    ($type:ty; $capacity:literal) => {
+        $crate::Vec::<$type, $capacity>::new()
+    };
+
+    ($($value:expr),+ $(,)?) => {
+        {
+            let mut vec = $crate::Vec::<_, { [$($value),+].len() }>::new();
+            // It's safe to call unwrap because we are initializing the vector with a known number of elements
+            // (which is also the capacity).
+            vec.extend_from_slice(&[$($value),+]).unwrap();
+            vec
+        }
+    };
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn vec_with_type_and_capacity() {
+        let vec = vec![i32; 10];
+        assert_eq!(vec.capacity(), 10);
+        assert!(vec.is_empty());
+    }
+
+    #[test]
+    fn vec_with_elements() {
+        let vec = vec![1, 2, 3];
+        assert_eq!(vec.capacity(), 3);
+        assert_eq!(vec.len(), 3);
+        assert_eq!(vec.as_slice(), &[1, 2, 3]);
+    }
+}