refactor: use *args for array construction instead of iterables

DynamicArray(1, 2, 3) instead of DynamicArray([1, 2, 3]).
StaticArray(1, 2, 3) for values, StaticArray(capacity=5) for empty.

Author: AzizAlievDevelopment

README.md

@@ -34,25 +34,23 @@ All structures implement common Python protocols: `len()`, `in`, `bool()`, `==`,
 
 \* amortised
 
-**Features:** negative indexing, slicing (`arr[1:3]`, `arr[::-1]`), construction from iterables.
+**Features:** negative indexing, slicing (`arr[1:3]`, `arr[::-1]`), `*args` construction.
 
 ```python
 from data_structures.array.static_array import StaticArray
 from data_structures.array.dynamic_array import DynamicArray
 
 # Static array — fixed capacity
-sa = StaticArray([1, 2, 3])
+sa = StaticArray(1, 2, 3)
 sa[0]              # 1
 sa[-1]             # 3
 sa[::2]            # [1, 3]
 
 # Dynamic array — grows and shrinks automatically
-da = DynamicArray()
-for i in range(1, 6):
-    da.append(i)
+da = DynamicArray(1, 2, 3, 4, 5)
 str(da)            # "[1, 2, 3, 4, 5]"
 da[::-1]           # [5, 4, 3, 2, 1]
-da == StaticArray([1, 2, 3, 4, 5])  # True (cross-type equality)
+da == StaticArray(1, 2, 3, 4, 5)  # True (cross-type equality)
 ```
 
 ### Linked Lists

data_structures/array/base.py

@@ -6,7 +6,7 @@ class IArray[T](ABC):
     """Abstract Array interface (random-access, indexed collection).
 
     >>> from data_structures.array.static_array import StaticArray
-    >>> a = StaticArray(4)
+    >>> a = StaticArray(capacity=4)
     >>> a.append(10); a.append(20); a.append(30)
     >>> a[1]
     20

data_structures/array/dynamic_array.py

@@ -1,4 +1,3 @@
-from collections.abc import Iterable
 from typing import Iterator, overload
 
 from .base import IArray
@@ -18,15 +17,15 @@ class DynamicArray[T](IArray[T]):
     elements between shrink thresholds.
     """
 
-    def __init__(self, values: Iterable[T] | None = None) -> None:
-        """Create a dynamic array, optionally pre-filled from *values*.
+    def __init__(self, *values: T) -> None:
+        """Create a dynamic array, optionally pre-filled with *values*.
 
         >>> DynamicArray()            # empty
         DynamicArray([])
-        >>> DynamicArray([1, 2, 3])   # pre-filled
+        >>> DynamicArray(1, 2, 3)     # pre-filled
         DynamicArray([1, 2, 3])
         """
-        if values is None:
+        if not values:
             self._capacity: int = _DEFAULT_CAPACITY
             self._size: int = 0
             self._data: list[T | None] = [None] * self._capacity

data_structures/array/static_array.py

@@ -1,4 +1,3 @@
-from collections.abc import Iterable
 from typing import Iterator, overload
 
 from .base import IArray
@@ -10,31 +9,33 @@ class StaticArray[T](IArray[T]):
     Capacity is set at construction time and cannot grow.
     Raises ``OverflowError`` when appending to a full array.
 
-    >>> StaticArray(3)             # empty with capacity 3
+    >>> StaticArray(capacity=3)    # empty with capacity 3
     StaticArray([])
-    >>> StaticArray([1, 2, 3])    # pre-filled, capacity == len
+    >>> StaticArray(1, 2, 3)       # pre-filled, capacity == len
     StaticArray([1, 2, 3])
     """
 
-    def __init__(self, capacity_or_values: int | Iterable[T]) -> None:
+    def __init__(self, *values: T, capacity: int | None = None) -> None:
         """Create a static array.
 
-        Pass an ``int`` for an empty array with that capacity, or an
-        iterable to pre-fill (capacity equals the number of elements).
+        Pass values as positional args to pre-fill (capacity equals the
+        number of elements), or use ``capacity`` for an empty array with
+        a fixed size.
         """
-        if isinstance(capacity_or_values, int):
-            if capacity_or_values <= 0:
+        if values and capacity is not None:
+            raise TypeError("Cannot specify both values and capacity")
+        if values:
+            self._capacity: int = len(values)
+            self._size: int = len(values)
+            self._data: list[T | None] = list(values)
+        elif capacity is not None:
+            if capacity <= 0:
                 raise ValueError("Capacity must be positive")
-            self._capacity: int = capacity_or_values
-            self._size: int = 0
-            self._data: list[T | None] = [None] * self._capacity
+            self._capacity = capacity
+            self._size = 0
+            self._data = [None] * self._capacity
         else:
-            values = list(capacity_or_values)
-            if not values:
-                raise ValueError("Capacity must be positive")
-            self._capacity = len(values)
-            self._size = len(values)
-            self._data = list(values)
+            raise TypeError("Provide values or capacity")
 
     def append(self, value: T) -> None:
         """Append *value* after the last element. O(1).

tests/test_arrays.py

@@ -4,7 +4,7 @@
 from data_structures.array.static_array import StaticArray
 
 
-@pytest.fixture(params=[lambda: StaticArray(5), DynamicArray])
+@pytest.fixture(params=[lambda: StaticArray(capacity=5), DynamicArray])
 def arr(request):
     return request.param()
 
@@ -168,20 +168,20 @@ def test_bool_non_empty(arr):
 def test_eq_same_elements(arr):
     for v in [1, 2, 3]:
         arr.append(v)
-    other = DynamicArray([1, 2, 3])
+    other = DynamicArray(1, 2, 3)
     assert arr == other
 
 
 def test_eq_different_elements(arr):
     for v in [1, 2, 3]:
         arr.append(v)
-    other = DynamicArray([1, 2, 4])
+    other = DynamicArray(1, 2, 4)
     assert arr != other
 
 
 def test_eq_different_length(arr):
     arr.append(1)
-    other = DynamicArray([1, 2])
+    other = DynamicArray(1, 2)
     assert arr != other
 
 
@@ -191,8 +191,8 @@ def test_eq_not_array(arr):
 
 
 def test_eq_cross_type():
-    sa = StaticArray([1, 2, 3])
-    da = DynamicArray([1, 2, 3])
+    sa = StaticArray(1, 2, 3)
+    da = DynamicArray(1, 2, 3)
     assert sa == da
 
 
@@ -249,72 +249,66 @@ def test_slice_empty_result(arr):
 
 
 def test_static_capacity():
-    arr = StaticArray(5)
+    arr = StaticArray(capacity=5)
     assert arr.capacity == 5
 
 
 def test_static_zero_capacity_raises():
     with pytest.raises(ValueError):
-        StaticArray(0)
+        StaticArray(capacity=0)
 
 
 def test_static_negative_capacity_raises():
     with pytest.raises(ValueError):
-        StaticArray(-1)
+        StaticArray(capacity=-1)
 
 
 def test_static_append_on_full_raises():
-    arr = StaticArray(3)
+    arr = StaticArray(capacity=3)
     for i in range(3):
         arr.append(i)
     with pytest.raises(OverflowError):
         arr.append(99)
 
 
 def test_static_insert_on_full_raises():
-    arr = StaticArray(3)
+    arr = StaticArray(capacity=3)
     for i in range(3):
         arr.append(i)
     with pytest.raises(OverflowError):
         arr.insert(0, 99)
 
 
 def test_static_repr():
-    arr = StaticArray(5)
+    arr = StaticArray(capacity=5)
     arr.append(1)
     arr.append(2)
     assert repr(arr) == "StaticArray([1, 2])"
 
 
 def test_static_repr_empty():
-    assert repr(StaticArray(5)) == "StaticArray([])"
+    assert repr(StaticArray(capacity=5)) == "StaticArray([])"
 
 
 def test_static_str():
-    arr = StaticArray([1, 2, 3])
+    arr = StaticArray(1, 2, 3)
     assert str(arr) == "[1, 2, 3]"
 
 
 def test_static_str_empty():
-    assert str(StaticArray(5)) == "[]"
+    assert str(StaticArray(capacity=5)) == "[]"
 
 
-def test_static_init_from_list():
-    arr = StaticArray([10, 20, 30])
+def test_static_init_from_args():
+    arr = StaticArray(10, 20, 30)
     assert list(arr) == [10, 20, 30]
     assert arr.capacity == 3
     assert len(arr) == 3
 
 
-def test_static_init_from_iterable():
-    arr = StaticArray(range(4))
-    assert list(arr) == [0, 1, 2, 3]
-    assert arr.capacity == 4
-
-
-def test_static_init_empty_iterable_raises():
-    with pytest.raises(ValueError):
-        StaticArray([])
+def test_static_init_no_args_raises():
+    with pytest.raises(TypeError):
+        StaticArray()
 
 
 # ── DynamicArray-specific tests ──────────────────────────────────────
@@ -388,32 +382,27 @@ def test_dynamic_repr_empty():
 
 
 def test_dynamic_str():
-    arr = DynamicArray([1, 2, 3])
+    arr = DynamicArray(1, 2, 3)
     assert str(arr) == "[1, 2, 3]"
 
 
 def test_dynamic_str_empty():
     assert str(DynamicArray()) == "[]"
 
 
-def test_dynamic_init_from_list():
-    arr = DynamicArray([10, 20, 30])
+def test_dynamic_init_from_args():
+    arr = DynamicArray(10, 20, 30)
     assert list(arr) == [10, 20, 30]
     assert len(arr) == 3
 
 
-def test_dynamic_init_from_iterable():
-    arr = DynamicArray(range(4))
-    assert list(arr) == [0, 1, 2, 3]
-
-
-def test_dynamic_init_empty_iterable():
-    arr = DynamicArray([])
+def test_dynamic_init_empty():
+    arr = DynamicArray()
     assert arr.is_empty()
     assert arr.capacity == 4
 
 
 def test_dynamic_init_large_sets_capacity():
-    arr = DynamicArray(range(10))
+    arr = DynamicArray(*range(10))
     assert arr.capacity >= 10
     assert len(arr) == 10

tests/test_benchmarks.py

@@ -21,7 +21,7 @@
 
 def test_static_array_append(benchmark):
     def run():
-        arr = StaticArray(N)
+        arr = StaticArray(capacity=N)
         for i in range(N):
             arr.append(i)
 
@@ -51,12 +51,12 @@ def run():
 
 @pytest.fixture
 def static_filled():
-    return StaticArray(range(N))
+    return StaticArray(*range(N))
 
 
 @pytest.fixture
 def dynamic_filled():
-    return DynamicArray(range(N))
+    return DynamicArray(*range(N))
 
 
 @pytest.fixture

tests/test_binary_search.py

@@ -114,29 +114,29 @@ def test_upper_bound_empty():
 
 
 def test_binary_search_static_array():
-    assert binary_search(StaticArray([1, 3, 5, 7, 9]), 5) == 2
-    assert binary_search(StaticArray([1, 3, 5, 7, 9]), 42) == -1
+    assert binary_search(StaticArray(1, 3, 5, 7, 9), 5) == 2
+    assert binary_search(StaticArray(1, 3, 5, 7, 9), 42) == -1
 
 
 def test_lower_bound_static_array():
-    assert lower_bound(StaticArray([1, 3, 5, 7]), 4) == 2
+    assert lower_bound(StaticArray(1, 3, 5, 7), 4) == 2
 
 
 def test_upper_bound_static_array():
-    assert upper_bound(StaticArray([1, 3, 3, 3, 5]), 3) == 4
+    assert upper_bound(StaticArray(1, 3, 3, 3, 5), 3) == 4
 
 
 # ── DynamicArray ─────────────────────────────────────────────────────
 
 
 def test_binary_search_dynamic_array():
-    assert binary_search(DynamicArray([1, 3, 5, 7, 9]), 5) == 2
-    assert binary_search(DynamicArray([1, 3, 5, 7, 9]), 42) == -1
+    assert binary_search(DynamicArray(1, 3, 5, 7, 9), 5) == 2
+    assert binary_search(DynamicArray(1, 3, 5, 7, 9), 42) == -1
 
 
 def test_lower_bound_dynamic_array():
-    assert lower_bound(DynamicArray([1, 3, 5, 7]), 4) == 2
+    assert lower_bound(DynamicArray(1, 3, 5, 7), 4) == 2
 
 
 def test_upper_bound_dynamic_array():
-    assert upper_bound(DynamicArray([1, 3, 3, 3, 5]), 3) == 4
+    assert upper_bound(DynamicArray(1, 3, 3, 3, 5), 3) == 4

tests/test_properties.py

@@ -38,19 +38,19 @@ def test_dynamic_array_len_matches_appends(values):
 
 
 @given(ints)
-def test_static_array_from_iterable_roundtrips(values):
+def test_static_array_from_args_roundtrips(values):
     if not values:
         return
-    arr = StaticArray(values)
+    arr = StaticArray(*values)
     assert list(arr) == values
 
 
 @given(ints)
 def test_dynamic_array_eq_static_array(values):
     if not values:
         return
-    da = DynamicArray(values)
-    sa = StaticArray(values)
+    da = DynamicArray(*values)
+    sa = StaticArray(*values)
     assert da == sa
 
 
@@ -66,7 +66,7 @@ def test_array_pop_reverses_append(values):
 
 @given(ints)
 def test_array_slice_matches_list_slice(values):
-    arr = DynamicArray(values)
+    arr = DynamicArray(*values)
     assert arr[:] == values
     assert arr[::2] == values[::2]
     assert arr[::-1] == values[::-1]