Many internal renames. Reverted to specify both _del and _clone parameter when giving _del.

21 files changed, 165 insertions, 179 deletions

diff --git a/docs/carray_api.md b/docs/carray_api.md
index e3d35083..90fc3815 100644
--- a/docs/carray_api.md
+++ b/docs/carray_api.md
@@ -10,7 +10,7 @@ See the c++ class [boost::multi_array](https://www.boost.org/doc/libs/release/li
 
 ```c
 using_carray(X, Value);
-using_carray(X, Value, valueDestroy);
+using_carray(X, Value, valueDel, valueClone);
 ```
 The macro `using_carray()` must be instantiated in the global scope. `X` and `N` are type tags and
 will affect the names of all cset types and methods. E.g. declaring `using_carray(my, int);`, `X` should
diff --git a/docs/cdeq_api.md b/docs/cdeq_api.md
index fd42d295..10a9cd74 100644
--- a/docs/cdeq_api.md
+++ b/docs/cdeq_api.md
@@ -9,9 +9,9 @@ See the c++ class [std::deque](https://en.cppreference.com/w/cpp/container/deque
 
 ```c
 using_cdeq(X, Value);
-using_cdeq(X, Value, valueCompareRaw);
-using_cdeq(X, Value, valueCompareRaw, valueDestroy);
-using_cdeq(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue);
+using_cdeq(X, Value, valueCompare);
+using_cdeq(X, Value, valueCompare, valueDel, valueClone);
+using_cdeq(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue);
 
 using_cdeq_str();
 ```
diff --git a/docs/clist_api.md b/docs/clist_api.md
index f6772aa0..5a8cea31 100644
--- a/docs/clist_api.md
+++ b/docs/clist_api.md
@@ -18,9 +18,9 @@ See the c++ class [std::forward_list](https://en.cppreference.com/w/cpp/containe
 
 ```c
 using_clist(X, Value);
-using_clist(X, Value, valueCompareRaw);
-using_clist(X, Value, valueCompareRaw, valueDestroy);
-using_clist(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue);
+using_clist(X, Value, valueCompare);
+using_clist(X, Value, valueCompare, valueDel, valueClone);
+using_clist(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue);
 
 using_clist_str()
 ```
diff --git a/docs/cmap_api.md b/docs/cmap_api.md
index 614e48c4..11397371 100644
--- a/docs/cmap_api.md
+++ b/docs/cmap_api.md
@@ -11,21 +11,21 @@ See the c++ class [std::unordered_map](https://en.cppreference.com/w/cpp/contain
 ```c
 using_cmap(X, Key, Mapped);
 using_cmap(X, Key, Mapped, keyEquals, keyHash);
-using_cmap(X, Key, Mapped, keyEquals, keyHash, mappedDestroy);
-using_cmap(X, Key, Mapped, keyEquals, keyHash, mappedDestroy, mappedFromRaw, mappedToRaw, RawMapped);
-using_cmap(X, Key, Mapped, keyEqualsRaw, keyHashRaw, mappedDestroy, mappedFromRaw, mappedToRaw, RawMapped,
-                                                     keyDestroy, keyFromRaw, keyToRaw, RawKey);
-using_cmap_keydef(X, Key, Mapped, keyEquals, keyHash, keyDestroy);
-using_cmap_keydef(X, Key, Mapped, keyEqualsRaw, keyHashRaw, keyDestroy, keyFromRaw, keyToRaw, RawKey);
+using_cmap(X, Key, Mapped, keyEquals, keyHash, mappedDel, mappedClone);
+using_cmap(X, Key, Mapped, keyEquals, keyHash, mappedDel, mappedFromRaw, mappedToRaw, RawMapped);
+using_cmap(X, Key, Mapped, keyEqualsRaw, keyHashRaw, mappedDel, mappedFromRaw, mappedToRaw, RawMapped,
+                                                     keyDel, keyFromRaw, keyToRaw, RawKey);
+using_cmap_keydef(X, Key, Mapped, keyEquals, keyHash, keyDel, keyClone);
+using_cmap_keydef(X, Key, Mapped, keyEqualsRaw, keyHashRaw, keyDel, keyFromRaw, keyToRaw, RawKey);
 
 using_cmap_strkey(X, Mapped);                   // using_cmap(X, cstr, Mapped, ...)
-using_cmap_strkey(X, Mapped, mappedDestroy);
-using_cmap_strkey(X, Mapped, mappedDestroy, mappedFromRaw, mappedToRaw, RawMapped);
+using_cmap_strkey(X, Mapped, mappedDel, mappedClone);
+using_cmap_strkey(X, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped);
 
 using_cmap_strval(X, Key);                      // using_cmap(X, Key, cstr, ...)
 using_cmap_strval(X, Key, keyEquals, keyHash);
-using_cmap_strval(X, Key, keyEquals, keyHash, keyDestroy);
-using_cmap_strval(X, Key, keyEqualsRaw, keyHashRaw, keyDestroy, keyFromRaw, keyToRaw, RawKey);
+using_cmap_strval(X, Key, keyEquals, keyHash, keyDel, keyClone);
+using_cmap_strval(X, Key, keyEqualsRaw, keyHashRaw, keyDel, keyFromRaw, keyToRaw, RawKey);
 
 using_cmap_str()                                // using_cmap(str, cstr, cstr, ...)
 ```
@@ -77,18 +77,16 @@ cmap_X_iter_t       cmap_X_begin(cmap_X* self);
 cmap_X_iter_t       cmap_X_end(cmap_X* self);
 void                cmap_X_next(cmap_X_iter_t* it);
 cmap_X_mapped_t*    cmap_X_itval(cmap_X_iter_t it);
-
-cmap_X_value_t      cmap_X_value_clone(cmap_X_value_t val);
-void                cmap_X_value_del(cmap_X_value_t* val);
 ```
 ```
 uint64_t            c_default_hash(const void *data, size_t len);
 uint64_t            c_default_hash32(const void* data, size_t len=4);
 uint64_t            c_default_hash64(const void* data, size_t len=8);
 int                 c_default_equals(const RawKey* a, const RawKey* b);
-void                c_default_destruct(Value* val);
-Value               c_default_fromraw(RawValue raw);
-RawValue            c_default_toraw(Value* val);
+void                c_plain_del(Type* val);
+Value               c_no_clone(Type val);
+Value               c_plain_fromraw(RawType raw);
+RawType             c_plain_toraw(Type* val);
 ```
 
 ## Types
@@ -200,7 +198,7 @@ Demonstrate cmap with plain-old-data key type Vec3i and int as mapped type: cmap
 
 typedef struct { int x, y, z; } Vec3i;
 
-using_cmap(v3, Vec3i, int, c_memcmp_equals, // compare Vec3i bitwise 
+using_cmap(v3, Vec3i, int, c_plain_equals, // compare Vec3i bitwise 
                            c_default_hash); // hash Vec3i bitwise.
 
 int main()
diff --git a/docs/cptr_api.md b/docs/cptr_api.md
index b924b55c..23cb4d41 100644
--- a/docs/cptr_api.md
+++ b/docs/cptr_api.md
@@ -11,11 +11,11 @@ The pointed-to elements are automatically destructed and deleted when the contai
 ```c
 using_cptr(X, Value);
 using_cptr(X, Value, valueCompare);
-using_cptr(X, Value, valueCompare, valueDestroy);
+using_cptr(X, Value, valueCompare, valueDel);
 
 using_csptr(X, Value);
 using_csptr(X, Value, valueCompare);
-using_csptr(X, Value, valueCompare, valueDestroy);
+using_csptr(X, Value, valueCompare, valueDel);
 ```
 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);`,
@@ -166,16 +166,15 @@ void Person_del(Person* p) {
 }
 
 // 1. cvec of Person struct; emplace and cloning disabled.
-using_cvec(pe, Person, Person_compare, Person_del);
+using_cvec(pe, Person, Person_compare, Person_del, c_no_clone);
 
 // 2. cvec of raw/owned pointers to Person; emplace and cloning disabled.
 using_cptr(pe, Person, Person_compare, Person_del);
-using_cvec(pp, Person*, cptr_pe_compare, cptr_pe_del);
+using_cvec(pp, Person*, cptr_pe_compare, cptr_pe_del, c_no_clone);
 
-// 3. cvec of shared-ptr to Person.
+// 3. cvec of shared-ptr to Person - with emplace_back() and cloning cvec ENABLED.
 using_csptr(pe, Person, Person_compare, Person_del);
-// To enable emplace_back() and cloning cvec, add 3 more args:
-using_cvec(ps, csptr_pe, csptr_pe_compare, csptr_pe_del, csptr_pe_clone, c_default_toraw, csptr_pe);
+using_cvec(ps, csptr_pe, csptr_pe_compare, csptr_pe_del, csptr_pe_clone);
 
 const char* names[] = {
     "Joe", "Jordan",
@@ -206,6 +205,7 @@ int main() {
 
     // Append a shared copy of vec3.data[0]. Will only be destructed once!
     cvec_ps_emplace_back(&vec3, vec3.data[0]);
+    //cvec_ps_push_back(&vec3, csptr_pe_clone(vec3.data[0])); // alternativ
     puts("\n3. Sorted vec3 of shared-pointer to Person:");
     cvec_ps_sort(&vec3);
     c_foreach (i, cvec_ps, vec3)
@@ -214,12 +214,12 @@ int main() {
     // Share vec3.data[1] with elem1 variable.
     csptr_pe elem1 = csptr_pe_clone(vec3.data[1]);
 
-    puts("\nDestroy vec3:");
-    cvec_ps_del(&vec3); // destroy the unique/unshared elements (two)
-    puts("\nDestroy vec2:");
-    cvec_pp_del(&vec2);
     puts("\nDestroy vec1:");
     cvec_pe_del(&vec1);
+    puts("\nDestroy vec2:");
+    cvec_pp_del(&vec2);
+    puts("\nDestroy vec3:");
+    cvec_ps_del(&vec3);
 
     puts("\nDestroy elem1:");
     csptr_pe_del(&elem1);
@@ -227,23 +227,25 @@ int main() {
 ```
 Output:
 ```
-1. sorted cvec of Person :
+1. Sorted vec1 of Person:
   Annie Aniston
   Jane Jacobs
   Joe Jordan
 
-2. sorted cvec of pointer to Person :       
+2. Sorted vec2 of pointer to Person:
   Annie Aniston
   Jane Jacobs
   Joe Jordan
 
-3. sorted cvec of shared-pointer to Person :
+3. Sorted vec3 of shared-pointer to Person:
   Annie Aniston
   Jane Jacobs
   Joe Jordan
+  Joe Jordan
 
-Destroy vec3:
+Destroy vec1:
 del: Annie
+del: Jane
 del: Joe
 
 Destroy vec2:
@@ -251,11 +253,10 @@ del: Annie
 del: Jane
 del: Joe
 
-Destroy vec1:
+Destroy vec3:
 del: Annie
-del: Jane
 del: Joe
 
-Destroy elem:
+Destroy elem1:
 del: Jane
 ```
diff --git a/docs/cset_api.md b/docs/cset_api.md
index 526a93d7..45df2afb 100644
--- a/docs/cset_api.md
+++ b/docs/cset_api.md
@@ -8,9 +8,9 @@ A **cset** is an associative container that contains a set of unique objects of
 

 ```c

 using_cset(X, Key);

-using_cset(X, Key, keyEqualsRaw, keyHashRaw);

-using_cset(X, Key, keyEqualsRaw, keyHashRaw, keyDestroy);

-using_cset(X, Key, keyEqualsRaw, keyHashRaw, keyDestroy, keyFromRaw, keyToRaw, RawKey);

+using_cset(X, Key, keyEquals, keyHash);

+using_cset(X, Key, keyEquals, keyHash, keyDel, keyClone);

+using_cset(X, Key, keyEqualsRaw, keyHashRaw, keyDel, keyFromRaw, keyToRaw, RawKey);

 using_cset_str();

 ```

 The macro `using_cset()` must be instantiated in the global scope. `X` is a type tag name and

@@ -59,9 +59,6 @@ cset_X_iter_t       cset_X_begin(cset_X* self);
 cset_X_iter_t       cset_X_end(cset_X* self);

 void                cset_X_next(cset_X_iter_t* it);

 cset_X_value_t*     cset_X_itval(cset_X_iter_t it);

-

-cset_X_value_t      cset_X_value_clone(cset_X_value_t val);

-void                cset_X_value_del(cset_X_value_t* val);

 ```

 

 ## Types

diff --git a/docs/csmap_api.md b/docs/csmap_api.md
index d404aa79..96087706 100644
--- a/docs/csmap_api.md
+++ b/docs/csmap_api.md
@@ -10,21 +10,21 @@ See the c++ class [std::map](https://en.cppreference.com/w/cpp/container/map) fo
 ```c
 using_csmap(X, Key, Mapped);
 using_csmap(X, Key, Mapped, keyCompare);
-using_csmap(X, Key, Mapped, keyCompare, mappedDestroy);
-using_csmap(X, Key, Mapped, keyCompare, mappedDestroy, mappedFromRaw, mappedToRaw, RawMapped);
-using_csmap(X, Key, Mapped, keyCompareRaw, mappedDestroy, mappedFromRaw, mappedToRaw, RawMapped,
-                                           keyDestroy, keyFromRaw, keyToRaw, RawKey);
-using_csmap_keydef(X, Key, Mapped, keyCompare, keyDestroy);
-using_csmap_keydef(X, Key, Mapped, keyCompareRaw, keyDestroy, keyFromRaw, keyToRaw, RawKey);
+using_csmap(X, Key, Mapped, keyCompare, mappedDel, mappedClone);
+using_csmap(X, Key, Mapped, keyCompare, mappedDel, mappedFromRaw, mappedToRaw, RawMapped);
+using_csmap(X, Key, Mapped, keyCompareRaw, mappedDel, mappedFromRaw, mappedToRaw, RawMapped,
+                                           keyDel, keyFromRaw, keyToRaw, RawKey);
+using_csmap_keydef(X, Key, Mapped, keyCompare, keyDel, keyClone);
+using_csmap_keydef(X, Key, Mapped, keyCompareRaw, keyDel, keyFromRaw, keyToRaw, RawKey);
 
 using_csmap_strkey(X, Mapped);                    // using_csmap(X, cstr, Mapped, ...)
-using_csmap_strkey(X, Mapped, mappedDestroy);
-using_csmap_strkey(X, Mapped, mappedDestroy, mappedFromRaw, mappedToRaw, RawMapped);
+using_csmap_strkey(X, Mapped, mappedDel, mappedClone);
+using_csmap_strkey(X, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped);
 
 using_csmap_strval(X, Key);                       // using_csmap(X, Key, cstr, ...)
 using_csmap_strval(X, Key, keyCompare);
-using_csmap_strval(X, Key, keyCompare, keyDestroy);
-using_csmap_strval(X, Key, keyCompareRaw, keyDestroy, keyFromRaw, keyToRaw, RawKey);
+using_csmap_strval(X, Key, keyCompare, keyDel, keyClone);
+using_csmap_strval(X, Key, keyCompareRaw, keyDel, keyFromRaw, keyToRaw, RawKey);
 
 using_csmap_str();                                // using_csmap(str, cstr, cstr, ...)
 ```
@@ -70,9 +70,6 @@ csmap_X_iter_t      csmap_X_begin(csmap_X* self);
 csmap_X_iter_t      csmap_X_end(csmap_X* self);
 void                csmap_X_next(csmap_X_iter_t* it);
 csmap_X_mapped_t*   csmap_X_itval(csmap_X_iter_t it);
-
-csmap_X_value_t     csmap_X_value_clone(csmap_X_value_t val);
-void                csmap_X_value_del(csmap_X_value_t* val);
 ```
 ## Types
 
diff --git a/docs/csset_api.md b/docs/csset_api.md
index 7a0085f5..96f7357a 100644
--- a/docs/csset_api.md
+++ b/docs/csset_api.md
@@ -10,8 +10,8 @@ See the c++ class [std::set](https://en.cppreference.com/w/cpp/container/set) fo
 ```c

 using_csset(X, Key);

 using_csset(X, Key, keyCompare);

-using_csset(X, Key, keyCompare, keyDestroy);

-using_csset(X, Key, keyCompare, keyDestroy, keyFromRaw, keyToRaw, RawKey);

+using_csset(X, Key, keyCompare, keyDel, keyClone);

+using_csset(X, Key, keyCompareRaw, keyDel, keyFromRaw, keyToRaw, RawKey);

 using_csset_str();

 ```

 The macro `using_csset()` must be instantiated in the global scope. `X` is a type tag name and

@@ -54,9 +54,6 @@ csset_X_iter_t      csset_X_begin(csset_X* self);
 csset_X_iter_t      csset_X_end(csset_X* self);

 void                csset_X_next(csset_X_iter_t* it);

 csset_X_value_t*    csset_X_itval(csset_X_iter_t it);

-

-csset_X_value_t     csset_X_value_clone(csset_X_value_t val);

-void                csset_X_value_del(csset_X_value_t* val);

 ```

 

 ## Types

diff --git a/docs/cvec_api.md b/docs/cvec_api.md
index b6aa841f..d3ac1e10 100644
--- a/docs/cvec_api.md
+++ b/docs/cvec_api.md
@@ -13,9 +13,9 @@ See the c++ class [std::vector](https://en.cppreference.com/w/cpp/container/vect
 
 ```c
 using_cvec(X, Value);
-using_cvec(X, Value, valueCompareRaw);
-using_cvec(X, Value, valueCompareRaw, valueDestroy);
-using_cvec(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue);
+using_cvec(X, Value, valueCompare);
+using_cvec(X, Value, valueCompare, valueDel, valueClone);
+using_cvec(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue);
 
 using_cvec_str()
 ```
diff --git a/examples/complex.c b/examples/complex.c
index 05d74557..161d0b31 100644
--- a/examples/complex.c
+++ b/examples/complex.c
@@ -5,10 +5,10 @@
 

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

 

-using_carray(f, float, check_del);

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

-using_cmap(l, int, clist_a, c_default_equals, c_default_hash, clist_a_del);

-using_cmap_strkey(s, cmap_l, cmap_l_del);

+using_carray(f, float, check_del, c_plain_fromraw);

+using_clist(a, carray2f, c_no_compare, carray2f_del, c_no_clone);

+using_cmap(l, int, clist_a, c_default_equals, c_default_hash, clist_a_del, c_no_clone);

+using_cmap_strkey(s, cmap_l, cmap_l_del, c_no_clone);

 

 int main() {

     int xdim = 4, ydim = 6;

diff --git a/examples/csmap_v1.h b/examples/csmap_v1.h
index 11602f83..78e40431 100644
--- a/examples/csmap_v1.h
+++ b/examples/csmap_v1.h
@@ -50,19 +50,19 @@ int main(void) {
     using_csmap_4(X, Key, Mapped, c_default_compare)

 

 #define using_csmap_4(X, Key, Mapped, keyCompare) \

-    using_csmap_6(X, Key, Mapped, keyCompare, c_default_del, c_default_fromraw)

+    using_csmap_6(X, Key, Mapped, keyCompare, c_plain_del, c_plain_fromraw)

 

 #define using_csmap_6(X, Key, Mapped, keyCompare, mappedDel, mappedClone) \

-    using_csmap_8(X, Key, Mapped, keyCompare, mappedDel, mappedClone, c_default_del, c_default_fromraw)

+    using_csmap_8(X, Key, Mapped, keyCompare, mappedDel, mappedClone, c_plain_del, c_plain_fromraw)

 

 #define using_csmap_8(X, Key, Mapped, keyCompare, mappedDel, mappedClone, keyDel, keyClone) \

     using_csmap_10(X, Key, Mapped, keyCompare, mappedDel, mappedClone, \

-                      keyDel, keyClone, c_default_toraw, Key)

+                      keyDel, keyClone, c_plain_toraw, Key)

 

 #define using_csmap_10(X, Key, Mapped, keyCompareRaw, mappedDel, mappedClone, \

                           keyDel, keyFromRaw, keyToRaw, RawKey) \

     _using_CBST(X, csmap, Key, Mapped, keyCompareRaw, mappedDel, keyDel, \

-                   keyFromRaw, keyToRaw, RawKey, mappedClone, c_default_toraw, Mapped)

+                   keyFromRaw, keyToRaw, RawKey, mappedClone, c_plain_toraw, Mapped)

 

 /* csset: */

 #define using_csset(...) \

@@ -72,10 +72,10 @@ int main(void) {
     using_csset_3(X, Key, c_default_compare)

 

 #define using_csset_3(X, Key, keyCompare) \

-    using_csset_5(X, Key, keyCompare, c_default_del, c_default_fromraw)

+    using_csset_5(X, Key, keyCompare, c_plain_del, c_plain_fromraw)

 

 #define using_csset_5(X, Key, keyCompare, keyDel, keyClone) \

-    using_csset_7(X, Key, keyCompare, keyDel, keyClone, c_default_toraw, Key)

+    using_csset_7(X, Key, keyCompare, keyDel, keyClone, c_plain_toraw, Key)

 

 #define using_csset_7(X, Key, keyCompareRaw, keyDel, keyFromRaw, keyToRaw, RawKey) \

     _using_CBST(X, csset, Key, Key, keyCompareRaw, _UNUSED_, keyDel, \

@@ -92,14 +92,14 @@ int main(void) {
     c_MACRO_OVERLOAD(using_csmap_strkey, __VA_ARGS__)

 

 #define using_csmap_strkey_2(X, Mapped) \

-    _using_CBST_strkey(X, csmap, Mapped, c_default_del, c_default_fromraw)

+    _using_CBST_strkey(X, csmap, Mapped, c_plain_del, c_plain_fromraw)

 

 #define using_csmap_strkey_4(X, Mapped, mappedDel, mappedClone) \

     _using_CBST_strkey(X, csmap, Mapped, mappedDel, mappedClone)

 

 #define _using_CBST_strkey(X, C, Mapped, mappedDel, mappedClone) \

     _using_CBST(X, C, cstr_t, Mapped, cstr_compare_raw, mappedDel, cstr_del, \

-                   cstr_from, cstr_c_str, const char*, mappedClone, c_default_toraw, Mapped)

+                   cstr_from, cstr_c_str, const char*, mappedClone, c_plain_toraw, Mapped)

 

 #define using_csmap_strval(...) \

     c_MACRO_OVERLOAD(using_csmap_strval, __VA_ARGS__)

@@ -108,10 +108,10 @@ int main(void) {
     using_csmap_strval_3(X, Key, c_default_compare)

 

 #define using_csmap_strval_3(X, Key, keyCompare) \

-    using_csmap_strval_5(X, Key, keyCompare, c_default_del, c_default_fromraw)

+    using_csmap_strval_5(X, Key, keyCompare, c_plain_del, c_plain_fromraw)

 

 #define using_csmap_strval_5(X, Key, keyCompare, keyDel, keyClone) \

-    using_csmap_strval_7(X, Key, keyCompare, keyDel, keyClone, c_default_toraw, Key)

+    using_csmap_strval_7(X, Key, keyCompare, keyDel, keyClone, c_plain_toraw, Key)

 

 #define using_csmap_strval_7(X, Key, keyCompare, keyDel, keyFromRaw, keyToRaw, RawKey) \

     _using_CBST(X, csmap, Key, cstr_t, keyCompare, cstr_del, keyDel, \

diff --git a/examples/inits.c b/examples/inits.c
index bf209e88..edcb4336 100644
--- a/examples/inits.c
+++ b/examples/inits.c
@@ -5,7 +5,7 @@
 #include <stc/cpque.h>

 #include <stc/clist.h>

 

-using_cmap(id, int, cstr, c_default_equals, c_default_hash, cstr_del); // Map of int -> cstr

+using_cmap(id, int, cstr, c_default_equals, c_default_hash, cstr_del, c_no_clone); // Map of int -> cstr

 using_cmap_strkey(cnt, int);

 

 typedef struct {int x, y;} ipair_t;

diff --git a/examples/mapmap.c b/examples/mapmap.c
index 5a5996f6..c775d870 100644
--- a/examples/mapmap.c
+++ b/examples/mapmap.c
@@ -4,7 +4,7 @@
 #include <stc/cstr.h>

 

 using_cmap_str();

-using_cmap_strkey(cfg, cmap_str, cmap_str_del);

+using_cmap_strkey(cfg, cmap_str, cmap_str_del, c_no_clone);

 

 int main(void) {

     cmap_cfg config = cmap_cfg_init();

diff --git a/stc/carray.h b/stc/carray.h
index 3f0983bc..39e1fba8 100644
--- a/stc/carray.h
+++ b/stc/carray.h
@@ -48,12 +48,9 @@ int main()
 

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

 #define using_carray_2(X, Value) \

-    using_carray_4(X, Value, c_default_del, c_default_fromraw)

+    using_carray_4(X, Value, c_plain_del, c_plain_fromraw)

 

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

-    using_carray_4(X, Value, valueDestroy, c_no_fromraw)

-

-#define using_carray_4(X, Value, valueDestroy, valueClone) \

+#define using_carray_4(X, Value, valueDel, valueClone) \

 \

     typedef Value carray1##X##_value_t; \

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

@@ -86,9 +83,9 @@ int main()
     STC_INLINE size_t \

     carray3##X##_zdim(carray3##X a) {return _carray_zdim(a);} \

 \

-    _using_carray_common(1, X, Value, valueDestroy, valueClone) \

-    _using_carray_common(2, X, Value, valueDestroy, valueClone) \

-    _using_carray_common(3, X, Value, valueDestroy, valueClone) \

+    _using_carray_common(1, X, Value, valueDel, valueClone) \

+    _using_carray_common(2, X, Value, valueDel, valueClone) \

+    _using_carray_common(3, X, Value, valueDel, valueClone) \

 \

     STC_INLINE carray1##X \

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

@@ -166,7 +163,7 @@ int main()
 #define _carray_ydim(a) (a)._ydim

 #define _carray_zdim(a) (a)._zdim

 

-#define _using_carray_common(D, X, Value, valueDestroy, valueClone) \

+#define _using_carray_common(D, X, Value, valueDel, valueClone) \

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

 \

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

@@ -184,7 +181,7 @@ int main()
     carray##D##X##_del(carray##D##X* self) { \

         if (self->_xdim & _carray_OWN) { \

             c_foreach_3 (i, carray##D##X, *self) \

-                valueDestroy(i.ref); \

+                valueDel(i.ref); \

             c_free(self->data); \

         } \

     } \

diff --git a/stc/ccommon.h b/stc/ccommon.h
index d3ceed52..590609fa 100644
--- a/stc/ccommon.h
+++ b/stc/ccommon.h
@@ -78,19 +78,18 @@
 #define c_swap(T, x, y)         do { T __t = x; x = y; y = __t; } while (0)

 #define c_arraylen(a)           (sizeof (a)/sizeof (a)[0])

 

-#define c_default_compare(x, y) c_less_compare(c_default_less, x, y)

+#define c_default_compare(x, y) (c_default_less(y, x) - c_default_less(x, y))

 #define c_default_less(x, y)    (*(x) < *(y))

-#define c_less_compare(less, x, y) (less(y, x) - less(x, y))

 #define c_no_compare(x, y)      (assert(!"c_no_compare() called"), 0)

 

 #define c_default_equals(x, y)  (*(x) == *(y))

-#define c_memcmp_equals(x, y)   (memcmp(x, y, sizeof *(x)) == 0)

+#define c_plain_equals(x, y)    (memcmp(x, y, sizeof *(x)) == 0)

 

-#define c_no_fromraw(x)         (assert(!"emplace*() with c_no_fromraw"), x)

-#define c_default_fromraw(x)    (x)

-#define c_default_toraw(ptr)    (*(ptr))

+#define c_plain_fromraw(x)      (x)

+#define c_no_clone(x)           (assert(!"emplace*() with c_no_clone"), x)

+#define c_plain_toraw(ptr)    (*(ptr))

 

-#define c_default_del(ptr)      ((void) (ptr))

+#define c_plain_del(ptr)      ((void) (ptr))

 

 /* Generic algorithms */

 

diff --git a/stc/cdeq.h b/stc/cdeq.h
index 0b5ed8d3..a5c743a5 100644
--- a/stc/cdeq.h
+++ b/stc/cdeq.h
@@ -31,9 +31,9 @@
 #define using_cdeq_2(X, Value) \

                     using_cdeq_3(X, Value, c_default_compare)

 #define using_cdeq_3(X, Value, valueCompare) \

-                    using_cdeq_7(X, Value, valueCompare, c_default_del, c_default_fromraw, c_default_toraw, Value)

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

-                    using_cdeq_7(X, Value, valueCompare, valueDestroy, c_no_fromraw, c_default_toraw, Value)

+                    using_cdeq_7(X, Value, valueCompare, c_plain_del, c_plain_fromraw, c_plain_toraw, Value)

+#define using_cdeq_5(X, Value, valueCompare, valueDel, valueFromRaw) \

+                    using_cdeq_7(X, Value, valueCompare, valueDel, valueFromRaw, c_plain_toraw, Value)

 #define using_cdeq_str() \

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

 

@@ -49,7 +49,7 @@ struct cdeq_rep { size_t size, cap; void* base[]; };
 #define cdeq_rep_(self) c_container_of((self)->base, struct cdeq_rep, base)

 typedef int (*c_cmp_fn)(const void*, const void*);

 

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

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

     typedefs_cdeq(X, Value, RawValue); \

 \

     STC_API cdeq_##X \

@@ -110,7 +110,7 @@ typedef int (*c_cmp_fn)(const void*, const void*);
     } \

     STC_INLINE void \

     cdeq_##X##_pop_back(cdeq_##X* self) { \

-        valueDestroy(&self->data[--cdeq_rep_(self)->size]); \

+        valueDel(&self->data[--cdeq_rep_(self)->size]); \

     } \

 \

     STC_API void \

@@ -121,7 +121,7 @@ typedef int (*c_cmp_fn)(const void*, const void*);
     } \

     STC_INLINE void \

     cdeq_##X##_pop_front(cdeq_##X* self) { \

-        valueDestroy(self->data++); \

+        valueDel(self->data++); \

         --cdeq_rep_(self)->size; \

     } \

 \

@@ -207,7 +207,7 @@ typedef int (*c_cmp_fn)(const void*, const void*);
     cdeq_##X##_sort(cdeq_##X* self) { \

         cdeq_##X##_sort_range(cdeq_##X##_begin(self), cdeq_##X##_end(self), cdeq_##X##_value_compare); \

     } \

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

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

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

 

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

@@ -219,7 +219,7 @@ static struct cdeq_rep _cdeq_inits = {0, 0};
 static inline double _minf(double x, double y) {return x < y ? x : y;}

 static inline double _maxf(double x, double y) {return x > y ? x : y;}

 

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

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

 \

     STC_DEF cdeq_##X \

     cdeq_##X##_init(void) { \

@@ -240,7 +240,7 @@ static inline double _maxf(double x, double y) {return x > y ? x : y;}
     cdeq_##X##_clear(cdeq_##X* self) { \

         struct cdeq_rep* rep = cdeq_rep_(self); if (rep->cap) { \

             for (cdeq_##X##_value_t *p = self->data, *q = p + rep->size; p != q; ++p) \

-                valueDestroy(p); \

+                valueDel(p); \

             rep->size = 0; \

         } \

     } \

@@ -278,7 +278,7 @@ static inline double _maxf(double x, double y) {return x > y ? x : y;}
     cdeq_##X##_resize(cdeq_##X* self, size_t size, Value null_val) { \

         _cdeq_##X##_expand(self, size, false); \

         size_t i, n = cdeq_rep_(self)->size; \

-        for (i=size; i<n; ++i) valueDestroy(self->data + i); \

+        for (i=size; i<n; ++i) valueDel(self->data + i); \

         for (i=n; i<size; ++i) self->data[i] = null_val; \

         if (self->data) cdeq_rep_(self)->size = size; \

     } \

@@ -330,7 +330,7 @@ static inline double _maxf(double x, double y) {return x > y ? x : y;}
         intptr_t len = finish - first; \

         if (len > 0) { \

             cdeq_##X##_value_t* p = first, *end = self->data + cdeq_rep_(self)->size; \

-            while (p != finish) valueDestroy(p++); \

+            while (p != finish) valueDel(p++); \

             if (first == self->data) self->data += len; \

             else memmove(first, finish, (end - finish) * sizeof(Value)); \

             cdeq_rep_(self)->size -= len; \

@@ -354,7 +354,7 @@ static inline double _maxf(double x, double y) {return x > y ? x : y;}
     }

 

 #else

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

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

 #endif

 

 #endif

diff --git a/stc/clist.h b/stc/clist.h
index 9ee6fb1f..95dee6e7 100644
--- a/stc/clist.h
+++ b/stc/clist.h
@@ -59,9 +59,9 @@
 #define using_clist_2(X, Value) \

                     using_clist_3(X, Value, c_default_compare)

 #define using_clist_3(X, Value, valueCompare) \

-                    using_clist_7(X, Value, valueCompare, c_default_del, c_default_fromraw, c_default_toraw, Value)

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

-                    using_clist_7(X, Value, valueCompare, valueDestroy, c_no_fromraw, c_default_toraw, Value)

+                    using_clist_7(X, Value, valueCompare, c_plain_del, c_plain_fromraw, c_plain_toraw, Value)

+#define using_clist_5(X, Value, valueCompare, valueDel, valueFromRaw) \

+                    using_clist_7(X, Value, valueCompare, valueDel, valueFromRaw, c_plain_toraw, Value)

 #define using_clist_str() \

                     using_clist_7(str, cstr_t, cstr_compare_raw, cstr_del, cstr_from, cstr_c_str, const char*)

 

@@ -96,7 +96,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, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue) \

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

 \

     using_clist_types(X, Value); \

     typedef RawValue clist_##X##_rawvalue_t; \

@@ -209,13 +209,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, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue) \

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

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

 

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

 

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

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

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

 \

     STC_DEF clist_##X \

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

@@ -292,7 +292,7 @@ STC_API size_t _clist_size(const clist_void* self);
         node->next = next; \

         if (del == next) self->last = node = NULL; \

         else if (self->last == del) self->last = node, node = NULL; \

-        valueDestroy(&del->value); c_free(del); \

+        valueDel(&del->value); c_free(del); \

         return node; \

     } \

 \

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

 

 #else

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

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

 #endif

 

 #endif

diff --git a/stc/cmap.h b/stc/cmap.h
index 43fae80d..203f0263 100644
--- a/stc/cmap.h
+++ b/stc/cmap.h
@@ -65,17 +65,17 @@ typedef struct {size_t idx; uint32_t hx;} chash_bucket_t;
 

 #define using_cmap_5(X, Key, Mapped, keyEquals, keyHash) \

     using_cmap_9(X, Key, Mapped, keyEquals, keyHash, \

-                    c_default_del, c_default_fromraw, c_default_toraw, Mapped)

+                    c_plain_del, c_plain_fromraw, c_plain_toraw, Mapped)

 

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

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

     using_cmap_9(X, Key, Mapped, keyEquals, keyHash, \

-                    mappedDel, c_no_fromraw, c_default_toraw, Mapped)

+                    mappedDel, mappedClone, c_plain_toraw, Mapped)

 

-#define using_cmap_9(X, Key, Mapped, keyEqualsRaw, keyHashRaw, \

-                          mappedDel, mappedFromRaw, mappedToRaw, RawMapped) \

-    _using_CHASH(X, cmap, Key, Mapped, keyEqualsRaw, keyHashRaw, \

+#define using_cmap_9(X, Key, Mapped, keyEquals, keyHash, \

+                        mappedDel, mappedFromRaw, mappedToRaw, RawMapped) \

+    _using_CHASH(X, cmap, Key, Mapped, keyEquals, keyHash, \

                     mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \

-                    c_default_del, c_default_fromraw, c_default_toraw, Key)

+                    c_plain_del, c_plain_fromraw, c_plain_toraw, Key)

 

 #define using_cmap_13(X, Key, Mapped, keyEqualsRaw, keyHashRaw, \

                          mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \

@@ -85,13 +85,13 @@ typedef struct {size_t idx; uint32_t hx;} chash_bucket_t;
                     keyDel, keyFromRaw, keyToRaw, RawKey)

 

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

-#define using_cmap_keydef_6(X, Key, Mapped, keyEquals, keyHash, keyDel) \

+#define using_cmap_keydef_7(X, Key, Mapped, keyEquals, keyHash, keyDel, keyClone) \

     using_cmap_keydef_9(X, Key, Mapped, keyEquals, keyHash, \

-                           keyDel, c_no_fromraw, c_default_toraw, Key)

+                           keyDel, keyClone, c_plain_toraw, Key)

 #define using_cmap_keydef_9(X, Key, Mapped, keyEqualsRaw, keyHashRaw, \

                                keyDel, keyFromRaw, keyToRaw, RawKey) \

     _using_CHASH(X, cmap, Key, Mapped, keyEqualsRaw, keyHashRaw, \

-                    c_default_del, c_default_fromraw, c_default_toraw, Mapped, \

+                    c_plain_del, c_plain_fromraw, c_plain_toraw, Mapped, \

                     keyDel, keyFromRaw, keyToRaw, RawKey)

 

 /* cset: */

@@ -102,10 +102,10 @@ typedef struct {size_t idx; uint32_t hx;} chash_bucket_t;
     using_cset_4(X, Key, c_default_equals, c_default_hash)

 

 #define using_cset_4(X, Key, keyEquals, keyHash) \

-    using_cset_8(X, Key, keyEquals, keyHash, c_default_del, c_default_fromraw, c_default_toraw, Key)

+    using_cset_8(X, Key, keyEquals, keyHash, c_plain_del, c_plain_fromraw, c_plain_toraw, Key)

 

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

-    using_cset_8(X, Key, keyEquals, keyHash, keyDel, c_no_fromraw, c_default_toraw, Key)

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

+    using_cset_8(X, Key, keyEquals, keyHash, keyDel, keyClone, c_plain_toraw, Key)

 

 #define using_cset_8(X, Key, keyEqualsRaw, keyHashRaw, keyDel, keyFromRaw, keyToRaw, RawKey) \

     _using_CHASH(X, cset, Key, Key, keyEqualsRaw, keyHashRaw, \

@@ -124,10 +124,10 @@ typedef struct {size_t idx; uint32_t hx;} chash_bucket_t;
     c_MACRO_OVERLOAD(using_cmap_strkey, __VA_ARGS__)

 

 #define using_cmap_strkey_2(X, Mapped) \

-    _using_CHASH_strkey(X, cmap, Mapped, c_default_del, c_default_fromraw, c_default_toraw, Mapped)

+    _using_CHASH_strkey(X, cmap, Mapped, c_plain_del, c_plain_fromraw, c_plain_toraw, Mapped)

 

-#define using_cmap_strkey_3(X, Mapped, mappedDel) \

-    _using_CHASH_strkey(X, cmap, Mapped, mappedDel, c_no_fromraw, c_default_toraw, Mapped)

+#define using_cmap_strkey_4(X, Mapped, mappedDel, mappedClone) \

+    _using_CHASH_strkey(X, cmap, Mapped, mappedDel, mappedClone, c_plain_toraw, Mapped)

 

 #define using_cmap_strkey_6(X, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped) \

     _using_CHASH_strkey(X, cmap, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped)

@@ -144,13 +144,13 @@ typedef struct {size_t idx; uint32_t hx;} chash_bucket_t;
     using_cmap_strval_4(X, Key, c_default_equals, c_default_hash)

 

 #define using_cmap_strval_4(X, Key, keyEquals, keyHash) \

-    using_cmap_strval_8(X, Key, keyEquals, keyHash, c_default_del, c_default_fromraw, c_default_toraw, Key)

+    using_cmap_strval_8(X, Key, keyEquals, keyHash, c_plain_del, c_plain_fromraw, c_plain_toraw, Key)

 

-#define using_cmap_strval_5(X, Key, keyEquals, keyHash, keyDel) \

-    using_cmap_strval_8(X, Key, keyEquals, keyHash, keyDel, c_no_fromraw, c_default_toraw, Key)

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

+    using_cmap_strval_8(X, Key, keyEquals, keyHash, keyDel, keyClone, c_plain_toraw, Key)

 

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

-    _using_CHASH(X, cmap, Key, cstr_t, keyEquals, keyHash, \

+#define using_cmap_strval_8(X, Key, keyEqualsRaw, keyHashRaw, keyDel, keyFromRaw, keyToRaw, RawKey) \

+    _using_CHASH(X, cmap, Key, cstr_t, keyEqualsRaw, keyHashRaw, \

                     cstr_del, cstr_from, cstr_c_str, const char*, \

                     keyDel, keyFromRaw, keyToRaw, RawKey)

 

diff --git a/stc/cptr.h b/stc/cptr.h
index 61b56123..2614238d 100644
--- a/stc/cptr.h
+++ b/stc/cptr.h
@@ -45,7 +45,7 @@ int Person_compare(const Person* p, const Person* q) {
 }

 

 using_cptr(pe, Person, Person_compare, Person_del);

-using_cvec(pe, Person*, cptr_pe_compare, cptr_pe_del);

+using_cvec(pe, Person*, cptr_pe_compare, cptr_pe_del, c_no_clone);

 

 int main() {

     cvec_pe vec = cvec_pe_init();

@@ -65,15 +65,15 @@ int main() {
     using_cptr_3(X, Value, c_default_compare)

 

 #define using_cptr_3(X, Value, valueCompare) \

-    using_cptr_4(X, Value, valueCompare, c_default_del)

+    using_cptr_4(X, Value, valueCompare, c_plain_del)

 

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

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

     typedef Value cptr_##X##_value_t; \

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

 \

     STC_INLINE void \

     cptr_##X##_del(cptr_##X* self) { \

-        valueDestroy(*self); \

+        valueDel(*self); \

         c_free(*self); \

     } \

 \

@@ -158,9 +158,9 @@ typedef long atomic_count_t;
     using_csptr_3(X, Value, c_default_compare)

 

 #define using_csptr_3(X, Value, valueCompare) \

-    using_csptr_4(X, Value, valueCompare, c_default_del)

+    using_csptr_4(X, Value, valueCompare, c_plain_del)

 

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

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

     typedef Value csptr_##X##_value_t; \

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

 \

@@ -185,7 +185,7 @@ typedef long atomic_count_t;
     csptr_##X##_del(csptr_##X* self) { \

         if (self->use_count && atomic_decrement(self->use_count) == 0) { \

             c_free(self->use_count); \

-            valueDestroy(self->get); \

+            valueDel(self->get); \

             c_free(self->get); \

         } \

     } \

diff --git a/stc/csmap.h b/stc/csmap.h
index 0f9fcec2..7b6b04bd 100644
--- a/stc/csmap.h
+++ b/stc/csmap.h
@@ -49,15 +49,15 @@ int main(void) {
     using_csmap_4(X, Key, Mapped, c_default_compare)

 

 #define using_csmap_4(X, Key, Mapped, keyCompare) \

-    using_csmap_8(X, Key, Mapped, keyCompare, c_default_del, c_default_fromraw, c_default_toraw, Mapped)

+    using_csmap_8(X, Key, Mapped, keyCompare, c_plain_del, c_plain_fromraw, c_plain_toraw, Mapped)

 

-#define using_csmap_5(X, Key, Mapped, keyCompare, mappedDel) \

-    using_csmap_8(X, Key, Mapped, keyCompare, mappedDel, c_no_fromraw, c_default_toraw, Mapped)

+#define using_csmap_6(X, Key, Mapped, keyCompare, mappedDel, mappedClone) \

+    using_csmap_8(X, Key, Mapped, keyCompare, mappedDel, mappedClone, c_plain_toraw, Mapped)

 

 #define using_csmap_8(X, Key, Mapped, keyCompare, mappedDel, mappedFromRaw, mappedToRaw, RawMapped) \

     using_csmap_12(X, Key, Mapped, keyCompare, \

                       mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \

-                      c_default_del, c_default_fromraw, c_default_toraw, Key)

+                      c_plain_del, c_plain_fromraw, c_plain_toraw, Key)

 

 #define using_csmap_12(X, Key, Mapped, keyCompareRaw, \

                           mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \

@@ -67,13 +67,13 @@ int main(void) {
                      keyDel, keyFromRaw, keyToRaw, RawKey)

 

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

-#define using_csmap_keydef_5(X, Key, Mapped, keyCompare, keyDel) \

+#define using_csmap_keydef_6(X, Key, Mapped, keyCompare, keyDel, keyClone) \

     using_csmap_keydef_8(X, Key, Mapped, keyCompare, \

-                            keyDel, c_no_fromraw, c_default_toraw, Key)

+                            keyDel, keyClone, c_plain_toraw, Key)

 #define using_csmap_keydef_8(X, Key, Mapped, keyCompareRaw, \

                                 keyDel, keyFromRaw, keyToRaw, RawKey) \

     _using_AATREE(X, csmap, Key, Mapped, keyCompareRaw, \

-                     c_default_del, c_default_fromraw, c_default_toraw, Mapped, \

+                     c_plain_del, c_plain_fromraw, c_plain_toraw, Mapped, \

                      keyDel, keyFromRaw, keyToRaw, RawKey)

 

 /* csset: */

@@ -84,10 +84,10 @@ int main(void) {
     using_csset_3(X, Key, c_default_compare)

 

 #define using_csset_3(X, Key, keyCompare) \

-    using_csset_7(X, Key, keyCompare, c_default_del, c_default_fromraw, c_default_toraw, Key)

+    using_csset_7(X, Key, keyCompare, c_plain_del, c_plain_fromraw, c_plain_toraw, Key)

 

-#define using_csset_4(X, Key, keyCompare, keyDel) \

-    using_csset_7(X, Key, keyCompare, keyDel, c_no_fromraw, c_default_toraw, Key)

+#define using_csset_5(X, Key, keyCompare, keyDel, keyClone) \

+    using_csset_7(X, Key, keyCompare, keyDel, keyClone, c_plain_toraw, Key)

 

 #define using_csset_7(X, Key, keyCompareRaw, keyDel, keyFromRaw, keyToRaw, RawKey) \

     _using_AATREE(X, csset, Key, Key, keyCompareRaw, \

@@ -106,10 +106,10 @@ int main(void) {
     c_MACRO_OVERLOAD(using_csmap_strkey, __VA_ARGS__)

 

 #define using_csmap_strkey_2(X, Mapped) \

-    _using_AATREE_strkey(X, csmap, Mapped, c_default_del, c_default_fromraw, c_default_toraw, Mapped)

+    _using_AATREE_strkey(X, csmap, Mapped, c_plain_del, c_plain_fromraw, c_plain_toraw, Mapped)

 

-#define using_csmap_strkey_3(X, Mapped, mappedDel) \

-    _using_AATREE_strkey(X, csmap, Mapped, mappedDel, c_no_fromraw, c_default_toraw, Mapped)

+#define using_csmap_strkey_4(X, Mapped, mappedDel, mappedClone) \

+    _using_AATREE_strkey(X, csmap, Mapped, mappedDel, mappedClone, c_plain_toraw, Mapped)

 

 #define using_csmap_strkey_6(X, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped) \

     _using_AATREE_strkey(X, csmap, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped)

@@ -126,13 +126,13 @@ int main(void) {
     using_csmap_strval_3(X, Key, c_default_compare)

 

 #define using_csmap_strval_3(X, Key, keyCompare) \

-    using_csmap_strval_7(X, Key, keyCompare, c_default_del, c_default_fromraw, c_default_toraw, Key)

+    using_csmap_strval_7(X, Key, keyCompare, c_plain_del, c_plain_fromraw, c_plain_toraw, Key)

 

-#define using_csmap_strval_4(X, Key, keyCompare, keyDel) \

-    using_csmap_strval_7(X, Key, keyCompare, keyDel, c_no_fromraw, c_default_toraw, Key)

+#define using_csmap_strval_5(X, Key, keyCompare, keyDel, keyClone) \

+    using_csmap_strval_7(X, Key, keyCompare, keyDel, keyClone, c_plain_toraw, Key)

 

-#define using_csmap_strval_7(X, Key, keyCompare, keyDel, keyFromRaw, keyToRaw, RawKey) \

-    _using_AATREE(X, csmap, Key, cstr_t, keyCompare, \

+#define using_csmap_strval_7(X, Key, keyCompareRaw, keyDel, keyFromRaw, keyToRaw, RawKey) \

+    _using_AATREE(X, csmap, Key, cstr_t, keyCompareRaw, \

                      cstr_del, cstr_from, cstr_c_str, const char*, \

                      keyDel, keyFromRaw, keyToRaw, RawKey)

 

diff --git a/stc/cvec.h b/stc/cvec.h
index 14e353be..1fa54d30 100644
--- a/stc/cvec.h
+++ b/stc/cvec.h
@@ -31,9 +31,9 @@
 #define using_cvec_2(X, Value) \

                     using_cvec_3(X, Value, c_default_compare)

 #define using_cvec_3(X, Value, valueCompare) \

-                    using_cvec_7(X, Value, valueCompare, c_default_del, c_default_fromraw, c_default_toraw, Value)

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

-                    using_cvec_7(X, Value, valueCompare, valueDestroy, c_no_fromraw, c_default_toraw, Value)

+                    using_cvec_7(X, Value, valueCompare, c_plain_del, c_plain_fromraw, c_plain_toraw, Value)

+#define using_cvec_5(X, Value, valueCompare, valueDel, valueFromRaw) \

+                    using_cvec_7(X, Value, valueCompare, valueDel, valueFromRaw, c_plain_toraw, Value)

 #define using_cvec_str() \

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

 

@@ -49,7 +49,7 @@ struct cvec_rep { size_t size, cap; void* data[]; };
 #define cvec_rep_(self) c_container_of((self)->data, struct cvec_rep, data)

 typedef int (*c_cmp_fn)(const void*, const void*);

 

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

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

     typedefs_cvec(X, Value, RawValue); \

 \

     STC_API cvec_##X \

@@ -105,7 +105,7 @@ typedef int (*c_cmp_fn)(const void*, const void*);
     } \

     STC_INLINE void \

     cvec_##X##_pop_back(cvec_##X* self) { \

-        valueDestroy(&self->data[--cvec_rep_(self)->size]); \

+        valueDel(&self->data[--cvec_rep_(self)->size]); \

     } \

 \

     STC_API cvec_##X##_iter_t \

@@ -197,7 +197,7 @@ typedef int (*c_cmp_fn)(const void*, const void*);
         cvec_##X##_sort_range(cvec_##X##_begin(self), cvec_##X##_end(self), cvec_##X##_value_compare); \

     } \

 \

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

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

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

 

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

@@ -205,7 +205,7 @@ typedef int (*c_cmp_fn)(const void*, const void*);
 #if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION)

 static struct cvec_rep _cvec_inits = {0, 0};

 

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

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

 \

     STC_DEF cvec_##X \

     cvec_##X##_init(void) { \

@@ -225,7 +225,7 @@ static struct cvec_rep _cvec_inits = {0, 0};
     cvec_##X##_clear(cvec_##X* self) { \

         struct cvec_rep* rep = cvec_rep_(self); if (rep->cap) { \

             for (cvec_##X##_value_t *p = self->data, *q = p + rep->size; p != q; ++p) \

-                valueDestroy(p); \

+                valueDel(p); \

             rep->size = 0; \

         } \

     } \

@@ -253,7 +253,7 @@ static struct cvec_rep _cvec_inits = {0, 0};
         cvec_##X##_reserve(self, len); \

         struct cvec_rep* rep = cvec_rep_(self); \

         size_t i, n = rep->size; \

-        for (i = len; i < n; ++i) valueDestroy(self->data + i); \

+        for (i = len; i < n; ++i) valueDel(self->data + i); \

         for (i = n; i < len; ++i) self->data[i] = null_val; \

         if (rep->cap) rep->size = len; \

     } \

@@ -294,7 +294,7 @@ static struct cvec_rep _cvec_inits = {0, 0};
         intptr_t len = finish - first; \

         if (len > 0) { \

             cvec_##X##_value_t* p = first, *end = self->data + cvec_rep_(self)->size; \

-            while (p != finish) valueDestroy(p++); \

+            while (p != finish) valueDel(p++); \

             memmove(first, finish, (end - finish) * sizeof(Value)); \

             cvec_rep_(self)->size -= len; \

         } \

@@ -332,7 +332,7 @@ static struct cvec_rep _cvec_inits = {0, 0};
     }

 

 #else

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

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

 #endif

 

 #endif