diff -r fe0d69d72bcd -r 35bcb3216c0d src/array_list.c
--- a/src/array_list.c	Thu May 23 20:29:28 2024 +0200
+++ b/src/array_list.c	Thu May 23 20:31:37 2024 +0200
@@ -194,13 +194,13 @@
     if (list->base.simple_destructor) {
         for (size_t i = 0; i < list->base.size; i++) {
             cx_invoke_simple_destructor(list, ptr);
-            ptr += list->base.item_size;
+            ptr += list->base.elem_size;
         }
     }
     if (list->base.advanced_destructor) {
         for (size_t i = 0; i < list->base.size; i++) {
             cx_invoke_advanced_destructor(list, ptr);
-            ptr += list->base.item_size;
+            ptr += list->base.elem_size;
         }
     }
 
@@ -223,7 +223,7 @@
     // do we need to move some elements?
     if (index < list->base.size) {
         char const *first_to_move = (char const *) arl->data;
-        first_to_move += index * list->base.item_size;
+        first_to_move += index * list->base.elem_size;
         size_t elems_to_move = list->base.size - index;
         size_t start_of_moved = index + n;
 
@@ -233,7 +233,7 @@
                 &arl->capacity,
                 start_of_moved,
                 first_to_move,
-                list->base.item_size,
+                list->base.elem_size,
                 elems_to_move,
                 &arl->reallocator
         )) {
@@ -253,7 +253,7 @@
             &arl->capacity,
             index,
             array,
-            list->base.item_size,
+            list->base.elem_size,
             n,
             &arl->reallocator
     )) {
@@ -286,7 +286,7 @@
         );
         if (result == 0 && prepend != 0) {
             iter->index++;
-            iter->elem_handle = ((char *) iter->elem_handle) + list->base.item_size;
+            iter->elem_handle = ((char *) iter->elem_handle) + list->base.elem_size;
         }
         return result;
     } else {
@@ -308,7 +308,7 @@
     }
 
     // content destruction
-    cx_invoke_destructor(list, ((char *) arl->data) + index * list->base.item_size);
+    cx_invoke_destructor(list, ((char *) arl->data) + index * list->base.elem_size);
 
     // short-circuit removal of last element
     if (index == list->base.size - 1) {
@@ -322,8 +322,8 @@
             &list->base.size,
             &arl->capacity,
             index,
-            ((char *) arl->data) + (index + 1) * list->base.item_size,
-            list->base.item_size,
+            ((char *) arl->data) + (index + 1) * list->base.elem_size,
+            list->base.elem_size,
             list->base.size - index - 1,
             &arl->reallocator
     );
@@ -346,17 +346,17 @@
     if (list->base.simple_destructor) {
         for (size_t i = 0; i < list->base.size; i++) {
             cx_invoke_simple_destructor(list, ptr);
-            ptr += list->base.item_size;
+            ptr += list->base.elem_size;
         }
     }
     if (list->base.advanced_destructor) {
         for (size_t i = 0; i < list->base.size; i++) {
             cx_invoke_advanced_destructor(list, ptr);
-            ptr += list->base.item_size;
+            ptr += list->base.elem_size;
         }
     }
 
-    memset(arl->data, 0, list->base.size * list->base.item_size);
+    memset(arl->data, 0, list->base.size * list->base.elem_size);
     list->base.size = 0;
 }
 
@@ -367,7 +367,7 @@
 ) {
     if (i >= list->base.size || j >= list->base.size) return 1;
     cx_array_list *arl = (cx_array_list *) list;
-    cx_array_swap(arl->data, list->base.item_size, i, j);
+    cx_array_swap(arl->data, list->base.elem_size, i, j);
     return 0;
 }
 
@@ -378,7 +378,7 @@
     if (index < list->base.size) {
         cx_array_list const *arl = (cx_array_list const *) list;
         char *space = arl->data;
-        return space + index * list->base.item_size;
+        return space + index * list->base.elem_size;
     } else {
         return NULL;
     }
@@ -405,7 +405,7 @@
                 return i;
             }
         }
-        cur += list->base.item_size;
+        cur += list->base.elem_size;
     }
 
     return -1;
@@ -415,7 +415,7 @@
     assert(list->base.cmpfunc != NULL);
     qsort(((cx_array_list *) list)->data,
           list->base.size,
-          list->base.item_size,
+          list->base.elem_size,
           list->base.cmpfunc
     );
 }
@@ -433,8 +433,8 @@
             if (d != 0) {
                 return d;
             }
-            left += list->base.item_size;
-            right += other->base.item_size;
+            left += list->base.elem_size;
+            right += other->base.elem_size;
         }
         return 0;
     } else {
@@ -447,7 +447,7 @@
     void *data = ((cx_array_list const *) list)->data;
     size_t half = list->base.size / 2;
     for (size_t i = 0; i < half; i++) {
-        cx_array_swap(data, list->base.item_size, i, list->base.size - 1 - i);
+        cx_array_swap(data, list->base.elem_size, i, list->base.size - 1 - i);
     }
 }
 
@@ -471,7 +471,7 @@
         iter->index++;
         iter->elem_handle =
                 ((char *) iter->elem_handle)
-                + ((struct cx_list_s const *) iter->src_handle.c)->base.item_size;
+                + ((struct cx_list_s const *) iter->src_handle.c)->base.elem_size;
     }
 }
 
@@ -485,7 +485,7 @@
     iter->index--;
     if (iter->index < list->base.base.size) {
         iter->elem_handle = ((char *) list->data)
-                            + iter->index * list->base.base.item_size;
+                            + iter->index * list->base.base.elem_size;
     }
 }
 
@@ -500,7 +500,7 @@
     iter.index = index;
     iter.src_handle.c = list;
     iter.elem_handle = cx_arl_at(list, index);
-    iter.elem_size = list->base.item_size;
+    iter.elem_size = list->base.elem_size;
     iter.elem_count = list->base.size;
     iter.base.valid = cx_arl_iter_valid;
     iter.base.current = cx_arl_iter_current;
@@ -530,7 +530,7 @@
 CxList *cxArrayListCreate(
         CxAllocator const *allocator,
         cx_compare_func comparator,
-        size_t item_size,
+        size_t elem_size,
         size_t initial_capacity
 ) {
     if (allocator == NULL) {
@@ -544,17 +544,17 @@
     list->base.base.allocator = allocator;
     list->capacity = initial_capacity;
 
-    if (item_size > 0) {
-        list->base.base.item_size = item_size;
+    if (elem_size > 0) {
+        list->base.base.elem_size = elem_size;
         list->base.base.cmpfunc = comparator;
     } else {
-        item_size = sizeof(void *);
+        elem_size = sizeof(void *);
         list->base.base.cmpfunc = comparator == NULL ? cx_cmp_ptr : comparator;
         cxListStorePointers((CxList *) list);
     }
 
-    // allocate the array after the real item_size is known
-    list->data = cxCalloc(allocator, initial_capacity, item_size);
+    // allocate the array after the real elem_size is known
+    list->data = cxCalloc(allocator, initial_capacity, elem_size);
     if (list->data == NULL) {
         cxFree(allocator, list);
         return NULL;