diff -r 35bcb3216c0d -r 6bbbf219251d src/array_list.c
--- a/src/array_list.c	Thu May 23 20:31:37 2024 +0200
+++ b/src/array_list.c	Thu May 23 20:43:04 2024 +0200
@@ -191,21 +191,21 @@
 
     char *ptr = arl->data;
 
-    if (list->base.simple_destructor) {
-        for (size_t i = 0; i < list->base.size; i++) {
+    if (list->collection.simple_destructor) {
+        for (size_t i = 0; i < list->collection.size; i++) {
             cx_invoke_simple_destructor(list, ptr);
-            ptr += list->base.elem_size;
+            ptr += list->collection.elem_size;
         }
     }
-    if (list->base.advanced_destructor) {
-        for (size_t i = 0; i < list->base.size; i++) {
+    if (list->collection.advanced_destructor) {
+        for (size_t i = 0; i < list->collection.size; i++) {
             cx_invoke_advanced_destructor(list, ptr);
-            ptr += list->base.elem_size;
+            ptr += list->collection.elem_size;
         }
     }
 
-    cxFree(list->base.allocator, arl->data);
-    cxFree(list->base.allocator, list);
+    cxFree(list->collection.allocator, arl->data);
+    cxFree(list->collection.allocator, list);
 }
 
 static size_t cx_arl_insert_array(
@@ -215,25 +215,25 @@
         size_t n
 ) {
     // out of bounds and special case check
-    if (index > list->base.size || n == 0) return 0;
+    if (index > list->collection.size || n == 0) return 0;
 
     // get a correctly typed pointer to the list
     cx_array_list *arl = (cx_array_list *) list;
 
     // do we need to move some elements?
-    if (index < list->base.size) {
+    if (index < list->collection.size) {
         char const *first_to_move = (char const *) arl->data;
-        first_to_move += index * list->base.elem_size;
-        size_t elems_to_move = list->base.size - index;
+        first_to_move += index * list->collection.elem_size;
+        size_t elems_to_move = list->collection.size - index;
         size_t start_of_moved = index + n;
 
         if (CX_ARRAY_SUCCESS != cx_array_copy(
                 &arl->data,
-                &list->base.size,
+                &list->collection.size,
                 &arl->capacity,
                 start_of_moved,
                 first_to_move,
-                list->base.elem_size,
+                list->collection.elem_size,
                 elems_to_move,
                 &arl->reallocator
         )) {
@@ -249,11 +249,11 @@
     // place the new elements
     if (CX_ARRAY_SUCCESS == cx_array_copy(
             &arl->data,
-            &list->base.size,
+            &list->collection.size,
             &arl->capacity,
             index,
             array,
-            list->base.elem_size,
+            list->collection.elem_size,
             n,
             &arl->reallocator
     )) {
@@ -278,7 +278,7 @@
         int prepend
 ) {
     struct cx_list_s *list = iter->src_handle.m;
-    if (iter->index < list->base.size) {
+    if (iter->index < list->collection.size) {
         int result = cx_arl_insert_element(
                 list,
                 iter->index + 1 - prepend,
@@ -286,12 +286,12 @@
         );
         if (result == 0 && prepend != 0) {
             iter->index++;
-            iter->elem_handle = ((char *) iter->elem_handle) + list->base.elem_size;
+            iter->elem_handle = ((char *) iter->elem_handle) + list->collection.elem_size;
         }
         return result;
     } else {
-        int result = cx_arl_insert_element(list, list->base.size, elem);
-        iter->index = list->base.size;
+        int result = cx_arl_insert_element(list, list->collection.size, elem);
+        iter->index = list->collection.size;
         return result;
     }
 }
@@ -303,28 +303,28 @@
     cx_array_list *arl = (cx_array_list *) list;
 
     // out-of-bounds check
-    if (index >= list->base.size) {
+    if (index >= list->collection.size) {
         return 1;
     }
 
     // content destruction
-    cx_invoke_destructor(list, ((char *) arl->data) + index * list->base.elem_size);
+    cx_invoke_destructor(list, ((char *) arl->data) + index * list->collection.elem_size);
 
     // short-circuit removal of last element
-    if (index == list->base.size - 1) {
-        list->base.size--;
+    if (index == list->collection.size - 1) {
+        list->collection.size--;
         return 0;
     }
 
     // just move the elements starting at index to the left
     int result = cx_array_copy(
             &arl->data,
-            &list->base.size,
+            &list->collection.size,
             &arl->capacity,
             index,
-            ((char *) arl->data) + (index + 1) * list->base.elem_size,
-            list->base.elem_size,
-            list->base.size - index - 1,
+            ((char *) arl->data) + (index + 1) * list->collection.elem_size,
+            list->collection.elem_size,
+            list->collection.size - index - 1,
             &arl->reallocator
     );
 
@@ -332,32 +332,32 @@
     assert(result == 0);
 
     // decrease the size
-    list->base.size--;
+    list->collection.size--;
 
     return 0;
 }
 
 static void cx_arl_clear(struct cx_list_s *list) {
-    if (list->base.size == 0) return;
+    if (list->collection.size == 0) return;
 
     cx_array_list *arl = (cx_array_list *) list;
     char *ptr = arl->data;
 
-    if (list->base.simple_destructor) {
-        for (size_t i = 0; i < list->base.size; i++) {
+    if (list->collection.simple_destructor) {
+        for (size_t i = 0; i < list->collection.size; i++) {
             cx_invoke_simple_destructor(list, ptr);
-            ptr += list->base.elem_size;
+            ptr += list->collection.elem_size;
         }
     }
-    if (list->base.advanced_destructor) {
-        for (size_t i = 0; i < list->base.size; i++) {
+    if (list->collection.advanced_destructor) {
+        for (size_t i = 0; i < list->collection.size; i++) {
             cx_invoke_advanced_destructor(list, ptr);
-            ptr += list->base.elem_size;
+            ptr += list->collection.elem_size;
         }
     }
 
-    memset(arl->data, 0, list->base.size * list->base.elem_size);
-    list->base.size = 0;
+    memset(arl->data, 0, list->collection.size * list->collection.elem_size);
+    list->collection.size = 0;
 }
 
 static int cx_arl_swap(
@@ -365,9 +365,9 @@
         size_t i,
         size_t j
 ) {
-    if (i >= list->base.size || j >= list->base.size) return 1;
+    if (i >= list->collection.size || j >= list->collection.size) return 1;
     cx_array_list *arl = (cx_array_list *) list;
-    cx_array_swap(arl->data, list->base.elem_size, i, j);
+    cx_array_swap(arl->data, list->collection.elem_size, i, j);
     return 0;
 }
 
@@ -375,10 +375,10 @@
         struct cx_list_s const *list,
         size_t index
 ) {
-    if (index < list->base.size) {
+    if (index < list->collection.size) {
         cx_array_list const *arl = (cx_array_list const *) list;
         char *space = arl->data;
-        return space + index * list->base.elem_size;
+        return space + index * list->collection.elem_size;
     } else {
         return NULL;
     }
@@ -389,12 +389,12 @@
         void const *elem,
         bool remove
 ) {
-    assert(list->base.cmpfunc != NULL);
-    assert(list->base.size < SIZE_MAX / 2);
+    assert(list->collection.cmpfunc != NULL);
+    assert(list->collection.size < SIZE_MAX / 2);
     char *cur = ((cx_array_list const *) list)->data;
 
-    for (ssize_t i = 0; i < (ssize_t) list->base.size; i++) {
-        if (0 == list->base.cmpfunc(elem, cur)) {
+    for (ssize_t i = 0; i < (ssize_t) list->collection.size; i++) {
+        if (0 == list->collection.cmpfunc(elem, cur)) {
             if (remove) {
                 if (0 == cx_arl_remove(list, i)) {
                     return i;
@@ -405,18 +405,18 @@
                 return i;
             }
         }
-        cur += list->base.elem_size;
+        cur += list->collection.elem_size;
     }
 
     return -1;
 }
 
 static void cx_arl_sort(struct cx_list_s *list) {
-    assert(list->base.cmpfunc != NULL);
+    assert(list->collection.cmpfunc != NULL);
     qsort(((cx_array_list *) list)->data,
-          list->base.size,
-          list->base.elem_size,
-          list->base.cmpfunc
+          list->collection.size,
+          list->collection.elem_size,
+          list->collection.cmpfunc
     );
 }
 
@@ -424,37 +424,37 @@
         struct cx_list_s const *list,
         struct cx_list_s const *other
 ) {
-    assert(list->base.cmpfunc != NULL);
-    if (list->base.size == other->base.size) {
+    assert(list->collection.cmpfunc != NULL);
+    if (list->collection.size == other->collection.size) {
         char const *left = ((cx_array_list const *) list)->data;
         char const *right = ((cx_array_list const *) other)->data;
-        for (size_t i = 0; i < list->base.size; i++) {
-            int d = list->base.cmpfunc(left, right);
+        for (size_t i = 0; i < list->collection.size; i++) {
+            int d = list->collection.cmpfunc(left, right);
             if (d != 0) {
                 return d;
             }
-            left += list->base.elem_size;
-            right += other->base.elem_size;
+            left += list->collection.elem_size;
+            right += other->collection.elem_size;
         }
         return 0;
     } else {
-        return list->base.size < other->base.size ? -1 : 1;
+        return list->collection.size < other->collection.size ? -1 : 1;
     }
 }
 
 static void cx_arl_reverse(struct cx_list_s *list) {
-    if (list->base.size < 2) return;
+    if (list->collection.size < 2) return;
     void *data = ((cx_array_list const *) list)->data;
-    size_t half = list->base.size / 2;
+    size_t half = list->collection.size / 2;
     for (size_t i = 0; i < half; i++) {
-        cx_array_swap(data, list->base.elem_size, i, list->base.size - 1 - i);
+        cx_array_swap(data, list->collection.elem_size, i, list->collection.size - 1 - i);
     }
 }
 
 static bool cx_arl_iter_valid(void const *it) {
     struct cx_iterator_s const *iter = it;
     struct cx_list_s const *list = iter->src_handle.c;
-    return iter->index < list->base.size;
+    return iter->index < list->collection.size;
 }
 
 static void *cx_arl_iter_current(void const *it) {
@@ -471,7 +471,7 @@
         iter->index++;
         iter->elem_handle =
                 ((char *) iter->elem_handle)
-                + ((struct cx_list_s const *) iter->src_handle.c)->base.elem_size;
+                + ((struct cx_list_s const *) iter->src_handle.c)->collection.elem_size;
     }
 }
 
@@ -483,9 +483,9 @@
         cx_arl_remove(iter->src_handle.m, iter->index);
     }
     iter->index--;
-    if (iter->index < list->base.base.size) {
+    if (iter->index < list->base.collection.size) {
         iter->elem_handle = ((char *) list->data)
-                            + iter->index * list->base.base.elem_size;
+                            + iter->index * list->base.collection.elem_size;
     }
 }
 
@@ -500,8 +500,8 @@
     iter.index = index;
     iter.src_handle.c = list;
     iter.elem_handle = cx_arl_at(list, index);
-    iter.elem_size = list->base.elem_size;
-    iter.elem_count = list->base.size;
+    iter.elem_size = list->collection.elem_size;
+    iter.elem_count = list->collection.size;
     iter.base.valid = cx_arl_iter_valid;
     iter.base.current = cx_arl_iter_current;
     iter.base.next = backwards ? cx_arl_iter_prev : cx_arl_iter_next;
@@ -541,15 +541,15 @@
     if (list == NULL) return NULL;
 
     list->base.cl = &cx_array_list_class;
-    list->base.base.allocator = allocator;
+    list->base.collection.allocator = allocator;
     list->capacity = initial_capacity;
 
     if (elem_size > 0) {
-        list->base.base.elem_size = elem_size;
-        list->base.base.cmpfunc = comparator;
+        list->base.collection.elem_size = elem_size;
+        list->base.collection.cmpfunc = comparator;
     } else {
         elem_size = sizeof(void *);
-        list->base.base.cmpfunc = comparator == NULL ? cx_cmp_ptr : comparator;
+        list->base.collection.cmpfunc = comparator == NULL ? cx_cmp_ptr : comparator;
         cxListStorePointers((CxList *) list);
     }