API change: Swapped destroy <-> compare function args in using_*() macros for cvec, cdeq, cptr and clist.

15 files changed, 94 insertions, 94 deletions

diff --git a/docs/cdeq_api.md b/docs/cdeq_api.md
index db9051f9..9f72406f 100644
--- a/docs/cdeq_api.md
+++ b/docs/cdeq_api.md
@@ -5,8 +5,8 @@ This describes the API of vector type **cdeq**.
 ## Declaration
 
 ```c
-#define using_cdeq(X, Value, valueDestroy=c_default_del,
-                             valueCompareRaw=c_default_compare,
+#define using_cdeq(X, Value, valueCompareRaw=c_default_compare,
+                             valueDestroy=c_default_del,
                              RawValue=Value,
                              valueToRaw=c_default_to_raw,
                              valueFromRaw=c_default_from_raw)
diff --git a/docs/clist_api.md b/docs/clist_api.md
index 9ed0ea31..e3673492 100644
--- a/docs/clist_api.md
+++ b/docs/clist_api.md
@@ -6,8 +6,8 @@ Implemented as a circular singly linked list. Also supports various *splice* fun
 ## Declaration
 
 ```c
-#define using_clist(X, Value, valueDestroy=c_default_del,
-                              valueCompareRaw=c_default_compare,
+#define using_clist(X, Value, valueCompareRaw=c_default_compare,
+                              valueDestroy=c_default_del,
                               RawValue=Value,
                               valueToRaw=c_default_to_raw,
                               valueFromRaw=c_default_from_raw)
diff --git a/docs/cptr_api.md b/docs/cptr_api.md
index 560db243..2d626fa8 100644
--- a/docs/cptr_api.md
+++ b/docs/cptr_api.md
@@ -7,11 +7,11 @@ This describes the API of the pointer type **cptr** and the shared pointer type
 ## Declaration
 
 ```c
-#define using_cptr(X, Value, valueDestroy=c_default_del,
-                             valueCompare=c_default_compare)
+#define using_cptr(X, Value, valueCompare=c_default_compare,
+                             valueDestroy=c_default_del)
 
-#define using_csptr(X, Value, valueDestroy=c_default_del,
-                              valueCompare=c_default_compare)
+#define using_csptr(X, Value, valueCompare=c_default_compare,
+                              valueDestroy=c_default_del)
 ```
 The macro `using_cptr()` must be instantiated in the global scope. `X` is a type tag name and will
 affect the names of all cptr types and methods. E.g. declaring `using_cptr(my, cvec_my);`,
diff --git a/docs/cvec_api.md b/docs/cvec_api.md
index 27667f13..8b6f751f 100644
--- a/docs/cvec_api.md
+++ b/docs/cvec_api.md
@@ -5,8 +5,8 @@ This describes the API of vector type **cvec**.
 ## Declaration
 
 ```c
-#define using_cvec(X, Value, valueDestroy=c_default_del,
-                             valueCompareRaw=c_default_compare,
+#define using_cvec(X, Value, valueCompareRaw=c_default_compare,
+                             valueDestroy=c_default_del,
                              RawValue=Value,
                              valueToRaw=c_default_to_raw,
                              valueFromRaw=c_default_from_raw)
diff --git a/examples/complex.c b/examples/complex.c
index 19e5ae2e..3dbf683d 100644
--- a/examples/complex.c
+++ b/examples/complex.c
@@ -6,7 +6,7 @@
 void check_del(float* v) {printf("destroy %g\n", *v);}

 

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

-using_clist(y, carray2f, carray2f_del, c_no_compare);

+using_clist(y, carray2f, c_no_compare, carray2f_del);

 using_cmap(g, int, clist_y, clist_y_del);

 using_cmap_strkey(s, cmap_g, cmap_g_del);

 

diff --git a/examples/ex_gaussian.c b/examples/ex_gaussian.c
index a5137614..bfc40363 100644
--- a/examples/ex_gaussian.c
+++ b/examples/ex_gaussian.c
@@ -14,7 +14,7 @@ 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

-using_cvec(e, cmap_i_entry_t, c_default_del, compare);

+using_cvec(e, cmap_i_entry_t, compare);

 

 int main()

 {

diff --git a/examples/inits.c b/examples/inits.c
index 28b54835..9138c5bb 100644
--- a/examples/inits.c
+++ b/examples/inits.c
@@ -14,8 +14,8 @@ inline static int ipair_compare(const ipair_t* a, const ipair_t* b) {
     return cx == 0 ? c_default_compare(&a->y, &b->y) : cx;

 }

 

-using_cvec(ip, ipair_t, c_default_del, ipair_compare);

-using_clist(ip, ipair_t, c_default_del, ipair_compare);

+using_cvec(ip, ipair_t, ipair_compare);

+using_clist(ip, ipair_t, ipair_compare);

 using_cvec(f, float);

 using_cpque(f, cvec_f, >);

 

diff --git a/examples/ptr.c b/examples/ptr.c
index b32fdb33..a9c4d258 100644
--- a/examples/ptr.c
+++ b/examples/ptr.c
@@ -17,13 +17,13 @@ int Person_compare(const Person* p, const Person* q) {
     return cmp == 0 ? strcmp(p->last.str, q->last.str) : cmp;

 }

 

-using_cvec(pe, Person, Person_del, Person_compare);

+using_cvec(pe, Person, Person_compare, Person_del);

 

-using_cptr(pu, Person, Person_del, Person_compare);

-using_cvec(pu, Person*, cptr_pu_del, cptr_pu_compare);

+using_cptr(pu, Person, Person_compare, Person_del);

+using_cvec(pu, Person*, cptr_pu_compare, cptr_pu_del);

 

-using_csptr(ps, Person, Person_del, Person_compare);

-using_cvec(ps, csptr_ps, csptr_ps_del, csptr_ps_compare);

+using_csptr(ps, Person, Person_compare, Person_del);

+using_cvec(ps, csptr_ps, csptr_ps_compare, csptr_ps_del);

 

 

 const char* names[] = {

diff --git a/examples/share_ptr.c b/examples/share_ptr.c
index 2ec2470e..785333d0 100644
--- a/examples/share_ptr.c
+++ b/examples/share_ptr.c
@@ -19,9 +19,9 @@ int Person_compare(const Person* p, const Person* q) {
     return cmp == 0 ? strcmp(p->last.str, q->last.str) : cmp;

 }

 

-using_csptr(pe, Person, Person_del, Person_compare);

-using_clist(pe, csptr_pe, csptr_pe_del, csptr_pe_compare);

-using_cvec(pe, csptr_pe, csptr_pe_del, csptr_pe_compare);

+using_csptr(pe, Person, Person_compare, Person_del);

+using_clist(pe, csptr_pe, csptr_pe_compare, csptr_pe_del);

+using_cvec(pe, csptr_pe, csptr_pe_compare, csptr_pe_del);

 

 int main() {

     clist_pe queue = clist_pe_init();

diff --git a/examples/share_ptr2.c b/examples/share_ptr2.c
index 65240969..34abcd74 100644
--- a/examples/share_ptr2.c
+++ b/examples/share_ptr2.c
@@ -13,7 +13,7 @@ void Person_del(Person* p) {
     c_del(cstr, &p->name, &p->last);

 }

 

-using_csptr(ps, Person, Person_del, c_no_compare);

+using_csptr(ps, Person, c_no_compare, Person_del);

 using_cmap(ps, int, csptr_ps, csptr_ps_del);

 

 

diff --git a/stc/cdeq.h b/stc/cdeq.h
index 682a962b..8f621f18 100644
--- a/stc/cdeq.h
+++ b/stc/cdeq.h
@@ -34,13 +34,13 @@
 

 #define using_cdeq(...) c_MACRO_OVERLOAD(using_cdeq, __VA_ARGS__)

 #define using_cdeq_2(X, Value) \

-                    using_cdeq_3(X, Value, c_default_del)

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

-                    using_cdeq_4(X, Value, valueDestroy, c_default_compare)

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

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

+                    using_cdeq_3(X, Value, c_default_compare)

+#define using_cdeq_3(X, Value, valueCompare) \

+                    using_cdeq_4(X, Value, valueCompare, c_default_del)

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

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

 #define using_cdeq_str() \

-                    using_cdeq_7(str, cstr_t, cstr_del, cstr_compare_raw, const char*, cstr_to_raw, cstr_from)

+                    using_cdeq_7(str, cstr_t, cstr_compare_raw, cstr_del, const char*, cstr_to_raw, cstr_from)

 

 #define typedefs_cdeq(X, Value, RawValue) \

     typedef Value cdeq_##X##_value_t; \

@@ -51,7 +51,7 @@
         cdeq_##X##_value_t *base, *data; \

     } cdeq_##X

 

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

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

     typedefs_cdeq(X, Value, RawValue); \

 \

     STC_INLINE cdeq_##X \

@@ -200,13 +200,13 @@
     STC_INLINE size_t \

     cdeq_##X##_index(cdeq_##X deq, cdeq_##X##_iter_t it) {return it.ref - deq.data;} \

 \

-    _c_implement_cdeq_7(X, Value, valueDestroy, RawValue, valueCompareRaw, valueToRaw, valueFromRaw) \

+    _c_implement_cdeq_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueToRaw, valueFromRaw) \

     typedef cdeq_##X cdeq_##X##_t

 

 /* -------------------------- IMPLEMENTATION ------------------------- */

 

 #if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION)

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

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

 \

     STC_DEF void \

     cdeq_##X##_push_n(cdeq_##X *self, const cdeq_##X##_input_t arr[], size_t n) { \

@@ -334,7 +334,7 @@
     }

 

 #else

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

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

 #endif

 

 #if defined(_WIN32) && defined(_DLL)

diff --git a/stc/clist.h b/stc/clist.h
index a7561a00..77eac272 100644
--- a/stc/clist.h
+++ b/stc/clist.h
@@ -58,13 +58,13 @@
 #define using_clist(...)   c_MACRO_OVERLOAD(using_clist, __VA_ARGS__)

 

 #define using_clist_2(X, Value) \

-                             using_clist_3(X, Value, c_default_del)

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

-                             using_clist_4(X, Value, valueDestroy, c_default_compare)

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

-                             using_clist_7(X, Value, valueDestroy, valueCompare, \

+                             using_clist_3(X, Value, c_default_compare)

+#define using_clist_3(X, Value, valueCompare) \

+                             using_clist_4(X, Value, valueCompare, c_default_del)

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

+                             using_clist_7(X, Value, valueCompare, valueDestroy, \

                                               Value, c_default_to_raw, c_default_from_raw)

-#define using_clist_str()  using_clist_7(str, cstr_t, cstr_del, cstr_compare_raw, \

+#define using_clist_str()    using_clist_7(str, cstr_t, cstr_compare_raw, cstr_del, \

                                               const char*, cstr_to_raw, cstr_from)

 

 #define using_clist_types(X, Value) \

@@ -100,7 +100,7 @@ using_clist_types(void, int);
 STC_API size_t _clist_size(const clist_void* self);

 #define _clist_node(X, vp) c_container_of(vp, clist_##X##_node_t, value)

 

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

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

 \

     using_clist_types(X, Value); \

     typedef RawValue clist_##X##_rawvalue_t; \

@@ -206,13 +206,13 @@ STC_API size_t _clist_size(const clist_void* self);
     STC_INLINE Value* \

     clist_##X##_back(clist_##X* self) {return &self->last->value;} \

 \

-    _c_implement_clist_7(X, Value, valueDestroy, valueCompareRaw, RawValue, valueToRaw, valueFromRaw) \

+    _c_implement_clist_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueToRaw, valueFromRaw) \

     typedef clist_##X clist_##X##_t

 

 /* -------------------------- IMPLEMENTATION ------------------------- */

 

 #if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION)

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

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

 \

     STC_DEF clist_##X \

     clist_##X##_clone(clist_##X list) { \

@@ -404,7 +404,7 @@ _clist_mergesort(clist_void_node_t *list, int (*cmp)(const void*, const void*))
 }

 

 #else

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

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

 #endif

 

 #endif

diff --git a/stc/cmap.h b/stc/cmap.h
index 8d5fd7cd..4c203ccc 100644
--- a/stc/cmap.h
+++ b/stc/cmap.h
@@ -75,22 +75,22 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
 #define using_cmap_3(X, Key, Mapped) \

     using_cmap_4(X, Key, Mapped, c_default_del)

 

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

-    using_cmap_6(X, Key, Mapped, valueDestroy, c_default_equals, c_default_hash)

+#define using_cmap_4(X, Key, Mapped, mappedDel) \

+    using_cmap_6(X, Key, Mapped, mappedDel, c_default_equals, c_default_hash)

 

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

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

-                    c_default_del, Key, c_default_to_raw, c_default_from_raw)

+#define using_cmap_6(X, Key, Mapped, mappedDel, keyEquals, keyHash) \

+    using_cmap_10(X, Key, Mapped, mappedDel, keyEquals, keyHash, \

+                     c_default_del, Key, c_default_to_raw, c_default_from_raw)

 

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

-                        keyDestroy, RawKey, keyToRaw, keyFromRaw) \

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

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

+#define using_cmap_10(X, Key, Mapped, mappedDel, keyEqualsRaw, keyHashRaw, \

+                        keyDel, RawKey, keyToRaw, keyFromRaw) \

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

+                        keyDel, RawKey, keyToRaw, keyFromRaw, Mapped, c_default_from_raw)

 

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

-                        keyDestroy, RawKey, keyToRaw, keyFromRaw, RawMapped, mappedFromRaw) \

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

-                        keyDestroy, RawKey, keyToRaw, keyFromRaw, RawMapped, mappedFromRaw)

+#define using_cmap_12(X, Key, Mapped, mappedDel, keyEqualsRaw, keyHashRaw, \

+                        keyDel, RawKey, keyToRaw, keyFromRaw, RawMapped, mappedFromRaw) \

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

+                        keyDel, RawKey, keyToRaw, keyFromRaw, RawMapped, mappedFromRaw)

 

 /* cset: */

 #define using_cset(...) \

@@ -102,14 +102,14 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
 #define using_cset_4(X, Key, keyEquals, keyHash) \

     using_cset_5(X, Key, keyEquals, keyHash, c_default_del)

 

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

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

+#define using_cset_5(X, Key, keyEquals, keyHash, keyDel) \

+    using_cset_8(X, Key, keyEquals, keyHash, keyDel, \

                 Key, c_default_to_raw, c_default_from_raw)

 

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

+#define using_cset_8(X, Key, keyEqualsRaw, keyHashRaw, keyDel, \

                     RawKey, keyToRaw, keyFromRaw) \

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

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

+                        keyDel, RawKey, keyToRaw, keyFromRaw, void, c_default_from_raw)

 

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

 #define using_cset_str() \

@@ -138,13 +138,13 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
     using_cmap_strval_8(X, Key, keyEquals, keyHash, \

                              c_default_del, Key, c_default_to_raw, c_default_from_raw)

 

-#define using_cmap_strval_8(X, Key, keyEquals, keyHash, keyDestroy, RawKey, keyToRaw, keyFromRaw) \

+#define using_cmap_strval_8(X, Key, keyEquals, keyHash, keyDel, RawKey, keyToRaw, keyFromRaw) \

     _c_typedef_CHASH(X, cmap, Key, cstr_t, cstr_del, keyEquals, keyHash, \

-                        keyDestroy, RawKey, keyToRaw, keyFromRaw, const char*, cstr_from)

+                        keyDel, RawKey, keyToRaw, keyFromRaw, const char*, cstr_from)

 

 

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

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

+#define _c_declare_CHASH_strkey(X, ctype, Mapped, mappedDel) \

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

                         cstr_del, const char*, cstr_to_raw, cstr_from, Mapped, c_default_from_raw)

 

 #define CSET_ONLY_cset(...) __VA_ARGS__

@@ -155,8 +155,8 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
 #define KEY_REF_cmap(e)     (e)->first

 

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

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

-                            keyDestroy, RawKey, keyToRaw, keyFromRaw, RawMapped, mappedFromRaw) \

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

+                            keyDel, RawKey, keyToRaw, keyFromRaw, RawMapped, mappedFromRaw) \

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

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

     typedef RawKey ctype##_##X##_rawkey_t; \

@@ -169,8 +169,8 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
 \

     STC_INLINE void \

     ctype##_##X##_entry_del(ctype##_##X##_value_t* e) { \

-        keyDestroy(&KEY_REF_##ctype(e)); \

-        CMAP_ONLY_##ctype(valueDestroy(&e->second);) \

+        keyDel(&KEY_REF_##ctype(e)); \

+        CMAP_ONLY_##ctype(mappedDel(&e->second);) \

     } \

     typedef CSET_ONLY_##ctype( ctype##_##X##_rawkey_t ) \

             CMAP_ONLY_##ctype( struct {ctype##_##X##_rawkey_t first; \

@@ -247,7 +247,7 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
     STC_INLINE ctype##_##X##_result_t \

     ctype##_##X##_insert_or_assign(ctype##_##X* self, RawKey rawKey, RawMapped rawVal) { \

         ctype##_##X##_result_t res = ctype##_##X##_insert_key_(self, rawKey); \

-        if (!res.second) valueDestroy(&res.first->second); \

+        if (!res.second) mappedDel(&res.first->second); \

         res.first->second = mappedFromRaw(rawVal); return res; \

     } \

     STC_INLINE ctype##_##X##_mapped_t* \

@@ -263,7 +263,7 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
     STC_INLINE ctype##_##X##_result_t \

     ctype##_##X##_put_mapped(ctype##_##X* self, RawKey rawKey, Mapped mapped) { \

         ctype##_##X##_result_t res = ctype##_##X##_insert_key_(self, rawKey); \

-        if (!res.second) valueDestroy(&res.first->second); \

+        if (!res.second) mappedDel(&res.first->second); \

         res.first->second = mapped; return res; \

     }) \

 \

@@ -304,15 +304,15 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
     STC_API uint32_t c_default_hash(const void *data, size_t len); \

     STC_API uint32_t c_default_hash32(const void* data, size_t len); \

 \

-    _c_implement_CHASH(X, ctype, Key, Mapped, valueDestroy, keyEqualsRaw, keyHashRaw, \

-                          keyDestroy, RawKey, keyToRaw, keyFromRaw, RawMapped, mappedFromRaw) \

+    _c_implement_CHASH(X, ctype, Key, Mapped, mappedDel, keyEqualsRaw, keyHashRaw, \

+                          keyDel, RawKey, keyToRaw, keyFromRaw, RawMapped, mappedFromRaw) \

     typedef ctype##_##X ctype##_##X##_t

 

 /* -------------------------- IMPLEMENTATION ------------------------- */

 

 #if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION)

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

-                              keyDestroy, RawKey, keyToRaw, keyFromRaw, RawMapped, mappedFromRaw) \

+#define _c_implement_CHASH(X, ctype, Key, Mapped, mappedDel, keyEqualsRaw, keyHashRaw, \

+                              keyDel, RawKey, keyToRaw, keyFromRaw, RawMapped, mappedFromRaw) \

     STC_DEF ctype##_##X \

     ctype##_##X##_with_capacity(size_t cap) { \

         ctype##_##X h = ctype##_inits; \

@@ -450,8 +450,8 @@ STC_DEF uint32_t c_default_hash32(const void* data, size_t len) {
 }

 

 #else

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

-                              keyDestroy, RawKey, keyToRaw, keyFromRaw, RawMapped, mappedFromRaw)

+#define _c_implement_CHASH(X, ctype, Key, Mapped, mappedDel, keyEqualsRaw, keyHashRaw, \

+                              keyDel, RawKey, keyToRaw, keyFromRaw, RawMapped, mappedFromRaw)

 #endif

 

 #endif

diff --git a/stc/cptr.h b/stc/cptr.h
index a3ec625f..23e1f09f 100644
--- a/stc/cptr.h
+++ b/stc/cptr.h
@@ -62,12 +62,12 @@ int main() {
 #define using_cptr(...) c_MACRO_OVERLOAD(using_cptr, __VA_ARGS__)

 

 #define using_cptr_2(X, Value) \

-    using_cptr_3(X, Value, c_default_del)

+    using_cptr_3(X, Value, c_default_compare)

 

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

-    using_cptr_4(X, Value, valueDestroy, c_default_compare)

+#define using_cptr_3(X, Value, valueCompare) \

+    using_cptr_4(X, Value, valueCompare, c_default_del)

 

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

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

     typedef Value cptr_##X##_value_t; \

     typedef cptr_##X##_value_t *cptr_##X; \

 \

@@ -153,12 +153,12 @@ typedef long atomic_count_t;
 #define using_csptr(...) c_MACRO_OVERLOAD(using_csptr, __VA_ARGS__)

 

 #define using_csptr_2(X, Value) \

-    using_csptr_3(X, Value, c_default_del)

+    using_csptr_3(X, Value, c_default_compare)

 

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

-    using_csptr_4(X, Value, valueDestroy, c_default_compare)

+#define using_csptr_3(X, Value, valueCompare) \

+    using_csptr_4(X, Value, valueCompare, c_default_del)

 

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

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

     typedef Value csptr_##X##_value_t; \

     typedef struct { csptr_##X##_value_t* get; atomic_count_t* use_count; } csptr_##X; \

 \

diff --git a/stc/cvec.h b/stc/cvec.h
index 7c693f0d..93d65493 100644
--- a/stc/cvec.h
+++ b/stc/cvec.h
@@ -31,13 +31,13 @@
 

 #define using_cvec(...) c_MACRO_OVERLOAD(using_cvec, __VA_ARGS__)

 #define using_cvec_2(X, Value) \

-                    using_cvec_3(X, Value, c_default_del)

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

-                    using_cvec_4(X, Value, valueDestroy, c_default_compare)

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

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

+                    using_cvec_3(X, Value, c_default_compare)

+#define using_cvec_3(X, Value, valueCompare) \

+                    using_cvec_4(X, Value, valueCompare, c_default_del)

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

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

 #define using_cvec_str() \

-                    using_cvec_7(str, cstr_t, cstr_del, cstr_compare_raw, const char*, cstr_to_raw, cstr_from)

+                    using_cvec_7(str, cstr_t, cstr_compare_raw, cstr_del, const char*, cstr_to_raw, cstr_from)

 

 #define typedefs_cvec(X, Value, RawValue) \

     typedef Value cvec_##X##_value_t; \

@@ -48,7 +48,7 @@
         cvec_##X##_value_t* data; \

     } cvec_##X

 

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

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

     typedefs_cvec(X, Value, RawValue); \

 \

     STC_INLINE cvec_##X \

@@ -188,13 +188,13 @@
     STC_INLINE size_t \

     cvec_##X##_index(cvec_##X vec, cvec_##X##_iter_t it) {return it.ref - vec.data;} \

 \

-    _c_implement_cvec_7(X, Value, valueDestroy, RawValue, valueCompareRaw, valueToRaw, valueFromRaw) \

+    _c_implement_cvec_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueToRaw, valueFromRaw) \

     typedef cvec_##X cvec_##X##_t

 

 /* -------------------------- IMPLEMENTATION ------------------------- */

 

 #if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION)

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

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

 \

     STC_DEF void \

     cvec_##X##_push_n(cvec_##X *self, const cvec_##X##_input_t arr[], size_t n) { \

@@ -298,7 +298,7 @@
     }

 

 #else

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

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

 #endif

 

 #if defined(_WIN32) && defined(_DLL)