From a913490c248f6cfdca3481d81d6d344f4d066cb9 Mon Sep 17 00:00:00 2001
From: Tyge Løvset <tylo@norceresearch.no>
Date: Tue, 18 Apr 2023 17:48:47 +0200
Subject: Removed unneeded custom size type in maps and bits.h. Prepared for
 possible robin-hood impl. Improved sso_bench.c testing string hash - twice as
 fast as m.ankeln robin impl !?.

---
 include/stc/cbits.h | 70 +++++++++++++++++++++++++----------------------------
 1 file changed, 33 insertions(+), 37 deletions(-)

(limited to 'include/stc/cbits.h')

diff --git a/include/stc/cbits.h b/include/stc/cbits.h
index 826df847..19e281a8 100644
--- a/include/stc/cbits.h
+++ b/include/stc/cbits.h
@@ -54,11 +54,8 @@ int main() {
 #include <stdlib.h>
 #include <string.h>
 
-#ifndef i_ssize
-#define i_ssize intptr_t
-#endif
 #define _cbits_bit(i) ((uint64_t)1 << ((i) & 63))
-#define _cbits_words(n) (i_ssize)(((n) + 63)>>6)
+#define _cbits_words(n) (int64_t)(((n) + 63)>>6)
 #define _cbits_bytes(n) (_cbits_words(n) * c_sizeof(uint64_t))
 
 #if defined(__GNUC__)
@@ -80,23 +77,23 @@ int main() {
     }
 #endif
 
-STC_INLINE i_ssize _cbits_count(const uint64_t* set, const i_ssize sz) {
-    const i_ssize n = sz>>6;
-    i_ssize count = 0;
-    for (i_ssize i = 0; i < n; ++i)
+STC_INLINE int64_t _cbits_count(const uint64_t* set, const int64_t sz) {
+    const int64_t n = sz>>6;
+    int64_t count = 0;
+    for (int64_t i = 0; i < n; ++i)
         count += cpopcount64(set[i]);
     if (sz & 63)
         count += cpopcount64(set[n] & (_cbits_bit(sz) - 1));
     return count;
 }
 
-STC_INLINE char* _cbits_to_str(const uint64_t* set, const i_ssize sz, 
-                               char* out, i_ssize start, i_ssize stop) {
+STC_INLINE char* _cbits_to_str(const uint64_t* set, const int64_t sz, 
+                               char* out, int64_t start, int64_t stop) {
     if (stop > sz) stop = sz;
     assert(start <= stop);
 
     c_memset(out, '0', stop - start);
-    for (i_ssize i = start; i < stop; ++i) 
+    for (int64_t i = start; i < stop; ++i) 
         if ((set[i>>6] & _cbits_bit(i)) != 0)
             out[i - start] = '1';
     out[stop - start] = '\0';
@@ -104,8 +101,8 @@ STC_INLINE char* _cbits_to_str(const uint64_t* set, const i_ssize sz,
 }
 
 #define _cbits_OPR(OPR, VAL) \
-    const i_ssize n = sz>>6; \
-    for (i_ssize i = 0; i < n; ++i) \
+    const int64_t n = sz>>6; \
+    for (int64_t i = 0; i < n; ++i) \
         if ((set[i] OPR other[i]) != VAL) \
             return false; \
     if (!(sz & 63)) \
@@ -113,10 +110,10 @@ STC_INLINE char* _cbits_to_str(const uint64_t* set, const i_ssize sz,
     const uint64_t i = (uint64_t)n, m = _cbits_bit(sz) - 1; \
     return ((set[i] OPR other[i]) & m) == (VAL & m)
 
-STC_INLINE bool _cbits_subset_of(const uint64_t* set, const uint64_t* other, const i_ssize sz)
+STC_INLINE bool _cbits_subset_of(const uint64_t* set, const uint64_t* other, const int64_t sz)
     { _cbits_OPR(|, set[i]); }
 
-STC_INLINE bool _cbits_disjoint(const uint64_t* set, const uint64_t* other, const i_ssize sz)
+STC_INLINE bool _cbits_disjoint(const uint64_t* set, const uint64_t* other, const int64_t sz)
     { _cbits_OPR(&, 0); }
 
 #endif // CBITS_H_INCLUDED
@@ -128,12 +125,12 @@ STC_INLINE bool _cbits_disjoint(const uint64_t* set, const uint64_t* other, cons
 #define _i_assert(x) assert(x)
 #define i_type cbits
 
-struct { uint64_t *data64; i_ssize _size; } typedef i_type;
+struct { uint64_t *data64; int64_t _size; } typedef i_type;
 
 STC_INLINE cbits   cbits_init(void) { return c_LITERAL(cbits){NULL}; }
 STC_INLINE void    cbits_create(cbits* self) { self->data64 = NULL; self->_size = 0; }
 STC_INLINE void    cbits_drop(cbits* self) { c_free(self->data64); }
-STC_INLINE i_ssize cbits_size(const cbits* self) { return self->_size; }
+STC_INLINE int64_t cbits_size(const cbits* self) { return self->_size; }
 
 STC_INLINE cbits* cbits_take(cbits* self, cbits other) {
     if (self->data64 != other.data64) {
@@ -144,7 +141,7 @@ STC_INLINE cbits* cbits_take(cbits* self, cbits other) {
 }
 
 STC_INLINE cbits cbits_clone(cbits other) {
-    const i_ssize bytes = _cbits_bytes(other._size);
+    const int64_t bytes = _cbits_bytes(other._size);
     cbits set = {(uint64_t *)c_memcpy(c_malloc(bytes), other.data64, bytes), other._size};
     return set;
 }
@@ -158,8 +155,8 @@ STC_INLINE cbits* cbits_copy(cbits* self, const cbits* other) {
     return self;
 }
 
-STC_INLINE void cbits_resize(cbits* self, const i_ssize size, const bool value) {
-    const i_ssize new_n = _cbits_words(size), osize = self->_size, old_n = _cbits_words(osize);
+STC_INLINE void cbits_resize(cbits* self, const int64_t size, const bool value) {
+    const int64_t new_n = _cbits_words(size), osize = self->_size, old_n = _cbits_words(osize);
     self->data64 = (uint64_t *)c_realloc(self->data64, new_n*8);
     self->_size = size;
     if (new_n >= old_n) {
@@ -181,13 +178,13 @@ STC_INLINE cbits cbits_move(cbits* self) {
     return tmp;
 }
 
-STC_INLINE cbits cbits_with_size(const i_ssize size, const bool value) {
+STC_INLINE cbits cbits_with_size(const int64_t size, const bool value) {
     cbits set = {(uint64_t *)c_malloc(_cbits_bytes(size)), size};
     cbits_set_all(&set, value);
     return set;
 }
 
-STC_INLINE cbits cbits_with_pattern(const i_ssize size, const uint64_t pattern) {
+STC_INLINE cbits cbits_with_pattern(const int64_t size, const uint64_t pattern) {
     cbits set = {(uint64_t *)c_malloc(_cbits_bytes(size)), size};
     cbits_set_pattern(&set, pattern);
     return set;
@@ -205,7 +202,7 @@ struct { uint64_t data64[(i_capacity - 1)/64 + 1]; } typedef i_type;
 STC_INLINE i_type   _i_memb(_init)(void) { return c_LITERAL(i_type){0}; }
 STC_INLINE void     _i_memb(_create)(i_type* self) {}
 STC_INLINE void     _i_memb(_drop)(i_type* self) {}
-STC_INLINE i_ssize  _i_memb(_size)(const i_type* self) { return i_capacity; }
+STC_INLINE int64_t  _i_memb(_size)(const i_type* self) { return i_capacity; }
 STC_INLINE i_type   _i_memb(_move)(i_type* self) { return *self; }
 
 STC_INLINE i_type*  _i_memb(_take)(i_type* self, i_type other)
@@ -220,13 +217,13 @@ STC_INLINE i_type* _i_memb(_copy)(i_type* self, const i_type* other)
 STC_INLINE void _i_memb(_set_all)(i_type *self, const bool value);
 STC_INLINE void _i_memb(_set_pattern)(i_type *self, const uint64_t pattern);
 
-STC_INLINE i_type _i_memb(_with_size)(const i_ssize size, const bool value) {
+STC_INLINE i_type _i_memb(_with_size)(const int64_t size, const bool value) {
     assert(size <= i_capacity);
     i_type set; _i_memb(_set_all)(&set, value);
     return set;
 }
 
-STC_INLINE i_type _i_memb(_with_pattern)(const i_ssize size, const uint64_t pattern) {
+STC_INLINE i_type _i_memb(_with_pattern)(const int64_t size, const uint64_t pattern) {
     assert(size <= i_capacity);
     i_type set; _i_memb(_set_pattern)(&set, pattern);
     return set;
@@ -239,31 +236,31 @@ STC_INLINE void _i_memb(_set_all)(i_type *self, const bool value)
     { c_memset(self->data64, value? ~0 : 0, _cbits_bytes(_i_memb(_size)(self))); }
 
 STC_INLINE void _i_memb(_set_pattern)(i_type *self, const uint64_t pattern) {
-    i_ssize n = _cbits_words(_i_memb(_size)(self));
+    int64_t n = _cbits_words(_i_memb(_size)(self));
     while (n--) self->data64[n] = pattern;
 }
 
-STC_INLINE bool _i_memb(_test)(const i_type* self, const i_ssize i) 
+STC_INLINE bool _i_memb(_test)(const i_type* self, const int64_t i) 
     { return (self->data64[i>>6] & _cbits_bit(i)) != 0; }
 
-STC_INLINE bool _i_memb(_at)(const i_type* self, const i_ssize i)
+STC_INLINE bool _i_memb(_at)(const i_type* self, const int64_t i)
     { return (self->data64[i>>6] & _cbits_bit(i)) != 0; }
 
-STC_INLINE void _i_memb(_set)(i_type *self, const i_ssize i)
+STC_INLINE void _i_memb(_set)(i_type *self, const int64_t i)
     { self->data64[i>>6] |= _cbits_bit(i); }
 
-STC_INLINE void _i_memb(_reset)(i_type *self, const i_ssize i)
+STC_INLINE void _i_memb(_reset)(i_type *self, const int64_t i)
     { self->data64[i>>6] &= ~_cbits_bit(i); }
 
-STC_INLINE void _i_memb(_set_value)(i_type *self, const i_ssize i, const bool b) {
+STC_INLINE void _i_memb(_set_value)(i_type *self, const int64_t i, const bool b) {
     self->data64[i>>6] ^= ((uint64_t)-(int)b ^ self->data64[i>>6]) & _cbits_bit(i);
 }
 
-STC_INLINE void _i_memb(_flip)(i_type *self, const i_ssize i)
+STC_INLINE void _i_memb(_flip)(i_type *self, const int64_t i)
     { self->data64[i>>6] ^= _cbits_bit(i); }
 
 STC_INLINE void _i_memb(_flip_all)(i_type *self) {
-    i_ssize n = _cbits_words(_i_memb(_size)(self));
+    int64_t n = _cbits_words(_i_memb(_size)(self));
     while (n--) self->data64[n] ^= ~(uint64_t)0;
 }
 
@@ -277,19 +274,19 @@ STC_INLINE i_type _i_memb(_from)(const char* str) {
 /* Intersection */
 STC_INLINE void _i_memb(_intersect)(i_type *self, const i_type* other) {
     _i_assert(self->_size == other->_size);
-    i_ssize n = _cbits_words(_i_memb(_size)(self));
+    int64_t n = _cbits_words(_i_memb(_size)(self));
     while (n--) self->data64[n] &= other->data64[n];
 }
 /* Union */
 STC_INLINE void _i_memb(_union)(i_type *self, const i_type* other) {
     _i_assert(self->_size == other->_size);
-    i_ssize n = _cbits_words(_i_memb(_size)(self));
+    int64_t n = _cbits_words(_i_memb(_size)(self));
     while (n--) self->data64[n] |= other->data64[n];
 }
 /* Exclusive disjunction */
 STC_INLINE void _i_memb(_xor)(i_type *self, const i_type* other) {
     _i_assert(self->_size == other->_size);
-    i_ssize n = _cbits_words(_i_memb(_size)(self));
+    int64_t n = _cbits_words(_i_memb(_size)(self));
     while (n--) self->data64[n] ^= other->data64[n];
 }
 
@@ -312,7 +309,6 @@ STC_INLINE bool _i_memb(_disjoint)(const i_type* self, const i_type* other) {
 #pragma GCC diagnostic pop
 #endif
 #define CBITS_H_INCLUDED
-#undef _i_size
 #undef _i_memb
 #undef _i_assert
 #undef i_capacity
-- 
cgit v1.2.3


From f916573e2b3652d9b3f6fb82aadd5f2cfb3ce2fe Mon Sep 17 00:00:00 2001
From: Tyge Løvset <tylo@norceresearch.no>
Date: Mon, 1 May 2023 10:00:07 +0200
Subject: Remove warnings when using -Wextra.

---
 include/stc/cbits.h                   |  4 ++--
 include/stc/csmap.h                   |  2 +-
 misc/benchmarks/shootout_hashmaps.cpp |  1 +
 misc/examples/birthday.c              |  4 ++--
 misc/examples/complex.c               |  2 +-
 misc/examples/gauss2.c                |  2 +-
 misc/examples/inits.c                 |  2 +-
 misc/examples/make.sh                 |  4 ++--
 misc/examples/new_list.c              |  2 +-
 misc/examples/new_map.c               |  6 +++---
 misc/examples/new_pque.c              |  2 +-
 misc/examples/new_queue.c             |  2 +-
 misc/examples/new_smap.c              |  2 +-
 misc/examples/new_vec.c               |  4 ++--
 misc/examples/prime.c                 | 12 ++++++------
 misc/examples/random.c                | 14 +++++++-------
 misc/examples/regex_match.c           |  2 +-
 misc/examples/shape.c                 |  8 ++++----
 src/cregex.c                          |  9 +++++----
 19 files changed, 43 insertions(+), 41 deletions(-)

(limited to 'include/stc/cbits.h')

diff --git a/include/stc/cbits.h b/include/stc/cbits.h
index 19e281a8..855d6eb7 100644
--- a/include/stc/cbits.h
+++ b/include/stc/cbits.h
@@ -125,7 +125,7 @@ STC_INLINE bool _cbits_disjoint(const uint64_t* set, const uint64_t* other, cons
 #define _i_assert(x) assert(x)
 #define i_type cbits
 
-struct { uint64_t *data64; int64_t _size; } typedef i_type;
+typedef struct { uint64_t *data64; int64_t _size; } i_type;
 
 STC_INLINE cbits   cbits_init(void) { return c_LITERAL(cbits){NULL}; }
 STC_INLINE void    cbits_create(cbits* self) { self->data64 = NULL; self->_size = 0; }
@@ -197,7 +197,7 @@ STC_INLINE cbits cbits_with_pattern(const int64_t size, const uint64_t pattern)
 #define i_type c_PASTE(cbits, i_capacity)
 #endif
 
-struct { uint64_t data64[(i_capacity - 1)/64 + 1]; } typedef i_type;
+typedef struct { uint64_t data64[(i_capacity - 1)/64 + 1]; } i_type;
 
 STC_INLINE i_type   _i_memb(_init)(void) { return c_LITERAL(i_type){0}; }
 STC_INLINE void     _i_memb(_create)(i_type* self) {}
diff --git a/include/stc/csmap.h b/include/stc/csmap.h
index 6b8475eb..fbfea8dd 100644
--- a/include/stc/csmap.h
+++ b/include/stc/csmap.h
@@ -283,7 +283,7 @@ _cx_memb(_reserve)(_cx_self* self, const intptr_t cap) {
     _cx_node* nodes = (_cx_node*)i_realloc(self->nodes, (cap + 1)*c_sizeof(_cx_node));
     if (!nodes)
         return false;
-    nodes[0] = c_LITERAL(_cx_node){{0, 0}, 0};
+    nodes[0] = c_LITERAL(_cx_node){0};
     self->nodes = nodes;
     self->cap = (int32_t)cap;
     return true;
diff --git a/misc/benchmarks/shootout_hashmaps.cpp b/misc/benchmarks/shootout_hashmaps.cpp
index 54680402..c6a81777 100644
--- a/misc/benchmarks/shootout_hashmaps.cpp
+++ b/misc/benchmarks/shootout_hashmaps.cpp
@@ -36,6 +36,7 @@ KHASH_MAP_INIT_INT64(ii, IValue)
 #define i_key IKey
 #define i_val IValue
 #define i_tag ii
+//#define i_expandby 1
 #define i_max_load_factor MAX_LOAD_FACTOR / 100.0f
 #include <stc/cmap.h>
 
diff --git a/misc/examples/birthday.c b/misc/examples/birthday.c
index c301128a..2820c42f 100644
--- a/misc/examples/birthday.c
+++ b/misc/examples/birthday.c
@@ -13,8 +13,8 @@ static uint64_t seed = 12345;
 static void test_repeats(void)
 {
     enum {BITS = 46, BITS_TEST = BITS/2 + 2};
-    const static uint64_t N = 1ull << BITS_TEST;
-    const static uint64_t mask = (1ull << BITS) - 1;
+    static const uint64_t N = 1ull << BITS_TEST;
+    static const uint64_t mask = (1ull << BITS) - 1;
 
     printf("birthday paradox: value range: 2^%d, testing repeats of 2^%d values\n", BITS, BITS_TEST);
     crand_t rng = crand_init(seed);
diff --git a/misc/examples/complex.c b/misc/examples/complex.c
index 7dde981d..c730db33 100644
--- a/misc/examples/complex.c
+++ b/misc/examples/complex.c
@@ -44,7 +44,7 @@ int main()
     const ListMap* lmap_p = MapMap_at(&mmap, "first");
     const StackList* list_p = ListMap_at(lmap_p, 42);
     const FloatStack* stack_p = StackList_back(list_p);
-    printf("value is: %f\n", *FloatStack_at(stack_p, 3)); // pi
+    printf("value is: %f\n", (double)*FloatStack_at(stack_p, 3)); // pi
 
     MapMap_drop(&mmap);
 }
diff --git a/misc/examples/gauss2.c b/misc/examples/gauss2.c
index df709d03..e786824b 100644
--- a/misc/examples/gauss2.c
+++ b/misc/examples/gauss2.c
@@ -14,7 +14,7 @@ int main()
     enum {N = 5000000};
     uint64_t seed = (uint64_t)time(NULL);
     crand_t rng = crand_init(seed);
-    const double Mean = round(crand_f64(&rng)*98.f - 49.f), StdDev = crand_f64(&rng)*10.f + 1.f, Scale = 74.f;
+    const double Mean = round(crand_f64(&rng)*98.0 - 49.0), StdDev = crand_f64(&rng)*10.0 + 1.0, Scale = 74.0;
 
     printf("Demo of gaussian / normal distribution of %d random samples\n", N);
     printf("Mean %f, StdDev %f\n", Mean, StdDev);
diff --git a/misc/examples/inits.c b/misc/examples/inits.c
index 81bcdd3e..e098422e 100644
--- a/misc/examples/inits.c
+++ b/misc/examples/inits.c
@@ -45,7 +45,7 @@ int main(void)
 
     puts("\npop and show high priorites first:");
     while (! cpque_f_empty(&floats)) {
-        printf("%.1f ", *cpque_f_top(&floats));
+        printf("%.1f ", (double)*cpque_f_top(&floats));
         cpque_f_pop(&floats);
     }
     puts("\n");
diff --git a/misc/examples/make.sh b/misc/examples/make.sh
index 0297e5a1..ee8d2267 100755
--- a/misc/examples/make.sh
+++ b/misc/examples/make.sh
@@ -1,12 +1,12 @@
 #!/bin/sh
 
 if [ "$(uname)" = 'Linux' ]; then
-    sanitize='-fsanitize=address'
+    sanitize='-fsanitize=address -fsanitize=undefined -fsanitize-trap'
     clibs='-lm' # -pthread
     oflag='-o '
 fi
 
-cc=gcc; cflags="-s -O3 -std=c99 -Wconversion -Wpedantic -Wall -Wsign-compare -Wwrite-strings"
+cc=gcc; cflags="-s -O3 -std=c99 -Wall -Wextra -Wpedantic -Wconversion -Wwrite-strings -Wdouble-promotion -Wno-unused-parameter -Wno-implicit-fallthrough -Wno-maybe-uninitialized -Wno-missing-field-initializers"
 #cc=gcc; cflags="-g -std=c99 -Werror -Wfatal-errors -Wpedantic -Wall $sanitize"
 #cc=tcc; cflags="-Wall -std=c99"
 #cc=clang; cflags="-s -O2 -std=c99 -Werror -Wfatal-errors -Wpedantic -Wall -Wno-unused-function -Wsign-compare -Wwrite-strings"
diff --git a/misc/examples/new_list.c b/misc/examples/new_list.c
index 8b291d34..14fabb4a 100644
--- a/misc/examples/new_list.c
+++ b/misc/examples/new_list.c
@@ -61,7 +61,7 @@ int main()
     clist_float_sort(&flst);
 
     c_foreach (i, clist_float, flst)
-        printf(" %g", *i.ref);
+        printf(" %g", (double)*i.ref);
 
     puts("");
     clist_float_drop(&flst);
diff --git a/misc/examples/new_map.c b/misc/examples/new_map.c
index 3a4f934d..f01db64f 100644
--- a/misc/examples/new_map.c
+++ b/misc/examples/new_map.c
@@ -3,10 +3,10 @@
 
 forward_cmap(cmap_pnt, struct Point, int);
 
-struct MyStruct {
+typedef struct MyStruct {
     cmap_pnt pntmap;
     cstr name;
-} typedef MyStruct;
+} MyStruct;
 
 // int => int map
 #define i_key int
@@ -14,7 +14,7 @@ struct MyStruct {
 #include <stc/cmap.h>
 
 // Point => int map
-struct Point { int x, y; } typedef Point;
+typedef struct Point { int x, y; } Point;
 
 int point_cmp(const Point* a, const Point* b) {
     int c = a->x - b->x;
diff --git a/misc/examples/new_pque.c b/misc/examples/new_pque.c
index 9147e3f2..5b26b3de 100644
--- a/misc/examples/new_pque.c
+++ b/misc/examples/new_pque.c
@@ -1,6 +1,6 @@
 #include <stdio.h>
 
-struct Point { int x, y; } typedef Point;
+typedef struct Point { int x, y; } Point;
 
 #define i_type PointQ
 #define i_val Point
diff --git a/misc/examples/new_queue.c b/misc/examples/new_queue.c
index 916f4dbc..b784bc18 100644
--- a/misc/examples/new_queue.c
+++ b/misc/examples/new_queue.c
@@ -5,7 +5,7 @@
 
 forward_cqueue(cqueue_pnt, struct Point);
 
-struct Point { int x, y; } typedef Point;
+typedef struct Point { int x, y; } Point;
 int point_cmp(const Point* a, const Point* b) {
     int c = c_default_cmp(&a->x, &b->x);
     return c ? c : c_default_cmp(&a->y, &b->y);
diff --git a/misc/examples/new_smap.c b/misc/examples/new_smap.c
index d8245b8b..f930eba2 100644
--- a/misc/examples/new_smap.c
+++ b/misc/examples/new_smap.c
@@ -10,7 +10,7 @@ typedef struct {
 } MyStruct;
 
 // Point => int map
-struct Point { int x, y; } typedef Point;
+typedef struct Point { int x, y; } Point;
 int point_cmp(const Point* a, const Point* b) {
     int c = a->x - b->x;
     return c ? c : a->y - b->y;
diff --git a/misc/examples/new_vec.c b/misc/examples/new_vec.c
index df443b7f..d4b66883 100644
--- a/misc/examples/new_vec.c
+++ b/misc/examples/new_vec.c
@@ -4,10 +4,10 @@
 forward_cvec(cvec_i32, int);
 forward_cvec(cvec_pnt, struct Point);
 
-struct MyStruct {
+typedef struct MyStruct {
     cvec_i32 intvec;
     cvec_pnt pntvec;
-} typedef MyStruct;
+} MyStruct;
 
 #define i_val int
 #define i_is_forward
diff --git a/misc/examples/prime.c b/misc/examples/prime.c
index d0887353..7efa26ff 100644
--- a/misc/examples/prime.c
+++ b/misc/examples/prime.c
@@ -26,15 +26,15 @@ cbits sieveOfEratosthenes(int64_t n)
 
 int main(void)
 {
-    int64_t n = 1000000000;
-    printf("Computing prime numbers up to %" c_ZI "\n", n);
+    int n = 1000000000;
+    printf("Computing prime numbers up to %d\n", n);
 
-    clock_t t1 = clock();
+    clock_t t = clock();
     cbits primes = sieveOfEratosthenes(n + 1);
-    int64_t np = cbits_count(&primes);
-    clock_t t2 = clock();
+    int np = (int)cbits_count(&primes);
+    t = t - clock();
 
-    printf("Number of primes: %" c_ZI ", time: %f\n\n", np, (float)(t2 - t1) / (float)CLOCKS_PER_SEC);
+    printf("Number of primes: %d, time: %f\n\n", np, (double)t/CLOCKS_PER_SEC);
     puts("Show all the primes in the range [2, 1000):");
     printf("2");
     c_forrange (i, 3, 1000, 2)
diff --git a/misc/examples/random.c b/misc/examples/random.c
index ea9c483e..e783fe55 100644
--- a/misc/examples/random.c
+++ b/misc/examples/random.c
@@ -4,7 +4,7 @@
 
 int main()
 {
-    const size_t N = 1000000000;
+    const int N = 1000000000;
     const uint64_t seed = (uint64_t)time(NULL), range = 1000000;
     crand_t rng = crand_init(seed);
 
@@ -18,8 +18,8 @@ int main()
         sum += (uint32_t)crand_u64(&rng);
     }
     diff = clock() - before;
-    printf("full range\t\t: %f secs, %" c_ZI ", avg: %f\n",
-           (float)diff / CLOCKS_PER_SEC, N, (float)sum / (float)N);
+    printf("full range\t\t: %f secs, %d, avg: %f\n",
+           (double)diff/CLOCKS_PER_SEC, N, (double)sum/N);
 
     crand_unif_t dist1 = crand_unif_init(0, range);
     rng = crand_init(seed);
@@ -29,8 +29,8 @@ int main()
         sum += crand_unif(&rng, &dist1); // unbiased
     }
     diff = clock() - before;
-    printf("unbiased 0-%" PRIu64 "\t: %f secs, %" c_ZI ", avg: %f\n",
-            range, (float)diff/CLOCKS_PER_SEC, N, (float)sum / (float)N);
+    printf("unbiased 0-%" PRIu64 "\t: %f secs, %d, avg: %f\n",
+            range, (double)diff/CLOCKS_PER_SEC, N, (double)sum/N);
 
     sum = 0;
     rng = crand_init(seed);
@@ -39,7 +39,7 @@ int main()
         sum += (int64_t)(crand_u64(&rng) % (range + 1)); // biased
     }
     diff = clock() - before;
-    printf("biased 0-%" PRIu64 "  \t: %f secs, %" c_ZI ", avg: %f\n",
-            range, (float)diff / CLOCKS_PER_SEC, N, (float)sum / (float)N);
+    printf("biased 0-%" PRIu64 "  \t: %f secs, %d, avg: %f\n",
+            range, (double)diff/CLOCKS_PER_SEC, N, (double)sum/N);
 
 }
diff --git a/misc/examples/regex_match.c b/misc/examples/regex_match.c
index def0ae7a..e49ebd0b 100644
--- a/misc/examples/regex_match.c
+++ b/misc/examples/regex_match.c
@@ -24,7 +24,7 @@ int main()
         cstack_float_push(&vec, (float)atof(i.match[0].str));
 
     c_foreach (i, cstack_float, vec)
-        printf("  %g\n", *i.ref);
+        printf("  %g\n", (double)*i.ref);
 
     // extracts the numbers only to a comma separated string.
     cstr nums = cregex_replace_sv(&re, csview_from(str), " $0,", 0, NULL, CREG_R_STRIP);
diff --git a/misc/examples/shape.c b/misc/examples/shape.c
index d7116039..22e993db 100644
--- a/misc/examples/shape.c
+++ b/misc/examples/shape.c
@@ -62,9 +62,9 @@ static void Triangle_draw(const Shape* shape)
 {
     const Triangle* self = DYN_CAST(Triangle, shape);
     printf("Triangle : (%g,%g), (%g,%g), (%g,%g)\n",
-           self->p[0].x, self->p[0].y,
-           self->p[1].x, self->p[1].y,
-           self->p[2].x, self->p[2].y);
+           (double)self->p[0].x, (double)self->p[0].y,
+           (double)self->p[1].x, (double)self->p[1].y,
+           (double)self->p[2].x, (double)self->p[2].y);
 }
 
 struct ShapeAPI Triangle_api = {
@@ -109,7 +109,7 @@ static void Polygon_draw(const Shape* shape)
     const Polygon* self = DYN_CAST(Polygon, shape);
     printf("Polygon  :");
     c_foreach (i, PointVec, self->points)
-        printf(" (%g,%g)", i.ref->x, i.ref->y);
+        printf(" (%g,%g)", (double)i.ref->x, (double)i.ref->y);
     puts("");
 }
 
diff --git a/src/cregex.c b/src/cregex.c
index 0688d9e1..a1d43944 100644
--- a/src/cregex.c
+++ b/src/cregex.c
@@ -842,16 +842,17 @@ _bldcclass(_Parser *par)
 
 
 static _Reprog*
-_regcomp1(_Reprog *progp, _Parser *par, const char *s, int cflags)
+_regcomp1(_Reprog *pp, _Parser *par, const char *s, int cflags)
 {
     _Token token;
 
     /* get memory for the program. estimated max usage */
     par->instcap = 5U + 6*strlen(s);
-    _Reprog* pp = (_Reprog *)c_realloc(progp, sizeof(_Reprog) + par->instcap*sizeof(_Reinst));
-    if (pp == NULL) {
+    _Reprog* old_pp = pp;
+    pp = (_Reprog *)c_realloc(pp, sizeof(_Reprog) + par->instcap*sizeof(_Reinst));
+    if (! pp) {
+        c_free(old_pp);
         par->error = CREG_OUTOFMEMORY;
-        c_free(progp);
         return NULL;
     }
     pp->flags.icase = (cflags & CREG_C_ICASE) != 0;
-- 
cgit v1.2.3


From 26513bb1352ab4e4ffe931aabd80868216afc551 Mon Sep 17 00:00:00 2001
From: Tyge Lovset <tylovset@gmail.com>
Date: Fri, 19 May 2023 20:55:57 +0200
Subject: Minor cbits change.

---
 include/stc/cbits.h  | 2 --
 include/stc/cdeq.h   | 4 ++--
 include/stc/cqueue.h | 4 ++--
 3 files changed, 4 insertions(+), 6 deletions(-)

(limited to 'include/stc/cbits.h')

diff --git a/include/stc/cbits.h b/include/stc/cbits.h
index 855d6eb7..cf13790a 100644
--- a/include/stc/cbits.h
+++ b/include/stc/cbits.h
@@ -128,7 +128,6 @@ STC_INLINE bool _cbits_disjoint(const uint64_t* set, const uint64_t* other, cons
 typedef struct { uint64_t *data64; int64_t _size; } i_type;
 
 STC_INLINE cbits   cbits_init(void) { return c_LITERAL(cbits){NULL}; }
-STC_INLINE void    cbits_create(cbits* self) { self->data64 = NULL; self->_size = 0; }
 STC_INLINE void    cbits_drop(cbits* self) { c_free(self->data64); }
 STC_INLINE int64_t cbits_size(const cbits* self) { return self->_size; }
 
@@ -200,7 +199,6 @@ STC_INLINE cbits cbits_with_pattern(const int64_t size, const uint64_t pattern)
 typedef struct { uint64_t data64[(i_capacity - 1)/64 + 1]; } i_type;
 
 STC_INLINE i_type   _i_memb(_init)(void) { return c_LITERAL(i_type){0}; }
-STC_INLINE void     _i_memb(_create)(i_type* self) {}
 STC_INLINE void     _i_memb(_drop)(i_type* self) {}
 STC_INLINE int64_t  _i_memb(_size)(const i_type* self) { return i_capacity; }
 STC_INLINE i_type   _i_memb(_move)(i_type* self) { return *self; }
diff --git a/include/stc/cdeq.h b/include/stc/cdeq.h
index 77fb015f..b3714bf8 100644
--- a/include/stc/cdeq.h
+++ b/include/stc/cdeq.h
@@ -94,7 +94,7 @@ _cx_memb(_emplace_at)(_cx_self* self, _cx_iter it, const _cx_raw raw)
     { return _cx_memb(_insert_at)(self, it, i_keyfrom(raw)); }
 #endif
 
-#if defined _i_has_eq || defined _i_has_cmp
+#if defined _i_has_cmp || defined _i_has_eq
 STC_API _cx_iter _cx_memb(_find_in)(_cx_iter p1, _cx_iter p2, _cx_raw raw);
 
 STC_INLINE _cx_iter
@@ -172,7 +172,7 @@ _cx_memb(_emplace_n)(_cx_self* self, const intptr_t idx, const _cx_raw* raw, con
 }
 #endif
 
-#if defined _i_has_eq || defined _i_has_cmp
+#if defined _i_has_cmp || defined _i_has_eq
 STC_DEF _cx_iter
 _cx_memb(_find_in)(_cx_iter i1, _cx_iter i2, _cx_raw raw) {
     for (; i1.pos != i2.pos; _cx_memb(_next)(&i1)) {
diff --git a/include/stc/cqueue.h b/include/stc/cqueue.h
index 1f2c7d0f..571c1fe9 100644
--- a/include/stc/cqueue.h
+++ b/include/stc/cqueue.h
@@ -62,7 +62,7 @@ STC_INLINE _cx_value*   _cx_memb(_emplace)(_cx_self* self, _cx_raw raw)
                             { return _cx_memb(_push)(self, i_keyfrom(raw)); }
 #endif
 
-#if defined _i_has_eq || defined _i_has_cmp
+#if defined _i_has_cmp || defined _i_has_eq
 STC_API bool _cx_memb(_eq)(const _cx_self* self, const _cx_self* other);
 #endif
 
@@ -216,7 +216,7 @@ _cx_memb(_clone)(_cx_self cx) {
 }
 #endif // i_no_clone
 
-#if defined _i_has_eq || defined _i_has_cmp
+#if defined _i_has_cmp || defined _i_has_eq
 STC_DEF bool
 _cx_memb(_eq)(const _cx_self* self, const _cx_self* other) {
     if (_cx_memb(_size)(self) != _cx_memb(_size)(other)) return false;
-- 
cgit v1.2.3


From b1bbd0564a0d8d43172a654b51ff28bb62e0979a Mon Sep 17 00:00:00 2001
From: Tyge Løvset <tylo@norceresearch.no>
Date: Tue, 23 May 2023 22:44:33 +0200
Subject: Some house holding cleanup.

---
 docs/ccommon_api.md   |  2 +-
 include/stc/cbits.h   |  4 ++--
 include/stc/ccommon.h |  4 ++--
 include/stc/cregex.h  |  1 -
 include/stc/cstack.h  | 16 +++++-----------
 5 files changed, 10 insertions(+), 17 deletions(-)

(limited to 'include/stc/cbits.h')

diff --git a/docs/ccommon_api.md b/docs/ccommon_api.md
index cdd4ec87..5f6c82ed 100644
--- a/docs/ccommon_api.md
+++ b/docs/ccommon_api.md
@@ -40,7 +40,7 @@ c_forpair (id, count, csmap_ii, map)
 ```
 
 ### c_forlist
-Iterate compound literal array elements. Additional to `i.ref`, you can access `i.data`, `i.size`, and `i.index` of the input list/element.
+Iterate compound literal array elements. Additional to `i.ref`, you can access `i.size` and `i.index` for the input list/element.
 ```c
 // apply multiple push_backs
 c_forlist (i, int, {1, 2, 3})
diff --git a/include/stc/cbits.h b/include/stc/cbits.h
index cf13790a..fe422202 100644
--- a/include/stc/cbits.h
+++ b/include/stc/cbits.h
@@ -198,7 +198,7 @@ STC_INLINE cbits cbits_with_pattern(const int64_t size, const uint64_t pattern)
 
 typedef struct { uint64_t data64[(i_capacity - 1)/64 + 1]; } i_type;
 
-STC_INLINE i_type   _i_memb(_init)(void) { return c_LITERAL(i_type){0}; }
+STC_INLINE void     _i_memb(_init)(i_type* self) { memset(self->data64, 0, i_capacity*8); }
 STC_INLINE void     _i_memb(_drop)(i_type* self) {}
 STC_INLINE int64_t  _i_memb(_size)(const i_type* self) { return i_capacity; }
 STC_INLINE i_type   _i_memb(_move)(i_type* self) { return *self; }
@@ -211,7 +211,7 @@ STC_INLINE i_type _i_memb(_clone)(i_type other)
 
 STC_INLINE i_type* _i_memb(_copy)(i_type* self, const i_type* other) 
     { *self = *other; return self; }
-    
+
 STC_INLINE void _i_memb(_set_all)(i_type *self, const bool value);
 STC_INLINE void _i_memb(_set_pattern)(i_type *self, const uint64_t pattern);
 
diff --git a/include/stc/ccommon.h b/include/stc/ccommon.h
index eb3a6601..01ead57a 100644
--- a/include/stc/ccommon.h
+++ b/include/stc/ccommon.h
@@ -217,8 +217,8 @@ STC_INLINE intptr_t cnextpow2(intptr_t n) {
 #else
   #include <initializer_list>
   #define c_forlist(it, T, ...) \
-    for (struct {std::initializer_list<T> _il; std::initializer_list<T>::iterator data, ref; size_t size, index;} \
-         it = {._il=__VA_ARGS__, .data=it._il.begin(), .ref=it.data, .size=it._il.size()} \
+    for (struct {std::initializer_list<T> _il; std::initializer_list<T>::iterator ref; size_t size, index;} \
+         it = {._il=__VA_ARGS__, .ref=it._il.begin(), .size=it._il.size()} \
          ; it.index < it.size; ++it.ref, ++it.index)
 #endif
 
diff --git a/include/stc/cregex.h b/include/stc/cregex.h
index bf239ff6..919f5474 100644
--- a/include/stc/cregex.h
+++ b/include/stc/cregex.h
@@ -53,7 +53,6 @@ enum {
 
 typedef enum {
     CREG_OK = 0,
-    CREG_SUCCESS = 0, /* [deprecated] */
     CREG_NOMATCH = -1,
     CREG_MATCHERROR = -2,
     CREG_OUTOFMEMORY = -3,
diff --git a/include/stc/cstack.h b/include/stc/cstack.h
index ae8b3c40..fa0fab2b 100644
--- a/include/stc/cstack.h
+++ b/include/stc/cstack.h
@@ -41,20 +41,14 @@
 #endif
 typedef i_keyraw _cx_raw;
 
-STC_INLINE _cx_self _cx_memb(_init)(void) { 
-    _cx_self cx; cx._len = 0;
-#ifndef i_capacity
-    cx._cap = 0; cx.data = NULL;
-#endif
-    return cx;
-}
-
 #ifdef i_capacity
-STC_INLINE void _cx_memb(_create)(_cx_self* self)
+STC_INLINE void _cx_memb(_init)(_cx_self* self)
     { self->_len = 0; }
 #else
-STC_INLINE void _cx_memb(_create)(_cx_self* self)
-    { self->_len = 0; self->_cap = 0; self->data = NULL; }
+STC_INLINE _cx_self _cx_memb(_init)(void) { 
+    _cx_self out = {0};
+    return out;
+}
 
 STC_INLINE _cx_self _cx_memb(_with_capacity)(intptr_t cap) {
     _cx_self out = {(_cx_value *) i_malloc(cap*c_sizeof(i_key)), 0, cap};
-- 
cgit v1.2.3


From 72b0f0e7839b487a5df7c79ffe84511480cad251 Mon Sep 17 00:00:00 2001
From: Tyge Løvset <tylo@norceresearch.no>
Date: Fri, 9 Jun 2023 19:31:59 +0200
Subject: Fixed issues with linking params i_implement, i_extern.

---
 docs/cregex_api.md              |   6 +--
 include/c11/fmt.h               |   1 +
 include/stc/cbits.h             |   6 +--
 include/stc/ccommon.h           |   2 +-
 include/stc/cdeq.h              |   2 +-
 include/stc/clist.h             |   2 +-
 include/stc/cmap.h              |   2 +-
 include/stc/cpque.h             |   2 +-
 include/stc/cqueue.h            |   2 +-
 include/stc/crand.h             |   2 +-
 include/stc/cregex.h            |  10 ++--
 include/stc/csmap.h             |   2 +-
 include/stc/cspan.h             |   2 +-
 include/stc/cstr.h              | 102 ++++++++++++++++++++--------------------
 include/stc/csview.h            |  36 +++++++-------
 include/stc/cvec.h              |   2 +-
 include/stc/forward.h           |   1 +
 include/stc/utf8.h              |  16 +++++--
 misc/examples/arc_containers.c  |   2 +-
 misc/examples/astar.c           |   1 +
 misc/examples/books.c           |   1 +
 misc/examples/box.c             |   1 +
 misc/examples/complex.c         |   3 +-
 misc/examples/convert.c         |   2 +-
 misc/examples/coread.c          |   2 +-
 misc/examples/csmap_erase.c     |   1 +
 misc/examples/csmap_find.c      |   1 +
 misc/examples/csmap_insert.c    |   1 +
 misc/examples/cstr_match.c      |   1 +
 misc/examples/demos.c           |   1 +
 misc/examples/forfilter.c       |   1 +
 misc/examples/gauss2.c          |   3 +-
 misc/examples/hashmap.c         |   1 +
 misc/examples/inits.c           |   2 +-
 misc/examples/list_splice.c     |   1 -
 misc/examples/make.sh           |   2 +-
 misc/examples/mapmap.c          |   2 +-
 misc/examples/mmap.c            |   1 +
 misc/examples/multimap.c        |   1 +
 misc/examples/music_arc.c       |   1 +
 misc/examples/new_map.c         |   1 +
 misc/examples/new_smap.c        |   1 +
 misc/examples/new_sptr.c        |   1 +
 misc/examples/person_arc.c      |   1 +
 misc/examples/phonebook.c       |   2 +-
 misc/examples/printspan.c       |   1 +
 misc/examples/rawptr_elements.c |   2 +-
 misc/examples/read.c            |   1 +
 misc/examples/regex_match.c     |   1 +
 misc/examples/replace.c         |   1 +
 misc/examples/splitstr.c        |   1 +
 misc/examples/sso_map.c         |   1 +
 misc/examples/sso_substr.c      |   2 +
 misc/examples/sview_split.c     |   2 +
 misc/examples/unordered_set.c   |   1 +
 misc/examples/utf8replace_c.c   |   1 +
 misc/examples/vikings.c         |   1 +
 src/cregex.c                    |  19 +++++++-
 src/libstc.c                    |  12 +++++
 src/utf8code.c                  |   5 +-
 60 files changed, 180 insertions(+), 107 deletions(-)

(limited to 'include/stc/cbits.h')

diff --git a/docs/cregex_api.md b/docs/cregex_api.md
index e702c47c..fc86cc63 100644
--- a/docs/cregex_api.md
+++ b/docs/cregex_api.md
@@ -44,15 +44,15 @@ bool        cregex_is_match(const cregex* re, const char* input);
 
             // Replace all matches in input
 cstr        cregex_replace(const cregex* re, const char* input, const char* replace, int count = INT_MAX);
-            // Replace count matches in input string-view. Optionally transform replacement with mfun.
+            // Replace count matches in input string-view. Optionally transform replacement.
 cstr        cregex_replace_sv(const cregex* re, csview input, const char* replace, int count = INT_MAX);
 cstr        cregex_replace_sv(const cregex* re, csview input, const char* replace, int count,
-                              bool(*mfun)(int capgrp, csview match, cstr* mstr), int rflags);
+                              bool(*transform)(int group, csview match, cstr* result), int rflags);
 
             // All-in-one replacement (compile + find/replace + drop)
 cstr        cregex_replace_pattern(const char* pattern, const char* input, const char* replace, int count = INT_MAX);
 cstr        cregex_replace_pattern(const char* pattern, const char* input, const char* replace, int count,
-                                   bool(*mfun)(int capgrp, csview match, cstr* mstr), int rflags);
+                                   bool(*transform)(int group, csview match, cstr* result), int rflags);
             // destroy
 void        cregex_drop(cregex* self);
 ```
diff --git a/include/c11/fmt.h b/include/c11/fmt.h
index 7e85e4dd..45044e33 100644
--- a/include/c11/fmt.h
+++ b/include/c11/fmt.h
@@ -69,6 +69,7 @@ int main() {
 */
 #include <stdio.h>
 #include <stdint.h>
+#include <stddef.h>
 #include <assert.h>
 
 #define fmt_OVERLOAD(name, ...) \
diff --git a/include/stc/cbits.h b/include/stc/cbits.h
index fe422202..8a6558bf 100644
--- a/include/stc/cbits.h
+++ b/include/stc/cbits.h
@@ -161,9 +161,9 @@ STC_INLINE void cbits_resize(cbits* self, const int64_t size, const bool value)
     if (new_n >= old_n) {
         c_memset(self->data64 + old_n, -(int)value, (new_n - old_n)*8);
         if (old_n > 0) {
-            uint64_t m = _cbits_bit(osize) - 1; /* mask */
-            value ? (self->data64[old_n - 1] |= ~m) 
-                  : (self->data64[old_n - 1] &= m);
+            uint64_t mask = _cbits_bit(osize) - 1;
+            if (value) self->data64[old_n - 1] |= ~mask; 
+            else       self->data64[old_n - 1] &= mask;
         }
     }
 }
diff --git a/include/stc/ccommon.h b/include/stc/ccommon.h
index 01ead57a..87522a6e 100644
--- a/include/stc/ccommon.h
+++ b/include/stc/ccommon.h
@@ -253,6 +253,6 @@ STC_INLINE intptr_t cnextpow2(intptr_t n) {
 #if defined(STC_EXTERN)
   #define i_extern
 #endif
-#if defined(i_static) || defined(STC_IMPLEMENT) || defined(i_extern)
+#if defined(STC_IMPLEMENT) || defined(i_extern)
   #define i_implement
 #endif
diff --git a/include/stc/cdeq.h b/include/stc/cdeq.h
index b3714bf8..8bb62602 100644
--- a/include/stc/cdeq.h
+++ b/include/stc/cdeq.h
@@ -113,7 +113,7 @@ _cx_memb(_get_mut)(_cx_self* self, _cx_raw raw)
 #endif
 
 /* -------------------------- IMPLEMENTATION ------------------------- */
-#if defined(i_implement)
+#if defined(i_implement) || defined(i_static)
 
 STC_DEF _cx_value*
 _cx_memb(_push_front)(_cx_self* self, i_key value) {
diff --git a/include/stc/clist.h b/include/stc/clist.h
index 128e848d..310db204 100644
--- a/include/stc/clist.h
+++ b/include/stc/clist.h
@@ -214,7 +214,7 @@ STC_INLINE bool _cx_memb(_eq)(const _cx_self* self, const _cx_self* other) {
 #endif
 
 // -------------------------- IMPLEMENTATION -------------------------
-#if defined(i_implement)
+#if defined(i_implement) || defined(i_static)
 
 #if !defined i_no_clone
 STC_DEF _cx_self
diff --git a/include/stc/cmap.h b/include/stc/cmap.h
index 837631f8..f6c3eb07 100644
--- a/include/stc/cmap.h
+++ b/include/stc/cmap.h
@@ -261,7 +261,7 @@ _cx_memb(_eq)(const _cx_self* self, const _cx_self* other) {
 }
 
 /* -------------------------- IMPLEMENTATION ------------------------- */
-#if defined(i_implement)
+#if defined(i_implement) || defined(i_static)
 #ifndef i_max_load_factor
   #define i_max_load_factor 0.80f
 #endif
diff --git a/include/stc/cpque.h b/include/stc/cpque.h
index 85002c67..31a53ece 100644
--- a/include/stc/cpque.h
+++ b/include/stc/cpque.h
@@ -108,7 +108,7 @@ STC_INLINE void _cx_memb(_emplace)(_cx_self* self, _cx_raw raw)
 #endif // !i_no_emplace
 
 /* -------------------------- IMPLEMENTATION ------------------------- */
-#if defined(i_implement)
+#if defined(i_implement) || defined(i_static)
 
 STC_DEF void
 _cx_memb(_sift_down_)(_cx_self* self, const intptr_t idx, const intptr_t n) {
diff --git a/include/stc/cqueue.h b/include/stc/cqueue.h
index 571c1fe9..28515877 100644
--- a/include/stc/cqueue.h
+++ b/include/stc/cqueue.h
@@ -121,7 +121,7 @@ STC_INLINE void _cx_memb(_adjust_end_)(_cx_self* self, intptr_t n)
     { self->end = (self->end + n) & self->capmask; }
 
 /* -------------------------- IMPLEMENTATION ------------------------- */
-#if defined(i_implement)
+#if defined(i_implement) || defined(i_static)
 
 STC_DEF _cx_iter _cx_memb(_advance)(_cx_iter it, intptr_t n) {
     intptr_t len = _cx_memb(_size)(it._s);
diff --git a/include/stc/crand.h b/include/stc/crand.h
index f566c1cf..b9687c01 100644
--- a/include/stc/crand.h
+++ b/include/stc/crand.h
@@ -92,7 +92,7 @@ STC_INLINE double crand_f64(crand_t* rng) {
 }
 
 /* -------------------------- IMPLEMENTATION ------------------------- */
-#if defined(i_implement)
+#if defined(i_implement) || defined(i_static)
 
 /* Global random() */
 static crand_t crand_global = {{
diff --git a/include/stc/cregex.h b/include/stc/cregex.h
index 919f5474..e6180a31 100644
--- a/include/stc/cregex.h
+++ b/include/stc/cregex.h
@@ -135,7 +135,7 @@ STC_INLINE bool cregex_is_match(const cregex* re, const char* input)
 #define cregex_replace_sv_4(pattern, input, replace, count) \
     cregex_replace_sv_6(pattern, input, replace, count, NULL, CREG_DEFAULT)
 cstr cregex_replace_sv_6(const cregex* re, csview input, const char* replace, int count,
-                       bool (*mfun)(int i, csview match, cstr* mstr), int rflags);
+                         bool (*transform)(int group, csview match, cstr* result), int rflags);
 
 /* replace input with replace using regular expression */
 #define cregex_replace(...) c_MACRO_OVERLOAD(cregex_replace, __VA_ARGS__)
@@ -153,20 +153,20 @@ STC_INLINE cstr cregex_replace_4(const cregex* re, const char* input, const char
 #define cregex_replace_pattern_4(pattern, input, replace, count) \
     cregex_replace_pattern_6(pattern, input, replace, count, NULL, CREG_DEFAULT)
 cstr cregex_replace_pattern_6(const char* pattern, const char* input, const char* replace, int count,
-                              bool (*mfun)(int i, csview match, cstr* mstr), int crflags);
+                              bool (*transform)(int group, csview match, cstr* result), int crflags);
 
 /* destroy regex */
 void cregex_drop(cregex* re);
 
-#endif // CREGEX_H_INCLUDED
-#if defined i_extern || defined i_implement
+#if defined i_implement
 #  include "../../src/cregex.c"
 #endif
 #if defined i_extern
 #  include "../../src/utf8code.c"
 #endif
+#endif // CREGEX_H_INCLUDED
 #undef i_opt
 #undef i_header
 #undef i_static
-#undef i_implement
 #undef i_extern
+#undef i_implement
diff --git a/include/stc/csmap.h b/include/stc/csmap.h
index e8138926..7638b8f2 100644
--- a/include/stc/csmap.h
+++ b/include/stc/csmap.h
@@ -249,7 +249,7 @@ _cx_memb(_from_n)(const _cx_raw* raw, intptr_t n)
     { _cx_self cx = {0}; _cx_memb(_put_n)(&cx, raw, n); return cx; }
 
 /* -------------------------- IMPLEMENTATION ------------------------- */
-#if defined(i_implement)
+#if defined(i_implement) || defined(i_static)
 
 STC_DEF void
 _cx_memb(_next)(_cx_iter *it) {
diff --git a/include/stc/cspan.h b/include/stc/cspan.h
index b07e75a8..5b592098 100644
--- a/include/stc/cspan.h
+++ b/include/stc/cspan.h
@@ -212,7 +212,7 @@ STC_API intptr_t _cspan_slice(int32_t odim[], int32_t ostri[], int* orank,
                               int rank, const int32_t a[][2]);
 
 /* -------------------------- IMPLEMENTATION ------------------------- */
-#if defined(i_implement)
+#if defined(i_implement) || defined(i_static)
 
 STC_DEF intptr_t _cspan_idxN(int rank, const int32_t shape[], const int32_t stri[], const int32_t a[]) {
     intptr_t off = a[0];
diff --git a/include/stc/cstr.h b/include/stc/cstr.h
index 03eefd2f..ae80dab4 100644
--- a/include/stc/cstr.h
+++ b/include/stc/cstr.h
@@ -24,16 +24,12 @@
 /* A string type with short string optimization in C99 with good small-string
  * optimization (22 characters with 24 bytes string).
  */
+#define _i_no_undef
+#include "utf8.h"
+
 #ifndef CSTR_H_INCLUDED
 #define CSTR_H_INCLUDED
 
-#define i_header
-#if defined i_extern || defined STC_EXTERN
-#  define _i_extern
-#endif
-#include "ccommon.h"
-#include "forward.h"
-#include "utf8.h"
 #include <stdlib.h> /* malloc */
 #include <stdarg.h>
 #include <stdio.h> /* vsnprintf */
@@ -65,8 +61,8 @@ enum  { cstr_s_cap =            sizeof(cstr_buf) - 2 };
 #define cstr_l_drop(s)          c_free((s)->lon.data)
 
 #define cstr_is_long(s)         ((s)->sml.size > 127)
-STC_API char* _cstr_init(cstr* self, intptr_t len, intptr_t cap);
-STC_API char* _cstr_internal_move(cstr* self, intptr_t pos1, intptr_t pos2);
+extern char* _cstr_init(cstr* self, intptr_t len, intptr_t cap);
+extern char* _cstr_internal_move(cstr* self, intptr_t pos1, intptr_t pos2);
 
 /**************************** PUBLIC API **********************************/
 
@@ -74,19 +70,21 @@ STC_API char* _cstr_internal_move(cstr* self, intptr_t pos1, intptr_t pos2);
 #define cstr_NULL (c_LITERAL(cstr){{{0}, 0}})
 #define cstr_toraw(self) cstr_str(self)
 
-STC_API char*       cstr_reserve(cstr* self, intptr_t cap);
-STC_API void        cstr_shrink_to_fit(cstr* self);
-STC_API char*       cstr_resize(cstr* self, intptr_t size, char value);
-STC_API intptr_t    cstr_find_at(const cstr* self, intptr_t pos, const char* search);
-STC_API char*       cstr_assign_n(cstr* self, const char* str, intptr_t len);
-STC_API char*       cstr_append_n(cstr* self, const char* str, intptr_t len);
-STC_API bool        cstr_getdelim(cstr *self, int delim, FILE *fp);
-STC_API void        cstr_erase(cstr* self, intptr_t pos, intptr_t len);
-STC_API void        cstr_u8_erase(cstr* self, intptr_t bytepos, intptr_t u8len);
-STC_API cstr        cstr_from_fmt(const char* fmt, ...);
-STC_API intptr_t    cstr_append_fmt(cstr* self, const char* fmt, ...);
-STC_API intptr_t    cstr_printf(cstr* self, const char* fmt, ...);
-STC_API cstr        cstr_replace_sv(csview sv, csview search, csview repl, int32_t count);
+extern char*        cstr_reserve(cstr* self, intptr_t cap);
+extern void         cstr_shrink_to_fit(cstr* self);
+extern char*        cstr_resize(cstr* self, intptr_t size, char value);
+extern intptr_t     cstr_find_at(const cstr* self, intptr_t pos, const char* search);
+extern intptr_t     cstr_find_sv(const cstr* self, csview search);
+extern char*        cstr_assign_n(cstr* self, const char* str, intptr_t len);
+extern char*        cstr_append_n(cstr* self, const char* str, intptr_t len);
+extern bool         cstr_getdelim(cstr *self, int delim, FILE *fp);
+extern void         cstr_erase(cstr* self, intptr_t pos, intptr_t len);
+extern void         cstr_u8_erase(cstr* self, intptr_t bytepos, intptr_t u8len);
+extern cstr         cstr_from_fmt(const char* fmt, ...);
+extern intptr_t     cstr_append_fmt(cstr* self, const char* fmt, ...);
+extern intptr_t     cstr_printf(cstr* self, const char* fmt, ...);
+extern cstr         cstr_replace_sv(csview sv, csview search, csview repl, int32_t count);
+extern uint64_t     cstr_hash(const cstr *self);
 
 STC_INLINE cstr_buf cstr_buffer(cstr* s) {
     return cstr_is_long(s)
@@ -284,8 +282,6 @@ STC_INLINE intptr_t cstr_find(const cstr* self, const char* search) {
     return res ? (res - str) : c_NPOS;
 }
 
-STC_API intptr_t cstr_find_sv(const cstr* self, csview search);
-
 STC_INLINE intptr_t cstr_find_s(const cstr* self, cstr search)
     { return cstr_find(self, cstr_str(&search)); }
 
@@ -404,13 +400,15 @@ STC_INLINE void cstr_insert_s(cstr* self, intptr_t pos, cstr s) {
     cstr_replace_at_sv(self, pos, 0, sv);
 }
 
-
 STC_INLINE bool cstr_getline(cstr *self, FILE *fp)
     { return cstr_getdelim(self, '\n', fp); }
 
-STC_API uint64_t cstr_hash(const cstr *self);
+#endif // CSTR_H_INCLUDED
+
+/* -------------------------- EXTERN ------------------------- */
+#if defined(i_extern) && !defined(CSTR_X_INCLUDED)
+#define CSTR_X_INCLUDED
 
-#ifdef _i_extern
 static struct {
     int      (*conv_asc)(int);
     uint32_t (*conv_utf)(uint32_t);
@@ -439,23 +437,25 @@ cstr cstr_tocase(csview sv, int k) {
     cstr_shrink_to_fit(&out);
     return out;
 }
-#endif
+#endif // i_extern
 
 /* -------------------------- IMPLEMENTATION ------------------------- */
-#if defined(i_implement)
+#ifndef CSTR_C_INCLUDED
+#if defined i_extern || (defined i_implement && !defined _i_no_undef)
+#define CSTR_C_INCLUDED
 
-STC_DEF uint64_t cstr_hash(const cstr *self) {
+uint64_t cstr_hash(const cstr *self) {
     csview sv = cstr_sv(self);
     return cfasthash(sv.str, sv.size);
 }
 
-STC_DEF intptr_t cstr_find_sv(const cstr* self, csview search) {
+intptr_t cstr_find_sv(const cstr* self, csview search) {
     csview sv = cstr_sv(self);
     char* res = cstrnstrn(sv.str, search.str, sv.size, search.size);
     return res ? (res - sv.str) : c_NPOS;
 }
 
-STC_DEF char* _cstr_internal_move(cstr* self, const intptr_t pos1, const intptr_t pos2) {
+char* _cstr_internal_move(cstr* self, const intptr_t pos1, const intptr_t pos2) {
     cstr_buf r = cstr_buffer(self);
     if (pos1 != pos2) {
         const intptr_t newlen = (r.size + pos2 - pos1);
@@ -467,7 +467,7 @@ STC_DEF char* _cstr_internal_move(cstr* self, const intptr_t pos1, const intptr_
     return r.data;
 }
 
-STC_DEF char* _cstr_init(cstr* self, const intptr_t len, const intptr_t cap) {
+char* _cstr_init(cstr* self, const intptr_t len, const intptr_t cap) {
     if (cap > cstr_s_cap) { 
         self->lon.data = (char *)c_malloc(cap + 1);
         cstr_l_set_size(self, len);
@@ -478,7 +478,7 @@ STC_DEF char* _cstr_init(cstr* self, const intptr_t len, const intptr_t cap) {
     return self->sml.data;
 }
 
-STC_DEF void cstr_shrink_to_fit(cstr* self) {
+void cstr_shrink_to_fit(cstr* self) {
     cstr_buf r = cstr_buffer(self);
     if (r.size == r.cap)
         return;
@@ -492,7 +492,7 @@ STC_DEF void cstr_shrink_to_fit(cstr* self) {
     }
 }
 
-STC_DEF char* cstr_reserve(cstr* self, const intptr_t cap) {
+char* cstr_reserve(cstr* self, const intptr_t cap) {
     if (cstr_is_long(self)) {
         if (cap > cstr_l_cap(self)) {
             self->lon.data = (char *)c_realloc(self->lon.data, cap + 1);
@@ -505,7 +505,7 @@ STC_DEF char* cstr_reserve(cstr* self, const intptr_t cap) {
         char* data = (char *)c_malloc(cap + 1);
         const intptr_t len = cstr_s_size(self);
         /* copy full short buffer to emulate realloc() */
-        c_memcpy(data, self->sml.data, cstr_s_cap + 2);
+        c_memcpy(data, self->sml.data, sizeof self->sml);
         self->lon.data = data;
         self->lon.size = (size_t)len;
         cstr_l_set_cap(self, cap);
@@ -514,7 +514,7 @@ STC_DEF char* cstr_reserve(cstr* self, const intptr_t cap) {
     return self->sml.data;
 }
 
-STC_DEF char* cstr_resize(cstr* self, const intptr_t size, const char value) {
+char* cstr_resize(cstr* self, const intptr_t size, const char value) {
     cstr_buf r = cstr_buffer(self);
     if (size > r.size) {
         if (size > r.cap && !(r.data = cstr_reserve(self, size)))
@@ -525,20 +525,20 @@ STC_DEF char* cstr_resize(cstr* self, const intptr_t size, const char value) {
     return r.data;
 }
 
-STC_DEF intptr_t cstr_find_at(const cstr* self, const intptr_t pos, const char* search) {
+intptr_t cstr_find_at(const cstr* self, const intptr_t pos, const char* search) {
     csview sv = cstr_sv(self);
     if (pos > sv.size) return c_NPOS;
     const char* res = strstr((char*)sv.str + pos, search);
     return res ? (res - sv.str) : c_NPOS;
 }
 
-STC_DEF char* cstr_assign_n(cstr* self, const char* str, const intptr_t len) {
+char* cstr_assign_n(cstr* self, const char* str, const intptr_t len) {
     char* d = cstr_reserve(self, len);
     if (d) { c_memmove(d, str, len); _cstr_set_size(self, len); }
     return d;
 }
 
-STC_DEF char* cstr_append_n(cstr* self, const char* str, const intptr_t len) {
+char* cstr_append_n(cstr* self, const char* str, const intptr_t len) {
     cstr_buf r = cstr_buffer(self);
     if (r.size + len > r.cap) {
         const size_t off = (size_t)(str - r.data);
@@ -551,7 +551,7 @@ STC_DEF char* cstr_append_n(cstr* self, const char* str, const intptr_t len) {
     return r.data;
 }
 
-STC_DEF bool cstr_getdelim(cstr *self, const int delim, FILE *fp) {
+bool cstr_getdelim(cstr *self, const int delim, FILE *fp) {
     int c = fgetc(fp);
     if (c == EOF)
         return false;
@@ -571,7 +571,7 @@ STC_DEF bool cstr_getdelim(cstr *self, const int delim, FILE *fp) {
     }
 }
 
-STC_DEF cstr
+cstr
 cstr_replace_sv(csview in, csview search, csview repl, int32_t count) {
     cstr out = cstr_NULL;
     intptr_t from = 0; char* res;
@@ -587,14 +587,14 @@ cstr_replace_sv(csview in, csview search, csview repl, int32_t count) {
     return out;
 }
 
-STC_DEF void cstr_erase(cstr* self, const intptr_t pos, intptr_t len) {
+void cstr_erase(cstr* self, const intptr_t pos, intptr_t len) {
     cstr_buf r = cstr_buffer(self);
     if (len > r.size - pos) len = r.size - pos;
     c_memmove(&r.data[pos], &r.data[pos + len], r.size - (pos + len));
     _cstr_set_size(self, r.size - len);
 }
 
-STC_DEF void cstr_u8_erase(cstr* self, const intptr_t bytepos, const intptr_t u8len) {
+void cstr_u8_erase(cstr* self, const intptr_t bytepos, const intptr_t u8len) {
     cstr_buf r = cstr_buffer(self);
     intptr_t len = utf8_pos(r.data + bytepos, u8len);
     c_memmove(&r.data[bytepos], &r.data[bytepos + len], r.size - (bytepos + len));
@@ -609,7 +609,7 @@ STC_DEF void cstr_u8_erase(cstr* self, const intptr_t bytepos, const intptr_t u8
 #  pragma warning(disable: 4996)
 #endif
 
-STC_DEF intptr_t cstr_vfmt(cstr* self, intptr_t start, const char* fmt, va_list args) {
+intptr_t cstr_vfmt(cstr* self, intptr_t start, const char* fmt, va_list args) {
     va_list args2;
     va_copy(args2, args);
     const int n = vsnprintf(NULL, 0ULL, fmt, args);
@@ -624,7 +624,7 @@ STC_DEF intptr_t cstr_vfmt(cstr* self, intptr_t start, const char* fmt, va_list
 #  pragma warning(pop)
 #endif
 
-STC_DEF cstr cstr_from_fmt(const char* fmt, ...) {
+cstr cstr_from_fmt(const char* fmt, ...) {
     cstr s = cstr_NULL;
     va_list args;
     va_start(args, fmt);
@@ -633,7 +633,7 @@ STC_DEF cstr cstr_from_fmt(const char* fmt, ...) {
     return s;
 }
 
-STC_DEF intptr_t cstr_append_fmt(cstr* self, const char* fmt, ...) {
+intptr_t cstr_append_fmt(cstr* self, const char* fmt, ...) {
     va_list args;
     va_start(args, fmt);
     const intptr_t n = cstr_vfmt(self, cstr_size(self), fmt, args);
@@ -642,21 +642,21 @@ STC_DEF intptr_t cstr_append_fmt(cstr* self, const char* fmt, ...) {
 }
 
 /* NB! self-data in args is UB */
-STC_DEF intptr_t cstr_printf(cstr* self, const char* fmt, ...) {
+intptr_t cstr_printf(cstr* self, const char* fmt, ...) {
     va_list args;
     va_start(args, fmt);
     const intptr_t n = cstr_vfmt(self, 0, fmt, args);
     va_end(args);
     return n;
 }
-
 #endif // i_implement
+#endif // CSTR_C_INCLUDED
+
 #if defined __GNUC__ && !defined __clang__
 #  pragma GCC diagnostic pop
 #endif
-#endif // CSTR_H_INCLUDED
 #undef i_opt
 #undef i_header
 #undef i_static
 #undef i_implement
-#undef _i_extern
+#undef i_extern
diff --git a/include/stc/csview.h b/include/stc/csview.h
index e8a3ad9b..d38d5f59 100644
--- a/include/stc/csview.h
+++ b/include/stc/csview.h
@@ -20,12 +20,12 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
+#define _i_no_undef
+#include "utf8.h"
+
 #ifndef CSVIEW_H_INCLUDED
 #define CSVIEW_H_INCLUDED
 
-#include "ccommon.h"
-#include "utf8.h"
-
 #define             csview_NULL c_sv_1("")
 #define             csview_init() csview_NULL
 #define             csview_drop(p) c_default_drop(p)
@@ -33,12 +33,12 @@
 #define             csview_lit(literal) c_sv_1(literal)
 #define             csview_from_n(str, n) c_sv_2(str, n)
 
-STC_API csview_iter csview_advance(csview_iter it, intptr_t pos);
-STC_API intptr_t    csview_find_sv(csview sv, csview search);
-STC_API uint64_t    csview_hash(const csview *self);
-STC_API csview      csview_slice_ex(csview sv, intptr_t p1, intptr_t p2);
-STC_API csview      csview_substr_ex(csview sv, intptr_t pos, intptr_t n);
-STC_API csview      csview_token(csview sv, const char* sep, intptr_t* start);
+extern csview_iter  csview_advance(csview_iter it, intptr_t pos);
+extern intptr_t     csview_find_sv(csview sv, csview search);
+extern uint64_t     csview_hash(const csview *self);
+extern csview       csview_slice_ex(csview sv, intptr_t p1, intptr_t p2);
+extern csview       csview_substr_ex(csview sv, intptr_t pos, intptr_t n);
+extern csview       csview_token(csview sv, const char* sep, intptr_t* start);
 
 STC_INLINE csview   csview_from(const char* str)
                         { return c_LITERAL(csview){str, c_strlen(str)}; }
@@ -147,10 +147,14 @@ STC_INLINE int csview_icmp(const csview* x, const csview* y)
 STC_INLINE bool csview_eq(const csview* x, const csview* y)
     { return x->size == y->size && !c_memcmp(x->str, y->str, x->size); }
 
+#endif // CSVIEW_H_INCLUDED
+
 /* -------------------------- IMPLEMENTATION ------------------------- */
-#if defined(i_implement)
+#ifndef CSVIEW_C_INCLUDED
+#if defined i_extern || (defined i_implement && !defined _i_no_undef)
+#define CSVIEW_C_INCLUDED
 
-STC_DEF csview_iter csview_advance(csview_iter it, intptr_t pos) {
+csview_iter csview_advance(csview_iter it, intptr_t pos) {
     int inc = -1;
     if (pos > 0) pos = -pos, inc = 1;
     while (pos && it.ref != it.u8.end) pos += (*(it.ref += inc) & 0xC0) != 0x80;
@@ -159,15 +163,15 @@ STC_DEF csview_iter csview_advance(csview_iter it, intptr_t pos) {
     return it;
 }
 
-STC_DEF intptr_t csview_find_sv(csview sv, csview search) {
+intptr_t csview_find_sv(csview sv, csview search) {
     char* res = cstrnstrn(sv.str, search.str, sv.size, search.size);
     return res ? (res - sv.str) : c_NPOS;
 }
 
-STC_DEF uint64_t csview_hash(const csview *self)
+uint64_t csview_hash(const csview *self)
     { return cfasthash(self->str, self->size); }
 
-STC_DEF csview csview_substr_ex(csview sv, intptr_t pos, intptr_t n) {
+csview csview_substr_ex(csview sv, intptr_t pos, intptr_t n) {
     if (pos < 0) { 
         pos += sv.size;
         if (pos < 0) pos = 0;
@@ -178,7 +182,7 @@ STC_DEF csview csview_substr_ex(csview sv, intptr_t pos, intptr_t n) {
     return sv;
 }
 
-STC_DEF csview csview_slice_ex(csview sv, intptr_t p1, intptr_t p2) {
+csview csview_slice_ex(csview sv, intptr_t p1, intptr_t p2) {
     if (p1 < 0) { 
         p1 += sv.size;
         if (p1 < 0) p1 = 0;
@@ -189,7 +193,7 @@ STC_DEF csview csview_slice_ex(csview sv, intptr_t p1, intptr_t p2) {
     return sv;
 }
 
-STC_DEF csview csview_token(csview sv, const char* sep, intptr_t* start) {
+csview csview_token(csview sv, const char* sep, intptr_t* start) {
     intptr_t sep_size = c_strlen(sep);
     csview slice = {sv.str + *start, sv.size - *start};
     const char* res = cstrnstrn(slice.str, sep, slice.size, sep_size);
diff --git a/include/stc/cvec.h b/include/stc/cvec.h
index 512dbf67..747c654d 100644
--- a/include/stc/cvec.h
+++ b/include/stc/cvec.h
@@ -264,7 +264,7 @@ _cx_memb(_sort)(_cx_self* self) {
 }
 #endif // !c_no_cmp
 /* -------------------------- IMPLEMENTATION ------------------------- */
-#if defined(i_implement)
+#if defined(i_implement) || defined(i_static)
 
 STC_DEF _cx_self
 _cx_memb(_init)(void) {
diff --git a/include/stc/forward.h b/include/stc/forward.h
index 9eafb857..484a8b63 100644
--- a/include/stc/forward.h
+++ b/include/stc/forward.h
@@ -24,6 +24,7 @@
 #define STC_FORWARD_H_INCLUDED
 
 #include <stdint.h>
+#include <stddef.h>
 
 #define forward_carc(CX, VAL) _c_carc_types(CX, VAL)
 #define forward_cbox(CX, VAL) _c_cbox_types(CX, VAL)
diff --git a/include/stc/utf8.h b/include/stc/utf8.h
index a4cc3846..338f0db9 100644
--- a/include/stc/utf8.h
+++ b/include/stc/utf8.h
@@ -1,3 +1,4 @@
+
 #ifndef UTF8_H_INCLUDED
 #define UTF8_H_INCLUDED
 
@@ -5,7 +6,6 @@
 #include "forward.h"
 #include "ccommon.h"
 
-// utf8 methods defined in src/utf8code.c:
 enum {
     U8G_Cc, U8G_Lt, U8G_Nd, U8G_Nl,
     U8G_Pc, U8G_Pd, U8G_Pf, U8G_Pi,
@@ -16,6 +16,7 @@ enum {
     U8G_SIZE
 };
 
+// utf8 methods defined in src/utf8code.c:
 extern bool     utf8_isgroup(int group, uint32_t c); 
 extern bool     utf8_isalpha(uint32_t c);
 extern uint32_t utf8_casefold(uint32_t c);
@@ -112,9 +113,16 @@ STC_INLINE const char* utf8_at(const char *s, intptr_t index) {
 
 STC_INLINE intptr_t utf8_pos(const char* s, intptr_t index)
     { return (intptr_t)(utf8_at(s, index) - s); }
-
 #endif // UTF8_H_INCLUDED
-#if defined(i_extern)
+
+#if defined i_extern || (defined i_implement && !defined _i_no_undef)
 #  include "../../src/utf8code.c"
-#  undef i_extern
 #endif
+#ifndef _i_no_undef
+#undef i_static
+#undef i_header
+#undef i_implement
+#undef i_extern
+#undef i_opt
+#endif
+#undef _i_no_undef
diff --git a/misc/examples/arc_containers.c b/misc/examples/arc_containers.c
index d6a0afa8..7038734e 100644
--- a/misc/examples/arc_containers.c
+++ b/misc/examples/arc_containers.c
@@ -1,6 +1,6 @@
 // Create a stack and a list of shared pointers to maps,
 // and demonstrate sharing and cloning of maps.
-#define i_static
+#define i_implement
 #include <stc/cstr.h>
 #include <stc/algo/raii.h>
 #define i_type Map
diff --git a/misc/examples/astar.c b/misc/examples/astar.c
index dae6d609..db6bbd70 100644
--- a/misc/examples/astar.c
+++ b/misc/examples/astar.c
@@ -4,6 +4,7 @@
 // This is a reimplementation of the CTL example to STC:
 //     https://github.com/glouw/ctl/blob/master/examples/astar.c
 //     https://www.redblobgames.com/pathfinding/a-star/introduction.html
+#define i_implement
 #include <stc/cstr.h>
 #include <stc/algo/raii.h>
 #include <stdio.h>
diff --git a/misc/examples/books.c b/misc/examples/books.c
index a62769b0..7f0660b8 100644
--- a/misc/examples/books.c
+++ b/misc/examples/books.c
@@ -1,4 +1,5 @@
 // https://doc.rust-lang.org/std/collections/struct.HashMap.html
+#define i_implement
 #include <stc/cstr.h>
 #define i_key_str
 #define i_val_str
diff --git a/misc/examples/box.c b/misc/examples/box.c
index 9954883c..e352aa2b 100644
--- a/misc/examples/box.c
+++ b/misc/examples/box.c
@@ -1,4 +1,5 @@
 /* cbox: heap allocated boxed type */
+#define i_implement
 #include <stc/cstr.h>
 
 typedef struct { cstr name, last; } Person;
diff --git a/misc/examples/complex.c b/misc/examples/complex.c
index c730db33..2d8dbf62 100644
--- a/misc/examples/complex.c
+++ b/misc/examples/complex.c
@@ -5,10 +5,9 @@
 // using StackList = std::stack<FloatStack>;
 // using ListMap = std::unordered_map<int, std::forward_list<StackList>>;
 // using MapMap = std::unordered_map<std::string, ListMap>;
-
+#define i_implement
 #include <stc/cstr.h>
 
-
 #define i_type FloatStack
 #define i_val float
 #include <stc/cstack.h>
diff --git a/misc/examples/convert.c b/misc/examples/convert.c
index c5649c55..318f09b8 100644
--- a/misc/examples/convert.c
+++ b/misc/examples/convert.c
@@ -1,3 +1,4 @@
+#define i_implement
 #include <stc/cstr.h>
 #include <stc/algo/raii.h>
 
@@ -9,7 +10,6 @@
 #include <stc/cvec.h>
 
 #define i_val_str
-#define i_extern // define _clist_mergesort() once
 #include <stc/clist.h>
 
 int main()
diff --git a/misc/examples/coread.c b/misc/examples/coread.c
index 2585fb81..63162ba3 100644
--- a/misc/examples/coread.c
+++ b/misc/examples/coread.c
@@ -1,4 +1,4 @@
-#define i_static
+#define i_implement
 #include <stc/cstr.h>
 #include <stc/algo/coroutine.h>
 #include <errno.h>
diff --git a/misc/examples/csmap_erase.c b/misc/examples/csmap_erase.c
index 568dae29..9433d370 100644
--- a/misc/examples/csmap_erase.c
+++ b/misc/examples/csmap_erase.c
@@ -1,5 +1,6 @@
 // map_erase.c
 // From C++ example: https://docs.microsoft.com/en-us/cpp/standard-library/map-class?view=msvc-160#example-16
+#define i_implement
 #include <stc/cstr.h>
 #include <stdio.h>
 
diff --git a/misc/examples/csmap_find.c b/misc/examples/csmap_find.c
index 92dd0031..a8928410 100644
--- a/misc/examples/csmap_find.c
+++ b/misc/examples/csmap_find.c
@@ -1,5 +1,6 @@
 // This implements the c++ std::map::find example at:
 // https://docs.microsoft.com/en-us/cpp/standard-library/map-class?view=msvc-160#example-17
+#define i_implement
 #include <stc/cstr.h>
 
 #define i_key int
diff --git a/misc/examples/csmap_insert.c b/misc/examples/csmap_insert.c
index 7708fdc9..f96cc08f 100644
--- a/misc/examples/csmap_insert.c
+++ b/misc/examples/csmap_insert.c
@@ -5,6 +5,7 @@
 #define i_tag ii  // Map of int => int
 #include <stc/csmap.h>
 
+#define i_implement
 #include <stc/cstr.h>
 #define i_key int
 #define i_val_str
diff --git a/misc/examples/cstr_match.c b/misc/examples/cstr_match.c
index 58cf8884..10a843cf 100644
--- a/misc/examples/cstr_match.c
+++ b/misc/examples/cstr_match.c
@@ -1,3 +1,4 @@
+#define i_implement
 #include <stc/cstr.h>
 #include <stc/csview.h>
 #include <stdio.h>
diff --git a/misc/examples/demos.c b/misc/examples/demos.c
index de92e378..8488dfb9 100644
--- a/misc/examples/demos.c
+++ b/misc/examples/demos.c
@@ -1,3 +1,4 @@
+#define i_implement
 #include <stc/cstr.h>
 
 void stringdemo1()
diff --git a/misc/examples/forfilter.c b/misc/examples/forfilter.c
index 8ea3e6a1..f9505aa9 100644
--- a/misc/examples/forfilter.c
+++ b/misc/examples/forfilter.c
@@ -1,6 +1,7 @@
 #include <stdio.h>
 #define i_extern
 #include <stc/cstr.h>
+#define i_implement
 #include <stc/csview.h>
 #include <stc/algo/filter.h>
 #include <stc/algo/crange.h>
diff --git a/misc/examples/gauss2.c b/misc/examples/gauss2.c
index e786824b..67586181 100644
--- a/misc/examples/gauss2.c
+++ b/misc/examples/gauss2.c
@@ -1,8 +1,9 @@
 #include <stdio.h>
 #include <time.h>
 
-#include <stc/crand.h>
+#define i_implement
 #include <stc/cstr.h>
+#include <stc/crand.h>
 
 // Declare int -> int sorted map.
 #define i_key int
diff --git a/misc/examples/hashmap.c b/misc/examples/hashmap.c
index 47a3bcff..cf11b7f7 100644
--- a/misc/examples/hashmap.c
+++ b/misc/examples/hashmap.c
@@ -1,4 +1,5 @@
 // https://doc.rust-lang.org/rust-by-example/std/hash.html
+#define i_implement
 #include <stc/cstr.h>
 #define i_key_str
 #define i_val_str
diff --git a/misc/examples/inits.c b/misc/examples/inits.c
index 1f01f88a..a3a6c4d2 100644
--- a/misc/examples/inits.c
+++ b/misc/examples/inits.c
@@ -1,3 +1,4 @@
+#define i_implement
 #include <stc/cstr.h>
 
 #define i_key int
@@ -25,7 +26,6 @@ inline static int ipair_cmp(const ipair_t* a, const ipair_t* b) {
 #define i_val ipair_t
 #define i_cmp ipair_cmp
 #define i_tag ip
-#define i_extern // define _clist_mergesort() once
 #include <stc/clist.h>
 
 #define i_val float
diff --git a/misc/examples/list_splice.c b/misc/examples/list_splice.c
index 73015454..e457694d 100644
--- a/misc/examples/list_splice.c
+++ b/misc/examples/list_splice.c
@@ -2,7 +2,6 @@
 
 #define i_val int
 #define i_tag i
-#define i_extern // define _clist_mergesort() once
 #include <stc/clist.h>
 
 void print_ilist(const char* s, clist_i list)
diff --git a/misc/examples/make.sh b/misc/examples/make.sh
index d58ed0cb..61d9f879 100755
--- a/misc/examples/make.sh
+++ b/misc/examples/make.sh
@@ -6,7 +6,7 @@ if [ "$(uname)" = 'Linux' ]; then
     oflag='-o '
 fi
 
-cc=gcc; cflags="-DSTC_STATIC -std=c99 -s -O3 -Wall -Wextra -Wpedantic -Wconversion -Wwrite-strings -Wdouble-promotion -Wno-unused-parameter -Wno-maybe-uninitialized -Wno-implicit-fallthrough -Wno-missing-field-initializers"
+cc=gcc; cflags="-std=c99 -s -O3 -Wall -Wextra -Wpedantic -Wconversion -Wwrite-strings -Wdouble-promotion -Wno-unused-parameter -Wno-maybe-uninitialized -Wno-implicit-fallthrough -Wno-missing-field-initializers"
 #cc=gcc; cflags="-DSTC_STATIC -std=c99 -g -Werror -Wfatal-errors -Wpedantic -Wall $sanitize"
 #cc=tcc; cflags="-DSTC_STATIC -std=c99 -Wall"
 #cc=clang; cflags="-DSTC_STATIC -std=c99 -s -O3 -Wall -Wextra -Wpedantic -Wconversion -Wwrite-strings -Wdouble-promotion -Wno-unused-parameter -Wno-unused-function -Wno-implicit-fallthrough -Wno-missing-field-initializers"
diff --git a/misc/examples/mapmap.c b/misc/examples/mapmap.c
index 668da5de..d3065659 100644
--- a/misc/examples/mapmap.c
+++ b/misc/examples/mapmap.c
@@ -1,5 +1,5 @@
 // create a structure like: std::map<std::string, std::map<std::string, std::string>>:
-
+#define i_implement
 #include <stc/cstr.h>
 
 // People: std::map<std::string, std::string>
diff --git a/misc/examples/mmap.c b/misc/examples/mmap.c
index 0394a2df..63312e04 100644
--- a/misc/examples/mmap.c
+++ b/misc/examples/mmap.c
@@ -2,6 +2,7 @@
 // https://en.cppreference.com/w/cpp/container/multimap/insert
 
 // Multimap entries
+#define i_implement
 #include <stc/cstr.h>
 #define i_val_str
 #include <stc/clist.h>
diff --git a/misc/examples/multimap.c b/misc/examples/multimap.c
index d8981a81..dc4a1ee0 100644
--- a/misc/examples/multimap.c
+++ b/misc/examples/multimap.c
@@ -1,3 +1,4 @@
+#define i_implement
 #include <stc/cstr.h>
 
 // Olympics multimap example
diff --git a/misc/examples/music_arc.c b/misc/examples/music_arc.c
index 87a57783..9c7173ef 100644
--- a/misc/examples/music_arc.c
+++ b/misc/examples/music_arc.c
@@ -1,5 +1,6 @@
 // shared_ptr-examples.cpp
 // based on https://docs.microsoft.com/en-us/cpp/cpp/how-to-create-and-use-shared-ptr-instances?view=msvc-160
+#define i_implement
 #include <stc/cstr.h>
 
 typedef struct
diff --git a/misc/examples/new_map.c b/misc/examples/new_map.c
index 1f50db83..277bcbc2 100644
--- a/misc/examples/new_map.c
+++ b/misc/examples/new_map.c
@@ -1,3 +1,4 @@
+#define i_implement
 #include <stc/cstr.h>
 #include <stc/forward.h>
 
diff --git a/misc/examples/new_smap.c b/misc/examples/new_smap.c
index 2eaae836..77c4cdce 100644
--- a/misc/examples/new_smap.c
+++ b/misc/examples/new_smap.c
@@ -1,3 +1,4 @@
+#define i_implement
 #include <stc/cstr.h>
 #include <stc/forward.h>
 
diff --git a/misc/examples/new_sptr.c b/misc/examples/new_sptr.c
index 1b72e4f5..aa8dd175 100644
--- a/misc/examples/new_sptr.c
+++ b/misc/examples/new_sptr.c
@@ -1,3 +1,4 @@
+#define i_implement
 #include <stc/cstr.h>
 
 typedef struct { cstr name, last; } Person;
diff --git a/misc/examples/person_arc.c b/misc/examples/person_arc.c
index c931089d..b4b926da 100644
--- a/misc/examples/person_arc.c
+++ b/misc/examples/person_arc.c
@@ -1,4 +1,5 @@
 /* cbox: heap allocated boxed type */
+#define i_implement
 #include <stc/cstr.h>
 #include <stc/algo/raii.h>
 
diff --git a/misc/examples/phonebook.c b/misc/examples/phonebook.c
index 38a71089..faf7566e 100644
--- a/misc/examples/phonebook.c
+++ b/misc/examples/phonebook.c
@@ -20,7 +20,7 @@
 // IN THE SOFTWARE.
 
 // Program to emulates the phone book.
-
+#define i_implement
 #include <stc/cstr.h>
 
 #define i_key_str
diff --git a/misc/examples/printspan.c b/misc/examples/printspan.c
index b9ec2476..b5099ed5 100644
--- a/misc/examples/printspan.c
+++ b/misc/examples/printspan.c
@@ -1,6 +1,7 @@
 // printspan.c
 
 #include <stdio.h>
+#define i_implement
 #include <stc/cstr.h>
 #define i_val int
 #include <stc/cvec.h>
diff --git a/misc/examples/rawptr_elements.c b/misc/examples/rawptr_elements.c
index 01bcdc44..8dd52aee 100644
--- a/misc/examples/rawptr_elements.c
+++ b/misc/examples/rawptr_elements.c
@@ -1,6 +1,6 @@
 #include <stc/ccommon.h>
 #include <stdio.h>
-
+#define i_implement
 #include <stc/cstr.h>
 
 // Create cmap of cstr => long*
diff --git a/misc/examples/read.c b/misc/examples/read.c
index edc89f0e..545d706a 100644
--- a/misc/examples/read.c
+++ b/misc/examples/read.c
@@ -1,3 +1,4 @@
+#define i_implement
 #include <stc/cstr.h>
 #include <stc/algo/raii.h>
 #define i_val_str
diff --git a/misc/examples/regex_match.c b/misc/examples/regex_match.c
index e49ebd0b..b4932015 100644
--- a/misc/examples/regex_match.c
+++ b/misc/examples/regex_match.c
@@ -1,5 +1,6 @@
 #define i_extern
 #include <stc/cregex.h>
+#define i_implement
 #include <stc/csview.h>
 
 #define i_val float
diff --git a/misc/examples/replace.c b/misc/examples/replace.c
index cf5b45cb..9ac26c07 100644
--- a/misc/examples/replace.c
+++ b/misc/examples/replace.c
@@ -1,3 +1,4 @@
+#define i_implement
 #include <stc/cstr.h>
 
 int main ()
diff --git a/misc/examples/splitstr.c b/misc/examples/splitstr.c
index 2bc6fc07..658c46a1 100644
--- a/misc/examples/splitstr.c
+++ b/misc/examples/splitstr.c
@@ -1,6 +1,7 @@
 #include <stdio.h>
 #define i_extern // cstr + utf8 functions
 #include <stc/cregex.h>
+#define i_implement
 #include <stc/csview.h>
 
 int main()
diff --git a/misc/examples/sso_map.c b/misc/examples/sso_map.c
index 70450e21..b78dcb2e 100644
--- a/misc/examples/sso_map.c
+++ b/misc/examples/sso_map.c
@@ -1,3 +1,4 @@
+#define i_implement
 #include <stc/cstr.h>
 #define i_key_str
 #define i_val_str
diff --git a/misc/examples/sso_substr.c b/misc/examples/sso_substr.c
index 4b2dbcc8..9b062eed 100644
--- a/misc/examples/sso_substr.c
+++ b/misc/examples/sso_substr.c
@@ -1,4 +1,6 @@
+#define i_implement
 #include <stc/cstr.h>
+#define i_implement
 #include <stc/csview.h>
 
 int main ()
diff --git a/misc/examples/sview_split.c b/misc/examples/sview_split.c
index 31a28e51..782e4096 100644
--- a/misc/examples/sview_split.c
+++ b/misc/examples/sview_split.c
@@ -1,4 +1,6 @@
+#define i_implement
 #include <stc/cstr.h>
+#define i_implement
 #include <stc/csview.h>
 
 int  main()
diff --git a/misc/examples/unordered_set.c b/misc/examples/unordered_set.c
index 90c78521..006a1e80 100644
--- a/misc/examples/unordered_set.c
+++ b/misc/examples/unordered_set.c
@@ -1,5 +1,6 @@
 // https://iq.opengenus.org/containers-cpp-stl/
 // C program to demonstrate various function of stc cset
+#define i_implement
 #include <stc/cstr.h>
 #include <stc/algo/raii.h>
 #define i_key_str
diff --git a/misc/examples/utf8replace_c.c b/misc/examples/utf8replace_c.c
index 3cde8701..17352fee 100644
--- a/misc/examples/utf8replace_c.c
+++ b/misc/examples/utf8replace_c.c
@@ -1,3 +1,4 @@
+#define i_implement
 #include <stc/cstr.h>
 
 int main()
diff --git a/misc/examples/vikings.c b/misc/examples/vikings.c
index abb909c3..cf087119 100644
--- a/misc/examples/vikings.c
+++ b/misc/examples/vikings.c
@@ -1,3 +1,4 @@
+#define i_implement
 #include <stc/cstr.h>
 
 typedef struct Viking {
diff --git a/src/cregex.c b/src/cregex.c
index 730d35a4..62a64b11 100644
--- a/src/cregex.c
+++ b/src/cregex.c
@@ -25,9 +25,24 @@ THE SOFTWARE.
 */
 #ifndef CREGEX_C_INCLUDED
 #define CREGEX_C_INCLUDED
-#include <stc/cstr.h>
-#include <stc/cregex.h> // header only
+
 #include <setjmp.h>
+#ifdef i_extern
+#  define _i_extern
+#endif
+#ifndef CREGEX_H_INCLUDED
+#  include "../include/stc/cregex.h"
+#endif
+#ifdef _i_extern
+#  include "utf8code.c"
+#endif
+#ifdef _i_extern
+#  define i_implement
+#else
+#  undef i_implement
+#endif
+#undef _i_extern
+#include "../include/stc/cstr.h"
 
 typedef uint32_t _Rune; /* Utf8 code point */
 typedef int32_t _Token;
diff --git a/src/libstc.c b/src/libstc.c
index bc61e37c..99611e05 100644
--- a/src/libstc.c
+++ b/src/libstc.c
@@ -1,4 +1,16 @@
+#include <stddef.h>
+#if 1
+#define i_extern
+#include "../include/stc/utf8.h"
+#define i_implement
+#include "../include/stc/cstr.h"
+#define i_implement
+#include "../include/stc/cregex.h"
+#define i_implement
+#include "../include/stc/csview.h"
+#else
 #define i_extern
 #include "../include/stc/cregex.h"
 #define i_implement
 #include "../include/stc/csview.h"
+#endif
diff --git a/src/utf8code.c b/src/utf8code.c
index 496f5eef..6a133050 100644
--- a/src/utf8code.c
+++ b/src/utf8code.c
@@ -1,6 +1,9 @@
 #ifndef UTF8_C_INCLUDED
 #define UTF8_C_INCLUDED
-#include <stc/utf8.h> // header only
+
+#ifndef UTF8_H_INCLUDED
+#include "../include/stc/utf8.h" /* header only */
+#endif
 #include "utf8tabs.inc"
 
 const uint8_t utf8_dtab[] = {
-- 
cgit v1.2.3


From 3a26c8fe4bce8a3af62042dd0fca5f36221359a9 Mon Sep 17 00:00:00 2001
From: Tyge Løvset <tylo@norceresearch.no>
Date: Fri, 7 Jul 2023 17:21:22 +0200
Subject: Issue #62: Fixed wrong printf format specifiers. Changed cbits.h to
 use long long (guaranteed at least 64-bit) instead of int64_t for easier
 print.

Second part of #62 is due to a clang compiler bug, can be avoided by using c_foreach instead of c_forpair.
---
 include/stc/cbits.h   | 76 +++++++++++++++++++++++++--------------------------
 include/stc/ccommon.h |  5 ++--
 misc/examples/bits.c  | 12 ++++----
 misc/examples/bits2.c |  4 +--
 4 files changed, 49 insertions(+), 48 deletions(-)

(limited to 'include/stc/cbits.h')

diff --git a/include/stc/cbits.h b/include/stc/cbits.h
index 8a6558bf..9463c82c 100644
--- a/include/stc/cbits.h
+++ b/include/stc/cbits.h
@@ -31,7 +31,7 @@ int main() {
     cbits_reset(&bset, 9);
     cbits_resize(&bset, 43, false);
 
-    printf("%4zu: ", cbits_size(&bset));
+    printf("%4lld: ", cbits_size(&bset));
     c_forrange (i, cbits_size(&bset))
         printf("%d", cbits_at(&bset, i));
     puts("");
@@ -41,7 +41,7 @@ int main() {
     cbits_resize(&bset, 102, true);
     cbits_set_value(&bset, 99, false);
 
-    printf("%4zu: ", cbits_size(&bset));
+    printf("%4lld: ", cbits_size(&bset));
     c_forrange (i, cbits_size(&bset))
         printf("%d", cbits_at(&bset, i));
     puts("");
@@ -55,7 +55,7 @@ int main() {
 #include <string.h>
 
 #define _cbits_bit(i) ((uint64_t)1 << ((i) & 63))
-#define _cbits_words(n) (int64_t)(((n) + 63)>>6)
+#define _cbits_words(n) (_llong)(((n) + 63)>>6)
 #define _cbits_bytes(n) (_cbits_words(n) * c_sizeof(uint64_t))
 
 #if defined(__GNUC__)
@@ -77,23 +77,23 @@ int main() {
     }
 #endif
 
-STC_INLINE int64_t _cbits_count(const uint64_t* set, const int64_t sz) {
-    const int64_t n = sz>>6;
-    int64_t count = 0;
-    for (int64_t i = 0; i < n; ++i)
+STC_INLINE _llong _cbits_count(const uint64_t* set, const _llong sz) {
+    const _llong n = sz>>6;
+    _llong count = 0;
+    for (_llong i = 0; i < n; ++i)
         count += cpopcount64(set[i]);
     if (sz & 63)
         count += cpopcount64(set[n] & (_cbits_bit(sz) - 1));
     return count;
 }
 
-STC_INLINE char* _cbits_to_str(const uint64_t* set, const int64_t sz, 
-                               char* out, int64_t start, int64_t stop) {
+STC_INLINE char* _cbits_to_str(const uint64_t* set, const _llong sz, 
+                               char* out, _llong start, _llong stop) {
     if (stop > sz) stop = sz;
     assert(start <= stop);
 
     c_memset(out, '0', stop - start);
-    for (int64_t i = start; i < stop; ++i) 
+    for (_llong i = start; i < stop; ++i) 
         if ((set[i>>6] & _cbits_bit(i)) != 0)
             out[i - start] = '1';
     out[stop - start] = '\0';
@@ -101,8 +101,8 @@ STC_INLINE char* _cbits_to_str(const uint64_t* set, const int64_t sz,
 }
 
 #define _cbits_OPR(OPR, VAL) \
-    const int64_t n = sz>>6; \
-    for (int64_t i = 0; i < n; ++i) \
+    const _llong n = sz>>6; \
+    for (_llong i = 0; i < n; ++i) \
         if ((set[i] OPR other[i]) != VAL) \
             return false; \
     if (!(sz & 63)) \
@@ -110,10 +110,10 @@ STC_INLINE char* _cbits_to_str(const uint64_t* set, const int64_t sz,
     const uint64_t i = (uint64_t)n, m = _cbits_bit(sz) - 1; \
     return ((set[i] OPR other[i]) & m) == (VAL & m)
 
-STC_INLINE bool _cbits_subset_of(const uint64_t* set, const uint64_t* other, const int64_t sz)
+STC_INLINE bool _cbits_subset_of(const uint64_t* set, const uint64_t* other, const _llong sz)
     { _cbits_OPR(|, set[i]); }
 
-STC_INLINE bool _cbits_disjoint(const uint64_t* set, const uint64_t* other, const int64_t sz)
+STC_INLINE bool _cbits_disjoint(const uint64_t* set, const uint64_t* other, const _llong sz)
     { _cbits_OPR(&, 0); }
 
 #endif // CBITS_H_INCLUDED
@@ -125,11 +125,11 @@ STC_INLINE bool _cbits_disjoint(const uint64_t* set, const uint64_t* other, cons
 #define _i_assert(x) assert(x)
 #define i_type cbits
 
-typedef struct { uint64_t *data64; int64_t _size; } i_type;
+typedef struct { uint64_t *data64; _llong _size; } i_type;
 
 STC_INLINE cbits   cbits_init(void) { return c_LITERAL(cbits){NULL}; }
 STC_INLINE void    cbits_drop(cbits* self) { c_free(self->data64); }
-STC_INLINE int64_t cbits_size(const cbits* self) { return self->_size; }
+STC_INLINE _llong  cbits_size(const cbits* self) { return self->_size; }
 
 STC_INLINE cbits* cbits_take(cbits* self, cbits other) {
     if (self->data64 != other.data64) {
@@ -140,7 +140,7 @@ STC_INLINE cbits* cbits_take(cbits* self, cbits other) {
 }
 
 STC_INLINE cbits cbits_clone(cbits other) {
-    const int64_t bytes = _cbits_bytes(other._size);
+    const _llong bytes = _cbits_bytes(other._size);
     cbits set = {(uint64_t *)c_memcpy(c_malloc(bytes), other.data64, bytes), other._size};
     return set;
 }
@@ -154,8 +154,8 @@ STC_INLINE cbits* cbits_copy(cbits* self, const cbits* other) {
     return self;
 }
 
-STC_INLINE void cbits_resize(cbits* self, const int64_t size, const bool value) {
-    const int64_t new_n = _cbits_words(size), osize = self->_size, old_n = _cbits_words(osize);
+STC_INLINE void cbits_resize(cbits* self, const _llong size, const bool value) {
+    const _llong new_n = _cbits_words(size), osize = self->_size, old_n = _cbits_words(osize);
     self->data64 = (uint64_t *)c_realloc(self->data64, new_n*8);
     self->_size = size;
     if (new_n >= old_n) {
@@ -177,13 +177,13 @@ STC_INLINE cbits cbits_move(cbits* self) {
     return tmp;
 }
 
-STC_INLINE cbits cbits_with_size(const int64_t size, const bool value) {
+STC_INLINE cbits cbits_with_size(const _llong size, const bool value) {
     cbits set = {(uint64_t *)c_malloc(_cbits_bytes(size)), size};
     cbits_set_all(&set, value);
     return set;
 }
 
-STC_INLINE cbits cbits_with_pattern(const int64_t size, const uint64_t pattern) {
+STC_INLINE cbits cbits_with_pattern(const _llong size, const uint64_t pattern) {
     cbits set = {(uint64_t *)c_malloc(_cbits_bytes(size)), size};
     cbits_set_pattern(&set, pattern);
     return set;
@@ -200,7 +200,7 @@ typedef struct { uint64_t data64[(i_capacity - 1)/64 + 1]; } i_type;
 
 STC_INLINE void     _i_memb(_init)(i_type* self) { memset(self->data64, 0, i_capacity*8); }
 STC_INLINE void     _i_memb(_drop)(i_type* self) {}
-STC_INLINE int64_t  _i_memb(_size)(const i_type* self) { return i_capacity; }
+STC_INLINE _llong   _i_memb(_size)(const i_type* self) { return i_capacity; }
 STC_INLINE i_type   _i_memb(_move)(i_type* self) { return *self; }
 
 STC_INLINE i_type*  _i_memb(_take)(i_type* self, i_type other)
@@ -215,13 +215,13 @@ STC_INLINE i_type* _i_memb(_copy)(i_type* self, const i_type* other)
 STC_INLINE void _i_memb(_set_all)(i_type *self, const bool value);
 STC_INLINE void _i_memb(_set_pattern)(i_type *self, const uint64_t pattern);
 
-STC_INLINE i_type _i_memb(_with_size)(const int64_t size, const bool value) {
+STC_INLINE i_type _i_memb(_with_size)(const _llong size, const bool value) {
     assert(size <= i_capacity);
     i_type set; _i_memb(_set_all)(&set, value);
     return set;
 }
 
-STC_INLINE i_type _i_memb(_with_pattern)(const int64_t size, const uint64_t pattern) {
+STC_INLINE i_type _i_memb(_with_pattern)(const _llong size, const uint64_t pattern) {
     assert(size <= i_capacity);
     i_type set; _i_memb(_set_pattern)(&set, pattern);
     return set;
@@ -234,36 +234,36 @@ STC_INLINE void _i_memb(_set_all)(i_type *self, const bool value)
     { c_memset(self->data64, value? ~0 : 0, _cbits_bytes(_i_memb(_size)(self))); }
 
 STC_INLINE void _i_memb(_set_pattern)(i_type *self, const uint64_t pattern) {
-    int64_t n = _cbits_words(_i_memb(_size)(self));
+    _llong n = _cbits_words(_i_memb(_size)(self));
     while (n--) self->data64[n] = pattern;
 }
 
-STC_INLINE bool _i_memb(_test)(const i_type* self, const int64_t i) 
+STC_INLINE bool _i_memb(_test)(const i_type* self, const _llong i) 
     { return (self->data64[i>>6] & _cbits_bit(i)) != 0; }
 
-STC_INLINE bool _i_memb(_at)(const i_type* self, const int64_t i)
+STC_INLINE bool _i_memb(_at)(const i_type* self, const _llong i)
     { return (self->data64[i>>6] & _cbits_bit(i)) != 0; }
 
-STC_INLINE void _i_memb(_set)(i_type *self, const int64_t i)
+STC_INLINE void _i_memb(_set)(i_type *self, const _llong i)
     { self->data64[i>>6] |= _cbits_bit(i); }
 
-STC_INLINE void _i_memb(_reset)(i_type *self, const int64_t i)
+STC_INLINE void _i_memb(_reset)(i_type *self, const _llong i)
     { self->data64[i>>6] &= ~_cbits_bit(i); }
 
-STC_INLINE void _i_memb(_set_value)(i_type *self, const int64_t i, const bool b) {
+STC_INLINE void _i_memb(_set_value)(i_type *self, const _llong i, const bool b) {
     self->data64[i>>6] ^= ((uint64_t)-(int)b ^ self->data64[i>>6]) & _cbits_bit(i);
 }
 
-STC_INLINE void _i_memb(_flip)(i_type *self, const int64_t i)
+STC_INLINE void _i_memb(_flip)(i_type *self, const _llong i)
     { self->data64[i>>6] ^= _cbits_bit(i); }
 
 STC_INLINE void _i_memb(_flip_all)(i_type *self) {
-    int64_t n = _cbits_words(_i_memb(_size)(self));
+    _llong n = _cbits_words(_i_memb(_size)(self));
     while (n--) self->data64[n] ^= ~(uint64_t)0;
 }
 
 STC_INLINE i_type _i_memb(_from)(const char* str) {
-    int64_t n = c_strlen(str);
+    _llong n = c_strlen(str);
     i_type set = _i_memb(_with_size)(n, false);
     while (n--) if (str[n] == '1') _i_memb(_set)(&set, n);
     return set;
@@ -272,26 +272,26 @@ STC_INLINE i_type _i_memb(_from)(const char* str) {
 /* Intersection */
 STC_INLINE void _i_memb(_intersect)(i_type *self, const i_type* other) {
     _i_assert(self->_size == other->_size);
-    int64_t n = _cbits_words(_i_memb(_size)(self));
+    _llong n = _cbits_words(_i_memb(_size)(self));
     while (n--) self->data64[n] &= other->data64[n];
 }
 /* Union */
 STC_INLINE void _i_memb(_union)(i_type *self, const i_type* other) {
     _i_assert(self->_size == other->_size);
-    int64_t n = _cbits_words(_i_memb(_size)(self));
+    _llong n = _cbits_words(_i_memb(_size)(self));
     while (n--) self->data64[n] |= other->data64[n];
 }
 /* Exclusive disjunction */
 STC_INLINE void _i_memb(_xor)(i_type *self, const i_type* other) {
     _i_assert(self->_size == other->_size);
-    int64_t n = _cbits_words(_i_memb(_size)(self));
+    _llong n = _cbits_words(_i_memb(_size)(self));
     while (n--) self->data64[n] ^= other->data64[n];
 }
 
-STC_INLINE int64_t _i_memb(_count)(const i_type* self)
+STC_INLINE _llong _i_memb(_count)(const i_type* self)
     { return _cbits_count(self->data64, _i_memb(_size)(self)); }
 
-STC_INLINE char* _i_memb(_to_str)(const i_type* self, char* out, int64_t start, int64_t stop)
+STC_INLINE char* _i_memb(_to_str)(const i_type* self, char* out, _llong start, _llong stop)
     { return _cbits_to_str(self->data64, _i_memb(_size)(self), out, start, stop); }
 
 STC_INLINE bool _i_memb(_subset_of)(const i_type* self, const i_type* other) { 
diff --git a/include/stc/ccommon.h b/include/stc/ccommon.h
index 63ce5b09..6f42bcc1 100644
--- a/include/stc/ccommon.h
+++ b/include/stc/ccommon.h
@@ -30,6 +30,7 @@
 #include <string.h>
 #include <assert.h>
 
+typedef long long _llong;
 #define c_NPOS INTPTR_MAX
 #define c_ZI PRIiPTR
 #define c_ZU PRIuPTR
@@ -200,9 +201,9 @@ STC_INLINE intptr_t cnextpow2(intptr_t n) {
 #define c_forrange_1(stop) c_forrange_3(_c_i, 0, stop)
 #define c_forrange_2(i, stop) c_forrange_3(i, 0, stop)
 #define c_forrange_3(i, start, stop) \
-    for (long long i=start, _end=(long long)(stop); i < _end; ++i)
+    for (_llong i=start, _end=(_llong)(stop); i < _end; ++i)
 #define c_forrange_4(i, start, stop, step) \
-    for (long long i=start, _inc=step, _end=(long long)(stop) - (_inc > 0) \
+    for (_llong i=start, _inc=step, _end=(_llong)(stop) - (_inc > 0) \
          ; (_inc > 0) ^ (i > _end); i += _inc)
 
 #ifndef __cplusplus
diff --git a/misc/examples/bits.c b/misc/examples/bits.c
index 95452300..ce8e1de4 100644
--- a/misc/examples/bits.c
+++ b/misc/examples/bits.c
@@ -10,18 +10,18 @@ int main(void)
         cbits_drop(&set),
         cbits_drop(&s2)
     ){
-        printf("count %" c_ZI ", %" c_ZI "\n", cbits_count(&set), cbits_size(&set));
+        printf("count %lld, %lld\n", cbits_count(&set), cbits_size(&set));
         cbits s1 = cbits_from("1110100110111");
         char buf[256];
         cbits_to_str(&s1, buf, 0, 255);
-        printf("buf: %s: %" c_ZI "\n", buf, cbits_count(&s1));
+        printf("buf: %s: %lld\n", buf, cbits_count(&s1));
         cbits_drop(&s1);
 
         cbits_reset(&set, 9);
         cbits_resize(&set, 43, false);
         printf(" str: %s\n", cbits_to_str(&set, buf, 0, 255));
 
-        printf("%4" c_ZI ": ", cbits_size(&set));
+        printf("%4lld: ", cbits_size(&set));
         c_forrange (i, cbits_size(&set))
             printf("%d", cbits_test(&set, i));
         puts("");
@@ -31,12 +31,12 @@ int main(void)
         cbits_resize(&set, 93, false);
         cbits_resize(&set, 102, true);
         cbits_set_value(&set, 99, false);
-        printf("%4" c_ZI ": ", cbits_size(&set));
+        printf("%4lld: ", cbits_size(&set));
         c_forrange (i, cbits_size(&set))
             printf("%d", cbits_test(&set, i));
 
         puts("\nIterate:");
-        printf("%4" c_ZI ": ", cbits_size(&set));
+        printf("%4lld: ", cbits_size(&set));
         c_forrange (i, cbits_size(&set))
             printf("%d", cbits_test(&set, i));
         puts("");
@@ -59,7 +59,7 @@ int main(void)
         puts("");
 
         cbits_set_all(&set, false);
-        printf("%4" c_ZI ": ", cbits_size(&set));
+        printf("%4lld: ", cbits_size(&set));
         c_forrange (i, cbits_size(&set))
             printf("%d", cbits_test(&set, i));
         puts("");
diff --git a/misc/examples/bits2.c b/misc/examples/bits2.c
index b002af3c..913bd185 100644
--- a/misc/examples/bits2.c
+++ b/misc/examples/bits2.c
@@ -9,10 +9,10 @@ int main()
 {
     Bits s1 = Bits_from("1110100110111");
     
-    printf("size %" c_ZI "\n", Bits_size(&s1));
+    printf("size %lld\n", Bits_size(&s1));
     char buf[256];
     Bits_to_str(&s1, buf, 0, 256);
-    printf("buf: %s: count=%" c_ZI "\n", buf, Bits_count(&s1));
+    printf("buf: %s: count=%lld\n", buf, Bits_count(&s1));
 
     Bits_reset(&s1, 8);
     printf(" s1: %s\n", Bits_to_str(&s1, buf, 0, 256));
-- 
cgit v1.2.3


From ebe5abc29d51c643520301e42124365477f44957 Mon Sep 17 00:00:00 2001
From: tylov <tylo@norceresearch.no>
Date: Wed, 12 Jul 2023 19:39:59 +0200
Subject: Changed docs and examples to use i_key* template parameters instead
 of i_val* for all non-maps. Renamed c_ASSERT() to c_assert() and added
 optional message parameter to c_static_assert().

---
 README.md                             | 36 ++++++++++----------
 docs/carc_api.md                      | 38 ++++++++++-----------
 docs/cbox_api.md                      | 52 ++++++++++++++--------------
 docs/ccommon_api.md                   | 10 +++---
 docs/cdeq_api.md                      | 54 ++++++++++++++---------------
 docs/clist_api.md                     | 56 +++++++++++++++---------------
 docs/cpque_api.md                     | 32 +++++++++---------
 docs/cqueue_api.md                    | 28 +++++++--------
 docs/cset_api.md                      |  2 +-
 docs/cspan_api.md                     |  7 ++--
 docs/csset_api.md                     |  2 +-
 docs/cstack_api.md                    | 38 ++++++++++-----------
 docs/csview_api.md                    |  2 +-
 docs/cvec_api.md                      | 64 +++++++++++++++++------------------
 include/stc/algo/sort.h               | 21 +++++++-----
 include/stc/cbits.h                   |  8 ++---
 include/stc/ccommon.h                 | 14 ++++----
 include/stc/cdeq.h                    |  4 +--
 include/stc/clist.h                   |  2 +-
 include/stc/cmap.h                    |  2 +-
 include/stc/cpque.h                   |  2 +-
 include/stc/cqueue.h                  |  4 +--
 include/stc/cspan.h                   | 28 +++++++--------
 include/stc/cstack.h                  |  8 ++---
 include/stc/cvec.h                    |  8 ++---
 include/stc/extend.h                  |  4 ++-
 misc/benchmarks/various/csort_bench.c |  2 +-
 misc/examples/arc_containers.c        |  8 ++---
 misc/examples/arc_demo.c              |  8 ++---
 misc/examples/arcvec_erase.c          |  6 ++--
 misc/examples/astar.c                 |  4 +--
 misc/examples/box.c                   |  4 +--
 misc/examples/box2.c                  |  6 ++--
 misc/examples/cointerleave.c          |  2 +-
 misc/examples/complex.c               |  4 +--
 misc/examples/convert.c               |  4 +--
 misc/examples/csmap_find.c            |  2 +-
 misc/examples/csmap_insert.c          |  2 +-
 misc/examples/demos.c                 |  6 ++--
 misc/examples/forfilter.c             |  4 +--
 misc/examples/forloops.c              |  2 +-
 misc/examples/functor.c               |  2 +-
 misc/examples/inits.c                 |  6 ++--
 misc/examples/intrusive.c             |  2 +-
 misc/examples/list.c                  |  2 +-
 misc/examples/list_erase.c            |  2 +-
 misc/examples/list_splice.c           |  2 +-
 misc/examples/lower_bound.c           |  4 +--
 misc/examples/mmap.c                  |  2 +-
 misc/examples/multimap.c              |  2 +-
 misc/examples/music_arc.c             |  4 +--
 misc/examples/new_list.c              | 10 +++---
 misc/examples/new_pque.c              |  2 +-
 misc/examples/new_queue.c             |  4 +--
 misc/examples/new_sptr.c              | 10 +++---
 misc/examples/new_vec.c               |  4 +--
 misc/examples/person_arc.c            |  4 +--
 misc/examples/printspan.c             |  8 ++---
 misc/examples/priority.c              |  2 +-
 misc/examples/queue.c                 |  2 +-
 misc/examples/rawptr_elements.c       |  2 +-
 misc/examples/read.c                  |  2 +-
 misc/examples/regex_match.c           |  2 +-
 misc/examples/scheduler.c             |  2 +-
 misc/examples/shape.c                 |  6 ++--
 misc/examples/stack.c                 |  4 +--
 misc/tests/cspan_test.c               |  4 +--
 67 files changed, 348 insertions(+), 338 deletions(-)

(limited to 'include/stc/cbits.h')

diff --git a/README.md b/README.md
index ab350488..67c4d7fd 100644
--- a/README.md
+++ b/README.md
@@ -81,7 +81,7 @@ List of contents
 1. ***Centralized analysis of template parameters***. The analyser assigns values to all
 non-specified template parameters (based on the specified ones) using meta-programming, so
 that you don't have to! You may specify a set of "standard" template parameters for each
-container, but as a minimum *only one is required*: `i_val` (+ `i_key` for maps). In this
+container, but as a minimum *only one is required*: `i_key` (+ `i_val` for maps). In this
 case, STC assumes that the elements are of basic types. For non-trivial types, additional
 template parameters must be given. 
 2. ***Alternative insert/lookup type***. You may specify an alternative type to use for
@@ -118,7 +118,7 @@ Benchmark notes:
 
 - Container names are prefixed by `c`, e.g. `cvec`, `cstr`.
 - Public STC macros are prefixed by `c_`, e.g. `c_foreach`, `c_init`.
-- Template parameter macros are prefixed by `i_`, e.g. `i_val`, `i_type`.
+- Template parameter macros are prefixed by `i_`, e.g. `i_key`, `i_type`.
 - All containers can be initialized with `{0}`, i.e. no heap allocation used by default init.
 - Common types for a container type Con:
     - Con
@@ -150,7 +150,7 @@ templated types in C++. However, to specify template parameters with STC, you de
 including the container:
 ```c
 #define i_type Floats  // Container type name; unless defined name would be cvec_float
-#define i_val float    // Container element type
+#define i_key float    // Container element type
 #include <stc/cvec.h>  // "instantiate" the desired container type
 #include <stdio.h>
 
@@ -177,7 +177,7 @@ You may switch to a different container type, e.g. a sorted set (csset):
 [ [Run this code](https://godbolt.org/z/qznfa65e1) ]
 ```c
 #define i_type Floats
-#define i_val float
+#define i_key float
 #include <stc/csset.h> // Use a sorted set instead
 #include <stdio.h>
 
@@ -196,7 +196,7 @@ int main()
 }
 ```
 For user-defined struct elements, `i_cmp` compare function should be defined as the default `<` and `==`
-only works for integral types. *Alternatively, `#define i_opt c_no_cmp` to disable sorting and searching*. Similarily, if an element destructor `i_valdrop` is defined, `i_valclone` function is required.
+only works for integral types. *Alternatively, `#define i_opt c_no_cmp` to disable sorting and searching*. Similarily, if an element destructor `i_keydrop` is defined, `i_keyclone` function is required.
 *Alternatively `#define i_opt c_no_clone` to disable container cloning.*
 
 Let's make a vector of vectors, which can be cloned. All of its element vectors will be destroyed when destroying the Vec2D.
@@ -206,11 +206,11 @@ Let's make a vector of vectors, which can be cloned. All of its element vectors
 #include <stdio.h>
 
 #define i_type Vec
-#define i_val float
+#define i_key float
 #include <stc/cvec.h>
 
 #define i_type Vec2D
-#define i_valclass Vec  // Use i_valclass when element type has "members" _clone(), _drop() and _cmp().
+#define i_keyclass Vec  // Use i_keyclass when element type has "members" _clone(), _drop() and _cmp().
 #define i_opt c_no_cmp  // Disable cmp (search/sort) for Vec2D because Vec_cmp() is not defined.
 #include <stc/cvec.h>
 
@@ -246,12 +246,12 @@ This example uses four different container types:
 
 struct Point { float x, y; };
 // Define cvec_pnt with a less-comparison function for Point.
-#define i_val struct Point
+#define i_key struct Point
 #define i_less(a, b) a->x < b->x || (a->x == b->x && a->y < b->y)
 #define i_tag pnt
 #include <stc/cvec.h>   // cvec_pnt: vector of struct Point
 
-#define i_val int
+#define i_key int
 #include <stc/clist.h>  // clist_int: singly linked list
 
 #define i_key int
@@ -369,10 +369,10 @@ or define your own, e.g.:
 #define i_tag ix
 #include <stc/cset.h>  // cset_ix
 
-#define i_val int
+#define i_key int
 #include <stc/cvec.h>  // cvec_int
 
-#define i_val Point
+#define i_key Point
 #define i_tag pnt
 #include <stc/clist.h> // clist_pnt
 ```
@@ -383,8 +383,8 @@ Each templated type requires one `#include`, even if it's the same container bas
 The template parameters are given by a `#define i_xxxx` statement, where *xxxx* is the parameter name.
 The list of template parameters:
 
-- `i_key` *Type* - Element key type for map/set only. **[required]**.
-- `i_val` *Type* - Element value type. **[required for]** cmap/csmap, it is the mapped value type.
+- `i_key` *Type* - Element key type. **[required]**. Note: `i_val` *may* be used instead for non-maps (not recommended).
+- `i_val` *Type* - Element value type. **[required for]** cmap/csmap as the mapped value type.
 - `i_cmp` *Func* - Three-way comparison of two *i_keyraw*\* or *i_valraw*\* - **[required for]** non-integral *i_keyraw* elements unless *i_opt* is defined with *c_no_cmp*.
 - `i_hash` *Func* - Hash function taking *i_keyraw*\* - defaults to *c_default_hash*. **[required for]** ***cmap/cset*** with non-POD *i_keyraw* elements.
 - `i_eq` *Func* - Equality comparison of two *i_keyraw*\* - defaults to *!i_cmp*. Companion with *i_hash*.
@@ -458,7 +458,7 @@ and non-emplace methods:
 #define i_implement     // define in ONE file to implement longer functions in cstr
 #include <stc/cstr.h>
 
-#define i_val_str       // special macro to enable container of cstr
+#define i_key_str       // special macro to enable container of cstr
 #include <stc/cvec.h>   // vector of string (cstr)
 ...
 cvec_str vec = {0};
@@ -518,7 +518,7 @@ last example on the **cmap** page demonstrates how to specify a map with non-tri
 Define `i_type` instead of `i_tag`:
 ```c
 #define i_type MyVec
-#define i_val int
+#define i_key int
 #include <stc/cvec.h>
 
 myvec vec = MyVec_init();
@@ -543,7 +543,7 @@ typedef struct Dataset {
 
 // Implementation
 #define i_is_forward                  // flag that the container was forward declared.
-#define i_val struct Point
+#define i_key struct Point
 #define i_tag pnt
 #include <stc/cstack.h>
 ```
@@ -617,8 +617,8 @@ STC is generally very memory efficient. Memory usage for the different container
 - coroutines: much improved with some new API and added features.
 - cspan: Support for column-major (fortran order) multidim spans and transposed views.
 - Removed default comparison for clist, cvec and cdeq (as with cstack and cqueue). 
-    - Using i_val_str, i_valclass, i_valboxed still expects comparisons defined. 
-    - Define i_native_cmp to enable built-in i_val types comparisons (<, ==).
+    - Using i_key_str, i_keyclass, i_keyboxed still expects comparisons defined. 
+    - Define i_native_cmp to enable built-in i_key types comparisons (<, ==).
 - cstr and csview are now shared linked by default. Static linking by defining i_static.
 - New cdeq and cqueue implementation(s), using circular buffer.
 - Renamed i_extern => i_import.
diff --git a/docs/carc_api.md b/docs/carc_api.md
index 22e6bac2..254f868a 100644
--- a/docs/carc_api.md
+++ b/docs/carc_api.md
@@ -6,14 +6,14 @@ deallocated when the last remaining **carc** owning the object is destroyed with
 
 The object is destroyed using *carc_X_drop()*. A **carc** may also own no objects, in which 
 case it is called empty. The *carc_X_cmp()*, *carc_X_drop()* methods are defined based on
-the `i_cmp` and `i_valdrop` macros specified. Use *carc_X_clone(p)* when sharing ownership of
+the `i_cmp` and `i_keydrop` macros specified. Use *carc_X_clone(p)* when sharing ownership of
 the pointed-to object. 
 
 All **carc** functions can be called by multiple threads on different instances of **carc** without
 additional synchronization even if these instances are copies and share ownership of the same object.
 **carc** uses thread-safe atomic reference counting, through the *carc_X_clone()* and *carc_X_drop()* methods.
 
-When declaring a container with shared pointers, define `i_valboxed` with the carc type, see example.
+When declaring a container with shared pointers, define `i_keyboxed` with the carc type, see example.
 
 See similar c++ class [std::shared_ptr](https://en.cppreference.com/w/cpp/memory/shared_ptr) for a functional reference, or Rust [std::sync::Arc](https://doc.rust-lang.org/std/sync/struct.Arc.html) / [std::rc::Rc](https://doc.rust-lang.org/std/rc/struct.Rc.html).
 
@@ -21,14 +21,14 @@ See similar c++ class [std::shared_ptr](https://en.cppreference.com/w/cpp/memory
 
 ```c
 #define i_type            // full typename of the carc
-#define i_val             // value: REQUIRED
+#define i_key             // element type: REQUIRED
 
-#define i_valraw          // convertion "raw" type - defaults to i_val
-#define i_valto           // convertion func i_val* => i_valraw: REQUIRED IF i_valraw defined.
-#define i_valfrom         // convertion func i_valraw => i_val
+#define i_keyraw          // convertion "raw" type - defaults to i_key
+#define i_keyto           // convertion func i_key* => i_keyraw: REQUIRED IF i_keyraw defined.
+#define i_keyfrom         // convertion func i_keyraw => i_key
       
 #define i_opt c_no_atomic // Non-atomic reference counting, like Rust Rc.
-#define i_tag             // alternative typename: carc_{i_tag}. i_tag defaults to i_val
+#define i_tag             // alternative typename: carc_{i_tag}. i_tag defaults to i_key
 #include <stc/carc.h>
 ```
 `X` should be replaced by the value of `i_tag` in all of the following documentation.
@@ -36,9 +36,9 @@ See similar c++ class [std::shared_ptr](https://en.cppreference.com/w/cpp/memory
 ## Methods
 ```c
 carc_X      carc_X_init();                                     // empty shared pointer
-carc_X      carc_X_from(i_valraw raw);                         // create an carc from raw type (available if i_valraw defined by user).
-carc_X      carc_X_from_ptr(i_val* p);                         // create an carc from raw pointer. Takes ownership of p.
-carc_X      carc_X_make(i_val val);                            // create an carc from constructed val object. Faster than from_ptr().
+carc_X      carc_X_from(i_keyraw raw);                         // create an carc from raw type (available if i_keyraw defined by user).
+carc_X      carc_X_from_ptr(i_key* p);                         // create an carc from raw pointer. Takes ownership of p.
+carc_X      carc_X_make(i_key key);                            // create an carc from constructed key object. Faster than from_ptr().
 
 carc_X      carc_X_clone(carc_X other);                        // return other with increased use count
 carc_X      carc_X_move(carc_X* self);                         // transfer ownership to receiver; self becomes NULL
@@ -49,7 +49,7 @@ void        carc_X_drop(carc_X* self);                         // destruct (decr
 long        carc_X_use_count(const carc_X* self);    
 
 void        carc_X_reset(carc_X* self);    
-void        carc_X_reset_to(carc_X* self, i_val* p);           // assign new carc from ptr. Takes ownership of p.
+void        carc_X_reset_to(carc_X* self, i_key* p);           // assign new carc from ptr. Takes ownership of p.
 
 uint64_t    carc_X_hash(const carc_X* x);                      // hash value
 int         carc_X_cmp(const carc_X* x, const carc_X* y);      // compares pointer addresses if no `i_cmp` is specified.
@@ -58,9 +58,9 @@ bool        carc_X_eq(const carc_X* x, const carc_X* y);       // carc_X_cmp() =
 
 // functions on pointed to objects.
 
-uint64_t    carc_X_value_hash(const i_val* x);
-int         carc_X_value_cmp(const i_val* x, const i_val* y);
-bool        carc_X_value_eq(const i_val* x, const i_val* y);
+uint64_t    carc_X_value_hash(const i_key* x);
+int         carc_X_value_cmp(const i_key* x, const i_key* y);
+bool        carc_X_value_eq(const i_key* x, const i_key* y);
 ```
 
 ## Types and constants
@@ -69,8 +69,8 @@ bool        carc_X_value_eq(const i_val* x, const i_val* y);
 |:------------------|:--------------------------------------------------|:-----------------------|
 | `carc_null`       | `{0}`                                             | Init nullptr const     |
 | `carc_X`          | `struct { carc_X_value* get; long* use_count; }`  | The carc type          |
-| `carc_X_value`    | `i_val`                                           | The carc element type  |
-| `carc_X_raw`      | `i_valraw`                                        | Convertion type        |
+| `carc_X_value`    | `i_key`                                           | The carc element type  |
+| `carc_X_raw`      | `i_keyraw`                                        | Convertion type        |
 
 ## Example
 
@@ -89,12 +89,12 @@ bool        carc_X_value_eq(const i_val* x, const i_val* y);
 #include <stc/csmap.h>
 
 #define i_type Arc // (atomic) ref. counted pointer
-#define i_val Map
-#define i_valdrop(p) (printf("drop Arc:\n"), Map_drop(p))
+#define i_key Map
+#define i_keydrop(p) (printf("drop Arc:\n"), Map_drop(p))
 #include <stc/carc.h>
 
 #define i_type Stack
-#define i_valboxed Arc // Note: use i_valboxed for carc or cbox value types
+#define i_keyboxed Arc // Note: use i_keyboxed for carc or cbox value types
 #include <stc/cstack.h>
 
 int main()
diff --git a/docs/cbox_api.md b/docs/cbox_api.md
index 9151f56d..83d59521 100644
--- a/docs/cbox_api.md
+++ b/docs/cbox_api.md
@@ -2,11 +2,11 @@
 
 **cbox** is a smart pointer to a heap allocated value of type X. A **cbox** can
 be empty. The *cbox_X_cmp()*, *cbox_X_drop()* methods are defined based on the `i_cmp`
-and `i_valdrop` macros specified. Use *cbox_X_clone(p)* to make a deep copy, which uses the
-`i_valclone` macro if defined.
+and `i_keydrop` macros specified. Use *cbox_X_clone(p)* to make a deep copy, which uses the
+`i_keyclone` macro if defined.
 
-When declaring a container of **cbox** values, define `i_valboxed` with the
-cbox type instead of defining `i_val`. This will auto-set `i_valdrop`, `i_valclone`, and `i_cmp` using 
+When declaring a container of **cbox** values, define `i_keyboxed` with the
+cbox type instead of defining `i_key`. This will auto-set `i_keydrop`, `i_keyclone`, and `i_cmp` using 
 functions defined by the specified **cbox**.
 
 See similar c++ class [std::unique_ptr](https://en.cppreference.com/w/cpp/memory/unique_ptr) for a functional reference, or Rust [std::boxed::Box](https://doc.rust-lang.org/std/boxed/struct.Box.html)
@@ -15,29 +15,29 @@ See similar c++ class [std::unique_ptr](https://en.cppreference.com/w/cpp/memory
 
 ```c
 #define i_type          // full typename of the cbox
-#define i_val           // value: REQUIRED
-#define i_cmp           // three-way compare two i_val* : REQUIRED IF i_val is a non-integral type
-#define i_valdrop       // destroy value func - defaults to empty destruct
-#define i_valclone      // REQUIRED if i_valdrop is defined, unless 'i_opt c_no_clone' is defined.
+#define i_key           // element type: REQUIRED
+#define i_cmp           // three-way compare two i_key* : REQUIRED IF i_key is a non-integral type
+#define i_keydrop       // destroy element func - defaults to empty destruct
+#define i_keyclone      // REQUIRED if i_keydrop is defined, unless 'i_opt c_no_clone' is defined.
 
-#define i_valraw        // convertion type (lookup): default to {i_val}
-#define i_valto         // convertion func i_val* => i_valraw: REQUIRED IF i_valraw defined.
-#define i_valfrom       // from-raw func.
+#define i_keyraw        // convertion type (lookup): default to {i_key}
+#define i_keyto         // convertion func i_key* => i_keyraw: REQUIRED IF i_keyraw defined.
+#define i_keyfrom       // from-raw func.
 
-#define i_valclass      // alt. to i_val: REQUIRES that {i_val}_clone, {i_val}_drop, {i_valraw}_cmp exist.
-#define i_tag           // alternative typename: cbox_{i_tag}. i_tag defaults to i_val
+#define i_keyclass      // alt. to i_key: REQUIRES that {i_key}_clone, {i_key}_drop, {i_keyraw}_cmp exist.
+#define i_tag           // alternative typename: cbox_{i_tag}. i_tag defaults to i_key
 #include <stc/cbox.h>    
 ```
 `X` should be replaced by the value of `i_tag` in all of the following documentation.
-Define `i_opt` with `c_no_cmp` if comparison between i_val's is not needed/available. Will then
+Define `i_opt` with `c_no_cmp` if comparison between i_key's is not needed/available. Will then
 compare the pointer addresses when used. Additionally, `c_no_clone` or `i_is_fwd` may be defined.
 
 ## Methods
 ```c
 cbox_X      cbox_X_init();                                    // return an empty cbox
-cbox_X      cbox_X_from(i_valraw raw);                        // create a cbox from raw type. Avail if i_valraw user defined.
-cbox_X      cbox_X_from_ptr(i_val* ptr);                      // create a cbox from a pointer. Takes ownership of ptr.
-cbox_X      cbox_X_make(i_val val);                           // create a cbox from unowned val object.
+cbox_X      cbox_X_from(i_keyraw raw);                        // create a cbox from raw type. Avail if i_keyraw user defined.
+cbox_X      cbox_X_from_ptr(i_key* ptr);                      // create a cbox from a pointer. Takes ownership of ptr.
+cbox_X      cbox_X_make(i_key val);                           // create a cbox from unowned val object.
 
 cbox_X      cbox_X_clone(cbox_X other);                       // return deep copied clone
 cbox_X      cbox_X_move(cbox_X* self);                        // transfer ownership to receiving cbox returned. self becomes NULL.
@@ -46,7 +46,7 @@ void        cbox_X_assign(cbox_X* self, cbox_X* moved);       // transfer owners
 void        cbox_X_drop(cbox_X* self);                        // destruct the contained object and free its heap memory.
 
 void        cbox_X_reset(cbox_X* self);   
-void        cbox_X_reset_to(cbox_X* self, i_val* p);          // assign new cbox from ptr. Takes ownership of p.
+void        cbox_X_reset_to(cbox_X* self, i_key* p);          // assign new cbox from ptr. Takes ownership of p.
 
 uint64_t    cbox_X_hash(const cbox_X* x);                     // hash value
 int         cbox_X_cmp(const cbox_X* x, const cbox_X* y);     // compares pointer addresses if no `i_cmp` is specified.
@@ -55,9 +55,9 @@ bool        cbox_X_eq(const cbox_X* x, const cbox_X* y);      // cbox_X_cmp() ==
 
 // functions on pointed to objects.
 
-uint64_t    cbox_X_value_hash(const i_val* x);
-int         cbox_X_value_cmp(const i_val* x, const i_val* y);
-bool        cbox_X_value_eq(const i_val* x, const i_val* y);
+uint64_t    cbox_X_value_hash(const i_key* x);
+int         cbox_X_value_cmp(const i_key* x, const i_key* y);
+bool        cbox_X_value_eq(const i_key* x, const i_key* y);
 ```
 
 ## Types and constants
@@ -66,7 +66,7 @@ bool        cbox_X_value_eq(const i_val* x, const i_val* y);
 |:-------------------|:--------------------------------|:------------------------|
 | `cbox_null`        | `{0}`                           | Init nullptr const      |
 | `cbox_X`           | `struct { cbox_X_value* get; }` | The cbox type           |
-| `cbox_X_value`     | `i_val`                         | The cbox element type   |
+| `cbox_X_value`     | `i_key`                         | The cbox element type   |
 
 ## Example
 
@@ -77,9 +77,9 @@ void int_drop(int* x) {
 }
 
 #define i_type IBox
-#define i_val int
-#define i_valdrop int_drop    // optional func, just to display elements destroyed
-#define i_valclone(x) x       // must specified when i_valdrop is defined.
+#define i_key int
+#define i_keydrop int_drop    // optional func, just to display elements destroyed
+#define i_keyclone(x) x       // must specified when i_keydrop is defined.
 #include <stc/cbox.h>
 
 #define i_type ISet
@@ -87,7 +87,7 @@ void int_drop(int* x) {
 #include <stc/csset.h>        // ISet : std::set<std::unique_ptr<int>>
 
 #define i_type IVec
-#define i_valboxed IBox       // NB: use i_valboxed instead of i_val
+#define i_keyboxed IBox       // NB: use i_keyboxed instead of i_key
 #include <stc/cvec.h>         // IVec : std::vector<std::unique_ptr<int>>
 
 int main()
diff --git a/docs/ccommon_api.md b/docs/ccommon_api.md
index 7569bb5b..52ad88e4 100644
--- a/docs/ccommon_api.md
+++ b/docs/ccommon_api.md
@@ -162,7 +162,7 @@ Note that `c_flt_take()` and `c_flt_takewhile()` breaks the loop on false.
 
 Make any container from an initializer list:
 ```c
-#define i_val_str // owned cstr string value type
+#define i_key_str // owned cstr string value type
 #include <stc/cset.h>
 
 #define i_key int
@@ -210,7 +210,7 @@ You may customize `i_tag` and the comparison function `i_cmp` or `i_less`.
 
 There is a [benchmark/test file here](../misc/benchmarks/various/csort_bench.c).
 ```c
-#define i_val int
+#define i_key int
 #include <stc/algo/sort.h>
 #include <stdio.h>
 
@@ -224,7 +224,7 @@ Containers with random access may also be sorted. Even sorting cdeq/cqueue (with
 possible and very fast. Note that `i_more` must be defined to retain specified template parameters for use by sort:
 ```c
 #define i_type MyDeq
-#define i_val int
+#define i_key int
 #define i_more
 #include <stc/cdeq.h> // deque
 #include <stc/algo/sort.h>
@@ -273,7 +273,7 @@ int* ip = c_const_cast(int*, cs);  // issues a warning!
 
 ### Predefined template parameter functions
 
-**crawstr** - Non-owned `const char*` "class" element type: `#define i_valclass crawstr`
+**crawstr** - Non-owned `const char*` "class" element type: `#define i_keyclass crawstr`
 ```c
 typedef     const char* crawstr;
 int         crawstr_cmp(const crawstr* x, const crawstr* y);
@@ -485,7 +485,7 @@ return ok;
 #define i_implement
 #include <stc/cstr.h>
 
-#define i_val_str
+#define i_key_str
 #include <stc/cvec.h>
 
 // receiver should check errno variable
diff --git a/docs/cdeq_api.md b/docs/cdeq_api.md
index 5a00d69a..292b0933 100644
--- a/docs/cdeq_api.md
+++ b/docs/cdeq_api.md
@@ -11,16 +11,16 @@ See the c++ class [std::deque](https://en.cppreference.com/w/cpp/container/deque
 
 ```c
 #define i_type      // full typename of the container
-#define i_val       // value: REQUIRED
-#define i_cmp       // three-way compare two i_valraw* : REQUIRED IF i_valraw is a non-integral type
-#define i_valdrop   // destroy value func - defaults to empty destruct
-#define i_valclone  // REQUIRED IF i_valdrop defined
+#define i_key       // value: REQUIRED
+#define i_cmp       // three-way compare two i_keyraw* : REQUIRED IF i_keyraw is a non-integral type
+#define i_keydrop   // destroy value func - defaults to empty destruct
+#define i_keyclone  // REQUIRED IF i_keydrop defined
 
-#define i_valraw    // convertion "raw" type - defaults to i_val
-#define i_valfrom   // convertion func i_valraw => i_val
-#define i_valto     // convertion func i_val* => i_valraw
+#define i_keyraw    // convertion "raw" type - defaults to i_key
+#define i_keyfrom   // convertion func i_keyraw => i_key
+#define i_keyto     // convertion func i_key* => i_keyraw
 
-#define i_tag       // alternative typename: cdeq_{i_tag}. i_tag defaults to i_val
+#define i_tag       // alternative typename: cdeq_{i_tag}. i_tag defaults to i_key
 #include <stc/cdeq.h>
 ```
 `X` should be replaced by the value of `i_tag` in all of the following documentation.
@@ -44,30 +44,30 @@ intptr_t            cdeq_X_capacity(const cdeq_X* self);
 
 const cdeq_X_value* cdeq_X_at(const cdeq_X* self, intptr_t idx);
 cdeq_X_value*       cdeq_X_at_mut(cdeq_X* self, intptr_t idx);
-const cdeq_X_value* cdeq_X_get(const cdeq_X* self, i_valraw raw);                   // return NULL if not found
-cdeq_X_value*       cdeq_X_get_mut(cdeq_X* self, i_valraw raw);                     // mutable get
-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);   // return cvec_X_end() if not found
+const cdeq_X_value* cdeq_X_get(const cdeq_X* self, i_keyraw raw);                   // return NULL if not found
+cdeq_X_value*       cdeq_X_get_mut(cdeq_X* self, i_keyraw raw);                     // mutable get
+cdeq_X_iter         cdeq_X_find(const cdeq_X* self, i_keyraw raw);
+cdeq_X_iter         cdeq_X_find_in(cdeq_X_iter i1, cdeq_X_iter i2, i_keyraw raw);   // return cvec_X_end() if not found
 
 cdeq_X_value*       cdeq_X_front(const cdeq_X* self);
 cdeq_X_value*       cdeq_X_back(const cdeq_X* self);
 
-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);
+cdeq_X_value*       cdeq_X_push_front(cdeq_X* self, i_key value);
+cdeq_X_value*       cdeq_X_emplace_front(cdeq_X* self, i_keyraw raw);
 void                cdeq_X_pop_front(cdeq_X* self);
 
-cdeq_X_value*       cdeq_X_push_back(cdeq_X* self, i_val value);
-cdeq_X_value*       cdeq_X_push(cdeq_X* self, i_val value);                         // alias for push_back()
-cdeq_X_value*       cdeq_X_emplace_back(cdeq_X* self, i_valraw raw);
-cdeq_X_value*       cdeq_X_emplace(cdeq_X* self, i_valraw raw);                     // alias for emplace_back()
+cdeq_X_value*       cdeq_X_push_back(cdeq_X* self, i_key value);
+cdeq_X_value*       cdeq_X_push(cdeq_X* self, i_key value);                         // alias for push_back()
+cdeq_X_value*       cdeq_X_emplace_back(cdeq_X* self, i_keyraw raw);
+cdeq_X_value*       cdeq_X_emplace(cdeq_X* self, i_keyraw raw);                     // alias for emplace_back()
 void                cdeq_X_pop_back(cdeq_X* self);
 
-cdeq_X_iter         cdeq_X_insert_n(cdeq_X* self, intptr_t idx, const i_val[] arr, intptr_t n);  // move values
-cdeq_X_iter         cdeq_X_insert_at(cdeq_X* self, cdeq_X_iter it, i_val value);    // move value 
+cdeq_X_iter         cdeq_X_insert_n(cdeq_X* self, intptr_t idx, const i_key[] arr, intptr_t n);  // move values
+cdeq_X_iter         cdeq_X_insert_at(cdeq_X* self, cdeq_X_iter it, i_key value);    // move value 
 cdeq_X_iter         cdeq_X_insert_uninit(cdeq_X* self, intptr_t idx, intptr_t n);   // uninitialized data 
                     // copy values:
-cdeq_X_iter         cdeq_X_emplace_n(cdeq_X* self, intptr_t idx, const i_valraw[] arr, intptr_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_n(cdeq_X* self, intptr_t idx, const i_keyraw[] arr, intptr_t n);
+cdeq_X_iter         cdeq_X_emplace_at(cdeq_X* self, cdeq_X_iter it, i_keyraw raw);
 
 void                cdeq_X_erase_n(cdeq_X* self, intptr_t idx, intptr_t n);
 cdeq_X_iter         cdeq_X_erase_at(cdeq_X* self, cdeq_X_iter it);
@@ -88,14 +88,14 @@ void                cdeq_X_value_drop(cdeq_X_value* pval);
 
 | 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_raw`       | `i_valraw`                          | The raw value type     |
-| `cdeq_X_iter`      | `struct { cdeq_X_value* ref; }`   | The iterator type      |
+| `cdeq_X`           | `struct { cdeq_X_value* data; }`    | The cdeq type          |
+| `cdeq_X_value`     | `i_key`                             | The cdeq value type    |
+| `cdeq_X_raw`       | `i_keyraw`                          | The raw value type     |
+| `cdeq_X_iter`      | `struct { cdeq_X_value* ref; }`     | The iterator type      |
 
 ## Examples
 ```c
-#define i_val int
+#define i_key int
 #define i_tag i
 #include <stc/cdeq.h>
 
diff --git a/docs/clist_api.md b/docs/clist_api.md
index 51b7af6a..023cca41 100644
--- a/docs/clist_api.md
+++ b/docs/clist_api.md
@@ -22,16 +22,16 @@ See the c++ class [std::list](https://en.cppreference.com/w/cpp/container/list)
 ## Header file and declaration
 
 ```c
-#define i_type      // container type name (default: clist_{i_val})
-#define i_val       // value: REQUIRED
-#define i_cmp       // three-way compare two i_valraw* : REQUIRED IF i_valraw is a non-integral type
-#define i_valdrop   // destroy value func - defaults to empty destruct
-#define i_valclone  // REQUIRED IF i_valdrop defined
-
-#define i_valraw    // convertion "raw" type (default: {i_val})
-#define i_valto     // convertion func i_val* => i_valraw
-#define i_valfrom   // convertion func i_valraw => i_val
-#define i_tag       // alternative typename: cpque_{i_tag}. i_tag defaults to i_val
+#define i_type      // container type name (default: clist_{i_key})
+#define i_key       // value: REQUIRED
+#define i_cmp       // three-way compare two i_keyraw* : REQUIRED IF i_keyraw is a non-integral type
+#define i_keydrop   // destroy value func - defaults to empty destruct
+#define i_keyclone  // REQUIRED IF i_keydrop defined
+
+#define i_keyraw    // convertion "raw" type (default: {i_key})
+#define i_keyto     // convertion func i_key* => i_keyraw
+#define i_keyfrom   // convertion func i_keyraw => i_key
+#define i_tag       // alternative typename: cpque_{i_tag}. i_tag defaults to i_key
 #include <stc/clist.h>
 ```
 
@@ -53,31 +53,31 @@ intptr_t            clist_X_count(const clist_X* list);
 clist_X_value*      clist_X_back(const clist_X* self);
 clist_X_value*      clist_X_front(const clist_X* self);
 
-void                clist_X_push_back(clist_X* self, i_val value);                      // note: no pop_back()
-void                clist_X_push_front(clist_X* self, i_val value);
-void                clist_X_push(clist_X* self, i_val value);                           // alias for push_back()
+void                clist_X_push_back(clist_X* self, i_key value);                      // note: no pop_back()
+void                clist_X_push_front(clist_X* self, i_key value);
+void                clist_X_push(clist_X* self, i_key value);                           // alias for push_back()
 
-void                clist_X_emplace_back(clist_X* self, i_valraw raw);
-void                clist_X_emplace_front(clist_X* self, i_valraw raw);
-void                clist_X_emplace(clist_X* self, i_valraw raw);                       // alias for emplace_back()
+void                clist_X_emplace_back(clist_X* self, i_keyraw raw);
+void                clist_X_emplace_front(clist_X* self, i_keyraw raw);
+void                clist_X_emplace(clist_X* self, i_keyraw raw);                       // alias for emplace_back()
 
-clist_X_iter        clist_X_insert_at(clist_X* self, clist_X_iter it, i_val value);     // return iter to new elem
-clist_X_iter        clist_X_emplace_at(clist_X* self, clist_X_iter it, i_valraw raw);
+clist_X_iter        clist_X_insert_at(clist_X* self, clist_X_iter it, i_key value);     // return iter to new elem
+clist_X_iter        clist_X_emplace_at(clist_X* self, clist_X_iter it, i_keyraw raw);
 
 void                clist_X_pop_front(clist_X* self);
 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);
-intptr_t            clist_X_remove(clist_X* self, i_valraw raw);                        // removes all matches
+intptr_t            clist_X_remove(clist_X* self, i_keyraw raw);                        // removes all matches
 
 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        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);
-const i_val*        clist_X_get(const clist_X* self, i_valraw raw);
-i_val*              clist_X_get_mut(clist_X* self, i_valraw raw);
+clist_X_iter        clist_X_find(const clist_X* self, i_keyraw raw);
+clist_X_iter        clist_X_find_in(clist_X_iter it1, clist_X_iter it2, i_keyraw raw);
+const i_key*        clist_X_get(const clist_X* self, i_keyraw raw);
+i_key*              clist_X_get_mut(clist_X* self, i_keyraw raw);
 
 void                clist_X_reverse(clist_X* self);
 void                clist_X_sort(clist_X* self);
@@ -108,8 +108,8 @@ void                clist_X_value_drop(clist_X_value* pval);
 |:--------------------|:------------------------------------|:-----------------------------------------|
 | `clist_X`           | `struct { clist_X_node* last; }`                      | The clist type         |
 | `clist_X_node`      | `struct { clist_X_node* next; clist_X_value value; }` | The clist node type |
-| `clist_X_value`     | `i_val`                                               | The clist element type |
-| `clist_X_raw`       | `i_valraw`                                            | clist raw value type   |
+| `clist_X_value`     | `i_key`                                               | The clist element type |
+| `clist_X_raw`       | `i_keyraw`                                            | clist raw value type   |
 | `clist_X_iter`      | `struct { clist_value *ref; ... }`                    | clist iterator         |
 
 ## Example
@@ -117,7 +117,7 @@ void                clist_X_value_drop(clist_X_value* pval);
 Interleave *push_front()* / *push_back()* then *sort()*:
 ```c
 #define i_type DList
-#define i_val double
+#define i_key double
 #include <stc/clist.h>
 
 #include <stdio.h>
@@ -154,7 +154,7 @@ Use of *erase_at()* and *erase_range()*:
 ```c
 // erasing from clist
 #define i_tag i
-#define i_val int
+#define i_key int
 #include <stc/clist.h>
 
 #include <stdio.h>
@@ -189,7 +189,7 @@ mylist contains: 10 30
 Splice `[30, 40]` from *L2* into *L1* before `3`:
 ```c
 #define i_tag i
-#define i_val int
+#define i_key int
 #include <stc/clist.h>
 
 #include <stdio.h>
diff --git a/docs/cpque_api.md b/docs/cpque_api.md
index 962ee162..ca94e367 100644
--- a/docs/cpque_api.md
+++ b/docs/cpque_api.md
@@ -8,17 +8,17 @@ See the c++ class [std::priority_queue](https://en.cppreference.com/w/cpp/contai
 ## Header file and declaration
 
 ```c
-#define i_type      // define type name of the container (default cpque_{i_val})
-#define i_val       // value: REQUIRED
-#define i_less      // compare two i_val* : REQUIRED IF i_val/i_valraw is a non-integral type
-#define i_valdrop   // destroy value func - defaults to empty destruct
-#define i_valclone  // REQUIRED IF i_valdrop defined
+#define i_type      // define type name of the container (default cpque_{i_key})
+#define i_key       // value: REQUIRED
+#define i_less      // compare two i_key* : REQUIRED IF i_key/i_keyraw is a non-integral type
+#define i_keydrop   // destroy value func - defaults to empty destruct
+#define i_keyclone  // REQUIRED IF i_keydrop defined
 
-#define i_valraw    // convertion type
-#define i_valfrom   // convertion func i_valraw => i_val
-#define i_valto     // convertion func i_val* => i_valraw.
+#define i_keyraw    // convertion type
+#define i_keyfrom   // convertion func i_keyraw => i_key
+#define i_keyto     // convertion func i_key* => i_keyraw.
 
-#define i_tag       // alternative typename: cpque_{i_tag}. i_tag defaults to i_val
+#define i_tag       // alternative typename: cpque_{i_tag}. i_tag defaults to i_key
 #include <stc/cpque.h>
 ```
 `X` should be replaced by the value of `i_tag` in all of the following documentation.
@@ -28,7 +28,7 @@ See the c++ class [std::priority_queue](https://en.cppreference.com/w/cpp/contai
 ```c
 cpque_X             cpque_X_init(void);                    // create empty pri-queue.
 cpque_X             cpque_X_with_capacity(intptr_t cap);
-cpque_X             cpque_X_with_size(intptr_t size, i_val null);
+cpque_X             cpque_X_with_size(intptr_t size, i_key null);
 cpque_X             cpque_X_clone(cpque_X pq);
 
 void                cpque_X_clear(cpque_X* self);
@@ -39,16 +39,16 @@ void                cpque_X_drop(cpque_X* self);        // destructor
 
 intptr_t            cpque_X_size(const cpque_X* self);
 bool                cpque_X_empty(const cpque_X* self);
-i_val*              cpque_X_top(const cpque_X* self);
+i_key*              cpque_X_top(const cpque_X* self);
 
 void                cpque_X_make_heap(cpque_X* self);  // heapify the vector.
-void                cpque_X_push(cpque_X* self, i_val value);
-void                cpque_X_emplace(cpque_X* self, i_valraw raw); // converts from raw
+void                cpque_X_push(cpque_X* self, i_key value);
+void                cpque_X_emplace(cpque_X* self, i_keyraw raw); // converts from raw
 
 void                cpque_X_pop(cpque_X* self);
 void                cpque_X_erase_at(cpque_X* self, intptr_t idx);
 
-i_val               cpque_X_value_clone(i_val value);
+i_key               cpque_X_value_clone(i_key value);
 ```
 
 ## Types
@@ -56,14 +56,14 @@ i_val               cpque_X_value_clone(i_val value);
 | 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_value`    | `i_key`                               | The cpque element type  |
 
 ## Example
 ```c
 #include <stc/crand.h>
 #include <stdio.h>
 
-#define i_val int64_t
+#define i_key int64_t
 #define i_cmp -c_default_cmp // min-heap
 #define i_tag i
 #include <stc/cpque.h>
diff --git a/docs/cqueue_api.md b/docs/cqueue_api.md
index f5df86d6..bce62833 100644
--- a/docs/cqueue_api.md
+++ b/docs/cqueue_api.md
@@ -7,16 +7,16 @@ See the c++ class [std::queue](https://en.cppreference.com/w/cpp/container/queue
 
 ## Header file and declaration
 ```c
-#define i_type      // container type name (default: cset_{i_key})
-#define i_val       // value: REQUIRED
-#define i_valdrop   // destroy value func - defaults to empty destruct
-#define i_valclone  // REQUIRED IF i_valdrop defined
+#define i_type      // container type name (default: cqueue_{i_key})
+#define i_key       // value: REQUIRED
+#define i_keydrop   // destroy value func - defaults to empty destruct
+#define i_keyclone  // REQUIRED IF i_keydrop defined
 
-#define i_valraw    // convertion "raw" type - defaults to i_val
-#define i_valfrom   // convertion func i_valraw => i_val
-#define i_valto     // convertion func i_val* => i_valraw
+#define i_keyraw    // convertion "raw" type - defaults to i_key
+#define i_keyfrom   // convertion func i_keyraw => i_key
+#define i_keyto     // convertion func i_key* => i_keyraw
 
-#define i_tag       // alternative typename: cqueue_{i_tag}. i_tag defaults to i_val
+#define i_tag       // alternative typename: cqueue_{i_tag}. i_tag defaults to i_key
 #include <stc/cqueue.h>
 ```
 `X` should be replaced by the value of `i_tag` in all of the following documentation.
@@ -42,8 +42,8 @@ bool                cqueue_X_empty(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*     cqueue_X_push(cqueue_X* self, i_val value);
-cqueue_X_value*     cqueue_X_emplace(cqueue_X* self, i_valraw raw);
+cqueue_X_value*     cqueue_X_push(cqueue_X* self, i_key value);
+cqueue_X_value*     cqueue_X_emplace(cqueue_X* self, i_keyraw raw);
 void                cqueue_X_pop(cqueue_X* self);
 
 cqueue_X_iter       cqueue_X_begin(const cqueue_X* self);
@@ -52,7 +52,7 @@ void                cqueue_X_next(cqueue_X_iter* it);
 cqueue_X_iter       cqueue_X_advance(cqueue_X_iter it, intptr_t n);
 
 bool                cqueue_X_eq(const cqueue_X* c1, const cqueue_X* c2); //  require i_eq/i_cmp/i_less.
-i_val               cqueue_X_value_clone(i_val value);
+i_key               cqueue_X_value_clone(i_key value);
 cqueue_X_raw        cqueue_X_value_toraw(const cqueue_X_value* pval);
 void                cqueue_X_value_drop(cqueue_X_value* pval);
 ```
@@ -62,13 +62,13 @@ void                cqueue_X_value_drop(cqueue_X_value* pval);
 | 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_raw`      | `i_valraw`           | cqueue raw value type    |
+| `cqueue_X_value`    | `i_key`              | The cqueue element type  |
+| `cqueue_X_raw`      | `i_keyraw`           | cqueue raw value type    |
 | `cqueue_X_iter`     | `cdeq_X_iter`        | cqueue iterator          |
 
 ## Examples
 ```c
-#define i_val int
+#define i_key int
 #define i_tag i
 #include <stc/cqueue.h>
 
diff --git a/docs/cset_api.md b/docs/cset_api.md
index ecf87e5b..7bce3136 100644
--- a/docs/cset_api.md
+++ b/docs/cset_api.md
@@ -18,7 +18,7 @@ A **cset** is an associative container that contains a set of unique objects of
 #define i_keyfrom   // convertion func i_keyraw => i_key - defaults to plain copy
 #define i_keyto     // convertion func i_key* => i_keyraw - defaults to plain copy
 
-#define i_tag       // alternative typename: cmap_{i_tag}. i_tag defaults to i_val
+#define i_tag       // alternative typename: cmap_{i_tag}. i_tag defaults to i_key
 #define i_expandby  // default 1. If 2, table expand 2x (else 1.5x)
 #include <stc/cset.h>
 ```
diff --git a/docs/cspan_api.md b/docs/cspan_api.md
index 4262b1ef..1aeeb4f7 100644
--- a/docs/cspan_api.md
+++ b/docs/cspan_api.md
@@ -47,8 +47,11 @@ SpanTypeN_iter  SpanType_begin(const SpanTypeN* self);
 SpanTypeN_iter  SpanType_end(const SpanTypeN* self);
 void            SpanType_next(SpanTypeN_iter* it);
 
-SpanTypeN       cspan_md(char order, ValueType* data, d1, d2, ...); // make a multi-dim cspan. order: 'C' or 'F' (Fortran)
-                // transpose the md span (inverse axes). no changes to the underlying array.
+SpanTypeN       cspan_md(ValueType* data, d1, d2, ...);                     // make a multi-dim cspan, row-major order.
+SpanTypeN       cspan_md_left(ValueType* data, d1, d2, ...);                // column-major ordered cspan (layout left).
+SpanTypeN       cspan_md_ordered(char order, ValueType* data, d1, d2, ...); // order='C': row-major, 'F' (Fortran): column-major.
+
+                // transpose a md span (inverse axes). no changes to the underlying array.
 void            cspan_transpose(const SpanTypeN* self);
 
                 // create a sub md span of lower rank. Like e.g. cspan_slice(Span2, &ms4, {x}, {y}, {c_ALL}, {c_ALL});
diff --git a/docs/csset_api.md b/docs/csset_api.md
index 5695ecf6..d086b660 100644
--- a/docs/csset_api.md
+++ b/docs/csset_api.md
@@ -18,7 +18,7 @@ See the c++ class [std::set](https://en.cppreference.com/w/cpp/container/set) fo
 #define i_keyfrom   // convertion func i_keyraw => i_key - defaults to plain copy
 #define i_keyto     // convertion func i_key* => i_keyraw - defaults to plain copy
 
-#define i_tag       // alternative typename: csset_{i_tag}. i_tag defaults to i_val
+#define i_tag       // alternative typename: csset_{i_tag}. i_tag defaults to i_key
 #include <stc/csset.h>
 ```
 `X` should be replaced by the value of `i_tag` in all of the following documentation.
diff --git a/docs/cstack_api.md b/docs/cstack_api.md
index 9cb7b42b..51889d7f 100644
--- a/docs/cstack_api.md
+++ b/docs/cstack_api.md
@@ -9,15 +9,15 @@ See the c++ class [std::stack](https://en.cppreference.com/w/cpp/container/stack
 
 ```c
 #define i_type      // full typename of the container
-#define i_val       // value: REQUIRED
-#define i_valdrop   // destroy value func - defaults to empty destruct
-#define i_valclone  // REQUIRED IF i_valdrop defined
+#define i_key       // value: REQUIRED
+#define i_keydrop   // destroy value func - defaults to empty destruct
+#define i_keyclone  // REQUIRED IF i_keydrop defined
 
-#define i_valraw    // convertion "raw" type - defaults to i_val
-#define i_valfrom   // convertion func i_valraw => i_val
-#define i_valto     // convertion func i_val* => i_valraw
+#define i_keyraw    // convertion "raw" type - defaults to i_key
+#define i_keyfrom   // convertion func i_keyraw => i_key
+#define i_keyto     // convertion func i_key* => i_keyraw
 
-#define i_tag       // alternative typename: cstack_{i_tag}. i_tag defaults to i_val
+#define i_tag       // alternative typename: cstack_{i_tag}. i_tag defaults to i_key
 #include <stc/cstack.h>
 ```
 `X` should be replaced by the value of `i_tag` in all of the following documentation.
@@ -27,13 +27,13 @@ See the c++ class [std::stack](https://en.cppreference.com/w/cpp/container/stack
 ```c
 cstack_X            cstack_X_init(void);
 cstack_X            cstack_X_with_capacity(intptr_t cap);
-cstack_X            cstack_X_with_size(intptr_t size, i_val fill);
+cstack_X            cstack_X_with_size(intptr_t size, i_key fill);
 cstack_X            cstack_X_clone(cstack_X st);
 
 void                cstack_X_clear(cstack_X* self);
 bool                cstack_X_reserve(cstack_X* self, intptr_t n);
 void                cstack_X_shrink_to_fit(cstack_X* self);
-i_val*              cstack_X_append_uninit(cstack_X* self, intptr_t n);
+i_key*              cstack_X_append_uninit(cstack_X* self, intptr_t n);
 void                cstack_X_copy(cstack_X* self, const cstack_X* other);
 void                cstack_X_drop(cstack_X* self);                       // destructor
 
@@ -41,12 +41,12 @@ intptr_t            cstack_X_size(const cstack_X* self);
 intptr_t            cstack_X_capacity(const cstack_X* self);
 bool                cstack_X_empty(const cstack_X* self);
 
-i_val*              cstack_X_top(const cstack_X* self);
-const i_val*        cstack_X_at(const cstack_X* self, intptr_t idx);
-i_val*              cstack_X_at_mut(cstack_X* self, intptr_t idx);
+i_key*              cstack_X_top(const cstack_X* self);
+const i_key*        cstack_X_at(const cstack_X* self, intptr_t idx);
+i_key*              cstack_X_at_mut(cstack_X* self, intptr_t idx);
 
-i_val*              cstack_X_push(cstack_X* self, i_val value);
-i_val*              cstack_X_emplace(cstack_X* self, i_valraw raw);
+i_key*              cstack_X_push(cstack_X* self, i_key value);
+i_key*              cstack_X_emplace(cstack_X* self, i_keyraw raw);
 
 void                cstack_X_pop(cstack_X* self);
 
@@ -55,8 +55,8 @@ cstack_X_iter       cstack_X_end(const cstack_X* self);
 void                cstack_X_next(cstack_X_iter* it);
 
 bool                cstack_X_eq(const cstack_X* c1, const cstack_X* c2); // require i_eq/i_cmp/i_less.
-i_val               cstack_X_value_clone(i_val value);
-i_valraw            cstack_X_value_toraw(const cvec_X_value* pval);
+i_key               cstack_X_value_clone(i_key value);
+i_keyraw            cstack_X_value_toraw(const cvec_X_value* pval);
 void                cstack_X_value_drop(cvec_X_value* pval);
 ```
 
@@ -65,14 +65,14 @@ void                cstack_X_value_drop(cvec_X_value* pval);
 | 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_raw`      | `i_valraw`                           | cstack raw value type       |
+| `cstack_X_value`    | `i_key`                              | The cstack element type     |
+| `cstack_X_raw`      | `i_keyraw`                           | cstack raw value type       |
 | `cstack_X_iter`     | `struct { cstack_value *ref; }`      | cstack iterator             |
 
 ## Example
 ```c
 #define i_type IStack
-#define i_val int
+#define i_key int
 #include <stc/cstack.h>
 
 #include <stdio.h>
diff --git a/docs/csview_api.md b/docs/csview_api.md
index a02b007a..33df6a64 100644
--- a/docs/csview_api.md
+++ b/docs/csview_api.md
@@ -185,7 +185,7 @@ void print_split(csview input, const char* sep)
 }
 #define i_implement
 #include <stc/cstr.h>
-#define i_val_str
+#define i_key_str
 #include <stc/cstack.h>
 
 cstack_str string_split(csview input, const char* sep)
diff --git a/docs/cvec_api.md b/docs/cvec_api.md
index d19f4bae..ce85e446 100644
--- a/docs/cvec_api.md
+++ b/docs/cvec_api.md
@@ -13,16 +13,16 @@ See the c++ class [std::vector](https://en.cppreference.com/w/cpp/container/vect
 
 ```c
 #define i_type      // full typename of the container
-#define i_val       // value: REQUIRED
-#define i_cmp       // three-way compare two i_valraw* : REQUIRED IF i_valraw is a non-integral type
-#define i_valdrop   // destroy value func - defaults to empty destruct
-#define i_valclone  // REQUIRED IF i_valdrop defined
+#define i_key       // value: REQUIRED
+#define i_cmp       // three-way compare two i_keyraw* : REQUIRED IF i_keyraw is a non-integral type
+#define i_keydrop   // destroy value func - defaults to empty destruct
+#define i_keyclone  // REQUIRED IF i_keydrop defined
 
-#define i_valraw    // convertion "raw" type - defaults to i_val
-#define i_valfrom   // convertion func i_valraw => i_val
-#define i_valto     // convertion func i_val* => i_valraw
+#define i_keyraw    // convertion "raw" type - defaults to i_key
+#define i_keyfrom   // convertion func i_keyraw => i_key
+#define i_keyto     // convertion func i_key* => i_keyraw
 
-#define i_tag       // alternative typename: cvec_{i_tag}. i_tag defaults to i_val
+#define i_tag       // alternative typename: cvec_{i_tag}. i_tag defaults to i_key
 #include <stc/cvec.h>
 ```
 `X` should be replaced by the value of `i_tag` in all of the following documentation.
@@ -31,15 +31,15 @@ See the c++ class [std::vector](https://en.cppreference.com/w/cpp/container/vect
 
 ```c
 cvec_X              cvec_X_init(void);
-cvec_X              cvec_X_with_size(intptr_t size, i_val null);
+cvec_X              cvec_X_with_size(intptr_t size, i_key null);
 cvec_X              cvec_X_with_capacity(intptr_t size);
 cvec_X              cvec_X_clone(cvec_X vec);
 
 void                cvec_X_clear(cvec_X* self);
 void                cvec_X_copy(cvec_X* self, const cvec_X* other);
-cvec_X_iter         cvec_X_copy_n(cvec_X* self, intptr_t idx, const i_val* arr, intptr_t n);
+cvec_X_iter         cvec_X_copy_n(cvec_X* self, intptr_t idx, const i_key* arr, intptr_t n);
 bool                cvec_X_reserve(cvec_X* self, intptr_t cap);
-bool                cvec_X_resize(cvec_X* self, intptr_t size, i_val null);
+bool                cvec_X_resize(cvec_X* self, intptr_t size, i_key null);
 void                cvec_X_shrink_to_fit(cvec_X* self);
 void                cvec_X_drop(cvec_X* self);                              // destructor
 
@@ -48,34 +48,34 @@ intptr_t            cvec_X_size(const cvec_X* self);
 intptr_t            cvec_X_capacity(const cvec_X* self);
 
 const cvec_X_value* cvec_X_at(const cvec_X* self, intptr_t idx);
-const cvec_X_value* cvec_X_get(const cvec_X* self, i_valraw raw);           // return NULL if not found
+const cvec_X_value* cvec_X_get(const cvec_X* self, i_keyraw raw);           // return NULL if not found
 cvec_X_value*       cvec_X_at_mut(cvec_X* self, intptr_t idx);              // return mutable at idx
-cvec_X_value*       cvec_X_get_mut(cvec_X* self, i_valraw raw);             // find mutable value
-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); // return cvec_X_end() if not found
+cvec_X_value*       cvec_X_get_mut(cvec_X* self, i_keyraw raw);             // find mutable value
+cvec_X_iter         cvec_X_find(const cvec_X* self, i_keyraw raw);
+cvec_X_iter         cvec_X_find_in(cvec_X_iter i1, cvec_X_iter i2, i_keyraw raw); // return cvec_X_end() if not found
                     // On sorted vectors:
-cvec_X_iter         cvec_X_binary_search(const cvec_X* self, i_valraw raw); // at elem == raw, else end
-cvec_X_iter         cvec_X_lower_bound(const cvec_X* self, i_valraw raw);   // at first elem >= raw, else end
+cvec_X_iter         cvec_X_binary_search(const cvec_X* self, i_keyraw raw); // at elem == raw, else end
+cvec_X_iter         cvec_X_lower_bound(const cvec_X* self, i_keyraw raw);   // at first elem >= raw, else end
 cvec_X_iter         cvec_X_binary_search_in(cvec_X_iter i1, cvec_X_iter i2,
-                                            i_valraw raw, cvec_X_iter* lower_bound);
+                                            i_keyraw raw, cvec_X_iter* lower_bound);
 
 cvec_X_value*       cvec_X_front(const cvec_X* self);
 cvec_X_value*       cvec_X_back(const cvec_X* self);
 
-cvec_X_value*       cvec_X_push(cvec_X* self, i_val value);
-cvec_X_value*       cvec_X_emplace(cvec_X* self, i_valraw raw);
-cvec_X_value*       cvec_X_push_back(cvec_X* self, i_val value);            // alias for push
-cvec_X_value*       cvec_X_emplace_back(cvec_X* self, i_valraw raw);        // alias for emplace
+cvec_X_value*       cvec_X_push(cvec_X* self, i_key value);
+cvec_X_value*       cvec_X_emplace(cvec_X* self, i_keyraw raw);
+cvec_X_value*       cvec_X_push_back(cvec_X* self, i_key value);            // alias for push
+cvec_X_value*       cvec_X_emplace_back(cvec_X* self, i_keyraw raw);        // alias for emplace
 
 void                cvec_X_pop(cvec_X* self);
 void                cvec_X_pop_back(cvec_X* self);                          // alias for pop
 
-cvec_X_iter         cvec_X_insert_n(cvec_X* self, intptr_t idx, const i_val arr[], intptr_t n); // move values
-cvec_X_iter         cvec_X_insert_at(cvec_X* self, cvec_X_iter it, i_val value);  // move value 
+cvec_X_iter         cvec_X_insert_n(cvec_X* self, intptr_t idx, const i_key arr[], intptr_t n); // move values
+cvec_X_iter         cvec_X_insert_at(cvec_X* self, cvec_X_iter it, i_key value);  // move value 
 cvec_X_iter         cvec_X_insert_uninit(cvec_X* self, intptr_t idx, intptr_t n); // return iter at idx 
 
-cvec_X_iter         cvec_X_emplace_n(cvec_X* self, intptr_t idx, const i_valraw raw[], intptr_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_n(cvec_X* self, intptr_t idx, const i_keyraw raw[], intptr_t n);
+cvec_X_iter         cvec_X_emplace_at(cvec_X* self, cvec_X_iter it, i_keyraw raw);
 
 cvec_X_iter         cvec_X_erase_n(cvec_X* self, intptr_t idx, intptr_t n);
 cvec_X_iter         cvec_X_erase_at(cvec_X* self, cvec_X_iter it);
@@ -83,7 +83,7 @@ cvec_X_iter         cvec_X_erase_range(cvec_X* self, cvec_X_iter it1, cvec_X_ite
 
 void                cvec_X_sort(cvec_X* self);
 void                cvec_X_sort_range(cvec_X_iter i1, cvec_X_iter i2,
-                                      int(*cmp)(const i_val*, const i_val*));
+                                      int(*cmp)(const i_key*, const i_key*));
 
 cvec_X_iter         cvec_X_begin(const cvec_X* self);
 cvec_X_iter         cvec_X_end(const cvec_X* self);
@@ -101,13 +101,13 @@ cvec_X_raw          cvec_X_value_drop(cvec_X_value* pval);
 | 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_raw`       | `i_valraw`                        | The raw value type     |
+| `cvec_X_value`     | `i_key`                           | The cvec value type    |
+| `cvec_X_raw`       | `i_keyraw`                        | The raw value type     |
 | `cvec_X_iter`      | `struct { cvec_X_value* ref; }`   | The iterator type      |
 
 ## Examples
 ```c
-#define i_val int
+#define i_key int
 #include <stc/cvec.h>
 
 #include <stdio.h>
@@ -150,7 +150,7 @@ sorted: 5 7 8 13 16 25
 #define i_implement
 #include <stc/cstr.h>
 
-#define i_val_str
+#define i_key_str
 #include <stc/cvec.h>
 
 int main() {
@@ -206,7 +206,7 @@ User User_clone(User user) {
 
 // Declare a managed, clonable vector of users.
 #define i_type UVec
-#define i_valclass User // User is a "class" as it has _cmp, _clone and _drop functions.
+#define i_keyclass User // User is a "class" as it has _cmp, _clone and _drop functions.
 #include <stc/cvec.h>
 
 int main(void) {
diff --git a/include/stc/algo/sort.h b/include/stc/algo/sort.h
index 8365ccc5..01e7d521 100644
--- a/include/stc/algo/sort.h
+++ b/include/stc/algo/sort.h
@@ -22,13 +22,13 @@
  */
 /* Generic Quicksort in C, performs as fast as c++ std::sort().
 template params:
-#define i_val           - value type [required]
+#define i_key           - value type [required]
 #define i_less          - less function. default: *x < *y
-#define i_type name     - define {{name}}_sort_n(), else {{i_val}}array_sort_n().
+#define i_type name     - define {{name}}_sort_n(), else {{i_key}}array_sort_n().
 
 // ex1:
 #include <stdio.h>
-#define i_val int
+#define i_key int
 #include <stc/algo/sort.h>
 
 int main() {
@@ -42,7 +42,7 @@ int main() {
 }
 
 // ex2:
-#define i_val int
+#define i_key int
 #define i_type IDeq
 #define i_more // retain input template params to be reused by sort.h
 #include <stc/cdeq.h>
@@ -62,13 +62,16 @@ int main() {
 */
 #include "../ccommon.h"
 
+#if !defined i_key && defined i_val
+  #define i_key i_val
+#endif
 #ifndef i_type
   #define i_at(arr, idx) (&arr[idx])
   #ifndef i_tag
-    #define i_tag i_val
+    #define i_tag i_key
   #endif
   #define i_type c_PASTE(i_tag, array)
-  typedef i_val i_type;
+  typedef i_key i_type;
 #endif
 #ifndef i_at
   #define i_at(arr, idx) _cx_MEMB(_at_mut)(arr, idx)
@@ -78,7 +81,7 @@ int main() {
 
 static inline void _cx_MEMB(_insertsort_ij)(_cx_Self* arr, intptr_t lo, intptr_t hi) {
     for (intptr_t j = lo, i = lo + 1; i <= hi; j = i, ++i) {
-        i_val key = *i_at(arr, i);
+        i_key key = *i_at(arr, i);
         while (j >= 0 && (i_less((&key), i_at(arr, j)))) {
             *i_at(arr, j + 1) = *i_at(arr, j);
             --j;
@@ -90,14 +93,14 @@ static inline void _cx_MEMB(_insertsort_ij)(_cx_Self* arr, intptr_t lo, intptr_t
 static inline void _cx_MEMB(_sort_ij)(_cx_Self* arr, intptr_t lo, intptr_t hi) {
     intptr_t i = lo, j;
     while (lo < hi) {
-        i_val pivot = *i_at(arr, lo + (hi - lo)*7/16);
+        i_key pivot = *i_at(arr, lo + (hi - lo)*7/16);
         j = hi;
 
         while (i <= j) {
             while (i_less(i_at(arr, i), (&pivot))) ++i;
             while (i_less((&pivot), i_at(arr, j))) --j;
             if (i <= j) {
-                c_swap(i_val, i_at(arr, i), i_at(arr, j));
+                c_swap(i_key, i_at(arr, i), i_at(arr, j));
                 ++i; --j;
             }
         }
diff --git a/include/stc/cbits.h b/include/stc/cbits.h
index 9463c82c..66bc6354 100644
--- a/include/stc/cbits.h
+++ b/include/stc/cbits.h
@@ -90,7 +90,7 @@ STC_INLINE _llong _cbits_count(const uint64_t* set, const _llong sz) {
 STC_INLINE char* _cbits_to_str(const uint64_t* set, const _llong sz, 
                                char* out, _llong start, _llong stop) {
     if (stop > sz) stop = sz;
-    assert(start <= stop);
+    c_assert(start <= stop);
 
     c_memset(out, '0', stop - start);
     for (_llong i = start; i < stop; ++i) 
@@ -122,7 +122,7 @@ STC_INLINE bool _cbits_disjoint(const uint64_t* set, const uint64_t* other, cons
 
 #if !defined i_capacity // DYNAMIC SIZE BITARRAY
 
-#define _i_assert(x) assert(x)
+#define _i_assert(x) c_assert(x)
 #define i_type cbits
 
 typedef struct { uint64_t *data64; _llong _size; } i_type;
@@ -216,13 +216,13 @@ STC_INLINE void _i_memb(_set_all)(i_type *self, const bool value);
 STC_INLINE void _i_memb(_set_pattern)(i_type *self, const uint64_t pattern);
 
 STC_INLINE i_type _i_memb(_with_size)(const _llong size, const bool value) {
-    assert(size <= i_capacity);
+    c_assert(size <= i_capacity);
     i_type set; _i_memb(_set_all)(&set, value);
     return set;
 }
 
 STC_INLINE i_type _i_memb(_with_pattern)(const _llong size, const uint64_t pattern) {
-    assert(size <= i_capacity);
+    c_assert(size <= i_capacity);
     i_type set; _i_memb(_set_pattern)(&set, pattern);
     return set;
 }
diff --git a/include/stc/ccommon.h b/include/stc/ccommon.h
index d6da8734..efbebdc3 100644
--- a/include/stc/ccommon.h
+++ b/include/stc/ccommon.h
@@ -34,11 +34,6 @@ typedef long long _llong;
 #define c_NPOS INTPTR_MAX
 #define c_ZI PRIiPTR
 #define c_ZU PRIuPTR
-#if defined STC_NDEBUG || defined NDEBUG
-  #define c_ASSERT(expr) (void)(0)
-#else
-  #define c_ASSERT(expr) assert(expr)
-#endif
 
 #if defined(_MSC_VER)
   #pragma warning(disable: 4116 4996) // unnamed type definition in parentheses
@@ -80,7 +75,14 @@ typedef long long _llong;
 #define c_free(p)               free(p)
 #define c_delete(T, ptr)        do { T *_tp = ptr; T##_drop(_tp); free(_tp); } while (0)
 
-#define c_static_assert(b)      ((int)(0*sizeof(int[(b) ? 1 : -1])))
+#define c_static_assert(...)    c_MACRO_OVERLOAD(c_static_assert, __VA_ARGS__)
+#define c_static_assert_1(b)    ((int)(0*sizeof(int[(b) ? 1 : -1])))
+#define c_static_assert_2(b, m) c_static_assert_1(b)
+#if defined STC_NDEBUG || defined NDEBUG
+  #define c_assert(expr)        ((void)0)
+#else
+  #define c_assert(expr)        assert(expr)
+#endif
 #define c_container_of(p, C, m) ((C*)((char*)(1 ? (p) : &((C*)0)->m) - offsetof(C, m)))
 #define c_const_cast(T, p)      ((T)(p) + 0*sizeof((T)0 == (p)))
 #define c_swap(T, xp, yp)       do { T *_xp = xp, *_yp = yp, \
diff --git a/include/stc/cdeq.h b/include/stc/cdeq.h
index bac40f90..056ef005 100644
--- a/include/stc/cdeq.h
+++ b/include/stc/cdeq.h
@@ -51,13 +51,13 @@ _cx_MEMB(_push_back)(_cx_Self* self, _cx_value val)
 
 STC_INLINE void
 _cx_MEMB(_pop_back)(_cx_Self* self) {
-    assert(!_cx_MEMB(_empty)(self));
+    c_assert(!_cx_MEMB(_empty)(self));
     self->end = (self->end - 1) & self->capmask;
     i_keydrop((self->data + self->end));
 }
 
 STC_INLINE _cx_value _cx_MEMB(_pull_back)(_cx_Self* self) { // move back out of deq
-    assert(!_cx_MEMB(_empty)(self));
+    c_assert(!_cx_MEMB(_empty)(self));
     self->end = (self->end - 1) & self->capmask;
     return self->data[self->end];
 }
diff --git a/include/stc/clist.h b/include/stc/clist.h
index 38358d73..9cc1bb39 100644
--- a/include/stc/clist.h
+++ b/include/stc/clist.h
@@ -145,7 +145,7 @@ STC_INLINE void         _cx_MEMB(_clear)(_cx_Self* self) { _cx_MEMB(_drop)(self)
 STC_INLINE _cx_value*   _cx_MEMB(_push)(_cx_Self* self, i_key value)
                             { return _cx_MEMB(_push_back)(self, value); }
 STC_INLINE void         _cx_MEMB(_pop_front)(_cx_Self* self)
-                            { assert(!_cx_MEMB(_empty)(self)); _cx_MEMB(_erase_after_node)(self, self->last); }
+                            { c_assert(!_cx_MEMB(_empty)(self)); _cx_MEMB(_erase_after_node)(self, self->last); }
 STC_INLINE _cx_value*   _cx_MEMB(_front)(const _cx_Self* self) { return &self->last->next->value; }
 STC_INLINE _cx_value*   _cx_MEMB(_back)(const _cx_Self* self) { return &self->last->value; }
 STC_INLINE _cx_raw      _cx_MEMB(_value_toraw)(const _cx_value* pval) { return i_keyto(pval); }
diff --git a/include/stc/cmap.h b/include/stc/cmap.h
index 21e7b933..513a8b93 100644
--- a/include/stc/cmap.h
+++ b/include/stc/cmap.h
@@ -117,7 +117,7 @@ STC_INLINE bool         _cx_MEMB(_contains)(const _cx_Self* self, _cx_keyraw rke
     STC_INLINE const _cx_mapped*
     _cx_MEMB(_at)(const _cx_Self* self, _cx_keyraw rkey) {
         chash_bucket b = _cx_MEMB(_bucket_)(self, &rkey);
-        assert(b.found);
+        c_assert(b.found);
         return &self->data[b.idx].second;
     }
     STC_INLINE _cx_mapped*
diff --git a/include/stc/cpque.h b/include/stc/cpque.h
index cfe027cc..ca51eeff 100644
--- a/include/stc/cpque.h
+++ b/include/stc/cpque.h
@@ -89,7 +89,7 @@ STC_INLINE const _cx_value* _cx_MEMB(_top)(const _cx_Self* self)
     { return &self->data[0]; }
 
 STC_INLINE void _cx_MEMB(_pop)(_cx_Self* self)
-    { assert(!_cx_MEMB(_empty)(self)); _cx_MEMB(_erase_at)(self, 0); }
+    { c_assert(!_cx_MEMB(_empty)(self)); _cx_MEMB(_erase_at)(self, 0); }
 
 #if !defined i_no_clone
 STC_API _cx_Self _cx_MEMB(_clone)(_cx_Self q);
diff --git a/include/stc/cqueue.h b/include/stc/cqueue.h
index e9f1b877..5d38ca89 100644
--- a/include/stc/cqueue.h
+++ b/include/stc/cqueue.h
@@ -88,13 +88,13 @@ STC_INLINE _cx_value*   _cx_MEMB(_back)(const _cx_Self* self)
                             { return self->data + ((self->end - 1) & self->capmask); }
 
 STC_INLINE void _cx_MEMB(_pop)(_cx_Self* self) { // pop_front
-    assert(!_cx_MEMB(_empty)(self));
+    c_assert(!_cx_MEMB(_empty)(self));
     i_keydrop((self->data + self->start));
     self->start = (self->start + 1) & self->capmask;
 }
 
 STC_INLINE _cx_value _cx_MEMB(_pull)(_cx_Self* self) { // move front out of queue
-    assert(!_cx_MEMB(_empty)(self));
+    c_assert(!_cx_MEMB(_empty)(self));
     intptr_t s = self->start;
     self->start = (s + 1) & self->capmask;
     return self->data[s];
diff --git a/include/stc/cspan.h b/include/stc/cspan.h
index 89986d6f..4d091395 100644
--- a/include/stc/cspan.h
+++ b/include/stc/cspan.h
@@ -84,7 +84,7 @@ int demo2() {
                                   const int rank, const int32_t a[][2]) { \
         Self s = {.data=v}; int outrank; \
         s.data += _cspan_slice(s.shape, s.stride.d, &outrank, shape, stri, rank, a); \
-        c_ASSERT(outrank == RANK); \
+        c_assert(outrank == RANK); \
         return s; \
     } \
     STC_INLINE Self##_iter Self##_begin(const Self* self) { \
@@ -145,7 +145,6 @@ using_cspan_tuple(7); using_cspan_tuple(8);
 #define cspan_subspan3(self, offset, count) \
     {.data=cspan_at(self, offset, 0, 0), .shape={count, (self)->shape[1], (self)->shape[2]}, .stride=(self)->stride}
 
-
 // cspan_submd(): Reduce rank (N <= 4) Optimized, same as e.g. cspan_slice(Span2, &ms4, {x}, {y}, {c_ALL}, {c_ALL});
 #define cspan_submd2(OutSpan, self, ...) _cspan_submdN(OutSpan, 2, self, __VA_ARGS__)
 #define cspan_submd3(OutSpan, self, ...) _cspan_submdN(OutSpan, 3, self, __VA_ARGS__)
@@ -172,23 +171,22 @@ using_cspan_tuple(7); using_cspan_tuple(8);
 #define _cspan_submd4_5(ok, self, x, y, z) \
     {.data=cspan_at(self, x, y, z, 0) + ok, .shape={(self)->shape[3]}, .stride={.d={(self)->stride.d[3]}}}
 
-#define cspan_md(array, ...) cspan_md_order('C', array, __VA_ARGS__)
-#define cspan_md_left(array, ...) cspan_md_order('F', array, __VA_ARGS__)
-#define cspan_md_order(order, array, ...) \
+#define cspan_md(array, ...) cspan_md_ordered('C', array, __VA_ARGS__)
+#define cspan_md_left(array, ...) cspan_md_ordered('F', array, __VA_ARGS__)
+#define cspan_md_ordered(order, array, ...) \
     {.data=array, .shape={__VA_ARGS__}, \
      .stride=*(c_PASTE(cspan_tuple, c_NUMARGS(__VA_ARGS__))*)_cspan_shape2stride(order, ((int32_t[]){__VA_ARGS__}), c_NUMARGS(__VA_ARGS__))}
 
 #define cspan_transpose(self) \
     _cspan_transpose((self)->shape, (self)->stride.d, cspan_rank(self))
 
-
 // General slicing function;
 #define cspan_slice(OutSpan, parent, ...) \
     OutSpan##_slice_((parent)->data, (parent)->shape, (parent)->stride.d, cspan_rank(parent) + \
                      c_static_assert(cspan_rank(parent) == sizeof((int32_t[][2]){__VA_ARGS__})/sizeof(int32_t[2])), \
                      (const int32_t[][2]){__VA_ARGS__})
 
-// ----------- private definitions ------------
+/* ------------------- PRIVAT DEFINITIONS ------------------- */
 
 // cspan_index() helpers:
 #define cspan_idx_1 cspan_idx_3
@@ -215,19 +213,19 @@ STC_INLINE void _cspan_transpose(int32_t shape[], int32_t stride[], int rank) {
 }
 
 STC_INLINE intptr_t _cspan_idx1(const int32_t shape[1], const cspan_tuple1 stri, int32_t x)
-    { c_ASSERT(c_LTu(x, shape[0])); return x; }
+    { c_assert(c_LTu(x, shape[0])); return (intptr_t)stri.d[0]*x; }
 
 STC_INLINE intptr_t _cspan_idx2(const int32_t shape[2], const cspan_tuple2 stri, int32_t x, int32_t y)
-    { c_ASSERT(c_LTu(x, shape[0]) && c_LTu(y, shape[1])); return (intptr_t)stri.d[0]*x + stri.d[1]*y; }
+    { c_assert(c_LTu(x, shape[0]) && c_LTu(y, shape[1])); return (intptr_t)stri.d[0]*x + stri.d[1]*y; }
 
 STC_INLINE intptr_t _cspan_idx3(const int32_t shape[3], const cspan_tuple3 stri, int32_t x, int32_t y, int32_t z) {
-    c_ASSERT(c_LTu(x, shape[0]) && c_LTu(y, shape[1]) && c_LTu(z, shape[2]));
+    c_assert(c_LTu(x, shape[0]) && c_LTu(y, shape[1]) && c_LTu(z, shape[2]));
     return (intptr_t)stri.d[0]*x + stri.d[1]*y + stri.d[2]*z;
 }
 STC_INLINE intptr_t _cspan_idxN(int rank, const int32_t shape[], const int32_t stride[], const int32_t a[]) {
     intptr_t off = 0;
     while (rank--) {
-        c_ASSERT(c_LTu(a[rank], shape[rank]));
+        c_assert(c_LTu(a[rank], shape[rank]));
         off += stride[rank]*a[rank];
     }
     return off;
@@ -239,6 +237,8 @@ STC_API intptr_t _cspan_next2(int32_t pos[], const int32_t shape[], const int32_
 #define _cspan_next4 _cspan_next2
 #define _cspan_next5 _cspan_next2
 #define _cspan_next6 _cspan_next2
+#define _cspan_next7 _cspan_next2
+#define _cspan_next8 _cspan_next2
 
 STC_API intptr_t _cspan_slice(int32_t oshape[], int32_t ostride[], int* orank,
                               const int32_t shape[], const int32_t stride[],
@@ -247,7 +247,7 @@ STC_API intptr_t _cspan_slice(int32_t oshape[], int32_t ostride[], int* orank,
 STC_API int32_t* _cspan_shape2stride(char order, int32_t shape[], int rank);
 #endif // STC_CSPAN_H_INCLUDED
 
-/* -------------------------- IMPLEMENTATION ------------------------- */
+/* --------------------- IMPLEMENTATION --------------------- */
 #if defined(i_implement) || defined(i_static)
 
 STC_DEF int32_t* _cspan_shape2stride(char order, int32_t shape[], int rank) {
@@ -283,13 +283,13 @@ STC_DEF intptr_t _cspan_slice(int32_t oshape[], int32_t ostride[], int* orank,
     for (; i < rank; ++i) {
         off += stride[i]*a[i][0];
         switch (a[i][1]) {
-            case 0: c_ASSERT(c_LTu(a[i][0], shape[i])); continue;
+            case 0: c_assert(c_LTu(a[i][0], shape[i])); continue;
             case -1: end = shape[i]; break;
             default: end = a[i][1];
         }
         oshape[oi] = end - a[i][0];
         ostride[oi] = stride[i];
-        c_ASSERT(c_LTu(0, oshape[oi]) & !c_LTu(shape[i], end));
+        c_assert(c_LTu(0, oshape[oi]) & !c_LTu(shape[i], end));
         ++oi;
     }
     *orank = oi;
diff --git a/include/stc/cstack.h b/include/stc/cstack.h
index 24ec2d5f..f8640ed1 100644
--- a/include/stc/cstack.h
+++ b/include/stc/cstack.h
@@ -129,10 +129,10 @@ STC_INLINE _cx_value* _cx_MEMB(_push)(_cx_Self* self, _cx_value val) {
 }
 
 STC_INLINE void _cx_MEMB(_pop)(_cx_Self* self)
-    { assert(self->_len); _cx_value* p = &self->data[--self->_len]; i_keydrop(p); }
+    { c_assert(self->_len); _cx_value* p = &self->data[--self->_len]; i_keydrop(p); }
 
 STC_INLINE _cx_value _cx_MEMB(_pull)(_cx_Self* self)
-    { assert(self->_len); return self->data[--self->_len]; }
+    { c_assert(self->_len); return self->data[--self->_len]; }
 
 STC_INLINE void _cx_MEMB(_put_n)(_cx_Self* self, const _cx_raw* raw, intptr_t n)
     { while (n--) _cx_MEMB(_push)(self, i_keyfrom(*raw++)); }
@@ -141,9 +141,9 @@ STC_INLINE _cx_Self _cx_MEMB(_from_n)(const _cx_raw* raw, intptr_t n)
     { _cx_Self cx = {0}; _cx_MEMB(_put_n)(&cx, raw, n); return cx; }
 
 STC_INLINE const _cx_value* _cx_MEMB(_at)(const _cx_Self* self, intptr_t idx)
-    { assert(idx < self->_len); return self->data + idx; }
+    { c_assert(idx < self->_len); return self->data + idx; }
 STC_INLINE _cx_value* _cx_MEMB(_at_mut)(_cx_Self* self, intptr_t idx)
-    { assert(idx < self->_len); return self->data + idx; }
+    { c_assert(idx < self->_len); return self->data + idx; }
 
 #if !defined i_no_emplace
 STC_INLINE _cx_value* _cx_MEMB(_emplace)(_cx_Self* self, _cx_raw raw)
diff --git a/include/stc/cvec.h b/include/stc/cvec.h
index e1d34365..9b95306e 100644
--- a/include/stc/cvec.h
+++ b/include/stc/cvec.h
@@ -133,9 +133,9 @@ STC_INLINE _cx_value*   _cx_MEMB(_front)(const _cx_Self* self) { return self->da
 STC_INLINE _cx_value*   _cx_MEMB(_back)(const _cx_Self* self)
                             { return self->data + self->_len - 1; }
 STC_INLINE void         _cx_MEMB(_pop)(_cx_Self* self)
-                            { assert(self->_len); _cx_value* p = &self->data[--self->_len]; i_keydrop(p); }
+                            { c_assert(self->_len); _cx_value* p = &self->data[--self->_len]; i_keydrop(p); }
 STC_INLINE _cx_value    _cx_MEMB(_pull)(_cx_Self* self)
-                            { assert(self->_len); return self->data[--self->_len]; }
+                            { c_assert(self->_len); return self->data[--self->_len]; }
 STC_INLINE _cx_value*   _cx_MEMB(_push_back)(_cx_Self* self, i_key value)
                             { return _cx_MEMB(_push)(self, value); }
 STC_INLINE void         _cx_MEMB(_pop_back)(_cx_Self* self) { _cx_MEMB(_pop)(self); }
@@ -182,11 +182,11 @@ _cx_MEMB(_erase_range)(_cx_Self* self, _cx_iter i1, _cx_iter i2) {
 
 STC_INLINE const _cx_value*
 _cx_MEMB(_at)(const _cx_Self* self, const intptr_t idx) {
-    assert(idx < self->_len); return self->data + idx;
+    c_assert(idx < self->_len); return self->data + idx;
 }
 STC_INLINE _cx_value*
 _cx_MEMB(_at_mut)(_cx_Self* self, const intptr_t idx) {
-    assert(idx < self->_len); return self->data + idx;
+    c_assert(idx < self->_len); return self->data + idx;
 }
 
 
diff --git a/include/stc/extend.h b/include/stc/extend.h
index c0a00ff8..52d59414 100644
--- a/include/stc/extend.h
+++ b/include/stc/extend.h
@@ -43,8 +43,10 @@
   #define _i_val i_val
 #endif
 
-#ifdef _i_key
+#if defined _i_key && defined _i_val
   c_PASTE(forward_, i_base)(i_type, _i_key, _i_val);
+#elif defined _i_key
+  c_PASTE(forward_, i_base)(i_type, _i_key);
 #else
   c_PASTE(forward_, i_base)(i_type, _i_val);
 #endif
diff --git a/misc/benchmarks/various/csort_bench.c b/misc/benchmarks/various/csort_bench.c
index d434693f..f6b7f1db 100644
--- a/misc/benchmarks/various/csort_bench.c
+++ b/misc/benchmarks/various/csort_bench.c
@@ -7,7 +7,7 @@
 #endif
 #define NDEBUG
 #define i_type Ints
-#define i_val int
+#define i_key int
 #define i_more
 #include <stc/cvec.h>
 #include <stc/algo/sort.h>
diff --git a/misc/examples/arc_containers.c b/misc/examples/arc_containers.c
index b05bbea6..524758e7 100644
--- a/misc/examples/arc_containers.c
+++ b/misc/examples/arc_containers.c
@@ -10,18 +10,18 @@
 #include <stc/csmap.h>
 
 #define i_type Arc // (atomic) ref. counted type
-#define i_val Map
-#define i_valdrop(p) (printf("drop Arc:\n"), Map_drop(p))
+#define i_key Map
+#define i_keydrop(p) (printf("drop Arc:\n"), Map_drop(p))
 // no need for atomic ref. count in single thread:
 #define i_opt c_no_atomic
 #include <stc/carc.h>
 
 #define i_type Stack
-#define i_valboxed Arc // define i_valboxed for carc/cbox value (not i_val)
+#define i_keyboxed Arc // define i_keyboxed for carc/cbox value (not i_key)
 #include <stc/cvec.h>
 
 #define i_type List
-#define i_valboxed Arc // as above
+#define i_keyboxed Arc // as above
 #include <stc/clist.h>
 
 int main()
diff --git a/misc/examples/arc_demo.c b/misc/examples/arc_demo.c
index 4cda1c8b..547e1737 100644
--- a/misc/examples/arc_demo.c
+++ b/misc/examples/arc_demo.c
@@ -6,18 +6,18 @@ void int_drop(int* x) {
 }
 
 // carc implements its own clone method using reference counting,
-// so 'i_valclone' is not required to be defined (ignored).
+// so 'i_keyclone' is not required to be defined (ignored).
 
 #define i_type Arc          // set type name to be defined (instead of 'carc_int')
-#define i_val int
-#define i_valdrop int_drop  // optional, just to display the elements destroyed
+#define i_key int
+#define i_keydrop int_drop  // optional, just to display the elements destroyed
 #define i_native_cmp        // use int comparison (x < y, x == y).
 #include <stc/carc.h>       // Arc
 
 #define i_keyboxed Arc      // note: use i_keyboxed instead of i_key for carc/cbox elements
 #include <stc/csset.h>      // csset_Arc (like: std::set<std::shared_ptr<int>>)
 
-#define i_valboxed Arc      // note: as above.
+#define i_keyboxed Arc      // note: as above.
 #include <stc/cvec.h>       // cvec_Arc (like: std::vector<std::shared_ptr<int>>)
 
 int main()
diff --git a/misc/examples/arcvec_erase.c b/misc/examples/arcvec_erase.c
index 0b9252d9..f409258b 100644
--- a/misc/examples/arcvec_erase.c
+++ b/misc/examples/arcvec_erase.c
@@ -3,13 +3,13 @@
 void show_drop(int* x) { printf("drop: %d\n", *x); }
 
 #define i_type Arc
-#define i_val int
-#define i_valdrop show_drop
+#define i_key int
+#define i_keydrop show_drop
 #define i_native_cmp        // enable sort/search for int type
 #include <stc/carc.h>       // Shared pointer to int
 
 #define i_type Vec
-#define i_valboxed Arc
+#define i_keyboxed Arc
 #include <stc/cvec.h>       // Vec: cvec<Arc>
 
 
diff --git a/misc/examples/astar.c b/misc/examples/astar.c
index 1b3876aa..44cdefee 100644
--- a/misc/examples/astar.c
+++ b/misc/examples/astar.c
@@ -57,11 +57,11 @@ point_key_cmp(const point* a, const point* b)
     return (i == j) ? 0 : (i < j) ? -1 : 1;
 }
 
-#define i_val point
+#define i_key point
 #define i_cmp point_cmp_priority
 #include <stc/cpque.h>
 
-#define i_val point
+#define i_key point
 #define i_opt c_no_cmp
 #include <stc/cdeq.h>
 
diff --git a/misc/examples/box.c b/misc/examples/box.c
index a9131afa..3f55e15d 100644
--- a/misc/examples/box.c
+++ b/misc/examples/box.c
@@ -29,11 +29,11 @@ void Person_drop(Person* p) {
 }
 
 #define i_type PBox
-#define i_valclass Person // "class" binds _cmp, _clone, _drop functions.
+#define i_keyclass Person // "class" binds _cmp, _clone, _drop functions.
 #include <stc/cbox.h>
 
 #define i_type Persons
-#define i_valboxed PBox // "arcbox" informs that PBox is a smart pointer.
+#define i_keyboxed PBox // "arcbox" informs that PBox is a smart pointer.
 #include <stc/csset.h>
 
 int main()
diff --git a/misc/examples/box2.c b/misc/examples/box2.c
index d3762462..5ac706d4 100644
--- a/misc/examples/box2.c
+++ b/misc/examples/box2.c
@@ -14,15 +14,15 @@ typedef struct {
     Point bottom_right;
 } Rectangle;
 
-#define i_val Point
+#define i_key Point
 #include <stc/cbox.h> // cbox_Point
 
-#define i_val Rectangle
+#define i_key Rectangle
 #include <stc/cbox.h> // cbox_Rectangle
 
 // Box in box:
 #define i_type BoxBoxPoint
-#define i_valboxed cbox_Point // NB: use i_valboxed when value is a cbox or carc!
+#define i_keyboxed cbox_Point // NB: use i_keyboxed when value is a cbox or carc!
 #define i_no_cmp
 #include <stc/cbox.h> // BoxBoxPoint
 
diff --git a/misc/examples/cointerleave.c b/misc/examples/cointerleave.c
index 61562a5f..c3c5926a 100644
--- a/misc/examples/cointerleave.c
+++ b/misc/examples/cointerleave.c
@@ -2,7 +2,7 @@
 #include <stdio.h>
 #include <stc/calgo.h>
 #define i_type IVec
-#define i_val int
+#define i_key int
 #include <stc/cvec.h>
 
 struct GenValue {
diff --git a/misc/examples/complex.c b/misc/examples/complex.c
index b5ea847a..405afef3 100644
--- a/misc/examples/complex.c
+++ b/misc/examples/complex.c
@@ -9,11 +9,11 @@
 #include <stc/cstr.h>
 
 #define i_type FloatStack
-#define i_val float
+#define i_key float
 #include <stc/cstack.h>
 
 #define i_type StackList
-#define i_valclass FloatStack  // "class" picks up _clone, _drop, _cmp
+#define i_keyclass FloatStack  // "class" picks up _clone, _drop, _cmp
 #define i_opt c_no_cmp         // exclude FloatStack_cmp(): not defined
 #include <stc/clist.h>
 
diff --git a/misc/examples/convert.c b/misc/examples/convert.c
index 318f09b8..3b9dc3ec 100644
--- a/misc/examples/convert.c
+++ b/misc/examples/convert.c
@@ -6,10 +6,10 @@
 #define i_val_str
 #include <stc/cmap.h>
 
-#define i_val_str
+#define i_key_str
 #include <stc/cvec.h>
 
-#define i_val_str
+#define i_key_str
 #include <stc/clist.h>
 
 int main()
diff --git a/misc/examples/csmap_find.c b/misc/examples/csmap_find.c
index 645828a3..b535e9ad 100644
--- a/misc/examples/csmap_find.c
+++ b/misc/examples/csmap_find.c
@@ -8,7 +8,7 @@
 #define i_tag istr
 #include <stc/csmap.h>
 
-#define i_val csmap_istr_raw
+#define i_key csmap_istr_raw
 #define i_tag istr
 #include <stc/cvec.h>
 
diff --git a/misc/examples/csmap_insert.c b/misc/examples/csmap_insert.c
index 18a88ec3..df638c22 100644
--- a/misc/examples/csmap_insert.c
+++ b/misc/examples/csmap_insert.c
@@ -12,7 +12,7 @@
 #define i_tag istr // Map of int => cstr
 #include <stc/csmap.h>
 
-#define i_val csmap_ii_raw
+#define i_key csmap_ii_raw
 #define i_opt c_no_cmp
 #define i_tag ii
 #include <stc/cvec.h>
diff --git a/misc/examples/demos.c b/misc/examples/demos.c
index b2f50ebf..2e91b20c 100644
--- a/misc/examples/demos.c
+++ b/misc/examples/demos.c
@@ -28,7 +28,7 @@ void stringdemo1()
     cstr_drop(&cs);
 }
 
-#define i_val int64_t
+#define i_key int64_t
 #define i_tag ix
 #include <stc/cvec.h>
 
@@ -52,7 +52,7 @@ void vectordemo1()
     cvec_ix_drop(&bignums);
 }
 
-#define i_val_str
+#define i_key_str
 #include <stc/cvec.h>
 
 void vectordemo2()
@@ -72,7 +72,7 @@ void vectordemo2()
     cvec_str_drop(&names);
 }
 
-#define i_val int
+#define i_key int
 #define i_tag ix
 #define i_native_cmp
 #include <stc/clist.h>
diff --git a/misc/examples/forfilter.c b/misc/examples/forfilter.c
index 7e3c4c9c..f3c008b3 100644
--- a/misc/examples/forfilter.c
+++ b/misc/examples/forfilter.c
@@ -7,7 +7,7 @@
 #include <stc/algo/crange.h>
 
 #define i_type IVec
-#define i_val int
+#define i_key int
 #include <stc/cstack.h>
 
 // filters and transforms:
@@ -83,7 +83,7 @@ fn main() {
 }
 */
 #define i_type SVec
-#define i_valclass csview
+#define i_keyclass csview
 #include <stc/cstack.h>
 
 void demo3(void)
diff --git a/misc/examples/forloops.c b/misc/examples/forloops.c
index 337cfaa1..99b12871 100644
--- a/misc/examples/forloops.c
+++ b/misc/examples/forloops.c
@@ -2,7 +2,7 @@
 #include <stc/algo/filter.h>
 
 #define i_type IVec
-#define i_val int
+#define i_key int
 #include <stc/cstack.h>
 
 #define i_type IMap
diff --git a/misc/examples/functor.c b/misc/examples/functor.c
index a233a874..ea409a56 100644
--- a/misc/examples/functor.c
+++ b/misc/examples/functor.c
@@ -6,7 +6,7 @@
 
 #define i_type IPQue
 #define i_base cpque
-#define i_val int
+#define i_key int
 #define i_extend bool(*less)(const int*, const int*);
 #define i_less(x, y) c_extend()->less(x, y)
 // Note: i_less: c_extend() accessible for cpque types
diff --git a/misc/examples/inits.c b/misc/examples/inits.c
index a3a6c4d2..53a49f1f 100644
--- a/misc/examples/inits.c
+++ b/misc/examples/inits.c
@@ -18,17 +18,17 @@ inline static int ipair_cmp(const ipair_t* a, const ipair_t* b) {
 }
 
 
-#define i_val ipair_t
+#define i_key ipair_t
 #define i_cmp ipair_cmp
 #define i_tag ip
 #include <stc/cvec.h>
 
-#define i_val ipair_t
+#define i_key ipair_t
 #define i_cmp ipair_cmp
 #define i_tag ip
 #include <stc/clist.h>
 
-#define i_val float
+#define i_key float
 #define i_tag f
 #include <stc/cpque.h>
 
diff --git a/misc/examples/intrusive.c b/misc/examples/intrusive.c
index e3939f4e..1e3f7b83 100644
--- a/misc/examples/intrusive.c
+++ b/misc/examples/intrusive.c
@@ -3,7 +3,7 @@
 #include <stdio.h> 
 
 #define i_type List
-#define i_val int
+#define i_key int
 #define i_native_cmp
 #include <stc/clist.h>
 
diff --git a/misc/examples/list.c b/misc/examples/list.c
index 08fe837f..a0045db9 100644
--- a/misc/examples/list.c
+++ b/misc/examples/list.c
@@ -4,7 +4,7 @@
 #include <stc/crand.h>
 
 #define i_type DList
-#define i_val double
+#define i_key double
 #define i_native_cmp
 #include <stc/clist.h>
 
diff --git a/misc/examples/list_erase.c b/misc/examples/list_erase.c
index 17adf11f..357dd75b 100644
--- a/misc/examples/list_erase.c
+++ b/misc/examples/list_erase.c
@@ -2,7 +2,7 @@
 #include <stdio.h>
 
 #define i_type IList
-#define i_val int
+#define i_key int
 #include <stc/clist.h>
 
 int main ()
diff --git a/misc/examples/list_splice.c b/misc/examples/list_splice.c
index e457694d..25c2a42d 100644
--- a/misc/examples/list_splice.c
+++ b/misc/examples/list_splice.c
@@ -1,6 +1,6 @@
 #include <stdio.h>
 
-#define i_val int
+#define i_key int
 #define i_tag i
 #include <stc/clist.h>
 
diff --git a/misc/examples/lower_bound.c b/misc/examples/lower_bound.c
index 5b395e45..ee32f49b 100644
--- a/misc/examples/lower_bound.c
+++ b/misc/examples/lower_bound.c
@@ -1,10 +1,10 @@
 #include <stdio.h>
 
-#define i_val int
+#define i_key int
 #define i_native_cmp
 #include <stc/cvec.h>
 
-#define i_val int
+#define i_key int
 #include <stc/csset.h>
 
 int main()
diff --git a/misc/examples/mmap.c b/misc/examples/mmap.c
index 63312e04..fd00499c 100644
--- a/misc/examples/mmap.c
+++ b/misc/examples/mmap.c
@@ -4,7 +4,7 @@
 // Multimap entries
 #define i_implement
 #include <stc/cstr.h>
-#define i_val_str
+#define i_key_str
 #include <stc/clist.h>
 
 // Map of int => clist_str.
diff --git a/misc/examples/multimap.c b/misc/examples/multimap.c
index dc4a1ee0..a89b251b 100644
--- a/misc/examples/multimap.c
+++ b/misc/examples/multimap.c
@@ -40,7 +40,7 @@ OlympicLoc OlympicLoc_clone(OlympicLoc loc);
 void OlympicLoc_drop(OlympicLoc* self);
 
 // Create a clist<OlympicLoc>, can be sorted by year.
-#define i_valclass OlympicLoc // binds _cmp, _clone and _drop.
+#define i_keyclass OlympicLoc // binds _cmp, _clone and _drop.
 #define i_tag OL
 #include <stc/clist.h>
 
diff --git a/misc/examples/music_arc.c b/misc/examples/music_arc.c
index 4efc35c8..49008523 100644
--- a/misc/examples/music_arc.c
+++ b/misc/examples/music_arc.c
@@ -22,13 +22,13 @@ void Song_drop(Song* s) {
 
 // Define the shared pointer:
 #define i_type SongArc
-#define i_valclass Song
+#define i_keyclass Song
 #define i_no_hash          // no hash fn for Song, fallback hash pointer to Song.
 #include <stc/carc.h>
 
 // ... and a vector of them
 #define i_type SongVec
-#define i_valboxed SongArc // use i_valboxed on carc / cbox (instead of i_val)
+#define i_keyboxed SongArc // use i_keyboxed on carc / cbox (instead of i_key)
 #include <stc/cvec.h>
 
 void example3()
diff --git a/misc/examples/new_list.c b/misc/examples/new_list.c
index 5ffdaca2..ee250b2b 100644
--- a/misc/examples/new_list.c
+++ b/misc/examples/new_list.c
@@ -9,7 +9,7 @@ typedef struct {
     clist_pnt pntlist;
 } MyStruct;
 
-#define i_val int
+#define i_key int
 #define i_tag i32
 #define i_is_forward
 #include <stc/clist.h>
@@ -20,20 +20,20 @@ int point_cmp(const Point* a, const Point* b) {
     return c ? c : a->y - b->y;
 }
 
-#define i_val Point
+#define i_key Point
 #define i_cmp point_cmp
 #define i_is_forward
 #define i_tag pnt
 #include <stc/clist.h>
 
-#define i_val float
+#define i_key float
 #define i_native_cmp               // use < and == operators for comparison 
 #include <stc/clist.h>
 
 void MyStruct_drop(MyStruct* s);
 #define i_type MyList
-#define i_val MyStruct
-#define i_valdrop MyStruct_drop   // define drop function
+#define i_key MyStruct
+#define i_keydrop MyStruct_drop   // define drop function
 #define i_no_clone                // must explicitely exclude or define cloning support because of drop.
 #include <stc/clist.h>
 
diff --git a/misc/examples/new_pque.c b/misc/examples/new_pque.c
index dc2ecf12..3df39e0e 100644
--- a/misc/examples/new_pque.c
+++ b/misc/examples/new_pque.c
@@ -3,7 +3,7 @@
 typedef struct Point { int x, y; } Point;
 
 #define i_type PointQ
-#define i_val Point
+#define i_key Point
 #define i_less(a, b) a->x < b->x || (a->x == b->x && a->y < b->y)
 #include <stc/cpque.h>
 
diff --git a/misc/examples/new_queue.c b/misc/examples/new_queue.c
index b784bc18..104871bf 100644
--- a/misc/examples/new_queue.c
+++ b/misc/examples/new_queue.c
@@ -10,14 +10,14 @@ int point_cmp(const Point* a, const Point* b) {
     int c = c_default_cmp(&a->x, &b->x);
     return c ? c : c_default_cmp(&a->y, &b->y);
 }
-#define i_val Point
+#define i_key Point
 #define i_cmp point_cmp
 #define i_is_forward
 #define i_tag pnt
 #include <stc/cqueue.h>
 
 #define i_type IQ
-#define i_val int
+#define i_key int
 #include <stc/cqueue.h>
 
 int main() {
diff --git a/misc/examples/new_sptr.c b/misc/examples/new_sptr.c
index 2eff41a5..7fef5d1f 100644
--- a/misc/examples/new_sptr.c
+++ b/misc/examples/new_sptr.c
@@ -9,21 +9,21 @@ int Person_cmp(const Person* a, const Person* b);
 uint64_t Person_hash(const Person* p);
 
 #define i_type PersonArc
-#define i_valclass Person // "class" assume _clone, _drop, _cmp, _hash is defined.
+#define i_keyclass Person // "class" assume _clone, _drop, _cmp, _hash is defined.
 #include <stc/carc.h>
 
 #define i_type IPtr
-#define i_val int
-#define i_valdrop(x) printf("drop: %d\n", *x)
+#define i_key int
+#define i_keydrop(x) printf("drop: %d\n", *x)
 #define i_native_cmp
 #include <stc/carc.h>
 
 #define i_type IPStack
-#define i_valboxed IPtr
+#define i_keyboxed IPtr
 #include <stc/cstack.h>
 
 #define i_type PASet
-#define i_valboxed PersonArc
+#define i_keyboxed PersonArc
 #include <stc/cset.h>
 
 
diff --git a/misc/examples/new_vec.c b/misc/examples/new_vec.c
index 6329b185..6d928cfc 100644
--- a/misc/examples/new_vec.c
+++ b/misc/examples/new_vec.c
@@ -9,14 +9,14 @@ typedef struct MyStruct {
     cvec_pnt pntvec;
 } MyStruct;
 
-#define i_val int
+#define i_key int
 #define i_tag i32
 #define i_is_forward
 #include <stc/cvec.h>
 
 typedef struct Point { int x, y; } Point;
 
-#define i_val Point
+#define i_key Point
 #define i_tag pnt
 #define i_less(a, b) a->x < b->x || (a->x == b->x && a->y < b->y)
 #define i_eq(a, b) a->x == b->x && a->y == b->y
diff --git a/misc/examples/person_arc.c b/misc/examples/person_arc.c
index 3614c02d..c78b541c 100644
--- a/misc/examples/person_arc.c
+++ b/misc/examples/person_arc.c
@@ -31,12 +31,12 @@ void Person_drop(Person* p) {
 }
 
 #define i_type PSPtr
-#define i_valclass Person // ensure Person_drop
+#define i_keyclass Person // ensure Person_drop
 #define i_cmp Person_cmp   // specify object cmp, instead of ptr cmp for arc.
 #include <stc/carc.h>
 
 #define i_type Persons
-#define i_valboxed PSPtr // binds PSPtr_cmp, PSPtr_drop...
+#define i_keyboxed PSPtr // binds PSPtr_cmp, PSPtr_drop...
 #include <stc/cvec.h>
 
 
diff --git a/misc/examples/printspan.c b/misc/examples/printspan.c
index 7564bd88..5084536a 100644
--- a/misc/examples/printspan.c
+++ b/misc/examples/printspan.c
@@ -3,14 +3,14 @@
 #include <stdio.h>
 #define i_implement
 #include <stc/cstr.h>
-#define i_val int
+#define i_key int
 #include <stc/cvec.h>
-#define i_val int
+#define i_key int
 #include <stc/cstack.h>
-#define i_val_str
+#define i_key_str
 #include <stc/csset.h>
-#include <stc/cspan.h>
 
+#include <stc/cspan.h>
 using_cspan(intspan, int, 1);
 
 void printMe(intspan container) {
diff --git a/misc/examples/priority.c b/misc/examples/priority.c
index 95dd3183..148e8fc5 100644
--- a/misc/examples/priority.c
+++ b/misc/examples/priority.c
@@ -3,7 +3,7 @@
 #include <time.h>
 #include <stc/crand.h>
 
-#define i_val int64_t
+#define i_key int64_t
 #define i_cmp -c_default_cmp  // min-heap (increasing values)
 #define i_tag i
 #include <stc/cpque.h>
diff --git a/misc/examples/queue.c b/misc/examples/queue.c
index 83c18d09..3154f115 100644
--- a/misc/examples/queue.c
+++ b/misc/examples/queue.c
@@ -1,7 +1,7 @@
 #include <stc/crand.h>
 #include <stdio.h>
 
-#define i_val int
+#define i_key int
 #define i_tag i
 #include <stc/cqueue.h>
 
diff --git a/misc/examples/rawptr_elements.c b/misc/examples/rawptr_elements.c
index 8dd52aee..9c394d8e 100644
--- a/misc/examples/rawptr_elements.c
+++ b/misc/examples/rawptr_elements.c
@@ -16,7 +16,7 @@
 
 // Alternatively, using cbox:
 #define i_type IBox
-#define i_val long
+#define i_key long
 #include <stc/cbox.h> // unique_ptr<long> alike.
 
 // cmap of cstr => IBox
diff --git a/misc/examples/read.c b/misc/examples/read.c
index 3c1cadf6..c25cd740 100644
--- a/misc/examples/read.c
+++ b/misc/examples/read.c
@@ -1,7 +1,7 @@
 #define i_implement
 #include <stc/cstr.h>
 #include <stc/algo/raii.h>
-#define i_val_str
+#define i_key_str
 #include <stc/cvec.h>
 #include <errno.h>
 
diff --git a/misc/examples/regex_match.c b/misc/examples/regex_match.c
index 310e0797..88d3747b 100644
--- a/misc/examples/regex_match.c
+++ b/misc/examples/regex_match.c
@@ -3,7 +3,7 @@
 #define i_implement
 #include <stc/csview.h>
 
-#define i_val float
+#define i_key float
 #include <stc/cstack.h>
 
 int main()
diff --git a/misc/examples/scheduler.c b/misc/examples/scheduler.c
index c1168850..d812ff42 100644
--- a/misc/examples/scheduler.c
+++ b/misc/examples/scheduler.c
@@ -9,7 +9,7 @@ struct Task {
 };
 
 #define i_type Scheduler
-#define i_val struct Task
+#define i_key struct Task
 #include <stc/cqueue.h>
 
 static bool schedule(Scheduler* sched)
diff --git a/misc/examples/shape.c b/misc/examples/shape.c
index 1d9fe5c5..bd4bdd5a 100644
--- a/misc/examples/shape.c
+++ b/misc/examples/shape.c
@@ -76,7 +76,7 @@ struct ShapeAPI Triangle_api = {
 // ============================================================
 
 #define i_type PointVec 
-#define i_val Point
+#define i_key Point
 #include <stc/cstack.h>
 
 typedef struct {
@@ -122,8 +122,8 @@ struct ShapeAPI Polygon_api = {
 // ============================================================
 
 #define i_type Shapes
-#define i_val Shape*
-#define i_valdrop(x) Shape_delete(*x)
+#define i_key Shape*
+#define i_keydrop(x) Shape_delete(*x)
 #define i_no_clone
 #include <stc/cstack.h>
 
diff --git a/misc/examples/stack.c b/misc/examples/stack.c
index c817e1ae..96bab24b 100644
--- a/misc/examples/stack.c
+++ b/misc/examples/stack.c
@@ -3,11 +3,11 @@
 
 #define i_tag i
 #define i_capacity 100
-#define i_val int
+#define i_key int
 #include <stc/cstack.h>
 
 #define i_tag c
-#define i_val char
+#define i_key char
 #include <stc/cstack.h>
 
 int main() {
diff --git a/misc/tests/cspan_test.c b/misc/tests/cspan_test.c
index 6834dce1..aa055ea6 100644
--- a/misc/tests/cspan_test.c
+++ b/misc/tests/cspan_test.c
@@ -44,7 +44,7 @@ CTEST(cspan, slice) {
     ASSERT_EQ(45, sum2);
 }
 
-#define i_val int
+#define i_key int
 #include <stc/cstack.h>
 
 CTEST(cspan, slice2) {
@@ -75,7 +75,7 @@ CTEST(cspan, slice2) {
 
 
 #define i_type Tiles
-#define i_val intspan3
+#define i_key intspan3
 #include <stc/cstack.h>
 
 CTEST_FIXTURE(cspan_cube) {
-- 
cgit v1.2.3


From e9121702a5d69624ef1e782e85a8f032e4f4e875 Mon Sep 17 00:00:00 2001
From: tylov <tylo@norceresearch.no>
Date: Sat, 15 Jul 2023 23:20:16 +0200
Subject: Improved warning, and other enhancements in ccommon.h

---
 README.md                                     |  2 +-
 docs/carc_api.md                              |  2 +-
 docs/cbox_api.md                              |  2 +-
 docs/ccommon_api.md                           | 10 +++++-----
 docs/cdeq_api.md                              |  2 +-
 docs/clist_api.md                             |  6 +++---
 docs/cmap_api.md                              | 12 ++++++------
 docs/cpque_api.md                             |  2 +-
 docs/cqueue_api.md                            |  2 +-
 docs/crandom_api.md                           |  2 +-
 docs/cregex_api.md                            |  2 +-
 docs/cset_api.md                              |  2 +-
 docs/csmap_api.md                             |  8 ++++----
 docs/cspan_api.md                             |  6 +++---
 docs/csset_api.md                             |  2 +-
 docs/cstack_api.md                            |  2 +-
 docs/cstr_api.md                              |  2 +-
 docs/csview_api.md                            |  6 +++---
 docs/cvec_api.md                              |  4 ++--
 include/c11/fmt.h                             |  2 +-
 include/stc/algo/crange.h                     |  2 +-
 include/stc/algo/filter.h                     |  2 +-
 include/stc/algo/sort.h                       |  4 ++--
 include/stc/carc.h                            |  4 ++--
 include/stc/cbits.h                           |  2 +-
 include/stc/cbox.h                            |  4 ++--
 include/stc/ccommon.h                         |  6 +++---
 include/stc/clist.h                           |  2 +-
 include/stc/crand.h                           |  2 +-
 include/stc/cvec.h                            |  2 +-
 misc/benchmarks/plotbench/cpque_benchmark.cpp |  2 +-
 misc/benchmarks/various/cspan_bench.c         |  2 +-
 misc/benchmarks/various/rust_cmap.c           |  2 +-
 misc/benchmarks/various/sso_bench.cpp         |  2 +-
 misc/benchmarks/various/string_bench_STC.cpp  |  2 +-
 misc/benchmarks/various/string_bench_STD.cpp  |  2 +-
 misc/examples/arc_containers.c                |  2 +-
 misc/examples/arc_demo.c                      |  2 +-
 misc/examples/arcvec_erase.c                  |  2 +-
 misc/examples/birthday.c                      |  2 +-
 misc/examples/bits2.c                         |  2 +-
 misc/examples/books.c                         |  2 +-
 misc/examples/box.c                           |  2 +-
 misc/examples/cointerleave.c                  |  2 +-
 misc/examples/complex.c                       |  2 +-
 misc/examples/convert.c                       |  2 +-
 misc/examples/csmap_erase.c                   |  2 +-
 misc/examples/csmap_find.c                    |  2 +-
 misc/examples/csmap_insert.c                  |  2 +-
 misc/examples/csset_erase.c                   |  2 +-
 misc/examples/cstr_match.c                    |  2 +-
 misc/examples/demos.c                         | 18 +++++++++---------
 misc/examples/dining_philosophers.c           |  2 +-
 misc/examples/forloops.c                      |  2 +-
 misc/examples/functor.c                       |  2 +-
 misc/examples/gauss2.c                        |  2 +-
 misc/examples/generator.c                     |  2 +-
 misc/examples/intrusive.c                     |  2 +-
 misc/examples/list.c                          |  2 +-
 misc/examples/list_erase.c                    |  2 +-
 misc/examples/list_splice.c                   |  2 +-
 misc/examples/lower_bound.c                   |  2 +-
 misc/examples/mmap.c                          |  2 +-
 misc/examples/multidim.c                      |  2 +-
 misc/examples/multimap.c                      |  2 +-
 misc/examples/music_arc.c                     |  4 ++--
 misc/examples/new_list.c                      |  2 +-
 misc/examples/new_map.c                       |  2 +-
 misc/examples/new_pque.c                      |  2 +-
 misc/examples/new_queue.c                     |  2 +-
 misc/examples/new_smap.c                      |  2 +-
 misc/examples/new_vec.c                       |  2 +-
 misc/examples/person_arc.c                    |  2 +-
 misc/examples/printspan.c                     |  2 +-
 misc/examples/priority.c                      |  2 +-
 misc/examples/queue.c                         |  2 +-
 misc/examples/random.c                        |  2 +-
 misc/examples/rawptr_elements.c               |  2 +-
 misc/examples/read.c                          |  2 +-
 misc/examples/regex2.c                        |  2 +-
 misc/examples/regex_match.c                   |  2 +-
 misc/examples/regex_replace.c                 |  2 +-
 misc/examples/replace.c                       |  2 +-
 misc/examples/scheduler.c                     |  2 +-
 misc/examples/sidebyside.cpp                  |  2 +-
 misc/examples/sorted_map.c                    |  2 +-
 misc/examples/splitstr.c                      |  2 +-
 misc/examples/sso_map.c                       |  2 +-
 misc/examples/sso_substr.c                    |  2 +-
 misc/examples/stack.c                         |  2 +-
 misc/examples/sview_split.c                   |  2 +-
 misc/examples/triples.c                       |  2 +-
 misc/examples/unordered_set.c                 |  2 +-
 misc/examples/utf8replace_c.c                 |  2 +-
 misc/examples/vikings.c                       |  2 +-
 95 files changed, 128 insertions(+), 128 deletions(-)

(limited to 'include/stc/cbits.h')

diff --git a/README.md b/README.md
index 1601204d..b7e06790 100644
--- a/README.md
+++ b/README.md
@@ -181,7 +181,7 @@ Switching to a different container type, e.g. a sorted set (csset):
 #include <stc/csset.h> // Use a sorted set instead
 #include <stdio.h>
 
-int main()
+int main(void)
 {
     Floats nums = {0};
     Floats_push(&nums, 30.f);
diff --git a/docs/carc_api.md b/docs/carc_api.md
index 254f868a..8b7b67a1 100644
--- a/docs/carc_api.md
+++ b/docs/carc_api.md
@@ -97,7 +97,7 @@ bool        carc_X_value_eq(const i_key* x, const i_key* y);
 #define i_keyboxed Arc // Note: use i_keyboxed for carc or cbox value types
 #include <stc/cstack.h>
 
-int main()
+int main(void)
 {
     Stack s1 = {0}, s2 = {0};
     Map *map;
diff --git a/docs/cbox_api.md b/docs/cbox_api.md
index 83d59521..b6c76d2f 100644
--- a/docs/cbox_api.md
+++ b/docs/cbox_api.md
@@ -90,7 +90,7 @@ void int_drop(int* x) {
 #define i_keyboxed IBox       // NB: use i_keyboxed instead of i_key
 #include <stc/cvec.h>         // IVec : std::vector<std::unique_ptr<int>>
 
-int main()
+int main(void)
 {
     IVec vec = c_init(Vec, {2021, 2012, 2022, 2015});
     ISet set = {0};
diff --git a/docs/ccommon_api.md b/docs/ccommon_api.md
index 6bce56af..e053f743 100644
--- a/docs/ccommon_api.md
+++ b/docs/ccommon_api.md
@@ -137,7 +137,7 @@ bool isPrime(long long i) {
     return true;
 }
 
-int main() {
+int main(void) {
     // Get 10 prime numbers starting from 1000. Skip the first 15 primes,
     // then select every 25th prime (including the initial).
     crange R = crange_make(1001, INT64_MAX, 2); // 1001, 1003, ...
@@ -214,7 +214,7 @@ There is a [benchmark/test file here](../misc/benchmarks/various/csort_bench.c).
 #include <stc/algo/sort.h>
 #include <stdio.h>
 
-int main() {
+int main(void) {
     int nums[] = {5, 3, 5, 9, 7, 4, 7, 2, 4, 9, 3, 1, 2, 6, 4};
     intarray_sort_n(nums, c_arraylen(nums));
     c_forrange (i, c_arraylen(arr)) printf(" %d", arr[i]);
@@ -230,7 +230,7 @@ possible and very fast. Note that `i_more` must be defined to retain specified t
 #include <stc/algo/sort.h>
 #include <stdio.h>
 
-int main() {
+int main(void) {
     MyDeq deq = c_init(MyDeq, {5, 3, 5, 9, 7, 4, 7, 2, 4, 9, 3, 1, 2, 6, 4});
     MyDeq_sort_n(&deq, MyDeq_size(&deq));
     c_foreach (i, MyDeq, deq) printf(" %d", *i.ref);
@@ -348,7 +348,7 @@ int gcd(int a, int b) { // greatest common denominator
     return a;
 }
 
-int main()
+int main(void)
 {
     struct triples t = {.n=INT32_MAX};
     int n = 0;
@@ -500,7 +500,7 @@ cvec_str readFile(const char* name)
     return vec;
 }
 
-int main()
+int main(void)
 {
     c_with (cvec_str vec = readFile(__FILE__), cvec_str_drop(&vec))
         c_foreach (i, cvec_str, vec)
diff --git a/docs/cdeq_api.md b/docs/cdeq_api.md
index 292b0933..c6de6cd6 100644
--- a/docs/cdeq_api.md
+++ b/docs/cdeq_api.md
@@ -101,7 +101,7 @@ void                cdeq_X_value_drop(cdeq_X_value* pval);
 
 #include <stdio.h>
 
-int main() {
+int main(void) {
     cdeq_i q = cdeq_i_init();
     cdeq_i_push_front(&q, 10);
     c_foreach (i, cdeq_i, q)
diff --git a/docs/clist_api.md b/docs/clist_api.md
index 023cca41..3d785789 100644
--- a/docs/clist_api.md
+++ b/docs/clist_api.md
@@ -122,7 +122,7 @@ Interleave *push_front()* / *push_back()* then *sort()*:
 
 #include <stdio.h>
 
-int main() {
+int main(void) {
     DList list = c_init(DList, {10., 20., 30., 40., 50., 60., 70., 80., 90.});
 
     c_forrange (i, 1, 10) {
@@ -159,7 +159,7 @@ Use of *erase_at()* and *erase_range()*:
 
 #include <stdio.h>
 
-int main ()
+int main(void)
 {
     clist_i L = c_init(clist_i, {10, 20, 30, 40, 50});
                                                 // 10 20 30 40 50
@@ -194,7 +194,7 @@ Splice `[30, 40]` from *L2* into *L1* before `3`:
 
 #include <stdio.h>
 
-int main() {
+int main(void) {
     clist_i L1 = c_init(clist_i, {1, 2, 3, 4, 5});
     clist_i L2 = c_init(clist_i, {10, 20, 30, 40, 50});
 
diff --git a/docs/cmap_api.md b/docs/cmap_api.md
index 8ef322e6..eca350b4 100644
--- a/docs/cmap_api.md
+++ b/docs/cmap_api.md
@@ -121,7 +121,7 @@ bool                  c_memcmp_eq(const i_keyraw* a, const i_keyraw* b);    // !
 #define i_val_str
 #include <stc/cmap.h>
 
-int main()
+int main(void)
 {
     // Create an unordered_map of three strings (that map to strings)
     cmap_str umap = c_init(cmap_str, {
@@ -165,7 +165,7 @@ This example uses a cmap with cstr as mapped value.
 #define i_val_str
 #include <stc/cmap.h>
 
-int main()
+int main(void)
 {
     uint32_t col = 0xcc7744ff;
 
@@ -208,7 +208,7 @@ typedef struct { int x, y, z; } Vec3i;
 #define i_tag vi
 #include <stc/cmap.h>
 
-int main()
+int main(void)
 {
     // Define map with defered destruct
     cmap_vi vecs = {0};
@@ -243,7 +243,7 @@ typedef struct { int x, y, z; } Vec3i;
 #define i_tag iv
 #include <stc/cmap.h>
 
-int main()
+int main(void)
 {
     cmap_iv vecs = {0}
 
@@ -304,7 +304,7 @@ static inline void Viking_drop(Viking* vk) {
 #define i_val int
 #include <stc/cmap.h>
 
-int main()
+int main(void)
 {
     // Use a HashMap to store the vikings' health points.
     Vikings vikings = {0};
@@ -380,7 +380,7 @@ static inline RViking Viking_toraw(const Viking* vp) {
 #define i_val       int
 #include <stc/cmap.h>
 
-int main()
+int main(void)
 {
     Vikings vikings = {0};
 
diff --git a/docs/cpque_api.md b/docs/cpque_api.md
index ca94e367..5b63dfd1 100644
--- a/docs/cpque_api.md
+++ b/docs/cpque_api.md
@@ -68,7 +68,7 @@ i_key               cpque_X_value_clone(i_key value);
 #define i_tag i
 #include <stc/cpque.h>
 
-int main()
+int main(void)
 {
     intptr_t N = 10000000;
     crand_t rng = crand_init(1234);
diff --git a/docs/cqueue_api.md b/docs/cqueue_api.md
index bce62833..b324e5fc 100644
--- a/docs/cqueue_api.md
+++ b/docs/cqueue_api.md
@@ -74,7 +74,7 @@ void                cqueue_X_value_drop(cqueue_X_value* pval);
 
 #include <stdio.h>
 
-int main() {
+int main(void) {
     cqueue_i Q = cqueue_i_init();
 
     // push() and pop() a few.
diff --git a/docs/crandom_api.md b/docs/crandom_api.md
index 74e23a6a..22a4f4dd 100644
--- a/docs/crandom_api.md
+++ b/docs/crandom_api.md
@@ -76,7 +76,7 @@ double              crand_norm(crand_t* rng, crand_norm_t* dist);
 #define i_tag i
 #include <stc/csmap.h>
 
-int main()
+int main(void)
 {
     enum {N = 10000000};
     const double Mean = -12.0, StdDev = 6.0, Scale = 74;
diff --git a/docs/cregex_api.md b/docs/cregex_api.md
index f87240f8..52476e09 100644
--- a/docs/cregex_api.md
+++ b/docs/cregex_api.md
@@ -102,7 +102,7 @@ If an error occurs ```cregex_compile``` returns a negative error code stored in
 #define i_import // include dependent cstr, utf8 and cregex function definitions.
 #include <stc/cregex.h>
 
-int main() {
+int main(void) {
     const char* input = "start date is 2023-03-01, end date 2025-12-31.";
     const char* pattern = "\\b(\\d\\d\\d\\d)-(\\d\\d)-(\\d\\d)\\b";
 
diff --git a/docs/cset_api.md b/docs/cset_api.md
index 7bce3136..e894ad4f 100644
--- a/docs/cset_api.md
+++ b/docs/cset_api.md
@@ -83,7 +83,7 @@ cset_X_value        cset_X_value_clone(cset_X_value val);
 #define i_key_str
 #include <stc/cset.h>
 
-int main ()
+int main(void)
 {
     Strset first, second={0}, third={0}, fourth={0}, fifth;
 
diff --git a/docs/csmap_api.md b/docs/csmap_api.md
index 2fd9f6a5..099d7dfc 100644
--- a/docs/csmap_api.md
+++ b/docs/csmap_api.md
@@ -108,7 +108,7 @@ void                  csmap_X_value_drop(csmap_X_value* pval);
 #define i_val_str // ditto
 #include <stc/csmap.h>
 
-int main()
+int main(void)
 {
     // Create a sorted map of three strings (maps to string)
     csmap_str colors = c_init(csmap_str, {
@@ -166,7 +166,7 @@ static void print_result(strmap_result result) {
     print_node(result.ref);
 }
  
-int main()
+int main(void)
 {
     strmap m = {0};
  
@@ -191,7 +191,7 @@ This example uses a csmap with cstr as mapped value.
 #define i_val_str
 #include <stc/csmap.h>
 
-int main()
+int main(void)
 {
     uint32_t col = 0xcc7744ff;
     IDSMap idnames = c_init(IDSMap, { {100, "Red"}, {110, "Blue"} });
@@ -237,7 +237,7 @@ static int Vec3i_cmp(const Vec3i* a, const Vec3i* b) {
 #include <stc/csmap.h>
 #include <stdio.h>
 
-int main()
+int main(void)
 {
     csmap_vi vmap = {0};
 
diff --git a/docs/cspan_api.md b/docs/cspan_api.md
index 1089e48d..09821450 100644
--- a/docs/cspan_api.md
+++ b/docs/cspan_api.md
@@ -101,7 +101,7 @@ if __name__ == '__main__':
 #include <stc/cspan.h>
 using_cspan3(myspan, int); // define myspan, myspan2, myspan3.
 
-int main() {
+int main(void) {
     int arr[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24};
 
     myspan3 ms3 = cspan_md(arr, 2, 3, 4); // C-order, i.e. row-major.
@@ -123,7 +123,7 @@ int main() {
 #include <mdspan>
 #include <tuple>
 
-int main() {
+int main(void) {
     int arr[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24};
 
     std::mdspan ms3(arr, 2, 3, 4);
@@ -147,7 +147,7 @@ Slicing cspan without and with reducing the rank:
 
 using_cspan3(Span, int); // Shorthand to define Span, Span2, and Span3
 
-int main()
+int main(void)
 {
     // c_init() can create any STC container/span from an initializer list:
     Span span = c_init(Span, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
diff --git a/docs/csset_api.md b/docs/csset_api.md
index d086b660..aef3af3c 100644
--- a/docs/csset_api.md
+++ b/docs/csset_api.md
@@ -83,7 +83,7 @@ csset_X_value        csset_X_value_clone(csset_X_value val);
 #define i_key_str
 #include <stc/csset.h>
 
-int main ()
+int main(void)
 {
     SSet second={0}, third={0}, fourth={0}, fifth={0};
 
diff --git a/docs/cstack_api.md b/docs/cstack_api.md
index 51889d7f..e799b152 100644
--- a/docs/cstack_api.md
+++ b/docs/cstack_api.md
@@ -77,7 +77,7 @@ void                cstack_X_value_drop(cvec_X_value* pval);
 
 #include <stdio.h>
 
-int main() {
+int main(void) {
     IStack stk = IStack_init();
 
     for (int i=0; i < 100; ++i)
diff --git a/docs/cstr_api.md b/docs/cstr_api.md
index c7d19e0c..dae5669f 100644
--- a/docs/cstr_api.md
+++ b/docs/cstr_api.md
@@ -160,7 +160,7 @@ char*        cstrnstrn(const char* str, const char* search, intptr_t slen, intpt
 #define i_implement
 #include <stc/cstr.h>
 
-int main() {
+int main(void) {
     cstr s0, s1, full_path;
     c_defer(
         cstr_drop(&s0),
diff --git a/docs/csview_api.md b/docs/csview_api.md
index 33df6a64..79a5c07b 100644
--- a/docs/csview_api.md
+++ b/docs/csview_api.md
@@ -121,7 +121,7 @@ uint64_t        csview_hash(const csview* x);
 #include <stc/cstr.h>
 #include <stc/csview.h>
 
-int main ()
+int main(void)
 {
     cstr str1 = cstr_lit("We think in generalities, but we live in details.");
                                                             // (quoting Alfred N. Whitehead)
@@ -151,7 +151,7 @@ red Apples
 #define i_import // include dependent cstr, utf8 and cregex function definitions.
 #include <stc/cstr.h>
 
-int main()
+int main(void)
 {
     cstr s1 = cstr_lit("hell😀 w😀rld");
 
@@ -198,7 +198,7 @@ cstack_str string_split(csview input, const char* sep)
     return out;
 }
 
-int main()
+int main(void)
 {
     print_split(c_sv("//This is a//double-slash//separated//string"), "//");
     print_split(c_sv("This has no matching separator"), "xx");
diff --git a/docs/cvec_api.md b/docs/cvec_api.md
index ce85e446..d38ef23f 100644
--- a/docs/cvec_api.md
+++ b/docs/cvec_api.md
@@ -112,7 +112,7 @@ cvec_X_raw          cvec_X_value_drop(cvec_X_value* pval);
 
 #include <stdio.h>
 
-int main()
+int main(void)
 {
     // Create a vector containing integers
     cvec_int vec = {0};
@@ -153,7 +153,7 @@ sorted: 5 7 8 13 16 25
 #define i_key_str
 #include <stc/cvec.h>
 
-int main() {
+int main(void) {
     cvec_str names = cvec_str_init();
 
     cvec_str_emplace(&names, "Mary");
diff --git a/include/c11/fmt.h b/include/c11/fmt.h
index 45044e33..d2eab8bc 100644
--- a/include/c11/fmt.h
+++ b/include/c11/fmt.h
@@ -33,7 +33,7 @@ void        fmt_close(fmt_stream* ss);
 #define FMT_SHORTS
 #include "c11/fmt.h"
 
-int main() {
+int main(void) {
     const double pi = 3.141592653589793;
     const size_t x = 1234567890;
     const char* string = "Hello world";
diff --git a/include/stc/algo/crange.h b/include/stc/algo/crange.h
index 45ef53a1..03162a2d 100644
--- a/include/stc/algo/crange.h
+++ b/include/stc/algo/crange.h
@@ -25,7 +25,7 @@
 #include <stc/algo/filter.h>
 #include <stc/algo/crange.h>
 
-int main()
+int main(void)
 {
     crange r1 = crange_make(80, 90);
     c_foreach (i, crange, r1)
diff --git a/include/stc/algo/filter.h b/include/stc/algo/filter.h
index f5de1811..4a227927 100644
--- a/include/stc/algo/filter.h
+++ b/include/stc/algo/filter.h
@@ -26,7 +26,7 @@
 #include <stc/cstack.h>
 #include <stc/calgo.h>
 
-int main()
+int main(void)
 {
     cstack_int stk = c_init(cstack_int, {1, 2, 3, 4, 5, 6, 7, 8, 9});
 
diff --git a/include/stc/algo/sort.h b/include/stc/algo/sort.h
index 01e7d521..06d7395f 100644
--- a/include/stc/algo/sort.h
+++ b/include/stc/algo/sort.h
@@ -31,7 +31,7 @@ template params:
 #define i_key int
 #include <stc/algo/sort.h>
 
-int main() {
+int main(void) {
     int nums[] = {23, 321, 5434, 25, 245, 1, 654, 33, 543, 21};
     
     intarray_sort_n(nums, c_arraylen(nums));
@@ -48,7 +48,7 @@ int main() {
 #include <stc/cdeq.h>
 #include <stc/algo/sort.h>
 
-int main() {
+int main(void) {
     IDeq nums = c_init(IDeq, {5434, 25, 245, 1, 654, 33, 543, 21});
     IDeq_push_front(&nums, 23);
     IDeq_push_front(&nums, 321);
diff --git a/include/stc/carc.h b/include/stc/carc.h
index b77b7dfb..9ba2ddd1 100644
--- a/include/stc/carc.h
+++ b/include/stc/carc.h
@@ -46,7 +46,7 @@ void Person_drop(Person* p) {
 #define i_opt c_no_cmp|c_no_hash  // exclude cmp, hash
 #include <stc/carc.h>
 
-int main() {
+int main(void) {
     ArcPers p = ArcPers_from(Person_make("John", "Smiths"));
     ArcPers q = ArcPers_clone(p); // share the pointer
 
@@ -225,4 +225,4 @@ STC_INLINE void _cx_MEMB(_assign)(_cx_Self* self, _cx_Self ptr) {
 #undef _i_atomic_inc
 #undef _i_atomic_dec_and_test
 #include "priv/template2.h"
-#undef _i_carc
\ No newline at end of file
+#undef _i_carc
diff --git a/include/stc/cbits.h b/include/stc/cbits.h
index 66bc6354..3b5785d3 100644
--- a/include/stc/cbits.h
+++ b/include/stc/cbits.h
@@ -26,7 +26,7 @@ Similar to boost::dynamic_bitset / std::bitset
 #include <stdio.h>
 #include "cbits.h"
 
-int main() {
+int main(void) {
     cbits bset = cbits_with_size(23, true);
     cbits_reset(&bset, 9);
     cbits_resize(&bset, 43, false);
diff --git a/include/stc/cbox.h b/include/stc/cbox.h
index 86d5a6a6..25d41b92 100644
--- a/include/stc/cbox.h
+++ b/include/stc/cbox.h
@@ -47,7 +47,7 @@ void Person_drop(Person* p) {
 #define i_no_cmp          // no cmp/hash is defined
 #include <stc/cbox.h>
 
-int main() {
+int main(void) {
     c_auto (PBox, p, q)
     {
         p = PBox_from(Person_from("John Smiths", "josmiths@gmail.com"));
@@ -205,4 +205,4 @@ STC_INLINE void _cx_MEMB(_assign)(_cx_Self* self, _cx_Self* moved) {
         { return c_default_hash(&self->get); }
 #endif
 #include "priv/template2.h"
-#undef _i_cbox
\ No newline at end of file
+#undef _i_cbox
diff --git a/include/stc/ccommon.h b/include/stc/ccommon.h
index 45c3a360..1f9ea80d 100644
--- a/include/stc/ccommon.h
+++ b/include/stc/ccommon.h
@@ -85,7 +85,7 @@ typedef long long _llong;
   #define c_assert(expr)        assert(expr)
 #endif
 #define c_container_of(p, C, m) ((C*)((char*)(1 ? (p) : &((C*)0)->m) - offsetof(C, m)))
-#define c_const_cast(T, p)      ((T)(p) + 0*sizeof((T)0 == (p)))
+#define c_const_cast(T, p)      ((T)(1 ? (p) : (T)0))
 #define c_swap(T, xp, yp)       do { T *_xp = xp, *_yp = yp, \
                                     _tv = *_xp; *_xp = *_yp; *_yp = _tv; } while (0)
 #define c_sizeof                (intptr_t)sizeof
@@ -96,8 +96,8 @@ typedef long long _llong;
 #define c_memmove(d, s, ilen)   memmove(d, s, c_i2u(ilen))
 #define c_memset(d, val, ilen)  memset(d, val, c_i2u(ilen))
 #define c_memcmp(a, b, ilen)    memcmp(a, b, c_i2u(ilen))
-#define c_u2i(u)                ((intptr_t)((u) + 0*sizeof((u) == 1U)))
-#define c_i2u(i)                ((size_t)(i) + 0*sizeof((i) == 1))
+#define c_u2i(u)                ((intptr_t)(1 ? (u) : (size_t)1))
+#define c_i2u(i)                ((size_t)(1 ? (i) : (intptr_t)1))
 #define c_LTu(a, b)             ((size_t)(a) < (size_t)(b))
 
 // x and y are i_keyraw* type, defaults to i_key*:
diff --git a/include/stc/clist.h b/include/stc/clist.h
index 9cc1bb39..d7cf30b9 100644
--- a/include/stc/clist.h
+++ b/include/stc/clist.h
@@ -32,7 +32,7 @@
     #define i_tag ix
     #include <stc/clist.h>
 
-    int main()
+    int main(void)
     {
         c_auto (clist_ix, list)
         {
diff --git a/include/stc/crand.h b/include/stc/crand.h
index 89b681cd..0a6aa9e0 100644
--- a/include/stc/crand.h
+++ b/include/stc/crand.h
@@ -29,7 +29,7 @@
 // crand: Pseudo-random number generator
 #include "stc/crand.h"
 
-int main() {
+int main(void) {
     uint64_t seed = 123456789;
     crand_t rng = crand_init(seed);
     crand_unif_t dist1 = crand_unif_init(1, 6);
diff --git a/include/stc/cvec.h b/include/stc/cvec.h
index 9b95306e..d08e382f 100644
--- a/include/stc/cvec.h
+++ b/include/stc/cvec.h
@@ -44,7 +44,7 @@ struct MyStruct {
 #define i_tag i32
 #include <stc/cvec.h>
 
-int main() {
+int main(void) {
     cvec_i32 vec = {0};
     cvec_i32_push(&vec, 123);
     cvec_i32_drop(&vec);
diff --git a/misc/benchmarks/plotbench/cpque_benchmark.cpp b/misc/benchmarks/plotbench/cpque_benchmark.cpp
index 2d4c7a28..6c62ae3e 100644
--- a/misc/benchmarks/plotbench/cpque_benchmark.cpp
+++ b/misc/benchmarks/plotbench/cpque_benchmark.cpp
@@ -58,7 +58,7 @@ void stc_test()
 }
 
 
-int main()
+int main(void)
 {
     puts("STD P.QUEUE:");
     std_test();
diff --git a/misc/benchmarks/various/cspan_bench.c b/misc/benchmarks/various/cspan_bench.c
index 392c9d3f..e3997ff0 100644
--- a/misc/benchmarks/various/cspan_bench.c
+++ b/misc/benchmarks/various/cspan_bench.c
@@ -114,7 +114,7 @@ static void MDRanges_loop_over_joined(intptr_t state)
     printf("joined: %.1f ms, %f\n", 1000.0f * t / CLOCKS_PER_SEC, sum);
 }
 
-int main()
+int main(void)
 {
     for (int i = 0; i < nx * ny * nz; ++i)
         Vin[i] = i + 1.23;
diff --git a/misc/benchmarks/various/rust_cmap.c b/misc/benchmarks/various/rust_cmap.c
index abdb42b0..97047e0b 100644
--- a/misc/benchmarks/various/rust_cmap.c
+++ b/misc/benchmarks/various/rust_cmap.c
@@ -22,7 +22,7 @@ uint64_t romu_trio(uint64_t s[3]) {
    return xp;
 }
 
-int main()
+int main(void)
 {
     cmap_u64 m = {0};
 
diff --git a/misc/benchmarks/various/sso_bench.cpp b/misc/benchmarks/various/sso_bench.cpp
index 6d3d107a..244c1291 100644
--- a/misc/benchmarks/various/sso_bench.cpp
+++ b/misc/benchmarks/various/sso_bench.cpp
@@ -112,7 +112,7 @@ int benchmark_lookup(C& container, const int n, const int strsize) {
 }
 
 #include <time.h>
-int main() {
+int main(void) {
     uint64_t seed = time(NULL); // 4321;
     int sum, n;
 
diff --git a/misc/benchmarks/various/string_bench_STC.cpp b/misc/benchmarks/various/string_bench_STC.cpp
index 319b0b19..a5dfd901 100644
--- a/misc/benchmarks/various/string_bench_STC.cpp
+++ b/misc/benchmarks/various/string_bench_STC.cpp
@@ -184,7 +184,7 @@ void benchmark(
 //const size_t MAX_LOOP = 1000000;
 const size_t MAX_LOOP = 2000;
 
-int main()
+int main(void)
 {
     c_auto (cvec_str, vec_string)
     c_auto (cvec_sv, vec_stringview)
diff --git a/misc/benchmarks/various/string_bench_STD.cpp b/misc/benchmarks/various/string_bench_STD.cpp
index 07934948..153ac02f 100644
--- a/misc/benchmarks/various/string_bench_STD.cpp
+++ b/misc/benchmarks/various/string_bench_STD.cpp
@@ -194,7 +194,7 @@ void benchmark(
 //const size_t MAX_LOOP = 1000000;
 const size_t MAX_LOOP = 2000;
 
-int main()
+int main(void)
 {
     std::vector<std::string> vec_shortstr;
     std::vector<std::string_view> vec_shortstrview;
diff --git a/misc/examples/arc_containers.c b/misc/examples/arc_containers.c
index 524758e7..2fb04c56 100644
--- a/misc/examples/arc_containers.c
+++ b/misc/examples/arc_containers.c
@@ -24,7 +24,7 @@
 #define i_keyboxed Arc // as above
 #include <stc/clist.h>
 
-int main()
+int main(void)
 {
     Stack stack = {0};
     List list = {0};
diff --git a/misc/examples/arc_demo.c b/misc/examples/arc_demo.c
index 547e1737..87d64e67 100644
--- a/misc/examples/arc_demo.c
+++ b/misc/examples/arc_demo.c
@@ -20,7 +20,7 @@ void int_drop(int* x) {
 #define i_keyboxed Arc      // note: as above.
 #include <stc/cvec.h>       // cvec_Arc (like: std::vector<std::shared_ptr<int>>)
 
-int main()
+int main(void)
 {
     const int years[] = {2021, 2012, 2022, 2015};
 
diff --git a/misc/examples/arcvec_erase.c b/misc/examples/arcvec_erase.c
index f409258b..addef8b7 100644
--- a/misc/examples/arcvec_erase.c
+++ b/misc/examples/arcvec_erase.c
@@ -13,7 +13,7 @@ void show_drop(int* x) { printf("drop: %d\n", *x); }
 #include <stc/cvec.h>       // Vec: cvec<Arc>
 
 
-int main()
+int main(void)
 {
     Vec vec = c_init(Vec, {2012, 1990, 2012, 2019, 2015});
     
diff --git a/misc/examples/birthday.c b/misc/examples/birthday.c
index 2820c42f..4742cb45 100644
--- a/misc/examples/birthday.c
+++ b/misc/examples/birthday.c
@@ -60,7 +60,7 @@ void test_distribution(void)
     cmap_x_drop(&map);
 }
 
-int main()
+int main(void)
 {
     seed = (uint64_t)time(NULL);
     test_distribution();
diff --git a/misc/examples/bits2.c b/misc/examples/bits2.c
index 913bd185..de2f16f4 100644
--- a/misc/examples/bits2.c
+++ b/misc/examples/bits2.c
@@ -5,7 +5,7 @@
 #define i_capacity 80 // enable fixed bitset on the stack
 #include <stc/cbits.h>
 
-int main() 
+int main(void) 
 {
     Bits s1 = Bits_from("1110100110111");
     
diff --git a/misc/examples/books.c b/misc/examples/books.c
index 7f0660b8..1fd57f27 100644
--- a/misc/examples/books.c
+++ b/misc/examples/books.c
@@ -7,7 +7,7 @@
 
 // Type inference lets us omit an explicit type signature (which
 // would be `HashMap<String, String>` in this example).
-int main()
+int main(void)
 {
     cmap_str book_reviews = {0};
 
diff --git a/misc/examples/box.c b/misc/examples/box.c
index 3f55e15d..94d126c0 100644
--- a/misc/examples/box.c
+++ b/misc/examples/box.c
@@ -36,7 +36,7 @@ void Person_drop(Person* p) {
 #define i_keyboxed PBox // "arcbox" informs that PBox is a smart pointer.
 #include <stc/csset.h>
 
-int main()
+int main(void)
 {
     Persons vec = {0};
     PBox p = PBox_from(Person_make("Laura", "Palmer"));
diff --git a/misc/examples/cointerleave.c b/misc/examples/cointerleave.c
index c3c5926a..599ceaab 100644
--- a/misc/examples/cointerleave.c
+++ b/misc/examples/cointerleave.c
@@ -56,7 +56,7 @@ void Use(void)
     c_drop(IVec, &a, &b);
 }
 
-int main()
+int main(void)
 {
     Use();
 }
diff --git a/misc/examples/complex.c b/misc/examples/complex.c
index 405afef3..4eb1574b 100644
--- a/misc/examples/complex.c
+++ b/misc/examples/complex.c
@@ -28,7 +28,7 @@
 #include <stc/cmap.h>
 
 
-int main()
+int main(void)
 {
     MapMap mmap = {0};
 
diff --git a/misc/examples/convert.c b/misc/examples/convert.c
index 3f2f60f6..fa64560e 100644
--- a/misc/examples/convert.c
+++ b/misc/examples/convert.c
@@ -11,7 +11,7 @@
 #define i_key_str
 #include <stc/clist.h>
 
-int main()
+int main(void)
 {
     cmap_str map, mclone;
     cvec_str keys = {0}, values = {0};
diff --git a/misc/examples/csmap_erase.c b/misc/examples/csmap_erase.c
index 9433d370..8d4eeae3 100644
--- a/misc/examples/csmap_erase.c
+++ b/misc/examples/csmap_erase.c
@@ -16,7 +16,7 @@ void printmap(mymap m)
     printf("\nsize() == %" c_ZI "\n\n", mymap_size(&m));
 }
 
-int main()
+int main(void)
 {
     mymap m1 = {0};
 
diff --git a/misc/examples/csmap_find.c b/misc/examples/csmap_find.c
index b535e9ad..c392338d 100644
--- a/misc/examples/csmap_find.c
+++ b/misc/examples/csmap_find.c
@@ -40,7 +40,7 @@ void findit(csmap_istr c, csmap_istr_key val)
     }
 }
 
-int main()
+int main(void)
 {
     csmap_istr m1 = c_init(csmap_istr, {{40, "Zr"}, {45, "Rh"}});
     cvec_istr v = {0};
diff --git a/misc/examples/csmap_insert.c b/misc/examples/csmap_insert.c
index df638c22..c9f02891 100644
--- a/misc/examples/csmap_insert.c
+++ b/misc/examples/csmap_insert.c
@@ -29,7 +29,7 @@ void print_istr(csmap_istr map) {
     puts("");
 }
 
-int main()
+int main(void)
 {
     // insert single values
     csmap_ii m1 = {0};
diff --git a/misc/examples/csset_erase.c b/misc/examples/csset_erase.c
index 649bb1e3..9c7f5e1a 100644
--- a/misc/examples/csset_erase.c
+++ b/misc/examples/csset_erase.c
@@ -3,7 +3,7 @@
 #define i_key int
 #include <stc/csset.h>
 
-int main()
+int main(void)
 {
     csset_int set = c_init(csset_int, {30, 20, 80, 40, 60, 90, 10, 70, 50});
 
diff --git a/misc/examples/cstr_match.c b/misc/examples/cstr_match.c
index 10a843cf..be03e981 100644
--- a/misc/examples/cstr_match.c
+++ b/misc/examples/cstr_match.c
@@ -3,7 +3,7 @@
 #include <stc/csview.h>
 #include <stdio.h>
 
-int main()
+int main(void)
 {
     cstr ss = cstr_lit("The quick brown fox jumps over the lazy dog.JPG");
 
diff --git a/misc/examples/demos.c b/misc/examples/demos.c
index 2e91b20c..ecc89f2e 100644
--- a/misc/examples/demos.c
+++ b/misc/examples/demos.c
@@ -1,7 +1,7 @@
 #define i_implement
 #include <stc/cstr.h>
 
-void stringdemo1()
+void stringdemo1(void)
 {
     cstr cs = cstr_lit("one-nine-three-seven-five");
     printf("%s.\n", cstr_str(&cs));
@@ -32,7 +32,7 @@ void stringdemo1()
 #define i_tag ix
 #include <stc/cvec.h>
 
-void vectordemo1()
+void vectordemo1(void)
 {
     cvec_ix bignums = cvec_ix_with_capacity(100);
     cvec_ix_reserve(&bignums, 100);
@@ -55,7 +55,7 @@ void vectordemo1()
 #define i_key_str
 #include <stc/cvec.h>
 
-void vectordemo2()
+void vectordemo2(void)
 {
     cvec_str names = {0};
     cvec_str_emplace_back(&names, "Mary");
@@ -77,7 +77,7 @@ void vectordemo2()
 #define i_native_cmp
 #include <stc/clist.h>
 
-void listdemo1()
+void listdemo1(void)
 {
     clist_ix nums = {0}, nums2 = {0};
     for (int i = 0; i < 10; ++i)
@@ -109,7 +109,7 @@ void listdemo1()
 #define i_tag i
 #include <stc/cset.h>
 
-void setdemo1()
+void setdemo1(void)
 {
     cset_i nums = {0};
     cset_i_insert(&nums, 8);
@@ -125,7 +125,7 @@ void setdemo1()
 #define i_tag ii
 #include <stc/cmap.h>
 
-void mapdemo1()
+void mapdemo1(void)
 {
     cmap_ii nums = {0};
     cmap_ii_insert(&nums, 8, 64);
@@ -139,7 +139,7 @@ void mapdemo1()
 #define i_tag si
 #include <stc/cmap.h>
 
-void mapdemo2()
+void mapdemo2(void)
 {
     cmap_si nums = {0};
     cmap_si_emplace_or_assign(&nums, "Hello", 64);
@@ -161,7 +161,7 @@ void mapdemo2()
 #define i_val_str
 #include <stc/cmap.h>
 
-void mapdemo3()
+void mapdemo3(void)
 {
     cmap_str table = {0};
     cmap_str_emplace(&table, "Map", "test");
@@ -181,7 +181,7 @@ void mapdemo3()
     cmap_str_drop(&table); // frees key and value cstrs, and hash table.
 }
 
-int main()
+int main(void)
 {
     printf("\nSTRINGDEMO1\n"); stringdemo1();
     printf("\nVECTORDEMO1\n"); vectordemo1();
diff --git a/misc/examples/dining_philosophers.c b/misc/examples/dining_philosophers.c
index 61fe67fb..a5063a42 100644
--- a/misc/examples/dining_philosophers.c
+++ b/misc/examples/dining_philosophers.c
@@ -86,7 +86,7 @@ int dining(struct Dining* d)
     return 0;
 }
 
-int main()
+int main(void)
 {
     struct Dining dine;
     cco_reset(&dine);
diff --git a/misc/examples/forloops.c b/misc/examples/forloops.c
index 99b12871..47cced8f 100644
--- a/misc/examples/forloops.c
+++ b/misc/examples/forloops.c
@@ -11,7 +11,7 @@
 #include <stc/cmap.h>
 
 
-int main()
+int main(void)
 {
     puts("c_forrange:");
     c_forrange (30) printf(" xx");
diff --git a/misc/examples/functor.c b/misc/examples/functor.c
index ea409a56..e3bde1dd 100644
--- a/misc/examples/functor.c
+++ b/misc/examples/functor.c
@@ -30,7 +30,7 @@ static bool int_less(const int* x, const int* y) { return *x < *y; }
 static bool int_greater(const int* x, const int* y) { return *x > *y; }
 static bool int_lambda(const int* x, const int* y) { return (*x ^ 1) < (*y ^ 1); }
 
-int main()
+int main(void)
 {
     const int data[] = {1,8,5,6,3,4,0,9,7,2}, n = c_arraylen(data);
     printf("data: \t");
diff --git a/misc/examples/gauss2.c b/misc/examples/gauss2.c
index 67586181..1ab8ade5 100644
--- a/misc/examples/gauss2.c
+++ b/misc/examples/gauss2.c
@@ -10,7 +10,7 @@
 #define i_val int
 #include <stc/csmap.h>
 
-int main()
+int main(void)
 {
     enum {N = 5000000};
     uint64_t seed = (uint64_t)time(NULL);
diff --git a/misc/examples/generator.c b/misc/examples/generator.c
index 3ff7a645..a15f9ba5 100644
--- a/misc/examples/generator.c
+++ b/misc/examples/generator.c
@@ -42,7 +42,7 @@ Triple_iter Triple_begin(Triple* g) {
 }
 
 
-int main()
+int main(void)
 {
     puts("Pythagorean triples with c < 100:");
     Triple triple = {.size=30}; // max number of triples
diff --git a/misc/examples/intrusive.c b/misc/examples/intrusive.c
index 1e3f7b83..4fca654b 100644
--- a/misc/examples/intrusive.c
+++ b/misc/examples/intrusive.c
@@ -14,7 +14,7 @@ void printList(List list) {
     puts("");
 }
 
-int main() {
+int main(void) {
     List list = {0};
     c_forlist (i, int, {6, 9, 3, 1, 7, 4, 5, 2, 8})
         List_push_back_node(&list, c_new(List_node, {0, *i.ref}));
diff --git a/misc/examples/list.c b/misc/examples/list.c
index a0045db9..fa33305a 100644
--- a/misc/examples/list.c
+++ b/misc/examples/list.c
@@ -8,7 +8,7 @@
 #define i_native_cmp
 #include <stc/clist.h>
 
-int main() {
+int main(void) {
     const int n = 3000000;
     DList list = {0};
 
diff --git a/misc/examples/list_erase.c b/misc/examples/list_erase.c
index 357dd75b..211c5a5d 100644
--- a/misc/examples/list_erase.c
+++ b/misc/examples/list_erase.c
@@ -5,7 +5,7 @@
 #define i_key int
 #include <stc/clist.h>
 
-int main ()
+int main(void)
 {
     IList L = c_init(IList, {10, 20, 30, 40, 50});
 
diff --git a/misc/examples/list_splice.c b/misc/examples/list_splice.c
index 25c2a42d..f1fd6e1f 100644
--- a/misc/examples/list_splice.c
+++ b/misc/examples/list_splice.c
@@ -13,7 +13,7 @@ void print_ilist(const char* s, clist_i list)
     puts("");
 }
 
-int main ()
+int main(void)
 {
     clist_i list1 = c_init(clist_i, {1, 2, 3, 4, 5});
     clist_i list2 = c_init(clist_i, {10, 20, 30, 40, 50});
diff --git a/misc/examples/lower_bound.c b/misc/examples/lower_bound.c
index ee32f49b..e5d816e9 100644
--- a/misc/examples/lower_bound.c
+++ b/misc/examples/lower_bound.c
@@ -7,7 +7,7 @@
 #define i_key int
 #include <stc/csset.h>
 
-int main()
+int main(void)
 {
     // TEST SORTED VECTOR
     {
diff --git a/misc/examples/mmap.c b/misc/examples/mmap.c
index fd00499c..04a605a7 100644
--- a/misc/examples/mmap.c
+++ b/misc/examples/mmap.c
@@ -30,7 +30,7 @@ void insert(Multimap* mmap, int key, const char* str)
     clist_str_emplace_back(list, str);
 }
 
-int main()
+int main(void)
 {
     Multimap mmap = {0};
 
diff --git a/misc/examples/multidim.c b/misc/examples/multidim.c
index 45b97378..798a1126 100644
--- a/misc/examples/multidim.c
+++ b/misc/examples/multidim.c
@@ -6,7 +6,7 @@
 
 using_cspan3(ispan, int);
 
-int main()
+int main(void)
 {
     cstack_int v = c_init(cstack_int, {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24});
 
diff --git a/misc/examples/multimap.c b/misc/examples/multimap.c
index a89b251b..1068a5dc 100644
--- a/misc/examples/multimap.c
+++ b/misc/examples/multimap.c
@@ -66,7 +66,7 @@ void OlympicLoc_drop(OlympicLoc* self) {
 }
 
 
-int main()
+int main(void)
 {
     // Define the multimap with destructor defered to when block is completed.
     csmap_OL multimap = {0};
diff --git a/misc/examples/music_arc.c b/misc/examples/music_arc.c
index 49008523..16111b0b 100644
--- a/misc/examples/music_arc.c
+++ b/misc/examples/music_arc.c
@@ -31,7 +31,7 @@ void Song_drop(Song* s) {
 #define i_keyboxed SongArc // use i_keyboxed on carc / cbox (instead of i_key)
 #include <stc/cvec.h>
 
-void example3()
+void example3(void)
 {
     SongVec vec1 = c_init(SongVec, {
         Song_make("Bob Dylan", "The Times They Are A Changing"),
@@ -61,7 +61,7 @@ void example3()
     c_drop(SongVec, &vec1, &vec2);
 }
 
-int main()
+int main(void)
 {
     example3();
 }
diff --git a/misc/examples/new_list.c b/misc/examples/new_list.c
index ee250b2b..9676e7b4 100644
--- a/misc/examples/new_list.c
+++ b/misc/examples/new_list.c
@@ -43,7 +43,7 @@ void MyStruct_drop(MyStruct* s) {
 }
 
 
-int main()
+int main(void)
 {
     MyStruct my = {0};
     clist_i32_push_back(&my.intlist, 123);
diff --git a/misc/examples/new_map.c b/misc/examples/new_map.c
index 277bcbc2..de990040 100644
--- a/misc/examples/new_map.c
+++ b/misc/examples/new_map.c
@@ -41,7 +41,7 @@ int point_cmp(const Point* a, const Point* b) {
 #include <stc/cset.h>
 
 
-int main()
+int main(void)
 {
     cmap_pnt pmap = c_init(cmap_pnt, {{{42, 14}, 1}, {{32, 94}, 2}, {{62, 81}, 3}});
 
diff --git a/misc/examples/new_pque.c b/misc/examples/new_pque.c
index 3df39e0e..16823bb6 100644
--- a/misc/examples/new_pque.c
+++ b/misc/examples/new_pque.c
@@ -8,7 +8,7 @@ typedef struct Point { int x, y; } Point;
 #include <stc/cpque.h>
 
 
-int main()
+int main(void)
 {
     PointQ pque = c_init(PointQ, {{23, 80}, {12, 32}, {54, 74}, {12, 62}});
     // print
diff --git a/misc/examples/new_queue.c b/misc/examples/new_queue.c
index 104871bf..f3592df6 100644
--- a/misc/examples/new_queue.c
+++ b/misc/examples/new_queue.c
@@ -20,7 +20,7 @@ int point_cmp(const Point* a, const Point* b) {
 #define i_key int
 #include <stc/cqueue.h>
 
-int main() {
+int main(void) {
     int n = 50000000;
     crand_t rng = crand_init((uint64_t)time(NULL));
     crand_unif_t dist = crand_unif_init(0, n);
diff --git a/misc/examples/new_smap.c b/misc/examples/new_smap.c
index 77c4cdce..ee946c9a 100644
--- a/misc/examples/new_smap.c
+++ b/misc/examples/new_smap.c
@@ -36,7 +36,7 @@ int point_cmp(const Point* a, const Point* b) {
 #include <stc/csset.h>
 
 
-int main()
+int main(void)
 {
     PMap pmap = c_init(PMap, {
         {{42, 14}, 1},
diff --git a/misc/examples/new_vec.c b/misc/examples/new_vec.c
index 6d928cfc..88efd55a 100644
--- a/misc/examples/new_vec.c
+++ b/misc/examples/new_vec.c
@@ -23,7 +23,7 @@ typedef struct Point { int x, y; } Point;
 #define i_is_forward
 #include <stc/cvec.h>
 
-int main()
+int main(void)
 {
     MyStruct my = {0};
 
diff --git a/misc/examples/person_arc.c b/misc/examples/person_arc.c
index 3a759610..38c883a7 100644
--- a/misc/examples/person_arc.c
+++ b/misc/examples/person_arc.c
@@ -39,7 +39,7 @@ void Person_drop(Person* p) {
 #include <stc/cvec.h>
 
 
-int main()
+int main(void)
 {
     PSPtr p = PSPtr_from(Person_make("Laura", "Palmer"));
     PSPtr q = PSPtr_from(Person_clone(*p.get)); // deep copy
diff --git a/misc/examples/printspan.c b/misc/examples/printspan.c
index 5084536a..cd3c5f4f 100644
--- a/misc/examples/printspan.c
+++ b/misc/examples/printspan.c
@@ -20,7 +20,7 @@ void printMe(intspan container) {
     puts("");
 }
 
-int main()
+int main(void)
 {
     intspan sp1 = cspan_init(intspan, {1, 2});
     printMe( sp1 );
diff --git a/misc/examples/priority.c b/misc/examples/priority.c
index 148e8fc5..bf2e188a 100644
--- a/misc/examples/priority.c
+++ b/misc/examples/priority.c
@@ -8,7 +8,7 @@
 #define i_tag i
 #include <stc/cpque.h>
 
-int main() {
+int main(void) {
     intptr_t N = 10000000;
     crand_t rng = crand_init((uint64_t)time(NULL));
     crand_unif_t dist = crand_unif_init(0, N * 10);
diff --git a/misc/examples/queue.c b/misc/examples/queue.c
index 3154f115..56b5beb9 100644
--- a/misc/examples/queue.c
+++ b/misc/examples/queue.c
@@ -5,7 +5,7 @@
 #define i_tag i
 #include <stc/cqueue.h>
 
-int main() {
+int main(void) {
     int n = 100000000;
     crand_unif_t dist;
     crand_t rng = crand_init(1234);
diff --git a/misc/examples/random.c b/misc/examples/random.c
index e783fe55..b7c0f277 100644
--- a/misc/examples/random.c
+++ b/misc/examples/random.c
@@ -2,7 +2,7 @@
 #include <time.h>
 #include <stc/crand.h>
 
-int main()
+int main(void)
 {
     const int N = 1000000000;
     const uint64_t seed = (uint64_t)time(NULL), range = 1000000;
diff --git a/misc/examples/rawptr_elements.c b/misc/examples/rawptr_elements.c
index 9c394d8e..694ce12e 100644
--- a/misc/examples/rawptr_elements.c
+++ b/misc/examples/rawptr_elements.c
@@ -25,7 +25,7 @@
 #define i_valboxed IBox // i_valboxed: use properties from IBox automatically
 #include <stc/cmap.h>
 
-int main()
+int main(void)
 {
     // These have the same behaviour, except IBox has a get member:
     SIPtrMap map1 = {0};
diff --git a/misc/examples/read.c b/misc/examples/read.c
index c25cd740..b12f7409 100644
--- a/misc/examples/read.c
+++ b/misc/examples/read.c
@@ -15,7 +15,7 @@ cvec_str read_file(const char* name)
     return vec;
 }
 
-int main()
+int main(void)
 {
     int n = 0;
     c_with (cvec_str vec = read_file(__FILE__), cvec_str_drop(&vec))
diff --git a/misc/examples/regex2.c b/misc/examples/regex2.c
index 734190cb..a798b1a1 100644
--- a/misc/examples/regex2.c
+++ b/misc/examples/regex2.c
@@ -1,7 +1,7 @@
 #define i_import
 #include <stc/cregex.h>
 
-int main()
+int main(void)
 {
     struct { const char *pattern, *input; } s[] = {
         {"(\\d\\d\\d\\d)[-_](1[0-2]|0[1-9])[-_](3[01]|[12][0-9]|0[1-9])",
diff --git a/misc/examples/regex_match.c b/misc/examples/regex_match.c
index 88d3747b..11426d2d 100644
--- a/misc/examples/regex_match.c
+++ b/misc/examples/regex_match.c
@@ -6,7 +6,7 @@
 #define i_key float
 #include <stc/cstack.h>
 
-int main()
+int main(void)
 {
     // Lets find the first sequence of digits in a string
     const char *str = "Hello numeric world, there are 24 hours in a day, 3600 seconds in an hour."
diff --git a/misc/examples/regex_replace.c b/misc/examples/regex_replace.c
index 76664b1b..f1ea2711 100644
--- a/misc/examples/regex_replace.c
+++ b/misc/examples/regex_replace.c
@@ -12,7 +12,7 @@ bool add_10_years(int i, csview match, cstr* out) {
     return false;
 }
 
-int main()
+int main(void)
 {
     const char* pattern = "\\b(\\d\\d\\d\\d)-(1[0-2]|0[1-9])-(3[01]|[12][0-9]|0[1-9])\\b";
     const char* input = "start date: 2015-12-31, end date: 2022-02-28";
diff --git a/misc/examples/replace.c b/misc/examples/replace.c
index 9ac26c07..59a56bf7 100644
--- a/misc/examples/replace.c
+++ b/misc/examples/replace.c
@@ -1,7 +1,7 @@
 #define i_implement
 #include <stc/cstr.h>
 
-int main ()
+int main(void)
 {
     const char *base = "this is a test string.";
     const char *s2 = "n example";
diff --git a/misc/examples/scheduler.c b/misc/examples/scheduler.c
index d812ff42..38defd0f 100644
--- a/misc/examples/scheduler.c
+++ b/misc/examples/scheduler.c
@@ -68,7 +68,7 @@ void Use(void)
     Scheduler_drop(&scheduler);
 }
 
-int main()
+int main(void)
 {
     Use();
 }
diff --git a/misc/examples/sidebyside.cpp b/misc/examples/sidebyside.cpp
index a7c1008c..9414b691 100644
--- a/misc/examples/sidebyside.cpp
+++ b/misc/examples/sidebyside.cpp
@@ -13,7 +13,7 @@
 #define i_val int
 #include <stc/cmap.h>
 
-int main() {
+int main(void) {
     {
         std::map<int, int> hist;
         hist.emplace(12, 100).first->second += 1;
diff --git a/misc/examples/sorted_map.c b/misc/examples/sorted_map.c
index ff727632..89381554 100644
--- a/misc/examples/sorted_map.c
+++ b/misc/examples/sorted_map.c
@@ -5,7 +5,7 @@
 #define i_val int
 #include <stc/csmap.h>
 
-int main() 
+int main(void) 
 { 
   
     // empty map containers
diff --git a/misc/examples/splitstr.c b/misc/examples/splitstr.c
index 32b5f17f..ef7ed174 100644
--- a/misc/examples/splitstr.c
+++ b/misc/examples/splitstr.c
@@ -4,7 +4,7 @@
 #define i_implement
 #include <stc/csview.h>
 
-int main()
+int main(void)
 {
     puts("Split with c_fortoken (csview):");
 
diff --git a/misc/examples/sso_map.c b/misc/examples/sso_map.c
index b78dcb2e..4f84b651 100644
--- a/misc/examples/sso_map.c
+++ b/misc/examples/sso_map.c
@@ -4,7 +4,7 @@
 #define i_val_str
 #include <stc/cmap.h>
 
-int main()
+int main(void)
 {
     cmap_str m = {0};
     cmap_str_emplace(&m, "Test short", "This is a short string");
diff --git a/misc/examples/sso_substr.c b/misc/examples/sso_substr.c
index 9b062eed..687658df 100644
--- a/misc/examples/sso_substr.c
+++ b/misc/examples/sso_substr.c
@@ -3,7 +3,7 @@
 #define i_implement
 #include <stc/csview.h>
 
-int main ()
+int main(void)
 {
     cstr str = cstr_lit("We think in generalities, but we live in details.");
     csview sv1 = cstr_substr_ex(&str, 3, 5);               // "think"
diff --git a/misc/examples/stack.c b/misc/examples/stack.c
index 96bab24b..6297fb6f 100644
--- a/misc/examples/stack.c
+++ b/misc/examples/stack.c
@@ -10,7 +10,7 @@
 #define i_key char
 #include <stc/cstack.h>
 
-int main() {
+int main(void) {
     cstack_i stack = {0};
     cstack_c chars = {0};
 
diff --git a/misc/examples/sview_split.c b/misc/examples/sview_split.c
index 782e4096..ac275da0 100644
--- a/misc/examples/sview_split.c
+++ b/misc/examples/sview_split.c
@@ -3,7 +3,7 @@
 #define i_implement
 #include <stc/csview.h>
 
-int  main()
+int main(void)
 {
     // No memory allocations or string length calculations!
     const csview date = c_sv("2021/03/12");
diff --git a/misc/examples/triples.c b/misc/examples/triples.c
index a8ca6b47..9f2fcc1e 100644
--- a/misc/examples/triples.c
+++ b/misc/examples/triples.c
@@ -52,7 +52,7 @@ int triples_coro(struct triples* t) {
     return 0;
 }
 
-int main()
+int main(void)
 {
     puts("Vanilla triples:");
     triples_vanilla(5);
diff --git a/misc/examples/unordered_set.c b/misc/examples/unordered_set.c
index 14d69ce5..dd899d78 100644
--- a/misc/examples/unordered_set.c
+++ b/misc/examples/unordered_set.c
@@ -5,7 +5,7 @@
 #define i_key_str
 #include <stc/cset.h>
 
-int main()
+int main(void)
 {
     // declaring set for storing string data-type
     cset_str stringSet = {0};
diff --git a/misc/examples/utf8replace_c.c b/misc/examples/utf8replace_c.c
index 17352fee..1d54486f 100644
--- a/misc/examples/utf8replace_c.c
+++ b/misc/examples/utf8replace_c.c
@@ -1,7 +1,7 @@
 #define i_implement
 #include <stc/cstr.h>
 
-int main()
+int main(void)
 {
     cstr hello = cstr_lit("hell😀 w😀rld");
     printf("%s\n", cstr_str(&hello));
diff --git a/misc/examples/vikings.c b/misc/examples/vikings.c
index d9024052..d6125854 100644
--- a/misc/examples/vikings.c
+++ b/misc/examples/vikings.c
@@ -41,7 +41,7 @@ static inline RViking Viking_toraw(const Viking* vp) {
 #define i_val       int         // mapped type
 #include <stc/cmap.h>
 
-int main()
+int main(void)
 {
     Vikings vikings = {0};
     Vikings_emplace(&vikings, c_LITERAL(RViking){"Einar", "Norway"}, 20);
-- 
cgit v1.2.3