NB! Changed API: *_erase_at(container, it) --> *_erase_it(container, it). cvec and cdeq insert_at() swapped with insert(). Docs update.

11 files changed, 57 insertions, 57 deletions

diff --git a/docs/cdeq_api.md b/docs/cdeq_api.md
index 03843fcf..b07ee2b0 100644
--- a/docs/cdeq_api.md
+++ b/docs/cdeq_api.md
@@ -54,27 +54,27 @@ void                cdeq_X_push_front(cdeq_X* self, Value value);
 void                cdeq_X_push_back(cdeq_X* self, Value value);
 void                cdeq_X_emplace_front(cdeq_X* self, RawValue raw);
 void                cdeq_X_emplace_back(cdeq_X* self, RawValue raw);
-void                cdeq_X_emplace_n(cdeq_X *self, const cdeq_X_rawvalue_t arr[], size_t size);
+void                cdeq_X_emplace_n(cdeq_X *self, const cdeq_X_rawvalue_t arr[], size_t n);
 
 void                cdeq_X_pop_front(cdeq_X* self);
-void                cdeq_X_pop_back(cdeq_X* self);
+void                cdeq_X_pop_back(cdeq_X* self); 
 
-cdeq_X_iter_t       cdeq_X_emplace(cdeq_X* self, size_t idx, RawValue raw);
-cdeq_X_iter_t       cdeq_X_emplace_at(cdeq_X* self, cdeq_X_iter_t pos, RawValue raw);
-cdeq_X_iter_t       cdeq_X_insert(cdeq_X* self, size_t idx, Value value);
-cdeq_X_iter_t       cdeq_X_insert_at(cdeq_X* self, cdeq_X_iter_t pos, Value value);
-cdeq_X_iter_t       cdeq_X_insert_range(cdeq_X* self, cdeq_X_iter_t pos,
+cdeq_X_iter_t       cdeq_X_emplace(cdeq_X* self, cdeq_X_iter_t it, RawValue raw);
+cdeq_X_iter_t       cdeq_X_emplace_at(cdeq_X* self, size_t idx, RawValue raw);
+cdeq_X_iter_t       cdeq_X_insert(cdeq_X* self, cdeq_X_iter_t it, Value value);
+cdeq_X_iter_t       cdeq_X_insert_at(cdeq_X* self, size_t idx, Value value);
+cdeq_X_iter_t       cdeq_X_insert_range(cdeq_X* self, cdeq_X_iter_t it,
                                         cdeq_X_iter_t first, cdeq_X_iter_t finish);
-cdeq_X_iter_t       cdeq_X_insert_range_p(cdeq_X* self, cdeq_X_value_t* pos,
+cdeq_X_iter_t       cdeq_X_insert_range_p(cdeq_X* self, cdeq_X_value_t* it,
                                           const cdeq_X_value_t* pfirst, const cdeq_X_value_t* pfinish);
 
-cdeq_X_iter_t       cdeq_X_erase(cdeq_X* self, size_t idx, size_t n);
-cdeq_X_iter_t       cdeq_X_erase_at(cdeq_X* self, cdeq_X_iter_t pos);
+cdeq_X_iter_t       cdeq_X_erase_it(cdeq_X* self, cdeq_X_iter_t it);
 cdeq_X_iter_t       cdeq_X_erase_range(cdeq_X* self, cdeq_X_iter_t first, cdeq_X_iter_t finish);
 cdeq_X_iter_t       cdeq_X_erase_range_p(cdeq_X* self, cdeq_X_value_t* pfirst, cdeq_X_value_t* pfinish);
+cdeq_X_iter_t       cdeq_X_erase_n(cdeq_X* self, size_t idx, size_t n);
 
 cdeq_X_iter_t       cdeq_X_find(const cdeq_X* self, RawValue raw);
-cdeq_X_iter_t       cdeq_X_find_in_range(cdeq_X_iter_t i1, cdeq_X_iter_t i2, RawValue raw);
+cdeq_X_iter_t       cdeq_X_find_in(cdeq_X_iter_t i1, cdeq_X_iter_t i2, RawValue raw);
 void                cdeq_X_sort(cdeq_X* self);
 void                cdeq_X_sort_range(cdeq_X_iter_t i1, cdeq_X_iter_t i2,
                                       int(*cmp)(const cdeq_X_value_t*, const cdeq_X_value_t*));
diff --git a/docs/clist_api.md b/docs/clist_api.md
index d1219046..6477eea7 100644
--- a/docs/clist_api.md
+++ b/docs/clist_api.md
@@ -15,8 +15,8 @@ However, an iterator to a succesive element can both be dereferenced and advance
 iterator is in a valid state. This implies:
 
 - `clist_X_insert(&L, clist_X_fwd(it,1), x)` is identical to *std::forward_list* `L.insert_after(it, x)`.
-- `clist_X_erase_at(&L, clist_X_fwd(it,1))` is identical to *std::forward_list* `L.erase_after(it)`.
-- Iterators returned from *clist_X_insert()* and *clist_X_erase_at()* are always valid.
+- `clist_X_erase_it(&L, clist_X_fwd(it,1))` is identical to *std::forward_list* `L.erase_after(it)`.
+- Iterators returned from *clist_X_insert()* and *clist_X_erase_it()* are always valid.
 - Elements can be safely removed from a list via multiple iterators if done back to front order.
 
 See the c++ class [std::list](https://en.cppreference.com/w/cpp/container/list) for similar API and
@@ -48,10 +48,10 @@ clist_X             clist_X_init(void);
 clist_X             clist_X_clone(clist_X list);
 
 void                clist_X_clear(clist_X* self);
-void                clist_X_del(clist_X* self);                                     // destructor
+void                clist_X_del(clist_X* self);                                       // destructor
 
 bool                clist_X_empty(clist_X list);
-size_t              clist_X_count(clist_X list);                                    // size() in O(n) time
+size_t              clist_X_count(clist_X list);                                      // size() in O(n) time
 
 clist_X_value_t*    clist_X_front(const clist_X* self);
 clist_X_value_t*    clist_X_back(const clist_X* self);
@@ -60,26 +60,26 @@ void                clist_X_push_front(clist_X* self, Value value);
 void                clist_X_emplace_front(clist_X* self, RawValue raw);
 void                clist_X_pop_front(clist_X* self);
 
-void                clist_X_push_back(clist_X* self, Value value);                  // note: no pop_back().
-void                clist_X_emplace_back(clist_X* self, RawValue raw);
-void                clist_X_emplace_n(clist_X *self, const clist_X_rawvalue_t arr[], size_t size);
+void                clist_X_push_back(clist_X* self, Value value);                    // note no pop_back().
+void                clist_X_emplace_back(clist_X* self, RawValue raw);                // note no emplace_back().
+void                clist_X_emplace_n(clist_X *self, const clist_X_rawvalue_t arr[], size_t n);
 
-clist_X_iter_t      clist_X_insert(clist_X* self, clist_X_iter_t it, Value value);  // return iter to new elem; End allowed
+clist_X_iter_t      clist_X_insert(clist_X* self, clist_X_iter_t it, Value value); // return iter to new elem
 clist_X_iter_t      clist_X_emplace(clist_X* self, clist_X_iter_t it, RawValue raw);
 
-clist_X_iter_t      clist_X_erase_at(clist_X* self, clist_X_iter_t it);             // return iter after it
+clist_X_iter_t      clist_X_erase_it(clist_X* self, clist_X_iter_t it);               // return iter after it
 clist_X_iter_t      clist_X_erase_range(clist_X* self, clist_X_iter_t it1, clist_X_iter_t it2);
-size_t              clist_X_remove(clist_X* self, RawValue raw);                    // removes all elements equal to raw
+size_t              clist_X_remove(clist_X* self, RawValue raw);                      // removes all elements equal to raw
 
 void                clist_X_splice(clist_X* self, clist_X_iter_t it, clist_X* other);
-void                clist_X_splice_range(clist_X* self, clist_X_iter_t it,          // see std::list::splice() docs
+void                clist_X_splice_range(clist_X* self, clist_X_iter_t it,            // see std::list::splice() docs
                                          clist_X* other, clist_X_iter_t it1, clist_X_iter_t it2);
                     // split out [it1, it2) from self, and return as a clist
 clist_X             clist_X_split(clist_X* self, clist_X_iter_t it1, clist_X_iter_t it2);
 
 clist_X_iter_t      clist_X_find(const clist_X* self, RawValue raw);
-clist_X_iter_t      clist_X_find_in_range(const clist_X* self,
-                                          clist_X_iter_t it1, clist_X_iter_t it2, RawValue raw);
+clist_X_iter_t      clist_X_find_in(const clist_X* self,
+                                    clist_X_iter_t it1, clist_X_iter_t it2, RawValue raw);
 
 void                clist_X_sort(clist_X* self);
 
@@ -139,7 +139,7 @@ sorted:  1 2 3 4 5 6 7 8 9 10 20 30 40 50 60 70 80 90
 ```
 ### Example 2
 
-Use of *erase_at()* and *erase_range()*:
+Use of *erase_it()* and *erase_range()*:
 ```c
 // erasing from clist
 #include <stc/clist.h>
@@ -153,7 +153,7 @@ int main ()
                                                  // 10 20 30 40 50
     clist_i_iter_t it = clist_i_begin(&L);       // ^
     clist_i_next(&it); 
-    it = clist_i_erase_at(&L, it);               // 10 30 40 50
+    it = clist_i_erase_it(&L, it);               // 10 30 40 50
                                                  //    ^
     clist_i_iter_t end = clist_i_end(&L);        //
     clist_i_next(&it);
diff --git a/docs/cmap_api.md b/docs/cmap_api.md
index aec048e6..39550a19 100644
--- a/docs/cmap_api.md
+++ b/docs/cmap_api.md
@@ -63,10 +63,10 @@ cmap_X_result_t     cmap_X_put(cmap_X* self, Key key, Mapped mapped);
 
 cmap_X_result_t     cmap_X_emplace(cmap_X* self, RawKey rkey, RawMapped rmapped);            // no change if rkey in map
 cmap_X_result_t     cmap_X_emplace_or_assign(cmap_X* self, RawKey rkey, RawMapped rmapped);  // always update rmapped
-void                cmap_X_emplace_n(cmap_X* self, const cmap_X_rawvalue_t arr[], size_t size);
+void                cmap_X_emplace_n(cmap_X* self, const cmap_X_rawvalue_t arr[], size_t n);
 
-size_t              cmap_X_erase(cmap_X* self, RawKey rkey);
-cmap_X_iter_t       cmap_X_erase_at(cmap_X* self, cmap_X_iter_t pos);
+size_t              cmap_X_erase(cmap_X* self, RawKey rkey);                                 // return 0 or 1
+cmap_X_iter_t       cmap_X_erase_it(cmap_X* self, cmap_X_iter_t it);                         // return iter after it
 void                cmap_X_erase_entry(cmap_X* self, cmap_X_value_t* entry);
 
 cmap_X_iter_t       cmap_X_begin(const cmap_X* self);
diff --git a/docs/cpque_api.md b/docs/cpque_api.md
index 822b4ad5..261c2909 100644
--- a/docs/cpque_api.md
+++ b/docs/cpque_api.md
@@ -37,7 +37,7 @@ const cpque_X_value_t*  cpque_X_top(const cpque_X* self);
 
 void                    cpque_X_push(cpque_X* self, cpque_X_value_t value);
 void                    cpque_X_emplace(cpque_X* self, cpque_X_rawvalue_t raw);
-void                    cpque_X_emplace_n(cpque_X *self, const cpque_X_rawvalue_t arr[], size_t size);
+void                    cpque_X_emplace_n(cpque_X *self, const cpque_X_rawvalue_t arr[], size_t n);
 
 void                    cpque_X_pop(cpque_X* self);
 void                    cpque_X_erase_at(cpque_X* self, size_t idx);
diff --git a/docs/cqueue_api.md b/docs/cqueue_api.md
index 2d9b113c..7a18a9b4 100644
--- a/docs/cqueue_api.md
+++ b/docs/cqueue_api.md
@@ -32,7 +32,7 @@ cqueue_X_value_t*       cqueue_X_back(const cqueue_X* self);
 
 void                    cqueue_X_push(cqueue_X* self, cqueue_X_value_t value);
 void                    cqueue_X_emplace(cqueue_X* self, cqueue_X_rawvalue_t raw);
-void                    cqueue_X_emplace_n(cqueue_X *self, const cqueue_X_rawvalue_t arr[], size_t size);
+void                    cqueue_X_emplace_n(cqueue_X *self, const cqueue_X_rawvalue_t arr[], size_t n);
 
 void                    cqueue_X_pop(cqueue_X* self);
 
diff --git a/docs/cset_api.md b/docs/cset_api.md
index dfdad074..848c6c63 100644
--- a/docs/cset_api.md
+++ b/docs/cset_api.md
@@ -43,10 +43,10 @@ bool                cset_X_contains(const cset_X* self, RawKey rkey);
 

 cset_X_result_t     cset_X_insert(cset_X* self, Key key);

 cset_X_result_t     cset_X_emplace(cset_X* self, RawKey rkey);

-void                cset_X_emplace_n(cset_X* self, const RawKey arr[], size_t size);

+void                cset_X_emplace_n(cset_X* self, const RawKey arr[], size_t n);

 

-size_t              cset_X_erase(cset_X* self, RawKey rkey);

-cset_X_iter_t       cset_X_erase_at(cset_X* self, cset_X_iter_t pos);

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

+cset_X_iter_t       cset_X_erase_it(cset_X* self, cset_X_iter_t it);                         // return iter after it

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

 

 cset_X_iter_t       cset_X_begin(const cset_X* self);

diff --git a/docs/csmap_api.md b/docs/csmap_api.md
index 758bce09..dca919fb 100644
--- a/docs/csmap_api.md
+++ b/docs/csmap_api.md
@@ -62,10 +62,10 @@ csmap_X_result_t    csmap_X_put(csmap_X* self, Key key, Mapped mapped);
 
 csmap_X_result_t    csmap_X_emplace(csmap_X* self, RawKey rkey, RawMapped rmapped);             // no change if rkey in map
 csmap_X_result_t    csmap_X_emplace_or_assign(csmap_X* self, RawKey rkey, RawMapped rmapped);   // always update rmapped
-void                csmap_X_emplace_n(csmap_X* self, const csmap_X_rawvalue_t arr[], size_t size);
+void                csmap_X_emplace_n(csmap_X* self, const csmap_X_rawvalue_t arr[], size_t n);
 
 size_t              csmap_X_erase(csmap_X* self, RawKey rkey);
-csmap_X_iter_t      csmap_X_erase_at(csmap_X* self, csmap_X_iter_t it);                         // returns iter after it
+csmap_X_iter_t      csmap_X_erase_it(csmap_X* self, csmap_X_iter_t it);                         // returns iter after it
 csmap_X_iter_t      csmap_X_erase_range(csmap_X* self, csmap_X_iter_t it1, csmap_X_iter_t it2); // returns updated it2
 
 csmap_X_iter_t      csmap_X_begin(const csmap_X* self);
diff --git a/docs/csptr_api.md b/docs/csptr_api.md
index 9669d97b..e1670bb2 100644
--- a/docs/csptr_api.md
+++ b/docs/csptr_api.md
@@ -39,7 +39,7 @@ The *csptr_X_compare()*, *csptr_X_equals()* and *csptr_X_del()* methods are defi
 csptr_X             csptr_X_from(csptr_X_value_t* ptr);     // constructor
 csptr_X             csptr_X_make(csptr_X_value_t val);      // make_shared
 void                csptr_X_reset(csptr_X* self);
-void                csptr_X_reset_to(csptr_X* self, csptr_X_value_t* ptr);
+void                csptr_X_reset_with(csptr_X* self, csptr_X_value_t* ptr);
 
 csptr_X             csptr_X_clone(csptr_X sptr);            // share the pointer (increase use count)
 void                csptr_X_move(csptr_X* self);            // transfer ownership instead of sharing. 
@@ -49,10 +49,11 @@ int                 csptr_X_compare(csptr_X* x, csptr_X* y);
 bool                csptr_X_equals(csptr_X* x, csptr_X* y);
 ```
 
-## Types
+## Types and constants
 
 | Type name           | Type definition                                               | Used to represent...     |
 |:--------------------|:--------------------------------------------------------------|:-------------------------|
+| `csptr_null`        | `{NULL, NULL}`                                                | Init nullptr const       |
 | `csptr_X`           | `struct { csptr_X_value_t* get; atomic_count_t* use_count; }` | The csptr type           |
 | `csptr_X_value_t`   | `Value`                                                       | The csptr element type   |
 | `atomic_count_t`    | `long`                                                        | The reference counter    |
diff --git a/docs/csset_api.md b/docs/csset_api.md
index 67e3c6a7..54a0ece9 100644
--- a/docs/csset_api.md
+++ b/docs/csset_api.md
@@ -41,10 +41,10 @@ bool                csset_X_contains(const csset_X* self, RawKey rkey);
 

 csset_X_result_t    csset_X_insert(csset_X* self, Key key);

 csset_X_result_t    csset_X_emplace(csset_X* self, RawKey rkey);

-void                csset_X_emplace_n(csset_X* self, const RawKey arr[], size_t size);

+void                csset_X_emplace_n(csset_X* self, const RawKey arr[], size_t n);

 

 size_t              csset_X_erase(csset_X* self, RawKey rkey);

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

+csset_X_iter_t      csset_X_erase_it(csset_X* self, csset_X_iter_t it);                         // return iter after it

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

 

 csset_X_iter_t      csset_X_begin(const csset_X* self);

diff --git a/docs/cstack_api.md b/docs/cstack_api.md
index 06163518..e892ac8e 100644
--- a/docs/cstack_api.md
+++ b/docs/cstack_api.md
@@ -32,7 +32,7 @@ cstack_X_value_t*       cstack_X_top(const cstack_X* self);
 
 void                    cstack_X_push(cstack_X* self, cstack_X_value_t value);
 void                    cstack_X_emplace(cstack_X* self, cstack_X_rawvalue_t raw);
-void                    cstack_X_emplace_n(cstack_X *self, const cstack_X_rawvalue_t arr[], size_t size);
+void                    cstack_X_emplace_n(cstack_X *self, const cstack_X_rawvalue_t arr[], size_t n);
 
 void                    cstack_X_pop(cstack_X* self);
 
diff --git a/docs/cvec_api.md b/docs/cvec_api.md
index 6f495cae..d945e5e2 100644
--- a/docs/cvec_api.md
+++ b/docs/cvec_api.md
@@ -55,35 +55,34 @@ cvec_X_value_t*     cvec_X_back(const cvec_X* self);
 
 void                cvec_X_push_back(cvec_X* self, Value value);
 void                cvec_X_emplace_back(cvec_X* self, RawValue raw);
-void                cvec_X_emplace_n(cvec_X *self, const cvec_X_rawvalue_t arr[], size_t size);
+void                cvec_X_emplace_n(cvec_X *self, const cvec_X_rawvalue_t arr[], size_t n);
 
 void                cvec_X_pop_back(cvec_X* self);
 
-cvec_X_iter_t       cvec_X_insert(cvec_X* self, size_t idx, Value value);
-cvec_X_iter_t       cvec_X_insert_at(cvec_X* self, cvec_X_iter_t pos, Value value);
-cvec_X_iter_t       cvec_X_insert_range(cvec_X* self, cvec_X_iter_t pos,
-                                        cvec_X_iter_t first, cvec_X_iter_t finish);
-cvec_X_iter_t       cvec_X_insert_range_p(cvec_X* self, cvec_X_value_t* pos,
-                                          const cvec_X_value_t* pfirst, const cvec_X_value_t* pfinish);
-cvec_X_iter_t       cvec_X_emplace(cvec_X* self, size_t idx, RawValue raw);
-cvec_X_iter_t       cvec_X_emplace_at(cvec_X* self, cvec_X_iter_t pos, RawValue raw);
+cvec_X_iter_t       cvec_X_insert(cvec_X* self, cvec_X_iter_t it, Value value);
+cvec_X_iter_t       cvec_X_insert_at(cvec_X* self, size_t idx, Value value);
+cvec_X_iter_t       cvec_X_insert_range(cvec_X* self, cvec_X_iter_t it,
+                                        cvec_X_iter_t i1, cvec_X_iter_t i2);
 
-cvec_X_iter_t       cvec_X_erase(cvec_X* self, size_t idx, size_t n);
-cvec_X_iter_t       cvec_X_erase_at(cvec_X* self, cvec_X_iter_t pos);
-cvec_X_iter_t       cvec_X_erase_range(cvec_X* self, cvec_X_iter_t first, cvec_X_iter_t finish);
-cvec_X_iter_t       cvec_X_erase_range_p(cvec_X* self, cvec_X_value_t* pfirst, cvec_X_value_t* pfinish);
+cvec_X_iter_t       cvec_X_emplace(cvec_X* self, cvec_X_iter_t it, RawValue raw);
+cvec_X_iter_t       cvec_X_emplace_at(cvec_X* self, size_t idx, RawValue raw);
+
+cvec_X_iter_t       cvec_X_erase_it(cvec_X* self, cvec_X_iter_t it);
+cvec_X_iter_t       cvec_X_erase_range(cvec_X* self, cvec_X_iter_t i1, cvec_X_iter_t i2);
+cvec_X_iter_t       cvec_X_erase_n(cvec_X* self, size_t idx, size_t n);
 
 cvec_X_iter_t       cvec_X_find(const cvec_X* self, RawValue raw);
-cvec_X_iter_t       cvec_X_find_in_range(cvec_X_iter_t i1, cvec_X_iter_t i2, RawValue raw);
+cvec_X_iter_t       cvec_X_find_in(cvec_X_iter_t i1, cvec_X_iter_t i2, RawValue raw);
 cvec_X_iter_t       cvec_X_bsearch(const cvec_X* self, RawValue raw);
-cvec_X_iter_t       cvec_X_bsearch_in_range(cvec_X_iter_t i1, cvec_X_iter_t i2, RawValue raw);
+cvec_X_iter_t       cvec_X_bsearch_in(cvec_X_iter_t i1, cvec_X_iter_t i2, RawValue raw);
+
 void                cvec_X_sort(cvec_X* self);
 void                cvec_X_sort_range(cvec_X_iter_t i1, cvec_X_iter_t i2,
                                       int(*cmp)(const cvec_X_value_t*, const cvec_X_value_t*));
 
 cvec_X_iter_t       cvec_X_begin(const cvec_X* self);
 cvec_X_iter_t       cvec_X_end(const cvec_X* self);
-void                cvec_X_next(cvec_X_iter_t* it);
+void                cvec_X_next(cvec_X_iter_t* iter);
 size_t              cvec_X_index(const cvec_X vec, cvec_X_iter_t it);
 
 cvec_X_value_t      cvec_X_value_clone(cvec_X_value_t val);