Small fixes, and changed tag parameter name to X.

1 files changed, 45 insertions, 45 deletions

diff --git a/docs/clist_api.md b/docs/clist_api.md
index eba55a90..74ae44f5 100644
--- a/docs/clist_api.md
+++ b/docs/clist_api.md
@@ -9,15 +9,15 @@ This describes the API of circular singly linked list type **clist**.
 ```c
 #define using_clist_str()
 
-#define using_clist(T, Value, valueDestroy=c_default_del,
+#define using_clist(X, Value, valueDestroy=c_default_del,
                               valueCompareRaw=c_default_compare,
                               RawValue=Value,
                               valueToRaw=c_default_to_raw,
                               valueFromRaw=c_default_from_raw)
 ```
 The macro `using_clist()` can be instantiated with 2, 3, 4, or 7 arguments in the global scope.
-Default values are given above for args not specified. `T` is a type tag name and
-will affect the names of all clist types and methods. E.g. declaring `using_clist(my, int);`, `T` should
+Default values are given above for args not specified. `X` is a type tag name and
+will affect the names of all clist types and methods. E.g. declaring `using_clist(my, int);`, `X` should
 be replaced by `my` in all of the following documentation.
 
 `using_clist_str()` is a predefined macro for `using_clist(str, cstr_t, ...)`.
@@ -26,17 +26,17 @@ be replaced by `my` in all of the following documentation.
 
 | Type name             | Type definition                        | Used to represent...                |
 |:----------------------|:---------------------------------------|:------------------------------------|
-| `clist_T`             | `struct { clist_T_node_t* last; }`     | The clist type                      |
-| `clist_T_node_t`      | `struct {`                             | clist node                          |
-|                       | `  struct clist_T_node* next;`         |                                     |
-|                       | `  clist_T_value_t value;`             |                                     |
+| `clist_X`             | `struct { clist_X_node_t* last; }`     | The clist type                      |
+| `clist_X_node_t`      | `struct {`                             | clist node                          |
+|                       | `  struct clist_X_node* next;`         |                                     |
+|                       | `  clist_X_value_t value;`             |                                     |
 |                       | `}`                                    |                                     |
-| `clist_T_value_t`     | `Value`                                | The clist element type              |
-| `clist_T_input_t`     | `clist_T_value_t`                      | clist input type                    |
-| `clist_T_rawvalue_t`  | `RawValue`                             | clist raw value type                |
-| `clist_T_iter_t`      | `struct {`                             | clist iterator                      |
+| `clist_X_value_t`     | `Value`                                | The clist element type              |
+| `clist_X_input_t`     | `clist_X_value_t`                      | clist input type                    |
+| `clist_X_rawvalue_t`  | `RawValue`                             | clist raw value type                |
+| `clist_X_iter_t`      | `struct {`                             | clist iterator                      |
+|                       | `  clist_X_value_t* val;`              |                                     |
 |                       | `  ...;`                               |                                     |
-|                       | `  clist_T_value_t* val;`              |                                     |
 |                       | `}`                                    |                                     |
 
 
@@ -58,52 +58,52 @@ All clist definitions and prototypes may be included in your C source file by in
 
 ### Construction
 
-The interfaces to create a clist_T object:
+The interfaces to create a clist_X object:
 ```c
-clist_T             clist_T_init(void);
+clist_X             clist_X_init(void);
 
-void                clist_T_clear(clist_T* self);
-void                clist_T_del(clist_T* self);
+void                clist_X_clear(clist_X* self);
+void                clist_X_del(clist_X* self);
 
-bool                clist_T_empty(clist_T list);
-size_t              clist_T_size(clist_T list);
-Value               clist_T_value_from_raw(RawValue val);
+bool                clist_X_empty(clist_X list);
+size_t              clist_X_size(clist_X list);
+Value               clist_X_value_from_raw(RawValue val);
 
-clist_T_value_t*    clist_T_front(clist_T* self);
-clist_T_value_t*    clist_T_back(clist_T* self);
+clist_X_value_t*    clist_X_front(clist_X* self);
+clist_X_value_t*    clist_X_back(clist_X* self);
 
-void                clist_T_push_n(clist_T *self, const clist_T_input_t in[], size_t size);
-void                clist_T_push_back(clist_T* self, Value value);
-void                clist_T_emplace_back(clist_T* self, RawValue val);
+void                clist_X_push_n(clist_X *self, const clist_X_input_t in[], size_t size);
+void                clist_X_push_back(clist_X* self, Value value);
+void                clist_X_emplace_back(clist_X* self, RawValue val);
 
-void                clist_T_push_front(clist_T* self, Value value);
-void                clist_T_emplace_front(clist_T* self, RawValue val);
-void                clist_T_pop_front(clist_T* self);
+void                clist_X_push_front(clist_X* self, Value value);
+void                clist_X_emplace_front(clist_X* self, RawValue val);
+void                clist_X_pop_front(clist_X* self);
 
-clist_T_iter_t      clist_T_insert_after(clist_T* self, clist_T_iter_t pos, Value val);
-clist_T_iter_t      clist_T_emplace_after(clist_T* self, clist_T_iter_t pos, RawValue val);
+clist_X_iter_t      clist_X_insert_after(clist_X* self, clist_X_iter_t pos, Value val);
+clist_X_iter_t      clist_X_emplace_after(clist_X* self, clist_X_iter_t pos, RawValue val);
 
-clist_T_iter_t      clist_T_erase_after(clist_T* self, clist_T_iter_t pos);
-clist_T_iter_t      clist_T_erase_range_after(clist_T* self, clist_T_iter_t pos, clist_T_iter_t finish);
+clist_X_iter_t      clist_X_erase_after(clist_X* self, clist_X_iter_t pos);
+clist_X_iter_t      clist_X_erase_range_after(clist_X* self, clist_X_iter_t pos, clist_X_iter_t finish);
 
-void                clist_T_splice_front(clist_T* self, clist_T* other);
-void                clist_T_splice_back(clist_T* self, clist_T* other);
-void                clist_T_splice_after(clist_T* self, clist_T_iter_t pos, clist_T* other);
+void                clist_X_splice_front(clist_X* self, clist_X* other);
+void                clist_X_splice_back(clist_X* self, clist_X* other);
+void                clist_X_splice_after(clist_X* self, clist_X_iter_t pos, clist_X* other);
 
-clist_T_iter_t      clist_T_find(const clist_T* self, RawValue val);
-clist_T_iter_t      clist_T_find_before(const clist_T* self,
-                                        clist_T_iter_t first, clist_T_iter_t finish, RawValue val);
+clist_X_iter_t      clist_X_find(const clist_X* self, RawValue val);
+clist_X_iter_t      clist_X_find_before(const clist_X* self,
+                                        clist_X_iter_t first, clist_X_iter_t finish, RawValue val);
 
-size_t              clist_T_remove(clist_T* self, RawValue val);
+size_t              clist_X_remove(clist_X* self, RawValue val);
 
-void                clist_T_sort(clist_T* self);
+void                clist_X_sort(clist_X* self);
 
-clist_T_iter_t      clist_T_before_begin(const clist_T* self);
-clist_T_iter_t      clist_T_begin(const clist_T* self);
-clist_T_iter_t      clist_T_last(const clist_T* self);
-clist_T_iter_t      clist_T_end(const clist_T* self);
-void                clist_T_next(clist_T_iter_t* it);
-clist_T_value_t*    clist_T_itval(clist_T_iter_t it);
+clist_X_iter_t      clist_X_before_begin(const clist_X* self);
+clist_X_iter_t      clist_X_begin(const clist_X* self);
+clist_X_iter_t      clist_X_last(const clist_X* self);
+clist_X_iter_t      clist_X_end(const clist_X* self);
+void                clist_X_next(clist_X_iter_t* it);
+clist_X_value_t*    clist_X_itval(clist_X_iter_t it);
 ```
 
 Example: