Renamed ..._value_t -> ..._value, etc. Deprecated, still works for cvec, cdeq, cmap, csmap, cslist

16 files changed, 279 insertions, 281 deletions

diff --git a/docs/carray_api.md b/docs/carray_api.md
index d7ece0fa..a6870b91 100644
--- a/docs/carray_api.md
+++ b/docs/carray_api.md
@@ -35,9 +35,9 @@ size_t              carr2_X_size(carr2_X arr);
 i_val*              carr2_X_data(carr2_X* self);          // access storage data
 i_val*              carr2_X_at(carr2_X* self, size_t x, size_t y);
 
-carr2_X_iter_t      carr2_X_begin(const carr2_X* self);
-carr2_X_iter_t      carr2_X_end(const carr2_X* self);
-void                carr2_X_next(carr2_X_iter_t* it);
+carr2_X_iter        carr2_X_begin(const carr2_X* self);
+carr2_X_iter        carr2_X_end(const carr2_X* self);
+void                carr2_X_next(carr2_X_iter* it);
 ```
 carr3:
 ```c
@@ -53,21 +53,21 @@ size_t              carr3_X_size(carr3_X arr);
 i_val*              carr3_X_data(carr3_X* self);          // access storage data
 i_val*              carr3_X_at(carr3_X* self, size_t x, size_t y, size_t z);
 
-carr3_X_iter_t      carr3_X_begin(const carr3_X* self);
-carr3_X_iter_t      carr3_X_end(const carr3_X* self);
-void                carr3_X_next(carr3_X_iter_t* it);
+carr3_X_iter        carr3_X_begin(const carr3_X* self);
+carr3_X_iter        carr3_X_end(const carr3_X* self);
+void                carr3_X_next(carr3_X_iter* it);
 ```
 ## Types
 
 | Type name         | Type definition                                      | Used to represent... |
 |:------------------|:-----------------------------------------------------|:---------------------|
 | `carr2_X`         | `struct { i_val **data; size_t xdim, ydim; }`        | The array 2D type    |
-| `carr2_X_value_t` | `i_val`                                              | The value type       |
-| `carr2_X_iter_t`  | `struct { i_val *ref; }`                             | Iterator type        |
+| `carr2_X_value`   | `i_val`                                              | The value type       |
+| `carr2_X_iter`    | `struct { i_val *ref; }`                             | Iterator type        |
 |                   |                                                      |                      |
 | `carr3_X`         | `struct { i_val ***data; size_t xdim, ydim, zdim; }` | The array 3D type    |
-| `carr3_X_value_t` | `i_val`                                              | The value type       |
-| `carr3_X_iter_t`  | `struct { i_val *ref; }`                             | Iterator type        |
+| `carr3_X_value`   | `i_val`                                              | The value type       |
+| `carr3_X_iter`    | `struct { i_val *ref; }`                             | Iterator type        |
 
 The **carr3** elements can be accessed like `carr3_i arr = ...; int val = arr.data[x][y][z];`, or with `carr3_i_at(&arr, x, y, z)`.
 
diff --git a/docs/cbits_api.md b/docs/cbits_api.md
index 4264b1d4..f13c5e8c 100644
--- a/docs/cbits_api.md
+++ b/docs/cbits_api.md
@@ -58,7 +58,7 @@ void             cbits_xor(cbits *self, cbits other);        // set of disjoint
 | cbits               | Type definition           | Used to represent...         |
 |:--------------------|:--------------------------|:-----------------------------|
 | `cbits`             | `struct { ... }`          | The cbits type               |
-| `cbits_iter_t`      | `struct { ... }`          | The cbits iterator type      |
+| `cbits_iter`        | `struct { ... }`          | The cbits iterator type      |
 
 ## Example
 ```c
diff --git a/docs/ccommon_api.md b/docs/ccommon_api.md
index 83f5dc6f..9a309835 100644
--- a/docs/ccommon_api.md
+++ b/docs/ccommon_api.md
@@ -95,7 +95,7 @@ c_apply(csset_x, insert, &set, {23, 3, 7, 5, 12});
 c_foreach (i, csset_x, set)
     printf(" %d", *i.ref);
 // 3 5 7 12 23
-csset_x_iter_t it = csset_x_find(&set, 7);
+csset_x_iter it = csset_x_find(&set, 7);
 c_foreach (i, csset_x, it, csset_x_end(&set))
     printf(" %d", *i.ref);
 // 7 12 23
diff --git a/docs/cdeq_api.md b/docs/cdeq_api.md
index 4f188143..ab0a1b12 100644
--- a/docs/cdeq_api.md
+++ b/docs/cdeq_api.md
@@ -38,58 +38,58 @@ bool                cdeq_X_empty(cdeq_X deq);
 size_t              cdeq_X_size(cdeq_X deq);
 size_t              cdeq_X_capacity(cdeq_X deq);
 
-cdeq_X_value_t*     cdeq_X_at(const cdeq_X* self, size_t idx);
-cdeq_X_value_t*     cdeq_X_front(const cdeq_X* self);
-cdeq_X_value_t*     cdeq_X_back(const cdeq_X* self);
+cdeq_X_value*       cdeq_X_at(const cdeq_X* self, size_t idx);
+cdeq_X_value*       cdeq_X_front(const cdeq_X* self);
+cdeq_X_value*       cdeq_X_back(const cdeq_X* self);
 
-cdeq_X_value_t*     cdeq_X_push_front(cdeq_X* self, i_val value);
-cdeq_X_value_t*     cdeq_X_emplace_front(cdeq_X* self, i_valraw raw);
+cdeq_X_value*       cdeq_X_push_front(cdeq_X* self, i_val value);
+cdeq_X_value*       cdeq_X_emplace_front(cdeq_X* self, i_valraw raw);
 void                cdeq_X_pop_front(cdeq_X* self);
 
-cdeq_X_value_t*     cdeq_X_push_back(cdeq_X* self, i_val value);
-cdeq_X_value_t*     cdeq_X_emplace_back(cdeq_X* self, i_valraw raw);
+cdeq_X_value*       cdeq_X_push_back(cdeq_X* self, i_val value);
+cdeq_X_value*       cdeq_X_emplace_back(cdeq_X* self, i_valraw raw);
 void                cdeq_X_pop_back(cdeq_X* self); 
 
-cdeq_X_iter_t       cdeq_X_insert(cdeq_X* self, size_t idx, i_val value);                        // move value 
-cdeq_X_iter_t       cdeq_X_insert_n(cdeq_X* self, size_t idx, const i_val[] arr, size_t n);      // move arr values
-cdeq_X_iter_t       cdeq_X_insert_at(cdeq_X* self, cdeq_X_iter_t it, i_val value);               // move value 
+cdeq_X_iter         cdeq_X_insert(cdeq_X* self, size_t idx, i_val value);                        // move value 
+cdeq_X_iter         cdeq_X_insert_n(cdeq_X* self, size_t idx, const i_val[] arr, size_t n);      // move arr values
+cdeq_X_iter         cdeq_X_insert_at(cdeq_X* self, cdeq_X_iter it, i_val value);               // move value 
 
-cdeq_X_iter_t       cdeq_X_emplace(cdeq_X* self, size_t idx, i_valraw raw);
-cdeq_X_iter_t       cdeq_X_emplace_n(cdeq_X* self, size_t idx, const i_valraw[] arr, size_t n);
-cdeq_X_iter_t       cdeq_X_emplace_at(cdeq_X* self, cdeq_X_iter_t it, i_valraw raw);
-cdeq_X_iter_t       cdeq_X_emplace_range(cdeq_X* self, cdeq_X_iter_t it, 
-                                         cdeq_X_iter_t it1, cdeq_X_iter_t it2);                 // will clone
-cdeq_X_iter_t       cdeq_X_emplace_range_p(cdeq_X* self, i_val* pos, 
+cdeq_X_iter         cdeq_X_emplace(cdeq_X* self, size_t idx, i_valraw raw);
+cdeq_X_iter         cdeq_X_emplace_n(cdeq_X* self, size_t idx, const i_valraw[] arr, size_t n);
+cdeq_X_iter         cdeq_X_emplace_at(cdeq_X* self, cdeq_X_iter it, i_valraw raw);
+cdeq_X_iter         cdeq_X_emplace_range(cdeq_X* self, cdeq_X_iter it, 
+                                         cdeq_X_iter it1, cdeq_X_iter it2);                 // will clone
+cdeq_X_iter         cdeq_X_emplace_range_p(cdeq_X* self, i_val* pos, 
                                            const i_val* p1, const i_val* p2);
 
-cdeq_X_iter_t       cdeq_X_erase_n(cdeq_X* self, size_t idx, size_t n);
-cdeq_X_iter_t       cdeq_X_erase_at(cdeq_X* self, cdeq_X_iter_t it);
-cdeq_X_iter_t       cdeq_X_erase_range(cdeq_X* self, cdeq_X_iter_t it1, cdeq_X_iter_t it2);
+cdeq_X_iter         cdeq_X_erase_n(cdeq_X* self, size_t idx, size_t n);
+cdeq_X_iter         cdeq_X_erase_at(cdeq_X* self, cdeq_X_iter it);
+cdeq_X_iter         cdeq_X_erase_range(cdeq_X* self, cdeq_X_iter it1, cdeq_X_iter it2);
 
-cdeq_X_iter_t       cdeq_X_find(const cdeq_X* self, i_valraw raw);
-cdeq_X_iter_t       cdeq_X_find_in(cdeq_X_iter_t i1, cdeq_X_iter_t i2, i_valraw raw);
-cdeq_X_value_t*     cdeq_X_get(const cdeq_X* self, i_valraw raw);                            // returns NULL if not found
+cdeq_X_iter         cdeq_X_find(const cdeq_X* self, i_valraw raw);
+cdeq_X_iter         cdeq_X_find_in(cdeq_X_iter i1, cdeq_X_iter i2, i_valraw raw);
+cdeq_X_value*       cdeq_X_get(const cdeq_X* self, i_valraw raw);                            // returns NULL if not found
 
 void                cdeq_X_sort(cdeq_X* self);
-void                cdeq_X_sort_range(cdeq_X_iter_t i1, cdeq_X_iter_t i2,
+void                cdeq_X_sort_range(cdeq_X_iter i1, cdeq_X_iter i2,
                                       int(*cmp)(const i_val*, const i_val*));
 
-cdeq_X_iter_t       cdeq_X_begin(const cdeq_X* self);
-cdeq_X_iter_t       cdeq_X_end(const cdeq_X* self);
-void                cdeq_X_next(cdeq_X_iter_t* it);
+cdeq_X_iter         cdeq_X_begin(const cdeq_X* self);
+cdeq_X_iter         cdeq_X_end(const cdeq_X* self);
+void                cdeq_X_next(cdeq_X_iter* it);
 
-cdeq_X_rawvalue_t   cdeq_X_value_toraw(cdeq_X_value_t* pval);
-cdeq_X_value_t      cdeq_X_value_clone(cdeq_X_value_t val);
+cdeq_X_rawvalue     cdeq_X_value_toraw(cdeq_X_value* pval);
+cdeq_X_value        cdeq_X_value_clone(cdeq_X_value val);
 ```
 
 ## Types
 
-| Type name            | Type definition                     | Used to represent...   |
-|:---------------------|:------------------------------------|:-----------------------|
-| `cdeq_X`             | `struct { cdeq_X_value_t* data; }`  | The cdeq type          |
-| `cdeq_X_value_t`     | `i_val`                             | The cdeq value type    |
-| `cdeq_X_rawvalue_t`  | `i_valraw`                          | The raw value type     |
-| `cdeq_X_iter_t`      | `struct { cdeq_X_value_t* ref; }`   | The iterator type      |
+| Type name          | Type definition                     | Used to represent...   |
+|:-------------------|:------------------------------------|:-----------------------|
+| `cdeq_X`           | `struct { cdeq_X_value* data; }`  | The cdeq type          |
+| `cdeq_X_value`     | `i_val`                             | The cdeq value type    |
+| `cdeq_X_rawvalue`  | `i_valraw`                          | The raw value type     |
+| `cdeq_X_iter`      | `struct { cdeq_X_value* ref; }`   | The iterator type      |
 
 ## Examples
 ```c
diff --git a/docs/clist_api.md b/docs/clist_api.md
index 7ef12153..6bb241f9 100644
--- a/docs/clist_api.md
+++ b/docs/clist_api.md
@@ -47,8 +47,8 @@ void                clist_X_del(clist_X* self);
 bool                clist_X_empty(clist_X list);
 size_t              clist_X_count(clist_X list);                                            // size() in O(n) time
 
-clist_X_value_t*    clist_X_front(const clist_X* self);
-clist_X_value_t*    clist_X_back(const clist_X* self);
+clist_X_value*      clist_X_front(const clist_X* self);
+clist_X_value*      clist_X_back(const clist_X* self);
 
 void                clist_X_push_front(clist_X* self, i_val value);
 void                clist_X_emplace_front(clist_X* self, i_valraw raw);
@@ -57,40 +57,40 @@ void                clist_X_pop_front(clist_X* self);
 void                clist_X_push_back(clist_X* self, i_val value);                          // note: no pop_back().
 void                clist_X_emplace_back(clist_X* self, i_valraw raw);
 
-clist_X_iter_t      clist_X_insert(clist_X* self, clist_X_iter_t it, i_val value);          // return iter to new elem
-clist_X_iter_t      clist_X_emplace(clist_X* self, clist_X_iter_t it, i_valraw raw);
+clist_X_iter        clist_X_insert(clist_X* self, clist_X_iter it, i_val value);          // return iter to new elem
+clist_X_iter        clist_X_emplace(clist_X* self, clist_X_iter it, i_valraw raw);
 
-clist_X_iter_t      clist_X_erase_at(clist_X* self, clist_X_iter_t it);                     // return iter after it
-clist_X_iter_t      clist_X_erase_range(clist_X* self, clist_X_iter_t it1, clist_X_iter_t it2);
+clist_X_iter        clist_X_erase_at(clist_X* self, clist_X_iter it);                     // return iter after it
+clist_X_iter        clist_X_erase_range(clist_X* self, clist_X_iter it1, clist_X_iter it2);
 size_t              clist_X_remove(clist_X* self, i_valraw raw);                            // removes matching elements
 
-clist_X             clist_X_split_off(clist_X* self, clist_X_iter_t i1, clist_X_iter_t i2); // split off [i1, i2)
-clist_X_iter_t      clist_X_splice(clist_X* self, clist_X_iter_t it, clist_X* other);       // return updated valid it
-clist_X_iter_t      clist_X_splice_range(clist_X* self, clist_X_iter_t it,                  // return updated valid it
-                                         clist_X* other, clist_X_iter_t it1, clist_X_iter_t it2);
+clist_X             clist_X_split_off(clist_X* self, clist_X_iter i1, clist_X_iter i2); // split off [i1, i2)
+clist_X_iter        clist_X_splice(clist_X* self, clist_X_iter it, clist_X* other);       // return updated valid it
+clist_X_iter        clist_X_splice_range(clist_X* self, clist_X_iter it,                  // return updated valid it
+                                         clist_X* other, clist_X_iter it1, clist_X_iter it2);
 
-clist_X_iter_t      clist_X_find(const clist_X* self, i_valraw raw);
-clist_X_iter_t      clist_X_find_in(clist_X_iter_t it1, clist_X_iter_t it2, i_valraw raw);
+clist_X_iter        clist_X_find(const clist_X* self, i_valraw raw);
+clist_X_iter        clist_X_find_in(clist_X_iter it1, clist_X_iter it2, i_valraw raw);
 
 void                clist_X_sort(clist_X* self);
 
-clist_X_iter_t      clist_X_begin(const clist_X* self);
-clist_X_iter_t      clist_X_end(const clist_X* self);
-void                clist_X_next(clist_X_iter_t* it);
-clist_X_iter_t      clist_X_advance(clist_X_iter it, size_t n);                        // return it n elements ahead. End allowed.
+clist_X_iter        clist_X_begin(const clist_X* self);
+clist_X_iter        clist_X_end(const clist_X* self);
+void                clist_X_next(clist_X_iter* it);
+clist_X_iter        clist_X_advance(clist_X_iter it, size_t n);                        // return it n elements ahead. End allowed.
 
-clist_X_rawvalue_t  clist_X_value_toraw(clist_X_value_t* pval);
-clist_X_value_t     clist_X_value_clone(clist_X_value_t val);
+clist_X_rawvalue    clist_X_value_toraw(clist_X_value* pval);
+clist_X_value       clist_X_value_clone(clist_X_value val);
 ```
 
 ## Types
 
-| Type name             | Type definition                     | Used to represent...      |
-|:----------------------|:------------------------------------|:--------------------------|
-| `clist_X`             | `struct { clist_X_node_t* last; }`  | The clist type            |
-| `clist_X_value_t`     | `i_val`                             | The clist element type    |
-| `clist_X_rawvalue_t`  | `i_valraw`                          | clist raw value type      |
-| `clist_X_iter_t`      | `struct { clist_value_t *ref; ... }`| clist iterator            |
+| Type name           | Type definition                     | Used to represent...      |
+|:--------------------|:------------------------------------|:--------------------------|
+| `clist_X`           | `struct { clist_X_node* last; }`    | The clist type            |
+| `clist_X_value`     | `i_val`                             | The clist element type    |
+| `clist_X_rawvalue`  | `i_valraw`                          | clist raw value type      |
+| `clist_X_iter`      | `struct { clist_value *ref; ... }`  | clist iterator            |
 
 ## Example
 
@@ -147,11 +147,11 @@ int main ()
     clist_i L = clist_i_init();
     c_apply(clist_i, push_back, &L, {10, 20, 30, 40, 50});
                                                  // 10 20 30 40 50
-    clist_i_iter_t it = clist_i_begin(&L);       // ^
+    clist_i_iter it = clist_i_begin(&L);       // ^
     clist_i_next(&it); 
     it = clist_i_erase_at(&L, it);               // 10 30 40 50
                                                  //    ^
-    clist_i_iter_t end = clist_i_end(&L);        //
+    clist_i_iter end = clist_i_end(&L);        //
     clist_i_next(&it);
     it = clist_i_erase_range(&L, it, end);       // 10 30
                                                  //       ^
@@ -183,8 +183,8 @@ int main() {
         c_apply(clist_i, push_back, &L1, {1, 2, 3, 4, 5});
         c_apply(clist_i, push_back, &L2, {10, 20, 30, 40, 50});
 
-        clist_i_iter_t i = clist_i_advance(clist_i_begin(&L1), 2);
-        clist_i_iter_t j1 = clist_i_advance(clist_i_begin(&L2), 2), j2 = clist_i_advance(j1, 2);
+        clist_i_iter i = clist_i_advance(clist_i_begin(&L1), 2);
+        clist_i_iter j1 = clist_i_advance(clist_i_begin(&L2), 2), j2 = clist_i_advance(j1, 2);
 
         clist_i_splice_range(&L1, i, &L2, j1, j2);
 
diff --git a/docs/cmap_api.md b/docs/cmap_api.md
index 31dd3f63..628e982a 100644
--- a/docs/cmap_api.md
+++ b/docs/cmap_api.md
@@ -55,27 +55,27 @@ size_t              cmap_X_capacity(cmap_X map);
 size_t              cmap_X_bucket_count(cmap_X map);                                          // num. of allocated buckets
 
 bool                cmap_X_contains(const cmap_X* self, i_keyraw rkey);
-cmap_X_mapped_t*    cmap_X_at(const cmap_X* self, i_keyraw rkey);                             // rkey must be in map.
-cmap_X_value_t*     cmap_X_get(const cmap_X* self, i_keyraw rkey);                            // return NULL if not found
-cmap_X_iter_t       cmap_X_find(const cmap_X* self, i_keyraw rkey);
+cmap_X_mapped*      cmap_X_at(const cmap_X* self, i_keyraw rkey);                             // rkey must be in map.
+cmap_X_value*       cmap_X_get(const cmap_X* self, i_keyraw rkey);                            // return NULL if not found
+cmap_X_iter         cmap_X_find(const cmap_X* self, i_keyraw rkey);
 
-cmap_X_result_t     cmap_X_insert(cmap_X* self, i_key key, i_val mapped);                     // no change if key in map
-cmap_X_result_t     cmap_X_insert_or_assign(cmap_X* self, i_key key, i_val mapped);           // always update mapped
-cmap_X_result_t     cmap_X_put(cmap_X* self, i_key key, i_val mapped);                        // alias for insert_or_assign
+cmap_X_result       cmap_X_insert(cmap_X* self, i_key key, i_val mapped);                     // no change if key in map
+cmap_X_result       cmap_X_insert_or_assign(cmap_X* self, i_key key, i_val mapped);           // always update mapped
+cmap_X_result       cmap_X_put(cmap_X* self, i_key key, i_val mapped);                        // alias for insert_or_assign
 
-cmap_X_result_t     cmap_X_emplace(cmap_X* self, i_keyraw rkey, i_valraw rmapped);            // no change if rkey in map
-cmap_X_result_t     cmap_X_emplace_or_assign(cmap_X* self, i_keyraw rkey, i_valraw rmapped);  // always update rmapped
+cmap_X_result       cmap_X_emplace(cmap_X* self, i_keyraw rkey, i_valraw rmapped);            // no change if rkey in map
+cmap_X_result       cmap_X_emplace_or_assign(cmap_X* self, i_keyraw rkey, i_valraw rmapped);  // always update rmapped
 
 size_t              cmap_X_erase(cmap_X* self, i_keyraw rkey);                                // return 0 or 1
-cmap_X_iter_t       cmap_X_erase_at(cmap_X* self, cmap_X_iter_t it);                          // return iter after it
-void                cmap_X_erase_entry(cmap_X* self, cmap_X_value_t* entry);
+cmap_X_iter         cmap_X_erase_at(cmap_X* self, cmap_X_iter it);                          // return iter after it
+void                cmap_X_erase_entry(cmap_X* self, cmap_X_value* entry);
 
-cmap_X_iter_t       cmap_X_begin(const cmap_X* self);
-cmap_X_iter_t       cmap_X_end(const cmap_X* self);
-void                cmap_X_next(cmap_X_iter_t* it);
+cmap_X_iter         cmap_X_begin(const cmap_X* self);
+cmap_X_iter         cmap_X_end(const cmap_X* self);
+void                cmap_X_next(cmap_X_iter* it);
 
-cmap_X_value_t      cmap_X_value_clone(cmap_X_value_t val);
-cmap_X_rawvalue_t   cmap_X_value_toraw(cmap_X_value_t* pval);
+cmap_X_value        cmap_X_value_clone(cmap_X_value val);
+cmap_X_rawvalue     cmap_X_value_toraw(cmap_X_value* pval);
 ```
 Helpers:
 ```c
@@ -99,17 +99,17 @@ void                c_default_del(Type* val);                               // d
 
 ## Types
 
-| Type name            | Type definition                                 | Used to represent...          |
-|:---------------------|:------------------------------------------------|:------------------------------|
-| `cmap_X`             | `struct { ... }`                                | The cmap type                 |
-| `cmap_X_rawkey_t`    | `i_keyraw`                                      | The raw key type              |
-| `cmap_X_rawmapped_t` | `i_valraw`                                      | The raw mapped type           |
-| `cmap_X_rawvalue_t`  | `struct { i_keyraw first; i_valraw second; }`   | i_keyraw + i_valraw type      |
-| `cmap_X_key_t`       | `i_key`                                         | The key type                  |
-| `cmap_X_mapped_t`    | `i_val`                                         | The mapped type               |
-| `cmap_X_value_t`     | `struct { const i_key first; i_val second; }`   | The value: key is immutable   |
-| `cmap_X_result_t`    | `struct { cmap_X_value_t *ref; bool inserted; }`| Result of insert/put/emplace  |
-| `cmap_X_iter_t`      | `struct { cmap_X_value_t *ref; ... }`           | Iterator type                 |
+| Type name          | Type definition                                 | Used to represent...          |
+|:-------------------|:------------------------------------------------|:------------------------------|
+| `cmap_X`           | `struct { ... }`                                | The cmap type                 |
+| `cmap_X_rawkey`    | `i_keyraw`                                      | The raw key type              |
+| `cmap_X_rawmapped` | `i_valraw`                                      | The raw mapped type           |
+| `cmap_X_rawvalue`  | `struct { i_keyraw first; i_valraw second; }`   | i_keyraw + i_valraw type      |
+| `cmap_X_key`       | `i_key`                                         | The key type                  |
+| `cmap_X_mapped`    | `i_val`                                         | The mapped type               |
+| `cmap_X_value`     | `struct { const i_key first; i_val second; }`   | The value: key is immutable   |
+| `cmap_X_result`    | `struct { cmap_X_value *ref; bool inserted; }`  | Result of insert/put/emplace  |
+| `cmap_X_iter`      | `struct { cmap_X_value *ref; ... }`             | Iterator type                 |
 
 ## Examples
 
diff --git a/docs/cpque_api.md b/docs/cpque_api.md
index 4f22fe0e..365ba4b9 100644
--- a/docs/cpque_api.md
+++ b/docs/cpque_api.md
@@ -32,26 +32,26 @@ void                cpque_X_del(cpque_X* self);        // destructor
 
 size_t              cpque_X_size(cpque_X pq);
 bool                cpque_X_empty(cpque_X pq);
-cpque_X_value_t*    cpque_X_top(const cpque_X* self);
+cpque_X_value*      cpque_X_top(const cpque_X* self);
 
 void                cpque_X_make_heap(cpque_X* self);  // call after using push_back().
-void                cpque_X_push(cpque_X* self, cpque_X_value_t value);
-void                cpque_X_emplace(cpque_X* self, cpque_X_rawvalue_t raw);
+void                cpque_X_push(cpque_X* self, cpque_X_value value);
+void                cpque_X_emplace(cpque_X* self, cpque_X_rawvalue raw);
 
 void                cpque_X_pop(cpque_X* self);
 void                cpque_X_erase_at(cpque_X* self, size_t idx);
 
-void                cpque_X_push_back(cpque_X* self, cpque_X_value_t value); // breaks heap-property
-cpque_X_value_t     cpque_X_value_clone(cpque_X_value_t val);
+void                cpque_X_push_back(cpque_X* self, cpque_X_value value); // breaks heap-property
+cpque_X_value       cpque_X_value_clone(cpque_X_value val);
 ```
 
 ## Types
 
-| Type name            | Type definition                       | Used to represent...    |
-|:---------------------|:--------------------------------------|:------------------------|
-| `cpque_X`            | `struct {cpque_X_value_t* data; ...}` | The cpque type          |
-| `cpque_X_value_t`    | `i_val`                               | The cpque element type  |
-| `cpque_X_rawvalue_t` | `i_valraw`                            | cpque raw value type    |
+| Type name          | Type definition                       | Used to represent...    |
+|:-------------------|:--------------------------------------|:------------------------|
+| `cpque_X`          | `struct {cpque_X_value* data; ...}`   | The cpque type          |
+| `cpque_X_value`    | `i_val`                               | The cpque element type  |
+| `cpque_X_rawvalue` | `i_valraw`                            | cpque raw value type    |
 
 ## Example
 ```c
diff --git a/docs/cqueue_api.md b/docs/cqueue_api.md
index 087f9da5..469b7c99 100644
--- a/docs/cqueue_api.md
+++ b/docs/cqueue_api.md
@@ -31,29 +31,29 @@ void                cqueue_X_del(cqueue_X* self);       // destructor
 
 size_t              cqueue_X_size(cqueue_X q);
 bool                cqueue_X_empty(cqueue_X q);
-cqueue_X_value_t*   cqueue_X_front(const cqueue_X* self);
-cqueue_X_value_t*   cqueue_X_back(const cqueue_X* self);
+cqueue_X_value*     cqueue_X_front(const cqueue_X* self);
+cqueue_X_value*     cqueue_X_back(const cqueue_X* self);
 
-cqueue_X_value_t*   cqueue_X_push(cqueue_X* self, i_val value);
-cqueue_X_value_t*   cqueue_X_emplace(cqueue_X* self, i_valraw raw);
+cqueue_X_value*     cqueue_X_push(cqueue_X* self, i_val value);
+cqueue_X_value*     cqueue_X_emplace(cqueue_X* self, i_valraw raw);
 
 void                cqueue_X_pop(cqueue_X* self);
 
-cqueue_X_iter_t     cqueue_X_begin(const cqueue_X* self);
-cqueue_X_iter_t     cqueue_X_end(const cqueue_X* self);
-void                cqueue_X_next(cqueue_X_iter_t* it);
+cqueue_X_iter       cqueue_X_begin(const cqueue_X* self);
+cqueue_X_iter       cqueue_X_end(const cqueue_X* self);
+void                cqueue_X_next(cqueue_X_iter* it);
 
 i_val               cqueue_X_value_clone(i_val value);
 ```
 
 ## Types
 
-| Type name             | Type definition      | Used to represent...     |
-|:----------------------|:---------------------|:-------------------------|
-| `cqueue_X`            | `cdeq_X`             | The cqueue type          |
-| `cqueue_X_value_t`    | `i_val`              | The cqueue element type  |
-| `cqueue_X_rawvalue_t` | `i_valraw`           | cqueue raw value type    |
-| `cqueue_X_iter_t`     | `cdeq_X_iter_t`      | cqueue iterator          |
+| Type name           | Type definition      | Used to represent...     |
+|:--------------------|:---------------------|:-------------------------|
+| `cqueue_X`          | `cdeq_X`             | The cqueue type          |
+| `cqueue_X_value`    | `i_val`              | The cqueue element type  |
+| `cqueue_X_rawvalue` | `i_valraw`           | cqueue raw value type    |
+| `cqueue_X_iter`     | `cdeq_X_iter`        | cqueue iterator          |
 
 ## Examples
 ```c
diff --git a/docs/cset_api.md b/docs/cset_api.md
index e09436ea..c422fdb2 100644
--- a/docs/cset_api.md
+++ b/docs/cset_api.md
@@ -41,34 +41,34 @@ size_t              cset_X_capacity(cset_X set);
 size_t              cset_X_bucket_count(cset_X set);

 

 bool                cset_X_contains(const cset_X* self, i_keyraw rkey);

-cset_X_value_t*     cset_X_get(const cset_X* self, i_keyraw rkey);                           // return NULL if not found

-cset_X_iter_t       cset_X_find(const cset_X* self, i_keyraw rkey);

+cset_X_value*       cset_X_get(const cset_X* self, i_keyraw rkey);                           // return NULL if not found

+cset_X_iter         cset_X_find(const cset_X* self, i_keyraw rkey);

 

-cset_X_result_t     cset_X_insert(cset_X* self, i_key key);

-cset_X_result_t     cset_X_emplace(cset_X* self, i_keyraw rkey);

+cset_X_result       cset_X_insert(cset_X* self, i_key key);

+cset_X_result       cset_X_emplace(cset_X* self, i_keyraw rkey);

 

 size_t              cset_X_erase(cset_X* self, i_keyraw rkey);                               // return 0 or 1

-cset_X_iter_t       cset_X_erase_at(cset_X* self, cset_X_iter_t it);                         // return iter after it

-void                cset_X_erase_entry(cset_X* self, cset_X_value_t* entry);

+cset_X_iter         cset_X_erase_at(cset_X* self, cset_X_iter it);                         // return iter after it

+void                cset_X_erase_entry(cset_X* self, cset_X_value* entry);

 

-cset_X_iter_t       cset_X_begin(const cset_X* self);

-cset_X_iter_t       cset_X_end(const cset_X* self);

-void                cset_X_next(cset_X_iter_t* it);

+cset_X_iter         cset_X_begin(const cset_X* self);

+cset_X_iter         cset_X_end(const cset_X* self);

+void                cset_X_next(cset_X_iter* it);

 

-cset_X_value_t      cset_X_value_clone(cset_X_value_t val);

+cset_X_value        cset_X_value_clone(cset_X_value val);

 ```

 

 ## Types

 

-| Type name            | Type definition                                  | Used to represent...        |

-|:---------------------|:-------------------------------------------------|:----------------------------|

-| `cset_X`             | `struct { ... }`                                 | The cset type               |

-| `cset_X_rawkey_t`    | `i_keyraw`                                       | The raw key type            |

-| `cset_X_rawvalue_t`  | `i_keyraw`                                       | The raw value type          |

-| `cset_X_key_t`       | `i_key`                                          | The key type                |

-| `cset_X_value_t`     | `i_key`                                          | The value                   |

-| `cset_X_result_t`    | `struct { cset_X_value_t* ref; bool inserted; }` | Result of insert/emplace    |

-| `cset_X_iter_t`      | `struct { cset_X_value_t *ref; ... }`            | Iterator type               |

+| Type name          | Type definition                                  | Used to represent...        |

+|:-------------------|:-------------------------------------------------|:----------------------------|

+| `cset_X`           | `struct { ... }`                                 | The cset type               |

+| `cset_X_rawkey`    | `i_keyraw`                                       | The raw key type            |

+| `cset_X_rawvalue`  | `i_keyraw`                                       | The raw value type          |

+| `cset_X_key`       | `i_key`                                          | The key type                |

+| `cset_X_value`     | `i_key`                                          | The value                   |

+| `cset_X_result`    | `struct { cset_X_value* ref; bool inserted; }`   | Result of insert/emplace    |

+| `cset_X_iter`      | `struct { cset_X_value *ref; ... }`              | Iterator type               |

 

 ## Example

 ```c

diff --git a/docs/csmap_api.md b/docs/csmap_api.md
index d76502b2..96d71d30 100644
--- a/docs/csmap_api.md
+++ b/docs/csmap_api.md
@@ -46,44 +46,44 @@ bool                csmap_X_empty(csmap_X map);
 size_t              csmap_X_size(csmap_X map);
 
 bool                csmap_X_contains(const csmap_X* self, i_keyraw rkey);
-csmap_X_mapped_t*   csmap_X_at(const csmap_X* self, i_keyraw rkey);                              // rkey must be in map.
-csmap_X_value_t*    csmap_X_get(const csmap_X* self, i_keyraw rkey);                             // return NULL if not found
-csmap_X_iter_t      csmap_X_lower_bound(const csmap_X* self, i_keyraw rkey);                     // find closest entry >= rkey
-csmap_X_iter_t      csmap_X_find(const csmap_X* self, i_keyraw rkey);
-csmap_X_value_t*    csmap_X_find_it(const csmap_X* self, i_keyraw rkey, csmap_X_iter_t* out);    // return NULL if not found
+csmap_X_mapped*     csmap_X_at(const csmap_X* self, i_keyraw rkey);                              // rkey must be in map.
+csmap_X_value*      csmap_X_get(const csmap_X* self, i_keyraw rkey);                             // return NULL if not found
+csmap_X_iter        csmap_X_lower_bound(const csmap_X* self, i_keyraw rkey);                     // find closest entry >= rkey
+csmap_X_iter        csmap_X_find(const csmap_X* self, i_keyraw rkey);
+csmap_X_value*      csmap_X_find_it(const csmap_X* self, i_keyraw rkey, csmap_X_iter* out);    // return NULL if not found
 
-csmap_X_result_t    csmap_X_insert(csmap_X* self, i_key key, i_val mapped);                      // no change if key in map
-csmap_X_result_t    csmap_X_insert_or_assign(csmap_X* self, i_key key, i_val mapped);            // always update mapped
-csmap_X_result_t    csmap_X_put(csmap_X* self, i_key key, i_val mapped);                         // same as insert_or_assign()
+csmap_X_result      csmap_X_insert(csmap_X* self, i_key key, i_val mapped);                      // no change if key in map
+csmap_X_result      csmap_X_insert_or_assign(csmap_X* self, i_key key, i_val mapped);            // always update mapped
+csmap_X_result      csmap_X_put(csmap_X* self, i_key key, i_val mapped);                         // same as insert_or_assign()
 
-csmap_X_result_t    csmap_X_emplace(csmap_X* self, i_keyraw rkey, i_valraw rmapped);             // no change if rkey in map
-csmap_X_result_t    csmap_X_emplace_or_assign(csmap_X* self, i_keyraw rkey, i_valraw rmapped);   // always update rmapped
+csmap_X_result      csmap_X_emplace(csmap_X* self, i_keyraw rkey, i_valraw rmapped);             // no change if rkey in map
+csmap_X_result      csmap_X_emplace_or_assign(csmap_X* self, i_keyraw rkey, i_valraw rmapped);   // always update rmapped
 
 size_t              csmap_X_erase(csmap_X* self, i_keyraw rkey);
-csmap_X_iter_t      csmap_X_erase_at(csmap_X* self, csmap_X_iter_t it);                          // returns iter after it
-csmap_X_iter_t      csmap_X_erase_range(csmap_X* self, csmap_X_iter_t it1, csmap_X_iter_t it2);  // returns updated it2
+csmap_X_iter        csmap_X_erase_at(csmap_X* self, csmap_X_iter it);                          // returns iter after it
+csmap_X_iter        csmap_X_erase_range(csmap_X* self, csmap_X_iter it1, csmap_X_iter it2);  // returns updated it2
 
-csmap_X_iter_t      csmap_X_begin(const csmap_X* self);
-csmap_X_iter_t      csmap_X_end(const csmap_X* self);
-void                csmap_X_next(csmap_X_iter_t* iter);
-csmap_X_iter_t      csmap_X_advance(csmap_X_iter_t it, size_t n);
+csmap_X_iter        csmap_X_begin(const csmap_X* self);
+csmap_X_iter        csmap_X_end(const csmap_X* self);
+void                csmap_X_next(csmap_X_iter* iter);
+csmap_X_iter        csmap_X_advance(csmap_X_iter it, size_t n);
 
-csmap_X_value_t     csmap_X_value_clone(csmap_X_value_t val);
-csmap_X_rawvalue_t  csmap_X_value_toraw(csmap_X_value_t* pval);
+csmap_X_value       csmap_X_value_clone(csmap_X_value val);
+csmap_X_rawvalue    csmap_X_value_toraw(csmap_X_value* pval);
 ```
 ## Types
 
-| Type name             | Type definition                                   | Used to represent...         |
-|:----------------------|:--------------------------------------------------|:-----------------------------|
-| `csmap_X`             | `struct { ... }`                                  | The csmap type               |
-| `csmap_X_rawkey_t`    | `i_keyraw`                                        | The raw key type             |
-| `csmap_X_rawmapped_t` | `i_valraw`                                        | The raw mapped type          |
-| `csmap_X_rawvalue_t`  | `struct { i_keyraw first; i_valraw second; }`     | i_keyraw+i_valraw type       |
-| `csmap_X_key_t`       | `i_key`                                           | The key type                 |
-| `csmap_X_mapped_t`    | `i_val`                                           | The mapped type              |
-| `csmap_X_value_t`     | `struct { const i_key first; i_val second; }`     | The value: key is immutable  |
-| `csmap_X_result_t`    | `struct { csmap_X_value_t *ref; bool inserted; }` | Result of insert/put/emplace |
-| `csmap_X_iter_t`      | `struct { csmap_X_value_t *ref; ... }`            | Iterator type                |
+| Type name           | Type definition                                   | Used to represent...         |
+|:--------------------|:--------------------------------------------------|:-----------------------------|
+| `csmap_X`           | `struct { ... }`                                  | The csmap type               |
+| `csmap_X_rawkey`    | `i_keyraw`                                        | The raw key type             |
+| `csmap_X_rawmapped` | `i_valraw`                                        | The raw mapped type          |
+| `csmap_X_rawvalue`  | `struct { i_keyraw first; i_valraw second; }`     | i_keyraw+i_valraw type       |
+| `csmap_X_key`       | `i_key`                                           | The key type                 |
+| `csmap_X_mapped`    | `i_val`                                           | The mapped type              |
+| `csmap_X_value`     | `struct { const i_key first; i_val second; }`     | The value: key is immutable  |
+| `csmap_X_result`    | `struct { csmap_X_value *ref; bool inserted; }`   | Result of insert/put/emplace |
+| `csmap_X_iter`      | `struct { csmap_X_value *ref; ... }`              | Iterator type                |
 
 ## Examples
 ```c
diff --git a/docs/csptr_api.md b/docs/csptr_api.md
index bd9bf7d2..60825152 100644
--- a/docs/csptr_api.md
+++ b/docs/csptr_api.md
@@ -60,8 +60,8 @@ bool                csptr_X_equals(const csptr_X* x, const csptr_X* y);
 | Type name           | Type definition                                               | Used to represent...     |
 |:--------------------|:--------------------------------------------------------------|:-------------------------|
 | `csptr_null`        | `{NULL, NULL}`                                                | Init nullptr const       |
-| `csptr_X`           | `struct { csptr_X_value_t* get; atomic_count_t* use_count; }` | The csptr type           |
-| `csptr_X_value_t`   | `i_val`                                                       | The csptr element type   |
+| `csptr_X`           | `struct { csptr_X_value* get; atomic_count_t* use_count; }` | The csptr type           |
+| `csptr_X_value`   | `i_val`                                                       | The csptr element type   |
 | `atomic_count_t`    | `long`                                                        | The reference counter    |
 
 ## Example
diff --git a/docs/csset_api.md b/docs/csset_api.md
index 67ff1911..22573b25 100644
--- a/docs/csset_api.md
+++ b/docs/csset_api.md
@@ -34,36 +34,36 @@ bool                csset_X_empty(csset_X set);
 size_t              csset_X_size(csset_X set);

 

 bool                csset_X_contains(const csset_X* self, i_keyraw rkey);

-csset_X_value_t*    csset_X_get(const csset_X* self, i_keyraw rkey);                            // return NULL if not found

-csset_X_iter_t      csset_X_lower_bound(const csset_X* self, i_keyraw rkey);                    // find closest entry >= rkey

-csset_X_iter_t      csset_X_find(const csset_X* self, i_keyraw rkey);

-csset_X_value_t*    csset_X_find_it(const csset_X* self, i_keyraw rkey, csset_X_iter_t* out);   // return NULL if not found

+csset_X_value*      csset_X_get(const csset_X* self, i_keyraw rkey);                            // return NULL if not found

+csset_X_iter        csset_X_lower_bound(const csset_X* self, i_keyraw rkey);                    // find closest entry >= rkey

+csset_X_iter        csset_X_find(const csset_X* self, i_keyraw rkey);

+csset_X_value*      csset_X_find_it(const csset_X* self, i_keyraw rkey, csset_X_iter* out);   // return NULL if not found

 

-csset_X_result_t    csset_X_insert(csset_X* self, i_key key);

-csset_X_result_t    csset_X_emplace(csset_X* self, i_keyraw rkey);

+csset_X_result      csset_X_insert(csset_X* self, i_key key);

+csset_X_result      csset_X_emplace(csset_X* self, i_keyraw rkey);

 

 size_t              csset_X_erase(csset_X* self, i_keyraw rkey);

-csset_X_iter_t      csset_X_erase_at(csset_X* self, csset_X_iter_t it);                         // return iter after it

-csset_X_iter_t      csset_X_erase_range(csset_X* self, csset_X_iter_t it1, csset_X_iter_t it2); // return updated it2

+csset_X_iter        csset_X_erase_at(csset_X* self, csset_X_iter it);                         // return iter after it

+csset_X_iter        csset_X_erase_range(csset_X* self, csset_X_iter it1, csset_X_iter it2); // return updated it2

 

-csset_X_iter_t      csset_X_begin(const csset_X* self);

-csset_X_iter_t      csset_X_end(const csset_X* self);

-void                csset_X_next(csset_X_iter_t* it);

+csset_X_iter        csset_X_begin(const csset_X* self);

+csset_X_iter        csset_X_end(const csset_X* self);

+void                csset_X_next(csset_X_iter* it);

 

-csset_X_value_t     csset_X_value_clone(csset_X_value_t val);

+csset_X_value       csset_X_value_clone(csset_X_value val);

 ```

 

 ## Types

 

-| Type name            | Type definition                                   | Used to represent...        |

-|:---------------------|:--------------------------------------------------|:----------------------------|

-| `csset_X`            | `struct { ... }`                                  | The csset type              |

-| `csset_X_rawkey_t`   | `i_rawkey`                                        | The raw key type            |

-| `csset_X_rawvalue_t` | `i_rawkey`                                        | The raw key type            |

-| `csset_X_key_t`      | `i_key`                                           | The key type                |

-| `csset_X_value_t`    | `i_key        `                                   | The value: key is immutable |

-| `csset_X_result_t`   | `struct { csset_X_value_t* ref; bool inserted; }` | Result of insert/emplace    |

-| `csset_X_iter_t`     | `struct { csset_X_value_t *ref; ... }`            | Iterator type               |

+| Type name          | Type definition                                   | Used to represent...        |

+|:-------------------|:--------------------------------------------------|:----------------------------|

+| `csset_X`          | `struct { ... }`                                  | The csset type              |

+| `csset_X_rawkey`   | `i_rawkey`                                        | The raw key type            |

+| `csset_X_rawvalue` | `i_rawkey`                                        | The raw key type            |

+| `csset_X_key`      | `i_key`                                           | The key type                |

+| `csset_X_value`    | `i_key        `                                   | The value: key is immutable |

+| `csset_X_result`   | `struct { csset_X_value* ref; bool inserted; }`   | Result of insert/emplace    |

+| `csset_X_iter`     | `struct { csset_X_value *ref; ... }`              | Iterator type               |

 

 ## Example

 ```c

diff --git a/docs/cstack_api.md b/docs/cstack_api.md
index c4a806e1..a1edf9ea 100644
--- a/docs/cstack_api.md
+++ b/docs/cstack_api.md
@@ -36,30 +36,30 @@ void                cstack_X_del(cstack_X* self);       // destructor
 size_t              cstack_X_size(cstack_X st);
 size_t              cstack_X_capacity(cstack_X st);
 bool                cstack_X_empty(cstack_X st);
-cstack_X_value_t*   cstack_X_top(const cstack_X* self);
-cstack_X_value_t*   cstack_X_at(const cstack_X* self, size_t idx);
+cstack_X_value*     cstack_X_top(const cstack_X* self);
+cstack_X_value*     cstack_X_at(const cstack_X* self, size_t idx);
 
-cstack_X_value_t*   cstack_X_push(cstack_X* self, i_val value);
-cstack_X_value_t*   cstack_X_emplace(cstack_X* self, i_valraw raw);
+cstack_X_value*     cstack_X_push(cstack_X* self, i_val value);
+cstack_X_value*     cstack_X_emplace(cstack_X* self, i_valraw raw);
 
 void                cstack_X_pop(cstack_X* self);
 
-cstack_X_iter_t     cstack_X_begin(const cstack_X* self);
-cstack_X_iter_t     cstack_X_end(const cstack_X* self);
-void                cstack_X_next(cstack_X_iter_t* it);
+cstack_X_iter       cstack_X_begin(const cstack_X* self);
+cstack_X_iter       cstack_X_end(const cstack_X* self);
+void                cstack_X_next(cstack_X_iter* it);
 
-i_valraw            cstack_X_value_toraw(cvec_X_value_t* pval);
+i_valraw            cstack_X_value_toraw(cvec_X_value* pval);
 i_val               cstack_X_value_clone(i_val value);
 ```
 
 ## Types
 
-| Type name             | Type definition                        | Used to represent...        |
-|:----------------------|:---------------------------------------|:----------------------------|
-| `cstack_X`            | `struct { cstack_value_t *data; ... }` | The cstack type             |
-| `cstack_X_value_t`    | `i_val`                                | The cstack element type     |
-| `cstack_X_rawvalue_t` | `i_valraw`                             | cstack raw value type       |
-| `cstack_X_iter_t`     | `struct { cstack_value_t *ref; }`      | cstack iterator             |
+| Type name           | Type definition                        | Used to represent...        |
+|:--------------------|:---------------------------------------|:----------------------------|
+| `cstack_X`          | `struct { cstack_value *data; ... }` | The cstack type             |
+| `cstack_X_value`    | `i_val`                                | The cstack element type     |
+| `cstack_X_rawvalue` | `i_valraw`                             | cstack raw value type       |
+| `cstack_X_iter`     | `struct { cstack_value *ref; }`      | cstack iterator             |
 
 ## Example
 ```c
diff --git a/docs/cstr_api.md b/docs/cstr_api.md
index ecb58637..4b1c959f 100644
--- a/docs/cstr_api.md
+++ b/docs/cstr_api.md
@@ -73,9 +73,9 @@ void         cstr_pop_back(cstr* self);
 char*        cstr_front(cstr* self);
 char*        cstr_back(cstr* self);
 
-cstr_iter_t  cstr_begin(cstr* self);
-cstr_iter_t  cstr_end(cstr* self);
-void         cstr_next(cstr_iter_t* it);
+cstr_iter    cstr_begin(cstr* self);
+cstr_iter    cstr_end(cstr* self);
+void         cstr_next(cstr_iter* it);
 
 bool         cstr_getline(cstr *self, FILE *stream);                  // cstr_getdelim(self, '\n', stream)
 bool         cstr_getdelim(cstr *self, int delim, FILE *stream);      // does not append delim to result
@@ -100,11 +100,11 @@ int          c_strncasecmp(const char* str1, const char* str2, size_t n);
 
 ## Types
 
-| Type name         | Type definition                  | Used to represent...     |
-|:------------------|:---------------------------------|:-------------------------|
-| `cstr`            | `struct { char *str; }`          | The string type          |
-| `cstr_value_t`    | `char`                           | The string element type  |
-| `cstr_iter_t`     | `struct { cstr_value_t *ref; }`  | cstr iterator            |
+| Type name       | Type definition                | Used to represent...     |
+|:----------------|:-------------------------------|:-------------------------|
+| `cstr`          | `struct { char *str; }`        | The string type          |
+| `cstr_value`    | `char`                         | The string element type  |
+| `cstr_iter`     | `struct { cstr_value *ref; }`  | cstr iterator            |
 
 ## Constants and macros
 
diff --git a/docs/csview_api.md b/docs/csview_api.md
index 6125ef07..4295e4e9 100644
--- a/docs/csview_api.md
+++ b/docs/csview_api.md
@@ -51,9 +51,9 @@ bool          csview_contains(csview sv, csview needle);
 bool          csview_starts_with(csview sv, csview sub);
 bool          csview_ends_with(csview sv, csview sub);
 
-csview_iter_t csview_begin(const csview* self);
-csview_iter_t csview_end(const csview* self);
-void          csview_next(csview_iter_t* it);
+csview_iter   csview_begin(const csview* self);
+csview_iter   csview_end(const csview* self);
+void          csview_next(csview_iter* it);
 ```
 #### Extended cstr methods
 ```c
@@ -84,11 +84,11 @@ uint64_t      csview_hash(const csview* x, ...);
 ```
 ## Types
 
-| Type name         | Type definition                           | Used to represent...     |
-|:------------------|:------------------------------------------|:-------------------------|
-| `csview`          | `struct { const char *str; size_t size }` | The string view type     |
-| `csview_value_t`  | `char`                                    | The string element type  |
-| `csview_iter_t`   | `struct { csview_value_t *ref; }`         | csview iterator          |
+| Type name       | Type definition                           | Used to represent...     |
+|:----------------|:------------------------------------------|:-------------------------|
+| `csview`        | `struct { const char *str; size_t size }` | The string view type     |
+| `csview_value`  | `char`                                    | The string element type  |
+| `csview_iter`   | `struct { csview_value *ref; }`           | csview iterator          |
 
 ## Constants and macros
 
diff --git a/docs/cvec_api.md b/docs/cvec_api.md
index a14f6952..9953bb4b 100644
--- a/docs/cvec_api.md
+++ b/docs/cvec_api.md
@@ -45,61 +45,60 @@ bool                cvec_X_empty(cvec_X vec);
 size_t              cvec_X_size(cvec_X vec);
 size_t              cvec_X_capacity(cvec_X vec);
 
-cvec_X_value_t*     cvec_X_at(const cvec_X* self, size_t idx);
-cvec_X_value_t*     cvec_X_front(const cvec_X* self);
-cvec_X_value_t*     cvec_X_back(const cvec_X* self);
+cvec_X_value*       cvec_X_at(const cvec_X* self, size_t idx);
+cvec_X_value*       cvec_X_front(const cvec_X* self);
+cvec_X_value*       cvec_X_back(const cvec_X* self);
 
-cvec_X_value_t*     cvec_X_push_back(cvec_X* self, i_val value);
-cvec_X_value_t*     cvec_X_emplace_back(cvec_X* self, i_valraw raw);
+cvec_X_value*       cvec_X_push_back(cvec_X* self, i_val value);
+cvec_X_value*       cvec_X_emplace_back(cvec_X* self, i_valraw raw);
 void                cvec_X_pop_back(cvec_X* self);
 
-cvec_X_iter_t       cvec_X_insert(cvec_X* self, size_t idx, i_val value);                        // move value 
-cvec_X_iter_t       cvec_X_insert_n(cvec_X* self, size_t idx, const i_val[] arr, size_t n);      // move arr values
-cvec_X_iter_t       cvec_X_insert_at(cvec_X* self, cvec_X_iter_t it, i_val value);               // move value 
+cvec_X_iter         cvec_X_insert(cvec_X* self, size_t idx, i_val value);                        // move value 
+cvec_X_iter         cvec_X_insert_n(cvec_X* self, size_t idx, const i_val[] arr, size_t n);      // move arr values
+cvec_X_iter         cvec_X_insert_at(cvec_X* self, cvec_X_iter it, i_val value);               // move value 
 
-cvec_X_iter_t       cvec_X_emplace(cvec_X* self, size_t idx, i_valraw raw);
-cvec_X_iter_t       cvec_X_emplace_n(cvec_X* self, size_t idx, const i_valraw[] arr, size_t n);
-cvec_X_iter_t       cvec_X_emplace_at(cvec_X* self, cvec_X_iter_t it, i_valraw raw);
-cvec_X_iter_t       cvec_X_emplace_range(cvec_X* self, cvec_X_iter_t it, 
-                                         cvec_X_iter_t it1, cvec_X_iter_t it2);                 // will clone
-cvec_X_iter_t       cvec_X_emplace_range_p(cvec_X* self, i_val* pos, 
+cvec_X_iter         cvec_X_emplace(cvec_X* self, size_t idx, i_valraw raw);
+cvec_X_iter         cvec_X_emplace_n(cvec_X* self, size_t idx, const i_valraw[] arr, size_t n);
+cvec_X_iter         cvec_X_emplace_at(cvec_X* self, cvec_X_iter it, i_valraw raw);
+cvec_X_iter         cvec_X_emplace_range(cvec_X* self, cvec_X_iter it, 
+                                         cvec_X_iter it1, cvec_X_iter it2);                 // will clone
+cvec_X_iter         cvec_X_emplace_range_p(cvec_X* self, i_val* pos, 
                                            const i_val* p1, const i_val* p2);
 
-cvec_X_iter_t       cvec_X_erase_n(cvec_X* self, size_t idx, size_t n);
-cvec_X_iter_t       cvec_X_erase_at(cvec_X* self, cvec_X_iter_t it);
-cvec_X_iter_t       cvec_X_erase_range(cvec_X* self, cvec_X_iter_t it1, cvec_X_iter_t it2);
+cvec_X_iter         cvec_X_erase_n(cvec_X* self, size_t idx, size_t n);
+cvec_X_iter         cvec_X_erase_at(cvec_X* self, cvec_X_iter it);
+cvec_X_iter         cvec_X_erase_range(cvec_X* self, cvec_X_iter it1, cvec_X_iter it2);
 
-cvec_X_iter_t       cvec_X_find(const cvec_X* self, i_valraw raw);
-cvec_X_iter_t       cvec_X_find_in(cvec_X_iter_t i1, cvec_X_iter_t i2, i_valraw raw);
-cvec_X_value_t*     cvec_X_get(const cvec_X* self, i_valraw raw);                             // return NULL if not found
-cvec_X_iter_t       cvec_X_bsearch(const cvec_X* self, i_valraw raw);
-cvec_X_iter_t       cvec_X_bsearch_in(cvec_X_iter_t i1, cvec_X_iter_t i2, i_valraw raw);
+cvec_X_iter         cvec_X_find(const cvec_X* self, i_valraw raw);
+cvec_X_iter         cvec_X_find_in(cvec_X_iter i1, cvec_X_iter i2, i_valraw raw);
+cvec_X_value*       cvec_X_get(const cvec_X* self, i_valraw raw);                             // return NULL if not found
+cvec_X_iter         cvec_X_bsearch(const cvec_X* self, i_valraw raw);
+cvec_X_iter         cvec_X_bsearch_in(cvec_X_iter i1, cvec_X_iter i2, i_valraw raw);
 
 void                cvec_X_sort(cvec_X* self);
-void                cvec_X_sort_range(cvec_X_iter_t i1, cvec_X_iter_t i2,
+void                cvec_X_sort_range(cvec_X_iter i1, cvec_X_iter i2,
                                       int(*cmp)(const i_val*, const i_val*));
 
-cvec_X_iter_t       cvec_X_begin(const cvec_X* self);
-cvec_X_iter_t       cvec_X_end(const cvec_X* self);
-void                cvec_X_next(cvec_X_iter_t* iter);
+cvec_X_iter         cvec_X_begin(const cvec_X* self);
+cvec_X_iter         cvec_X_end(const cvec_X* self);
+void                cvec_X_next(cvec_X_iter* iter);
 
-cvec_X_rawvalue_t   cvec_X_value_toraw(cvec_X_value_t* pval);
-cvec_X_value_t      cvec_X_value_clone(cvec_X_value_t val);
+cvec_X_rawvalue     cvec_X_value_toraw(cvec_X_value* pval);
+cvec_X_value        cvec_X_value_clone(cvec_X_value val);
 ```
 
 ## Types
 
-| Type name            | Type definition                     | Used to represent...   |
-|:---------------------|:------------------------------------|:-----------------------|
-| `cvec_X`             | `struct { cvec_X_value_t* data; }`  | The cvec type          |
-| `cvec_X_value_t`     | `i_val`                             | The cvec value type    |
-| `cvec_X_rawvalue_t`  | `i_valraw`                          | The raw value type     |
-| `cvec_X_iter_t`      | `struct { cvec_X_value_t* ref; }`   | The iterator type      |
+| Type name          | Type definition                   | Used to represent...   |
+|:-------------------|:----------------------------------|:-----------------------|
+| `cvec_X`           | `struct { cvec_X_value* data; }`  | The cvec type          |
+| `cvec_X_value`     | `i_val`                           | The cvec value type    |
+| `cvec_X_rawvalue`  | `i_valraw`                        | The raw value type     |
+| `cvec_X_iter`      | `struct { cvec_X_value* ref; }`   | The iterator type      |
 
 ## Examples
 ```c
 #define i_val int
-#define i_tag i
 #include <stc/cvec.h>
 
 #include <stdio.h>
@@ -107,29 +106,28 @@ cvec_X_value_t      cvec_X_value_clone(cvec_X_value_t val);
 int main()
 {
     // Create a vector containing integers
-    cvec_i vec = cvec_i_init();
-
-    // Add two integers to vector
-    cvec_i_push_back(&vec, 25);
-    cvec_i_push_back(&vec, 13);
-
-    // Append a set of numbers
-    c_apply(cvec_i, push_back, &vec, {7, 5, 16, 8});
-
-    printf("initial:");
-    c_foreach (k, cvec_i, vec) {
-        printf(" %d", *k.ref);
+    c_auto (cvec_int, vec)
+    {
+        // Add two integers to vector
+        cvec_int_push_back(&vec, 25);
+        cvec_int_push_back(&vec, 13);
+
+        // Append a set of numbers
+        c_apply(cvec_int, push_back, &vec, {7, 5, 16, 8});
+
+        printf("initial:");
+        c_foreach (k, cvec_int, vec) {
+            printf(" %d", *k.ref);
+        }
+
+        // Sort the vector
+        cvec_int_sort(&vec);
+
+        printf("\nsorted:");
+        c_foreach (k, cvec_int, vec) {
+            printf(" %d", *k.ref);
+        }
     }
-
-    // Sort the vector
-    cvec_i_sort(&vec);
-
-    printf("\nsorted:");
-    c_foreach (k, cvec_i, vec) {
-        printf(" %d", *k.ref);
-    }
-
-    cvec_i_del(&vec);
 }
 ```
 Output: