Changed earlier declare_<container>(..) macro to typedef_<container>(..)

24 files changed, 265 insertions, 264 deletions

diff --git a/README.md b/README.md
index 07ef79ff..d347b64b 100644
--- a/README.md
+++ b/README.md
@@ -24,7 +24,7 @@ The usage of the containers is vert similar to the C++ standard containers, so i
 All containers mentioned above, except cstr_t and cbitset_t are generic and typesafe (similar to templates in C++). No casting is used. A simple example:

 ```

 #include <stc/cvec.h>

-c_cvec(i, int);

+typedef_cvec(i, int);

 

 int main(void) {

     cvec_i vec = cvec_ini;

@@ -55,10 +55,10 @@ Because it is headers only, files can simply be included in your program. The fu
 #include <stc/clist.h>

 #include "Vec3.h"

 

-c_cmap(ii, int, int);

-c_cset(ix, int64_t);

-c_cvec(i, int);

-c_clist(v3, Vec3);

+typedef_cmap(ii, int, int);

+typedef_cset(ix, int64_t);

+typedef_cvec(i, int);

+typedef_clist(v3, Vec3);

 ...

 ```

 Performance

@@ -118,7 +118,7 @@ cmap discussion
 

 You can customize the destroy-, hash- and equals- function. **cmap/cset** also supports a few other arguments in the declare-statement that allows to define a convertion from a raw/literal type to the key-type specified. This is very useful when e.g. having cstr as key, as it enables the usage of string literals as key in *put() and find()* functions, instead of requering a constructed cstr. Without it, the code would become: 

 ```

-c_cmap(si, cstr_t, int); // don't do this.

+typedef_cmap(si, cstr_t, int); // don't do this.

 ...

 cmap_si_put(&map, cstr("mykey"), 12);

 ```

@@ -129,12 +129,12 @@ int x = cmap_si_find(&map, lookup)->value;
 cstr_destroy(&lookup);

 ```

 To avoid this, use 

-- *c_cmap_strkey(tag, valuetype)*

-- *c_cmap_strval(tag, keytype)*

-- *c_cmap_str()* // cstr_t -> cstr_t

-- *c_cset_str()* // cstr_t set

+- *typedef_cmap_strkey(tag, valuetype)*

+- *typedef_cmap_strval(tag, keytype)*

+- *typedef_cmap_str()* // cstr_t -> cstr_t

+- *typedef_cset_str()* // cstr_t set

 ```

-c_cmap_strkey(si, int);

+typedef_cmap_strkey(si, int);

 ...

 cmap_si map = cmap_ini;

 cmap_si_put(&map, "mykey", 12);             // constructs a cstr_t key from the const char* internally.

@@ -142,9 +142,9 @@ int x = cmap_si_find(&map, "mykey")->value; // no allocation of string key happe
 cmap_si_destroy(&map);

 ```

 An alternative is to use *char* * as key type, but then you must manage allcoated memory of the hash char* keys yourself.

-Note that this predefined customization is also available for **cvec** and **clist**. See *c_cvec_str()*, *c_clist_str()*.

+Note that this predefined customization is also available for **cvec** and **clist**. See *typedef_cvec_str()*, *typedef_clist_str()*.

 

-To customize your own cmap type to work like cmap_str, you may want to look at **examples/advanced.c**. It demonstrates how to use a custom struct as a hash map key, using the optional parameters to c_cmap().

+To customize your own cmap type to work like cmap_str, you may want to look at **examples/advanced.c**. It demonstrates how to use a custom struct as a hash map key, using the optional parameters to typedef_cmap().

 

 Example usages

 --------------

@@ -181,7 +181,7 @@ int main() {
 **cvec** of *int64_t*. 

 ```

 #include <stc/cvec.h>

-c_cvec(ix, int64_t); // ix is just an example type tag name.

+typedef_cvec(ix, int64_t); // ix is just an example type tag name.

 

 int main() {

     cvec_ix bignums = cvec_ini; // use cvec_ix_init() if initializing after declaration.

@@ -200,7 +200,7 @@ int main() {
 ```

 #include <stc/cstr.h>

 #include <stc/cvec.h>

-c_cvec_str();

+typedef_cvec_str();

 

 int main() {

     cvec_str names = cvec_ini;

@@ -220,7 +220,7 @@ int main() {
 ```

 #include <stdio.h>

 #include <stc/cmap.h>

-c_cmap(ii, int, int);

+typedef_cmap(ii, int, int);

 

 int main() {

     cmap_ii nums = cmap_ini;

@@ -235,7 +235,7 @@ int main() {
 ```

 #include <stc/cstr.h>

 #include <stc/cmap.h>

-c_cset_str(); // cstr set. See the discussion above.

+typedef_cset_str(); // cstr set. See the discussion above.

 

 int main() {

     cset_str words = cset_ini;

@@ -254,7 +254,7 @@ int main() {
 ```

 #include <stc/cstr.h>

 #include <stc/cmap.h>

-c_cmap_str(); 

+typedef_cmap_str(); 

 

 int main() {

     cmap_str table = cmap_ini;

@@ -276,7 +276,7 @@ int main() {
 #include <time.h>

 #include <stc/clist.h>

 #include <stc/crandom.h>

-c_clist(fx, double);

+typedef_clist(fx, double);

 

 int main() {

     clist_fx list = clist_ini;

@@ -313,7 +313,7 @@ int main() {
 ```

 #include <stdio.h>

 #include <stc/carray.h>

-c_carray(f, float);

+typedef_carray(f, float);

 

 int main()

 {

diff --git a/examples/README.md b/examples/README.md
index d12cc522..8820f5cf 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -51,9 +51,9 @@ static inline Viking viking_fromVw(VikingVw vw) { // note: parameter is by value
     Viking vk = {cstr(vw.name), cstr(vw.country)}; return vk;

 }

 ```

-With this in place, we use the full c_cmap() macro to define {Viking -> int} hash map type:

+With this in place, we use the full typedef_cmap() macro to define {Viking -> int} hash map type:

 ```

-c_cmap(vk, Viking, int, c_default_destroy, vikingvw_equals, vikingvw_hash, 

+typedef_cmap(vk, Viking, int, c_default_destroy, vikingvw_equals, vikingvw_hash, 

                  viking_destroy, VikingVw, viking_toVw, viking_fromVw);

 ```

 cmap_vk uses vikingvw_hash() for hash value calculations, and vikingvw_equals() for equality test. cmap_vk_destroy() will free all memory allocated for Viking keys and the hash table values.

diff --git a/examples/advanced.c b/examples/advanced.c
index 0570ce55..2c736e2d 100644
--- a/examples/advanced.c
+++ b/examples/advanced.c
@@ -50,8 +50,8 @@ Viking viking_fromVw(VikingVw vw) {
     Viking vk = {cstr(vw.name), cstr(vw.country)}; return vk;
 }
 
-// Using the full c_cmap() macro to define [Viking -> int] hash map type:
-c_cmap(vk, Viking, int, c_default_destroy, vikingvw_equals, vikingvw_hash,
+// Using the full typedef_cmap() macro to define [Viking -> int] hash map type:
+typedef_cmap(vk, Viking, int, c_default_destroy, vikingvw_equals, vikingvw_hash,
                  viking_destroy, VikingVw, viking_toVw, viking_fromVw);
 
 // cmap_vk uses vikingvw_hash() for hash value calculations, and vikingvw_equals() for equality test.
diff --git a/examples/benchmark.c b/examples/benchmark.c
index 0a492d3d..969cf3cc 100644
--- a/examples/benchmark.c
+++ b/examples/benchmark.c
@@ -22,7 +22,7 @@ static inline uint32_t fibonacci_hash(const void* data, size_t len) {
 }

 

 // cmap and khash template expansion

-c_cmap(ii, int64_t, int64_t, c_default_destroy, c_default_equals, fibonacci_hash);

+typedef_cmap(ii, int64_t, int64_t, c_default_destroy, c_default_equals, fibonacci_hash);

 KHASH_MAP_INIT_INT64(ii, int64_t)

 

 

@@ -34,100 +34,100 @@ crand_rng64_t rng;
 #define RAND(N) (crand_i64(&rng) & ((1 << N) - 1))

 

 

-#define CMAP_SETUP(tt, Key, Value) cmap_##tt map = cmap_ini \

-                                    ; cmap_##tt##_set_load_factors(&map, max_load_factor, 0.0)

-#define CMAP_PUT(tt, key, val)     cmap_##tt##_put(&map, key, val).first->second

-#define CMAP_EMPLACE(tt, key, val) cmap_##tt##_emplace(&map, key, val)

-#define CMAP_ERASE(tt, key)        cmap_##tt##_erase(&map, key)

-#define CMAP_FIND(tt, key)         (cmap_##tt##_find(map, key) != NULL)

-#define CMAP_FOR(tt, i)            c_foreach (i, cmap_##tt, map)

-#define CMAP_ITEM(tt, i)           i.get->second

-#define CMAP_SIZE(tt)              cmap_size(map)

-#define CMAP_BUCKETS(tt)           cmap_bucket_count(map)

-#define CMAP_CLEAR(tt)             cmap_##tt##_clear(&map)

-#define CMAP_DTOR(tt)              cmap_##tt##_destroy(&map)

-

-#define KMAP_SETUP(tt, Key, Value) khash_t(ii)* map = kh_init(ii); khiter_t ki; int ret

-#define KMAP_PUT(tt, key, val)     (*(ki = kh_put(ii, map, key, &ret), map->vals[ki] = val, &map->vals[ki]))

-#define KMAP_EMPLACE(tt, key, val)  (ki = kh_put(ii, map, key, &ret), ret ? (map->vals[ki] = val) : val)

-#define KMAP_ERASE(tt, key)        ((ki = kh_get(ii, map, key)) != kh_end(map) ? kh_del(ii, map, ki), 1 : 0)

-#define KMAP_FIND(tt, key)         (kh_get(ii, map, key) != kh_end(map))

-#define KMAP_SIZE(tt)              kh_size(map)

-#define KMAP_BUCKETS(tt)           kh_n_buckets(map)

-#define KMAP_CLEAR(tt)             kh_clear(ii, map)

-#define KMAP_DTOR(tt)              kh_destroy(ii, map)

-

-#define UMAP_SETUP(tt, Key, Value) std::unordered_map<Key, Value> map; map.max_load_factor(max_load_factor)

-#define UMAP_PUT(tt, key, val)     (map[key] = val)

-#define UMAP_EMPLACE(tt, key, val) map.emplace(key, val)

-#define UMAP_FIND(tt, key)         (map.find(key) != map.end())

-#define UMAP_ERASE(tt, key)        map.erase(key)

-#define UMAP_FOR(tt, i)            for (auto i: map)

-#define UMAP_ITEM(tt, i)           i.second

-#define UMAP_SIZE(tt)              map.size()

-#define UMAP_BUCKETS(tt)           map.bucket_count()

-#define UMAP_CLEAR(tt)             map.clear()

-#define UMAP_DTOR(tt)              destroy_me(map)

-

-#define BMAP_SETUP(tt, Key, Value) ska::bytell_hash_map<Key, Value> map; map.max_load_factor(max_load_factor)

-#define BMAP_PUT(tt, key, val)     UMAP_PUT(tt, key, val)

-#define BMAP_EMPLACE(tt, key, val) UMAP_EMPLACE(tt, key, val)

-#define BMAP_FIND(tt, key)         UMAP_FIND(tt, key)

-#define BMAP_ERASE(tt, key)        UMAP_ERASE(tt, key)

-#define BMAP_FOR(tt, i)            UMAP_FOR(tt, i)

-#define BMAP_ITEM(tt, i)           UMAP_ITEM(tt, i)

-#define BMAP_SIZE(tt)              UMAP_SIZE(tt)

-#define BMAP_BUCKETS(tt)           UMAP_BUCKETS(tt)

-#define BMAP_CLEAR(tt)             UMAP_CLEAR(tt)

-#define BMAP_DTOR(tt)              UMAP_DTOR(tt)

-

-#define FMAP_SETUP(tt, Key, Value) ska::flat_hash_map<Key, Value> map; map.max_load_factor(max_load_factor)

-#define FMAP_PUT(tt, key, val)     UMAP_PUT(tt, key, val)

-#define FMAP_EMPLACE(tt, key, val) UMAP_EMPLACE(tt, key, val)

-#define FMAP_FIND(tt, key)         UMAP_FIND(tt, key)

-#define FMAP_ERASE(tt, key)        UMAP_ERASE(tt, key)

-#define FMAP_FOR(tt, i)            UMAP_FOR(tt, i)

-#define FMAP_ITEM(tt, i)           UMAP_ITEM(tt, i)

-#define FMAP_SIZE(tt)              UMAP_SIZE(tt)

-#define FMAP_BUCKETS(tt)           UMAP_BUCKETS(tt)

-#define FMAP_CLEAR(tt)             UMAP_CLEAR(tt)

-#define FMAP_DTOR(tt)              UMAP_DTOR(tt)

-

-#define HMAP_SETUP(tt, Key, Value) tsl::hopscotch_map<Key, Value> map; map.max_load_factor(max_load_factor)

-#define HMAP_PUT(tt, key, val)     UMAP_PUT(tt, key, val)

-#define HMAP_EMPLACE(tt, key, val) UMAP_EMPLACE(tt, key, val)

-#define HMAP_FIND(tt, key)         UMAP_FIND(tt, key)

-#define HMAP_ERASE(tt, key)        UMAP_ERASE(tt, key)

-#define HMAP_FOR(tt, i)            UMAP_FOR(tt, i)

-#define HMAP_ITEM(tt, i)           UMAP_ITEM(tt, i)

-#define HMAP_SIZE(tt)              UMAP_SIZE(tt)

-#define HMAP_BUCKETS(tt)           UMAP_BUCKETS(tt)

-#define HMAP_CLEAR(tt)             UMAP_CLEAR(tt)

-#define HMAP_DTOR(tt)              UMAP_DTOR(tt)

-

-#define RMAP_SETUP(tt, Key, Value) robin_hood::unordered_map<Key, Value> map

-#define RMAP_PUT(tt, key, val)     UMAP_PUT(tt, key, val)

-#define RMAP_EMPLACE(tt, key, val) UMAP_EMPLACE(tt, key, val)

-#define RMAP_FIND(tt, key)         UMAP_FIND(tt, key)

-#define RMAP_ERASE(tt, key)        UMAP_ERASE(tt, key)

-#define RMAP_FOR(tt, i)            UMAP_FOR(tt, i)

-#define RMAP_ITEM(tt, i)           UMAP_ITEM(tt, i)

-#define RMAP_SIZE(tt)              UMAP_SIZE(tt)

-#define RMAP_BUCKETS(tt)           map.mask()

-#define RMAP_CLEAR(tt)             UMAP_CLEAR(tt)

-#define RMAP_DTOR(tt)              UMAP_DTOR(tt)

-

-#define SMAP_SETUP(tt, Key, Value) spp::sparse_hash_map<Key, Value> map; map.max_load_factor(max_load_factor)

-#define SMAP_PUT(tt, key, val)     UMAP_PUT(tt, key, val)

-#define SMAP_EMPLACE(tt, key, val) UMAP_EMPLACE(tt, key, val)

-#define SMAP_FIND(tt, key)         UMAP_FIND(tt, key)

-#define SMAP_ERASE(tt, key)        UMAP_ERASE(tt, key)

-#define SMAP_FOR(tt, i)            UMAP_FOR(tt, i)

-#define SMAP_ITEM(tt, i)           UMAP_ITEM(tt, i)

-#define SMAP_SIZE(tt)              UMAP_SIZE(tt)

-#define SMAP_BUCKETS(tt)           UMAP_BUCKETS(tt)

-#define SMAP_CLEAR(tt)             UMAP_CLEAR(tt)

-#define SMAP_DTOR(tt)              UMAP_DTOR(tt)

+#define CMAP_SETUP(X, Key, Value) cmap_##X map = cmap_ini \

+                                  ; cmap_##X##_set_load_factors(&map, max_load_factor, 0.0)

+#define CMAP_PUT(X, key, val)     cmap_##X##_put(&map, key, val).first->second

+#define CMAP_EMPLACE(X, key, val) cmap_##X##_emplace(&map, key, val)

+#define CMAP_ERASE(X, key)        cmap_##X##_erase(&map, key)

+#define CMAP_FIND(X, key)         (cmap_##X##_find(map, key) != NULL)

+#define CMAP_FOR(X, i)            c_foreach (i, cmap_##X, map)

+#define CMAP_ITEM(X, i)           i.get->second

+#define CMAP_SIZE(X)              cmap_size(map)

+#define CMAP_BUCKETS(X)           cmap_##X##_bucket_count(map)

+#define CMAP_CLEAR(X)             cmap_##X##_clear(&map)

+#define CMAP_DTOR(X)              cmap_##X##_destroy(&map)

+

+#define KMAP_SETUP(X, Key, Value) khash_t(ii)* map = kh_init(ii); khiter_t ki; int ret

+#define KMAP_PUT(X, key, val)     (*(ki = kh_put(ii, map, key, &ret), map->vals[ki] = val, &map->vals[ki]))

+#define KMAP_EMPLACE(X, key, val)  (ki = kh_put(ii, map, key, &ret), ret ? (map->vals[ki] = val) : val)

+#define KMAP_ERASE(X, key)        ((ki = kh_get(ii, map, key)) != kh_end(map) ? kh_del(ii, map, ki), 1 : 0)

+#define KMAP_FIND(X, key)         (kh_get(ii, map, key) != kh_end(map))

+#define KMAP_SIZE(X)              kh_size(map)

+#define KMAP_BUCKETS(X)           kh_n_buckets(map)

+#define KMAP_CLEAR(X)             kh_clear(ii, map)

+#define KMAP_DTOR(X)              kh_destroy(ii, map)

+

+#define UMAP_SETUP(X, Key, Value) std::unordered_map<Key, Value> map; map.max_load_factor(max_load_factor)

+#define UMAP_PUT(X, key, val)     (map[key] = val)

+#define UMAP_EMPLACE(X, key, val) map.emplace(key, val)

+#define UMAP_FIND(X, key)         (map.find(key) != map.end())

+#define UMAP_ERASE(X, key)        map.erase(key)

+#define UMAP_FOR(X, i)            for (auto i: map)

+#define UMAP_ITEM(X, i)           i.second

+#define UMAP_SIZE(X)              map.size()

+#define UMAP_BUCKETS(X)           map.bucket_count()

+#define UMAP_CLEAR(X)             map.clear()

+#define UMAP_DTOR(X)              destroy_me(map)

+

+#define BMAP_SETUP(X, Key, Value) ska::bytell_hash_map<Key, Value> map; map.max_load_factor(max_load_factor)

+#define BMAP_PUT(X, key, val)     UMAP_PUT(X, key, val)

+#define BMAP_EMPLACE(X, key, val) UMAP_EMPLACE(X, key, val)

+#define BMAP_FIND(X, key)         UMAP_FIND(X, key)

+#define BMAP_ERASE(X, key)        UMAP_ERASE(X, key)

+#define BMAP_FOR(X, i)            UMAP_FOR(X, i)

+#define BMAP_ITEM(X, i)           UMAP_ITEM(X, i)

+#define BMAP_SIZE(X)              UMAP_SIZE(X)

+#define BMAP_BUCKETS(X)           UMAP_BUCKETS(X)

+#define BMAP_CLEAR(X)             UMAP_CLEAR(X)

+#define BMAP_DTOR(X)              UMAP_DTOR(X)

+

+#define FMAP_SETUP(X, Key, Value) ska::flat_hash_map<Key, Value> map; map.max_load_factor(max_load_factor)

+#define FMAP_PUT(X, key, val)     UMAP_PUT(X, key, val)

+#define FMAP_EMPLACE(X, key, val) UMAP_EMPLACE(X, key, val)

+#define FMAP_FIND(X, key)         UMAP_FIND(X, key)

+#define FMAP_ERASE(X, key)        UMAP_ERASE(X, key)

+#define FMAP_FOR(X, i)            UMAP_FOR(X, i)

+#define FMAP_ITEM(X, i)           UMAP_ITEM(X, i)

+#define FMAP_SIZE(X)              UMAP_SIZE(X)

+#define FMAP_BUCKETS(X)           UMAP_BUCKETS(X)

+#define FMAP_CLEAR(X)             UMAP_CLEAR(X)

+#define FMAP_DTOR(X)              UMAP_DTOR(X)

+

+#define HMAP_SETUP(X, Key, Value) tsl::hopscotch_map<Key, Value> map; map.max_load_factor(max_load_factor)

+#define HMAP_PUT(X, key, val)     UMAP_PUT(X, key, val)

+#define HMAP_EMPLACE(X, key, val) UMAP_EMPLACE(X, key, val)

+#define HMAP_FIND(X, key)         UMAP_FIND(X, key)

+#define HMAP_ERASE(X, key)        UMAP_ERASE(X, key)

+#define HMAP_FOR(X, i)            UMAP_FOR(X, i)

+#define HMAP_ITEM(X, i)           UMAP_ITEM(X, i)

+#define HMAP_SIZE(X)              UMAP_SIZE(X)

+#define HMAP_BUCKETS(X)           UMAP_BUCKETS(X)

+#define HMAP_CLEAR(X)             UMAP_CLEAR(X)

+#define HMAP_DTOR(X)              UMAP_DTOR(X)

+

+#define RMAP_SETUP(X, Key, Value) robin_hood::unordered_map<Key, Value> map

+#define RMAP_PUT(X, key, val)     UMAP_PUT(X, key, val)

+#define RMAP_EMPLACE(X, key, val) UMAP_EMPLACE(X, key, val)

+#define RMAP_FIND(X, key)         UMAP_FIND(X, key)

+#define RMAP_ERASE(X, key)        UMAP_ERASE(X, key)

+#define RMAP_FOR(X, i)            UMAP_FOR(X, i)

+#define RMAP_ITEM(X, i)           UMAP_ITEM(X, i)

+#define RMAP_SIZE(X)              UMAP_SIZE(X)

+#define RMAP_BUCKETS(X)           map.mask()

+#define RMAP_CLEAR(X)             UMAP_CLEAR(X)

+#define RMAP_DTOR(X)              UMAP_DTOR(X)

+

+#define SMAP_SETUP(X, Key, Value) spp::sparse_hash_map<Key, Value> map; map.max_load_factor(max_load_factor)

+#define SMAP_PUT(X, key, val)     UMAP_PUT(X, key, val)

+#define SMAP_EMPLACE(X, key, val) UMAP_EMPLACE(X, key, val)

+#define SMAP_FIND(X, key)         UMAP_FIND(X, key)

+#define SMAP_ERASE(X, key)        UMAP_ERASE(X, key)

+#define SMAP_FOR(X, i)            UMAP_FOR(X, i)

+#define SMAP_ITEM(X, i)           UMAP_ITEM(X, i)

+#define SMAP_SIZE(X)              UMAP_SIZE(X)

+#define SMAP_BUCKETS(X)           UMAP_BUCKETS(X)

+#define SMAP_CLEAR(X)             UMAP_CLEAR(X)

+#define SMAP_DTOR(X)              UMAP_DTOR(X)

 

 enum {

     FAC = 3,

@@ -140,68 +140,68 @@ enum {
 int rr = RR;

 

 

-#define MAP_TEST1(M, tt) \

+#define MAP_TEST1(M, X) \

 { \

-    M##_SETUP(tt, int64_t, int64_t); \

+    M##_SETUP(X, int64_t, int64_t); \

     uint64_t checksum = 0, erased = 0; \

     SEED(seed); \

     clock_t difference, before = clock(); \

     for (size_t i = 0; i < N1; ++i) { \

-        checksum += ++ M##_PUT(tt, RAND(rr), i); \

-        erased += M##_ERASE(tt, RAND(rr)); \

+        checksum += ++ M##_PUT(X, RAND(rr), i); \

+        erased += M##_ERASE(X, RAND(rr)); \

     } \

     difference = clock() - before; \

     printf(#M ": size: %zu, buckets: %8zu, time: %5.02f, sum: %zu, erased %zu\n", \

-           (size_t) M##_SIZE(tt), (size_t) M##_BUCKETS(tt), (float) difference / CLOCKS_PER_SEC, checksum, erased); \

-    M##_CLEAR(tt); \

+           (size_t) M##_SIZE(X), (size_t) M##_BUCKETS(X), (float) difference / CLOCKS_PER_SEC, checksum, erased); \

+    M##_CLEAR(X); \

 }

 

-#define MAP_TEST2(M, tt) \

+#define MAP_TEST2(M, X) \

 { \

-    M##_SETUP(tt, int64_t, int64_t); \

+    M##_SETUP(X, int64_t, int64_t); \

     size_t erased = 0; \

     clock_t difference, before = clock(); \

     for (size_t i = 0; i < N2; ++i) \

-        M##_PUT(tt, i, i); \

+        M##_PUT(X, i, i); \

     for (size_t i = 0; i < N2; ++i) \

-        erased += M##_ERASE(tt, i); \

+        erased += M##_ERASE(X, i); \

     difference = clock() - before; \

     printf(#M ": size: %zu, buckets: %8zu, time: %5.02f, erased %zu\n", \

-           (size_t) M##_SIZE(tt), (size_t) M##_BUCKETS(tt), (float) difference / CLOCKS_PER_SEC, erased); \

-    M##_CLEAR(tt); \

+           (size_t) M##_SIZE(X), (size_t) M##_BUCKETS(X), (float) difference / CLOCKS_PER_SEC, erased); \

+    M##_CLEAR(X); \

 }

 

-#define MAP_TEST3(M, tt) \

+#define MAP_TEST3(M, X) \

 { \

-    M##_SETUP(tt, int64_t, int64_t); \

+    M##_SETUP(X, int64_t, int64_t); \

     size_t erased = 0; \

     clock_t difference, before = clock(); \

     SEED(seed); \

     for (size_t i = 0; i < N3; ++i) \

-        M##_PUT(tt, RAND(rr), i); \

+        M##_PUT(X, RAND(rr), i); \

     SEED(seed); \

     for (size_t i = 0; i < N3; ++i) \

-        erased += M##_ERASE(tt, RAND(rr)); \

+        erased += M##_ERASE(X, RAND(rr)); \

     difference = clock() - before; \

     printf(#M ": size: %zu, buckets: %8zu, time: %5.02f, erased %zu\n", \

-           (size_t) M##_SIZE(tt), (size_t) M##_BUCKETS(tt), (float) difference / CLOCKS_PER_SEC, erased); \

-    M##_CLEAR(tt); \

+           (size_t) M##_SIZE(X), (size_t) M##_BUCKETS(X), (float) difference / CLOCKS_PER_SEC, erased); \

+    M##_CLEAR(X); \

 }

 

-#define MAP_TEST4(M, tt) \

+#define MAP_TEST4(M, X) \

 { \

-    M##_SETUP(tt, int64_t, int64_t); \

+    M##_SETUP(X, int64_t, int64_t); \

     size_t sum = 0; \

     SEED(seed); \

     for (size_t i = 0; i < N4; ++i) \

-        M##_PUT(tt, RAND(rr), i); \

+        M##_PUT(X, RAND(rr), i); \

     clock_t difference, before = clock(); \

-    for (int k=0; k<5; k++) M##_FOR (tt, i) \

-        sum += M##_ITEM(tt, i); \

+    for (int k=0; k<5; k++) M##_FOR (X, i) \

+        sum += M##_ITEM(X, i); \

     difference = clock() - before; \

     printf(#M ": size: %zu, buckets: %8zu, time: %5.02f, sum %zu\n", \

-           (size_t) M##_SIZE(tt), (size_t) M##_BUCKETS(tt), (float) difference / CLOCKS_PER_SEC, sum); \

-    M##_CLEAR(tt); \

+           (size_t) M##_SIZE(X), (size_t) M##_BUCKETS(X), (float) difference / CLOCKS_PER_SEC, sum); \

+    M##_CLEAR(X); \

 }

 

 

diff --git a/examples/birthday.c b/examples/birthday.c
index 1cd57066..e085e25c 100644
--- a/examples/birthday.c
+++ b/examples/birthday.c
@@ -7,7 +7,7 @@
 #include <stc/cvec.h>

 #include <stc/cstr.h>

 

-c_cmap(ic, uint64_t, uint8_t);

+typedef_cmap(ic, uint64_t, uint8_t);

 

 const static uint64_t seed = 1234;

 const static uint64_t N = 1ull << 27;

@@ -29,8 +29,8 @@ void repeats(void)
 }

 

 

-c_cmap(x, uint32_t, uint64_t);

-c_cvec(x, uint64_t);

+typedef_cmap(x, uint32_t, uint64_t);

+typedef_cvec(x, uint64_t);

 

 void distribution(void)

 {

diff --git a/examples/complex.c b/examples/complex.c
index aa746b90..e0bc5200 100644
--- a/examples/complex.c
+++ b/examples/complex.c
@@ -5,10 +5,10 @@
 

 void check_destroy(float* v) {printf("destroy %g\n", *v);}

 

-c_carray(f, float, check_destroy); // normally omit the last argument - float type need no destroy.

-c_clist(y, carray2f, carray2f_destroy, c_no_compare);

-c_cmap(g, int, clist_y, clist_y_destroy);

-c_cmap_strkey(s, cmap_g, cmap_g_destroy);

+typedef_carray(f, float, check_destroy); // normally omit the last argument - float type need no destroy.

+typedef_clist(y, carray2f, carray2f_destroy, c_no_compare);

+typedef_cmap(g, int, clist_y, clist_y_destroy);

+typedef_cmap_strkey(s, cmap_g, cmap_g_destroy);

 

 int main() {

     int xdim = 4, ydim = 6;

diff --git a/examples/demos.c b/examples/demos.c
index 0247945d..634e4dde 100644
--- a/examples/demos.c
+++ b/examples/demos.c
@@ -34,7 +34,7 @@ void stringdemo1()
 }

 

 

-c_cvec(ix, int64_t); // ix is just an example tag name.

+typedef_cvec(ix, int64_t); // ix is just an example tag name.

 

 void vectordemo1()

 {

@@ -55,7 +55,7 @@ void vectordemo1()
 

 

 

-c_cvec_str();

+typedef_cvec_str();

 

 void vectordemo2()

 {

@@ -73,7 +73,7 @@ void vectordemo2()
     cvec_str_destroy(&names);

 }

 

-c_clist(ix, int);

+typedef_clist(ix, int);

 

 void listdemo1()

 {

@@ -100,7 +100,7 @@ void listdemo1()
     clist_ix_destroy(&nums);

 }

 

-c_cset(i, int);

+typedef_cset(i, int);

 

 void setdemo1()

 {

@@ -115,7 +115,7 @@ void setdemo1()
 }

 

 

-c_cmap(ii, int, int);

+typedef_cmap(ii, int, int);

 

 void mapdemo1()

 {

@@ -128,7 +128,7 @@ void mapdemo1()
 }

 

 

-c_cmap_strkey(si, int); // Shorthand macro for the general c_cmap expansion.

+typedef_cmap_strkey(si, int); // Shorthand macro for the general typedef_cmap expansion.

 

 void mapdemo2()

 {

@@ -150,7 +150,7 @@ void mapdemo2()
 }

 

 

-c_cmap_str();

+typedef_cmap_str();

 

 void mapdemo3()

 {

@@ -172,7 +172,7 @@ void mapdemo3()
 }

 

 

-c_carray(f, float);

+typedef_carray(f, float);

 

 void arraydemo1()

 {

diff --git a/examples/ex_gaussian.c b/examples/ex_gaussian.c
index 559512ce..3c3a05bf 100644
--- a/examples/ex_gaussian.c
+++ b/examples/ex_gaussian.c
@@ -7,14 +7,14 @@
 #include <stc/cvec.h>

 

 // Declare int -> int hashmap. Uses typetag 'i' for ints.

-c_cmap(i, int, size_t);

+typedef_cmap(i, int, size_t);

 

 // Declare int vector with map entries that can be sorted by map keys.

 static int compare(cmap_i_entry_t *a, cmap_i_entry_t *b) {

     return c_default_compare(&a->first, &b->first);

 }

 // Vector: typetag 'e' for (map) entry

-c_cvec(e, cmap_i_entry_t, c_default_destroy, compare);

+typedef_cvec(e, cmap_i_entry_t, c_default_destroy, compare);

 

 int main()

 {

diff --git a/examples/heap.c b/examples/heap.c
index 99806c17..18ba247c 100644
--- a/examples/heap.c
+++ b/examples/heap.c
@@ -4,8 +4,8 @@
 #include <stc/cvec.h>

 #include <stc/cpqueue.h>

 

-c_cvec(f, float);

-c_cpqueue(f, cvec_f, >);

+typedef_cvec(f, float);

+typedef_cpqueue(f, cvec_f, >);

 

 int main()

 {

diff --git a/examples/inits.c b/examples/inits.c
index 6540290a..4d07cb02 100644
--- a/examples/inits.c
+++ b/examples/inits.c
@@ -5,19 +5,19 @@
 #include <stc/cpqueue.h>

 #include <stc/clist.h>

 

-c_cmap(id, int, cstr_t, cstr_destroy); // Map of int -> cstr_t

-c_cmap_strkey(cnt, int);

+typedef_cmap(id, int, cstr_t, cstr_destroy); // Map of int -> cstr_t

+typedef_cmap_strkey(cnt, int);

 

 typedef struct {int x, y;} ipair_t;

 inline static int ipair_compare(const ipair_t* a, const ipair_t* b) {

     int c = c_default_compare(&a->x, &b->x);

     return c != 0 ? c : c_default_compare(&a->y, &b->y);

 }

-c_cvec(ip, ipair_t, c_default_destroy, ipair_compare);

-c_clist(ip, ipair_t, c_default_destroy, ipair_compare);

+typedef_cvec(ip, ipair_t, c_default_destroy, ipair_compare);

+typedef_clist(ip, ipair_t, c_default_destroy, ipair_compare);

 

-c_cvec(f, float);

-c_cpqueue(f, cvec_f, >);

+typedef_cvec(f, float);

+typedef_cpqueue(f, cvec_f, >);

 

 

 int main(void) {

diff --git a/examples/list.c b/examples/list.c
index a0a3b456..55e6c419 100644
--- a/examples/list.c
+++ b/examples/list.c
@@ -2,7 +2,7 @@
 #include <time.h>

 #include <stc/clist.h>

 #include <stc/crandom.h>

-c_clist(fx, double);

+typedef_clist(fx, double);

 

 int main() {

     int k, n = 100000;

diff --git a/examples/mapmap.c b/examples/mapmap.c
index 50806e3d..f40d6be5 100644
--- a/examples/mapmap.c
+++ b/examples/mapmap.c
@@ -3,8 +3,8 @@
 #include <stc/cmap.h>

 #include <stc/cstr.h>

 

-c_cmap_str();

-c_cmap_strkey(cfg, cmap_str, cmap_str_destroy);

+typedef_cmap_str();

+typedef_cmap_strkey(cfg, cmap_str, cmap_str_destroy);

 

 int main(void) {

     cmap_cfg config = cmap_ini;

diff --git a/examples/phonebook.c b/examples/phonebook.c
index 5395d774..66b54e33 100644
--- a/examples/phonebook.c
+++ b/examples/phonebook.c
@@ -25,7 +25,7 @@
 #include <stc/cmap.h>

 #include <stc/cstr.h>

 

-c_cmap_str();

+typedef_cmap_str();

 

 void print_phone_book(cmap_str phone_book)

 {

diff --git a/examples/priority.c b/examples/priority.c
index 1a8eff78..d35ec4c7 100644
--- a/examples/priority.c
+++ b/examples/priority.c
@@ -6,8 +6,8 @@
 #include <stc/cmap.h>

 #include <stc/crandom.h>

 

-c_cvec(i, int64_t);

-c_cpqueue(i, cvec_i, >); // min-heap (increasing values)

+typedef_cvec(i, int64_t);

+typedef_cpqueue(i, cvec_i, >); // min-heap (increasing values)

 

 int main() {

     size_t N = 10000000;

diff --git a/examples/queue.c b/examples/queue.c
index addecaa6..330e79fe 100644
--- a/examples/queue.c
+++ b/examples/queue.c
@@ -2,8 +2,8 @@
 #include <stc/cqueue.h>

 #include <stdio.h>

 

-c_clist(i, int);

-c_cqueue(i, clist_i); // min-heap (increasing values)

+typedef_clist(i, int);

+typedef_cqueue(i, clist_i); // min-heap (increasing values)

 

 int main() {

     int n = 10000000;

diff --git a/examples/stack.c b/examples/stack.c
index ba7de082..c51c420c 100644
--- a/examples/stack.c
+++ b/examples/stack.c
@@ -3,10 +3,10 @@
 #include <stc/cstr.h>

 #include <stc/cstack.h>

 

-c_cvec(i, int);

-c_cvec(c, char);

-c_cstack(i, cvec_i);

-c_cstack(c, cvec_c);

+typedef_cvec(i, int);

+typedef_cvec(c, char);

+typedef_cstack(i, cvec_i);

+typedef_cstack(c, cvec_c);

 

 int main() {

     cstack_i stack = cstack_i_init();

diff --git a/examples/words.c b/examples/words.c
index fe738d0d..70a4878f 100644
--- a/examples/words.c
+++ b/examples/words.c
@@ -4,9 +4,9 @@
 #include <stc/clist.h>
 #include <stc/cvec.h>
 
-c_cvec_str();
-c_clist_str();
-c_cmap_strkey(si, int);
+typedef_cvec_str();
+typedef_clist_str();
+typedef_cmap_strkey(si, int);
 
 
 int main1()
diff --git a/stc/carray.h b/stc/carray.h
index e2f404eb..b7557f59 100644
--- a/stc/carray.h
+++ b/stc/carray.h
@@ -30,7 +30,7 @@
  Multi-dimensional generic array allocated as one block of heap-memory.

  // demo:

 #include <stc/carray.h>

-c_carray(f, float);

+typedef_carray(f, float);

 

 int main()

 {

@@ -68,7 +68,7 @@ STC_INLINE size_t _carray3_size(const size_t* zdim) {
 }

 

 

-#define c_carray_common(D, X, Value, valueDestroy) \

+#define typedef_carray_common(D, X, Value, valueDestroy) \

     typedef struct { Value *get; } carray##D##X##_iter_t; \

 \

     STC_INLINE carray##D##X##_iter_t \

@@ -91,12 +91,12 @@ STC_INLINE size_t _carray3_size(const size_t* zdim) {
         } \

     }

 

-#define c_carray(...) c_MACRO_OVERLOAD(c_carray, __VA_ARGS__)

-#define c_carray_2(X, Value) \

-    c_carray_3(X, Value, c_default_destroy)

+#define typedef_carray(...) c_MACRO_OVERLOAD(typedef_carray, __VA_ARGS__)

+#define typedef_carray_2(X, Value) \

+    typedef_carray_3(X, Value, c_default_destroy)

 

 

-#define c_carray_3(X, Value, valueDestroy) \

+#define typedef_carray_3(X, Value, valueDestroy) \

 \

     typedef Value carray1##X##_value_t; \

     typedef carray1##X##_value_t carray2##X##_value_t, carray3##X##_value_t; \

@@ -116,9 +116,9 @@ STC_INLINE size_t _carray3_size(const size_t* zdim) {
         size_t _xdim, _yxdim, _zdim; \

     } carray3##X; \

 \

-    c_carray_common(1, X, Value, valueDestroy) \

-    c_carray_common(2, X, Value, valueDestroy) \

-    c_carray_common(3, X, Value, valueDestroy) \

+    typedef_carray_common(1, X, Value, valueDestroy) \

+    typedef_carray_common(2, X, Value, valueDestroy) \

+    typedef_carray_common(3, X, Value, valueDestroy) \

 \

     STC_INLINE carray1##X \

     carray1##X##_make(size_t xdim, Value val) { \

diff --git a/stc/clist.h b/stc/clist.h
index 27bdefb4..1fd88310 100644
--- a/stc/clist.h
+++ b/stc/clist.h
@@ -35,7 +35,7 @@
     #include <stdio.h>

     #include <stc/clist.h>

     #include <stc/crandom.h>

-    c_clist(ix, int64_t);

+    typedef_clist(ix, int64_t);

 

     int main() {

         clist_ix list = clist_ini;

@@ -56,19 +56,19 @@
     }

 */

 

-#define c_clist(...)   c_MACRO_OVERLOAD(c_clist, __VA_ARGS__)

+#define typedef_clist(...)   c_MACRO_OVERLOAD(typedef_clist, __VA_ARGS__)

 

-#define c_clist_2(X, Value) \

-                             c_clist_3(X, Value, c_default_destroy)

-#define c_clist_3(X, Value, valueDestroy) \

-                             c_clist_4(X, Value, valueDestroy, c_default_compare)

-#define c_clist_4(X, Value, valueDestroy, valueCompare) \

-                             c_clist_7(X, Value, valueDestroy, Value, \

+#define typedef_clist_2(X, Value) \

+                             typedef_clist_3(X, Value, c_default_destroy)

+#define typedef_clist_3(X, Value, valueDestroy) \

+                             typedef_clist_4(X, Value, valueDestroy, c_default_compare)

+#define typedef_clist_4(X, Value, valueDestroy, valueCompare) \

+                             typedef_clist_7(X, Value, valueDestroy, Value, \

                                           valueCompare, c_default_to_raw, c_default_from_raw)

-#define c_clist_str()  c_clist_7(str, cstr_t, cstr_destroy, const char*, \

+#define typedef_clist_str()  typedef_clist_7(str, cstr_t, cstr_destroy, const char*, \

                                       cstr_compare_raw, cstr_to_raw, cstr)

 

-#define c_clist_types(X, Value) \

+#define typedef_clist_types(X, Value) \

     typedef Value clist_##X##_value_t; \

 \

     typedef struct clist_##X##_node { \

@@ -97,12 +97,12 @@
         __pos = ctype##_emplace_after(__self, __pos, __arr[__i]); \

 } while (0)

 

-c_clist_types(void, int);

+typedef_clist_types(void, int);

 STC_API size_t _clist_size(const clist_void* self);

 

-#define c_clist_7(X, Value, valueDestroy, RawValue, valueCompareRaw, valueToRaw, valueFromRaw) \

+#define typedef_clist_7(X, Value, valueDestroy, RawValue, valueCompareRaw, valueToRaw, valueFromRaw) \

 \

-    c_clist_types(X, Value); \

+    typedef_clist_types(X, Value); \

     typedef RawValue clist_##X##_rawvalue_t; \

     typedef clist_##X##_rawvalue_t clist_##X##_input_t; \

 \

diff --git a/stc/cmap.h b/stc/cmap.h
index 5f18bb00..3192be93 100644
--- a/stc/cmap.h
+++ b/stc/cmap.h
@@ -23,8 +23,8 @@
 /*

 #include <stdio.h>

 #include <stc/cmap.h>

-c_cset(sx, int);       // Set of int

-c_cmap(mx, int, char); // Map of int -> char

+typedef_cset(sx, int);       // Set of int

+typedef_cmap(mx, int, char); // Map of int -> char

 

 int main(void) {

     cset_sx s = cset_ini;

@@ -56,10 +56,9 @@ int main(void) {
 #define cmap_ini                      {NULL, NULL, 0, 0, 0.85f, 0.15f}

 #define cmap_empty(m)                 ((m).size == 0)

 #define cmap_size(m)                  ((size_t) (m).size)

-#define cmap_bucket_count(m)          ((size_t) (m).bucket_count)

 #define cset_ini                      cmap_ini

+#define cset_empty(s)                 cmap_empty(s)

 #define cset_size(s)                  cmap_size(s)

-#define cset_bucket_count(s)          cmap_bucket_count(s)

 

 #define c_try_emplace(self, ctype, key, val) do { \

     ctype##_result_t __r = ctype##_insert_key_(self, key); \

@@ -77,72 +76,72 @@ int main(void) {
 enum {chash_HASH = 0x7f, chash_USED = 0x80};

 typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;

 

-#define c_cmap(...) \

-    c_MACRO_OVERLOAD(c_cmap, __VA_ARGS__)

+#define typedef_cmap(...) \

+    c_MACRO_OVERLOAD(typedef_cmap, __VA_ARGS__)

 

-#define c_cmap_3(X, Key, Mapped) \

-    c_cmap_4(X, Key, Mapped, c_default_destroy)

+#define typedef_cmap_3(X, Key, Mapped) \

+    typedef_cmap_4(X, Key, Mapped, c_default_destroy)

 

-#define c_cmap_4(X, Key, Mapped, valueDestroy) \

-    c_cmap_6(X, Key, Mapped, valueDestroy, c_default_equals, c_default_hash16)

+#define typedef_cmap_4(X, Key, Mapped, valueDestroy) \

+    typedef_cmap_6(X, Key, Mapped, valueDestroy, c_default_equals, c_default_hash16)

 

-#define c_cmap_6(X, Key, Mapped, valueDestroy, keyEquals, keyHash) \

-    c_cmap_10(X, Key, Mapped, valueDestroy, keyEquals, keyHash, \

+#define typedef_cmap_6(X, Key, Mapped, valueDestroy, keyEquals, keyHash) \

+    typedef_cmap_10(X, Key, Mapped, valueDestroy, keyEquals, keyHash, \

                  c_default_destroy, Key, c_default_to_raw, c_default_from_raw)

 

-#define c_cmap_10(X, Key, Mapped, valueDestroy, keyEqualsRaw, keyHashRaw, \

+#define typedef_cmap_10(X, Key, Mapped, valueDestroy, keyEqualsRaw, keyHashRaw, \

                      keyDestroy, RawKey, keyToRaw, keyFromRaw) \

-    _c_declare_CHASH(X, cmap, Key, Mapped, valueDestroy, keyEqualsRaw, keyHashRaw, \

+    _c_typedef_CHASH(X, cmap, Key, Mapped, valueDestroy, keyEqualsRaw, keyHashRaw, \

                         keyDestroy, RawKey, keyToRaw, keyFromRaw, Mapped, c_default_from_raw)

 

 /* cset: */

-#define c_cset(...) \

-    c_MACRO_OVERLOAD(c_cset, __VA_ARGS__)

+#define typedef_cset(...) \

+    c_MACRO_OVERLOAD(typedef_cset, __VA_ARGS__)

 

-#define c_cset_2(X, Key) \

-    c_cset_4(X, Key, c_default_equals, c_default_hash16)

+#define typedef_cset_2(X, Key) \

+    typedef_cset_4(X, Key, c_default_equals, c_default_hash16)

 

-#define c_cset_4(X, Key, keyEquals, keyHash) \

-    c_cset_5(X, Key, keyEquals, keyHash, c_default_destroy)

+#define typedef_cset_4(X, Key, keyEquals, keyHash) \

+    typedef_cset_5(X, Key, keyEquals, keyHash, c_default_destroy)

 

-#define c_cset_5(X, Key, keyEquals, keyHash, keyDestroy) \

-    c_cset_8(X, Key, keyEquals, keyHash, keyDestroy, \

+#define typedef_cset_5(X, Key, keyEquals, keyHash, keyDestroy) \

+    typedef_cset_8(X, Key, keyEquals, keyHash, keyDestroy, \

                 Key, c_default_to_raw, c_default_from_raw)

 

-#define c_cset_8(X, Key, keyEqualsRaw, keyHashRaw, keyDestroy, \

+#define typedef_cset_8(X, Key, keyEqualsRaw, keyHashRaw, keyDestroy, \

                     RawKey, keyToRaw, keyFromRaw) \

-    _c_declare_CHASH(X, cset, Key, Key, void, keyEqualsRaw, keyHashRaw, \

+    _c_typedef_CHASH(X, cset, Key, Key, void, keyEqualsRaw, keyHashRaw, \

                         keyDestroy, RawKey, keyToRaw, keyFromRaw, void, c_default_from_raw)

 

 /* cset_str, cmap_str, cmap_strkey, cmap_strval: */

-#define c_cset_str() \

+#define typedef_cset_str() \

     _c_declare_CHASH_strkey(str, cset, cstr_t, void)

 

-#define c_cmap_str() \

-    _c_declare_CHASH(str, cmap, cstr_t, cstr_t, cstr_destroy, cstr_equals_raw, cstr_hash_raw, \

+#define typedef_cmap_str() \

+    _c_typedef_CHASH(str, cmap, cstr_t, cstr_t, cstr_destroy, cstr_equals_raw, cstr_hash_raw, \

                           cstr_destroy, const char*, cstr_to_raw, cstr, const char*, cstr)

 

-#define c_cmap_strkey(...) \

-    c_MACRO_OVERLOAD(c_cmap_strkey, __VA_ARGS__)

+#define typedef_cmap_strkey(...) \

+    c_MACRO_OVERLOAD(typedef_cmap_strkey, __VA_ARGS__)

 

-#define c_cmap_strkey_2(X, Mapped) \

+#define typedef_cmap_strkey_2(X, Mapped) \

     _c_declare_CHASH_strkey(X, cmap, Mapped, c_default_destroy)

 

-#define c_cmap_strkey_3(X, Mapped, ValueDestroy) \

+#define typedef_cmap_strkey_3(X, Mapped, ValueDestroy) \

     _c_declare_CHASH_strkey(X, cmap, Mapped, ValueDestroy)

 

-#define c_cmap_strval(...) \

-    c_MACRO_OVERLOAD(c_cmap_strval, __VA_ARGS__)

+#define typedef_cmap_strval(...) \

+    c_MACRO_OVERLOAD(typedef_cmap_strval, __VA_ARGS__)

 

-#define c_cmap_strval_2(X, Key) \

-    c_cmap_strval_4(X, Key, c_default_equals, c_default_hash16)

+#define typedef_cmap_strval_2(X, Key) \

+    typedef_cmap_strval_4(X, Key, c_default_equals, c_default_hash16)

 

-#define c_cmap_strval_4(X, Key, keyEquals, keyHash) \

-    _c_declare_CHASH(X, cmap, Key, cstr_t, cstr_destroy, keyEquals, keyHash, \

+#define typedef_cmap_strval_4(X, Key, keyEquals, keyHash) \

+    _c_typedef_CHASH(X, cmap, Key, cstr_t, cstr_destroy, keyEquals, keyHash, \

                         c_default_destroy, Key, c_default_to_raw, c_default_from_raw, const char*, cstr)

 

 #define _c_declare_CHASH_strkey(X, ctype, Mapped, valueDestroy) \

-    _c_declare_CHASH(X, ctype, cstr_t, Mapped, valueDestroy, cstr_equals_raw, cstr_hash_raw, \

+    _c_typedef_CHASH(X, ctype, cstr_t, Mapped, valueDestroy, cstr_equals_raw, cstr_hash_raw, \

                         cstr_destroy, const char*, cstr_to_raw, cstr, Mapped, c_default_from_raw)

 

 #define CSET_ONLY_cset(...) __VA_ARGS__

@@ -153,7 +152,7 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
 #define KEY_NAME_cmap       first

 

 /* CHASH full: use 'void' for Mapped if ctype is cset */

-#define _c_declare_CHASH(X, ctype, Key, Mapped, valueDestroy, keyEqualsRaw, keyHashRaw, \

+#define _c_typedef_CHASH(X, ctype, Key, Mapped, valueDestroy, keyEqualsRaw, keyHashRaw, \

                             keyDestroy, RawKey, keyToRaw, keyFromRaw, RawVal, valueFromRaw) \

     typedef Key ctype##_##X##_key_t; \

     typedef Mapped ctype##_##X##_mapped_t; \

@@ -201,6 +200,8 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
     STC_INLINE size_t \

     ctype##_##X##_size(ctype##_##X m) {return (size_t) m.size;} \

     STC_INLINE size_t \

+    ctype##_##X##_bucket_count(ctype##_##X m) {return (size_t) m.bucket_count;} \

+    STC_INLINE size_t \

     ctype##_##X##_capacity(ctype##_##X m) {return (size_t) (m.bucket_count * m.max_load_factor);} \

     STC_INLINE void \

     ctype##_##X##_swap(ctype##_##X* a, ctype##_##X* b) {c_swap(ctype##_##X, *a, *b);} \

diff --git a/stc/cpqueue.h b/stc/cpqueue.h
index e65c67e0..7b2a02ad 100644
--- a/stc/cpqueue.h
+++ b/stc/cpqueue.h
@@ -25,8 +25,8 @@
 

     #include <stc/crandom.h>

     #include <stc/cpqueue.h>

-    c_cvec(f, float);

-    c_cpqueue(f, cvec_f, >); // min-heap (increasing values)

+    typedef_cvec(f, float);

+    typedef_cpqueue(f, cvec_f, >); // min-heap (increasing values)

 

     int main() {

         crand_rng32_t gen = crand_rng32_init(1234);

@@ -50,7 +50,7 @@
 

 #include "cvec.h"

 

-#define c_cpqueue(X, ctype, cmpOpr) /* cmpOpr: < or > */ \

+#define typedef_cpqueue(X, ctype, cmpOpr) /* cmpOpr: < or > */ \

 \

     typedef struct ctype cpqueue_##X; \

     typedef ctype##_value_t cpqueue_##X##_value_t; \

diff --git a/stc/cqueue.h b/stc/cqueue.h
index c4e095d8..3962f3d8 100644
--- a/stc/cqueue.h
+++ b/stc/cqueue.h
@@ -25,8 +25,8 @@
 

     #include <stc/crandom.h>

     #include <stc/cqueue.h>

-    c_clist(i, int);

-    c_cqueue(i, clist_i); // min-heap (increasing values)

+    typedef_clist(i, int);

+    typedef_cqueue(i, clist_i); // min-heap (increasing values)

 

     int main() {

         int n = 10000000;

@@ -58,7 +58,7 @@
 

 #include "clist.h"

 

-#define c_cqueue(X, ctype) \

+#define typedef_cqueue(X, ctype) \

 \

     typedef struct ctype cqueue_##X; \

     typedef ctype##_value_t cqueue_##X##_value_t; \

diff --git a/stc/cstack.h b/stc/cstack.h
index 97e7a0e2..f6a5777e 100644
--- a/stc/cstack.h
+++ b/stc/cstack.h
@@ -26,8 +26,8 @@
     #include <stc/cstack.h>

     #include <stdio.h>

 

-    c_cvec(i, int);

-    c_cstack(i, cvec_i);

+    typedef_cvec(i, int);

+    typedef_cstack(i, cvec_i);

 

     int main() {

         cstack_i stack = cstack_i_init();

@@ -47,7 +47,7 @@
 

 #include "cvec.h"

 

-#define c_cstack(X, ctype) \

+#define typedef_cstack(X, ctype) \

 \

     typedef struct ctype cstack_##X; \

     typedef ctype##_value_t cstack_##X##_value_t; \

diff --git a/stc/cvec.h b/stc/cvec.h
index f3ab9325..0b664c9c 100644
--- a/stc/cvec.h
+++ b/stc/cvec.h
@@ -32,18 +32,18 @@
 #define cvec_capacity(v)   _cvec_safe_capacity((v).data)

 #define cvec_empty(v)      (cvec_size(v) == 0)

 

-#define c_cvec(...) c_MACRO_OVERLOAD(c_cvec, __VA_ARGS__)

-#define c_cvec_2(X, Value) \

-                    c_cvec_3(X, Value, c_default_destroy)

-#define c_cvec_3(X, Value, valueDestroy) \

-                    c_cvec_4(X, Value, valueDestroy, c_default_compare)

-#define c_cvec_4(X, Value, valueDestroy, valueCompare) \

-                    c_cvec_7(X, Value, valueDestroy, valueCompare, Value, c_default_to_raw, c_default_from_raw)

-#define c_cvec_str() \

-                    c_cvec_7(str, cstr_t, cstr_destroy, cstr_compare_raw, const char*, cstr_to_raw, cstr)

+#define typedef_cvec(...) c_MACRO_OVERLOAD(typedef_cvec, __VA_ARGS__)

+#define typedef_cvec_2(X, Value) \

+                    typedef_cvec_3(X, Value, c_default_destroy)

+#define typedef_cvec_3(X, Value, valueDestroy) \

+                    typedef_cvec_4(X, Value, valueDestroy, c_default_compare)

+#define typedef_cvec_4(X, Value, valueDestroy, valueCompare) \

+                    typedef_cvec_7(X, Value, valueDestroy, valueCompare, Value, c_default_to_raw, c_default_from_raw)

+#define typedef_cvec_str() \

+                    typedef_cvec_7(str, cstr_t, cstr_destroy, cstr_compare_raw, const char*, cstr_to_raw, cstr)

 

 

-#define c_cvec_7(X, Value, valueDestroy, valueCompareRaw, RawValue, valueToRaw, valueFromRaw) \

+#define typedef_cvec_7(X, Value, valueDestroy, valueCompareRaw, RawValue, valueToRaw, valueFromRaw) \

 \

     typedef struct cvec_##X { \

         Value* data; \