development branch for 4.2

Removed uses of c_auto and c_with in documentation examples and code examples. Still using c_defer a few places.
Renamed c11/fmt.h to c11/print.h.
Some additions in ccommon.h, e.g. c_const_cast(T, x).
Improved docs.

14 files changed, 426 insertions, 434 deletions

diff --git a/docs/carc_api.md b/docs/carc_api.md
index cc6c9c32..48b64ff0 100644
--- a/docs/carc_api.md
+++ b/docs/carc_api.md
@@ -98,56 +98,56 @@ bool        carc_X_value_eq(const i_val* x, const i_val* y);
 
 int main()
 {
-    c_auto (Stack, s1, s2) // RAII
-    {
-        // POPULATE s1 with shared pointers to Map:
-        Map *map;
-
-        map = Stack_push(&s1, Arc_make(Map_init()))->get; // push empty map to s1.
-        c_forlist (i, Map_raw, { {"Joey", 1990}, {"Mary", 1995}, {"Joanna", 1992} }) {
-            Map_emplace(map, c_PAIR(i.ref)); // populate it.
-        }
-
-        map = Stack_push(&s1, Arc_make(Map_init()))->get;
-        c_forlist (i, Map_raw, { {"Rosanna", 2001}, {"Brad", 1999}, {"Jack", 1980} }) {
-            Map_emplace(map, c_PAIR(i.ref));
-        }
-
-        // POPULATE s2:
-        map = Stack_push(&s2, Arc_make(Map_init()))->get;
-        c_forlist (i, Map_raw, { {"Steve", 1979}, {"Rick", 1974}, {"Tracy", 2003} }) {
-            Map_emplace(map, c_PAIR(i.ref));
-        }
-        
-        // Share two Maps from s1 with s2 by cloning(=sharing) the carcs:
-        Stack_push(&s2, Arc_clone(s1.data[0]));
-        Stack_push(&s2, Arc_clone(s1.data[1]));
-        
-        // Deep-copy (does not share) a Map from s1 to s2.
-        // s2 will contain two shared and two unshared maps.
-        map = Stack_push(&s2, Arc_from(Map_clone(*s1.data[1].get)))->get;
-        
-        // Add one more element to the cloned map:
-        Map_emplace_or_assign(map, "Cloned", 2022);
-
-        // Add one more element to the shared map:
-        Map_emplace_or_assign(s1.data[1].get, "Shared", 2022);
-
-        puts("S1");
-        c_foreach (i, Stack, s1) {
-            c_forpair (name, year, Map, *i.ref->get)
-                printf("  %s:%d", cstr_str(_.name), *_.year);
-            puts("");
-        }
-
-        puts("S2");
-        c_foreach (i, Stack, s2) {
-            c_forpair (name, year, Map, *i.ref->get)
-                printf("  %s:%d", cstr_str(_.name), *_.year);
-            puts("");
-        }
+    Stack s1 = {0}, s2 = {0};
+    Map *map;
+
+    // POPULATE s1 with shared pointers to Map:
+    map = Stack_push(&s1, Arc_make(Map_init()))->get; // push empty map to s1.
+    Map_emplace(map, "Joey", 1990);
+    Map_emplace(map, "Mary", 1995);
+    Map_emplace(map, "Joanna", 1992);
+
+    map = Stack_push(&s1, Arc_make(Map_init()))->get;
+    Map_emplace(map, "Rosanna", 2001);
+    Map_emplace(map, "Brad", 1999);
+    Map_emplace(map, "Jack", 1980);
+
+    // POPULATE s2:
+    map = Stack_push(&s2, Arc_make(Map_init()))->get;
+    Map_emplace(map, "Steve", 1979);
+    Map_emplace(map, "Rick", 1974);
+    Map_emplace(map, "Tracy", 2003);
+
+    // Share two Maps from s1 with s2 by cloning(=sharing) the carcs:
+    Stack_push(&s2, Arc_clone(s1.data[0]));
+    Stack_push(&s2, Arc_clone(s1.data[1]));
+    
+    // Deep-copy (does not share) a Map from s1 to s2.
+    // s2 will contain two shared and two unshared maps.
+    map = Stack_push(&s2, Arc_from(Map_clone(*s1.data[1].get)))->get;
+    
+    // Add one more element to the cloned map:
+    Map_emplace_or_assign(map, "Cloned", 2022);
+
+    // Add one more element to the shared map:
+    Map_emplace_or_assign(s1.data[1].get, "Shared", 2022);
+
+    puts("S1");
+    c_foreach (i, Stack, s1) {
+        c_forpair (name, year, Map, *i.ref->get)
+            printf("  %s:%d", cstr_str(_.name), *_.year);
         puts("");
     }
+
+    puts("S2");
+    c_foreach (i, Stack, s2) {
+        c_forpair (name, year, Map, *i.ref->get)
+            printf("  %s:%d", cstr_str(_.name), *_.year);
+        puts("");
+    }
+    puts("");
+
+    c_drop(Stack, &s1, &s2);
 }
 ```
 Output:
diff --git a/docs/cbox_api.md b/docs/cbox_api.md
index 8b03d004..ca4d90da 100644
--- a/docs/cbox_api.md
+++ b/docs/cbox_api.md
@@ -92,11 +92,12 @@ void int_drop(int* x) {
 
 int main()
 {
-    c_auto (IVec, vec)  // declare and init vec, call drop at scope exit
-    c_auto (ISet, set)  // similar
-    {
-        vec = c_make(Vec, {2021, 2012, 2022, 2015});
-
+    IVec vec = c_make(Vec, {2021, 2012, 2022, 2015});
+    ISet set = {0};
+    c_defer(
+      IVec_drop(&vec),
+      ISet_drop(&set)
+    ){
         printf("vec:");
         c_foreach (i, IVec, vec)
             printf(" %d", *i.ref->get);
diff --git a/docs/ccommon_api.md b/docs/ccommon_api.md
index 64daad42..010ea204 100644
--- a/docs/ccommon_api.md
+++ b/docs/ccommon_api.md
@@ -2,96 +2,6 @@
 
 The following macros are recommended to use, and they safe/have no side-effects.
 
-## Scope macros (RAII)
-### c_auto, c_with, c_scope, c_defer
-General ***defer*** mechanics for resource acquisition. These macros allows you to specify the
-freeing of the resources at the point where the acquisition takes place.
-The **checkauto** utility described below, ensures that the `c_auto*` macros are used correctly.
-
-| Usage                                  | Description                                               |
-|:---------------------------------------|:----------------------------------------------------------|
-| `c_with (Type var=init, drop)`         | Declare `var`. Defer `drop...` to end of scope            |
-| `c_with (Type var=init, pred, drop)`   | Adds a predicate in order to exit early if init failed    |
-| `c_auto (Type, var1,...,var4)`         | `c_with (Type var1=Type_init(), Type_drop(&var1))` ...    |
-| `c_scope (init, drop)`                 | Execute `init` and defer `drop` to end of scope           |
-| `c_defer (drop...)`                    | Defer `drop...` to end of scope                           |
-| `continue`                             | Exit a block above without memory leaks                   |
-
-For multiple variables, use either multiple **c_with** in sequence, or declare variable outside
-scope and use **c_scope**. For convenience, **c_auto** support up to 4 variables.
-```c
-// `c_with` is similar to python `with`: it declares and can drop a variable after going out of scope.
-bool ok = false;
-c_with (uint8_t* buf = malloc(BUF_SIZE), buf != NULL, free(buf))
-c_with (FILE* fp = fopen(fname, "rb"), fp != NULL, fclose(fp))
-{
-    int n = fread(buf, 1, BUF_SIZE, fp);
-    if (n <= 0) continue; // auto cleanup! NB do not break or return here.
-    ...
-    ok = true;
-}
-return ok;
-
-// `c_auto` automatically initialize and destruct up to 4 variables:
-c_auto (cstr, s1, s2)
-{
-    cstr_append(&s1, "Hello");
-    cstr_append(&s1, " world");
-
-    cstr_append(&s2, "Cool");
-    cstr_append(&s2, " stuff");
-
-    printf("%s %s\n", cstr_str(&s1), cstr_str(&s2));
-}
-
-// `c_with` is a general variant of `c_auto`:
-c_with (cstr str = cstr_lit("Hello"), cstr_drop(&str))
-{
-    cstr_append(&str, " world");
-    printf("%s\n", cstr_str(&str));
-}
-
-// `c_scope` is like `c_with` but works with an already declared variable.
-static pthread_mutex_t mut;
-c_scope (pthread_mutex_lock(&mut), pthread_mutex_unlock(&mut))
-{
-    /* Do syncronized work. */
-}
-
-// `c_defer` executes the expressions when leaving scope. Prefer c_with or c_scope.
-cstr s1 = cstr_lit("Hello"), s2 = cstr_lit("world");
-c_defer (cstr_drop(&s1), cstr_drop(&s2))
-{
-    printf("%s %s\n", cstr_str(&s1), cstr_str(&s2));
-}
-```
-**Example**: Load each line of a text file into a vector of strings:
-```c
-#include <errno.h>
-#include <stc/cstr.h>
-
-#define i_val_str
-#include <stc/cvec.h>
-
-// receiver should check errno variable
-cvec_str readFile(const char* name)
-{
-    cvec_str vec = cvec_str_init(); // returned
-
-    c_with (FILE* fp = fopen(name, "r"), fp != NULL, fclose(fp))
-    c_with (cstr line = cstr_NULL, cstr_drop(&line))
-        while (cstr_getline(&line, fp))
-            cvec_str_emplace_back(&vec, cstr_str(&line));
-    return vec;
-}
-
-int main()
-{
-    c_with (cvec_str x = readFile(__FILE__), cvec_str_drop(&x))
-        c_foreach (i, cvec_str, x)
-            printf("%s\n", cstr_str(i.ref));
-}
-```
 ## Loop abstraction macros
 
 ### c_foreach, c_foreach_r, c_forpair
@@ -165,10 +75,6 @@ c_forlist (i, cmap_ii_raw, { {4, 5}, {6, 7} })
 // string literals pushed to a stack of cstr:
 c_forlist (i, const char*, {"Hello", "crazy", "world"})
     cstack_str_emplace(&stk, *i.ref);
-
-// reverse the list:
-c_forlist (i, int, {1, 2, 3})
-    cvec_i_push_back(&vec, i.data[i.size - 1 - i.index]);
 ```
 
 ### c_forfilter
@@ -297,13 +203,18 @@ if (it.ref) cmap_str_erase_at(&map, it);
 c_erase_if(i, csmap_str, map, cstr_contains(i.ref, "hello"));
 ```
 
-### c_swap, c_drop
+### c_swap, c_drop, c_const_cast
 ```c
 // Safe macro for swapping internals of two objects of same type:
 c_swap(cmap_int, &map1, &map2);
 
 // Drop multiple containers of same type:
 c_drop(cvec_i, &vec1, &vec2, &vec3);
+
+// Type-safe casting a from const (pointer):
+const char* cs = "Hello";
+char* s = c_const_cast(char*, cs); // OK
+int* ip = c_const_cast(int*, cs);  // issues a warning!
 ```
 
 ### General predefined template parameter functions
@@ -329,7 +240,99 @@ int array[] = {1, 2, 3, 4};
 intptr_t n = c_arraylen(array);
 ```
 
-## The **checkauto** utility program (for RAII)
+## Scope macros (RAII)
+### c_auto, c_with, c_scope, c_defer
+General ***defer*** mechanics for resource acquisition. These macros allows you to specify the
+freeing of the resources at the point where the acquisition takes place.
+The **checkauto** utility described below, ensures that the `c_auto*` macros are used correctly.
+
+| Usage                                  | Description                                               |
+|:---------------------------------------|:----------------------------------------------------------|
+| `c_defer (drop...)`                    | Defer `drop...` to end of scope                           |
+| `c_scope (init, drop)`                 | Execute `init` and defer `drop` to end of scope           |
+| `c_scope (init, pred, drop)`           | Adds a predicate in order to exit early if init failed    |
+| `c_with (Type var=init, drop)`         | Declare `var`. Defer `drop...` to end of scope            |
+| `c_with (Type var=init, pred, drop)`   | Adds a predicate in order to exit early if init failed    |
+| `c_auto (Type, var1,...,var4)`         | `c_with (Type var1=Type_init(), Type_drop(&var1))` ...    |
+| `continue`                             | Exit a block above without memory leaks                   |
+
+For multiple variables, use either multiple **c_with** in sequence, or declare variable outside
+scope and use **c_scope**. For convenience, **c_auto** support up to 4 variables.
+```c
+// `c_with` is similar to python `with`: it declares and can drop a variable after going out of scope.
+bool ok = false;
+c_with (uint8_t* buf = malloc(BUF_SIZE), buf != NULL, free(buf))
+c_with (FILE* fp = fopen(fname, "rb"), fp != NULL, fclose(fp))
+{
+    int n = fread(buf, 1, BUF_SIZE, fp);
+    if (n <= 0) continue; // auto cleanup! NB do not break or return here.
+    ...
+    ok = true;
+}
+return ok;
+
+// `c_auto` automatically initialize and destruct up to 4 variables:
+c_auto (cstr, s1, s2)
+{
+    cstr_append(&s1, "Hello");
+    cstr_append(&s1, " world");
+
+    cstr_append(&s2, "Cool");
+    cstr_append(&s2, " stuff");
+
+    printf("%s %s\n", cstr_str(&s1), cstr_str(&s2));
+}
+
+// `c_with` is a general variant of `c_auto`:
+c_with (cstr str = cstr_lit("Hello"), cstr_drop(&str))
+{
+    cstr_append(&str, " world");
+    printf("%s\n", cstr_str(&str));
+}
+
+// `c_scope` is like `c_with` but works with an already declared variable.
+static pthread_mutex_t mut;
+c_scope (pthread_mutex_lock(&mut), pthread_mutex_unlock(&mut))
+{
+    /* Do syncronized work. */
+}
+
+// `c_defer` executes the expressions when leaving scope. Prefer c_with or c_scope.
+cstr s1 = cstr_lit("Hello"), s2 = cstr_lit("world");
+c_defer (cstr_drop(&s1), cstr_drop(&s2))
+{
+    printf("%s %s\n", cstr_str(&s1), cstr_str(&s2));
+}
+```
+**Example**: Load each line of a text file into a vector of strings:
+```c
+#include <errno.h>
+#include <stc/cstr.h>
+
+#define i_val_str
+#include <stc/cvec.h>
+
+// receiver should check errno variable
+cvec_str readFile(const char* name)
+{
+    cvec_str vec = cvec_str_init(); // returned
+
+    c_with (FILE* fp = fopen(name, "r"), fp != NULL, fclose(fp))
+    c_with (cstr line = cstr_NULL, cstr_drop(&line))
+        while (cstr_getline(&line, fp))
+            cvec_str_emplace_back(&vec, cstr_str(&line));
+    return vec;
+}
+
+int main()
+{
+    c_with (cvec_str x = readFile(__FILE__), cvec_str_drop(&x))
+        c_foreach (i, cvec_str, x)
+            printf("%s\n", cstr_str(i.ref));
+}
+```
+
+### The **checkauto** utility program (for RAII)
 The **checkauto** program will check the source code for any misuses of the `c_auto*` macros which
 may lead to resource leakages. The `c_auto*`- macros are implemented as one-time executed **for-loops**,
 so any `return` or `break` appearing within such a block will lead to resource leaks, as it will disable
diff --git a/docs/clist_api.md b/docs/clist_api.md
index be6949ec..a1dbe105 100644
--- a/docs/clist_api.md
+++ b/docs/clist_api.md
@@ -193,21 +193,20 @@ Splice `[30, 40]` from *L2* into *L1* before `3`:
 #include <stdio.h>
 
 int main() {
-    c_auto (clist_i, L1, L2)
-    {
-        L1 = c_make(clist_i, {1, 2, 3, 4, 5});
-        L2 = c_make(clist_i, {10, 20, 30, 40, 50});
+    clist_i L1 = c_make(clist_i, {1, 2, 3, 4, 5});
+    clist_i L2 = c_make(clist_i, {10, 20, 30, 40, 50});
 
-        clist_i_iter i = clist_i_advance(clist_i_begin(&L1), 2);
-        clist_i_iter j1 = clist_i_advance(clist_i_begin(&L2), 2), j2 = clist_i_advance(j1, 2);
+    clist_i_iter i = clist_i_advance(clist_i_begin(&L1), 2);
+    clist_i_iter j1 = clist_i_advance(clist_i_begin(&L2), 2), j2 = clist_i_advance(j1, 2);
 
-        clist_i_splice_range(&L1, i, &L2, j1, j2);
+    clist_i_splice_range(&L1, i, &L2, j1, j2);
 
-        c_foreach (i, clist_i, L1)
-            printf(" %d", *i.ref); puts("");
-        c_foreach (i, clist_i, L2)
-            printf(" %d", *i.ref); puts("");
-    }
+    c_foreach (i, clist_i, L1)
+        printf(" %d", *i.ref); puts("");
+    c_foreach (i, clist_i, L2)
+        printf(" %d", *i.ref); puts("");
+
+    c_drop(clist_i, &L1, &L2);
 }
 ```
 Output:
diff --git a/docs/cmap_api.md b/docs/cmap_api.md
index bf3dddcc..71e00265 100644
--- a/docs/cmap_api.md
+++ b/docs/cmap_api.md
@@ -125,27 +125,26 @@ bool                  c_memcmp_eq(const i_keyraw* a, const i_keyraw* b);    // !
 int main()
 {
     // Create an unordered_map of three strings (that map to strings)
-    c_auto (cmap_str, u)
-    {
-        u = c_make(cmap_str, {
-            {"RED", "#FF0000"},
-            {"GREEN", "#00FF00"},
-            {"BLUE", "#0000FF"}
-        });
-
-        // Iterate and print keys and values of unordered map
-        c_foreach (n, cmap_str, u) {
-            printf("Key:[%s] Value:[%s]\n", cstr_str(&n.ref->first), cstr_str(&n.ref->second));
-        }
-
-        // Add two new entries to the unordered map
-        cmap_str_emplace(&u, "BLACK", "#000000");
-        cmap_str_emplace(&u, "WHITE", "#FFFFFF");
-
-        // Output values by key
-        printf("The HEX of color RED is:[%s]\n", cstr_str(cmap_str_at(&u, "RED")));
-        printf("The HEX of color BLACK is:[%s]\n", cstr_str(cmap_str_at(&u, "BLACK")));
+    cmap_str umap = c_make(cmap_str, {
+        {"RED", "#FF0000"},
+        {"GREEN", "#00FF00"},
+        {"BLUE", "#0000FF"}
+    });
+
+    // Iterate and print keys and values of unordered map
+    c_foreach (n, cmap_str, umap) {
+        printf("Key:[%s] Value:[%s]\n", cstr_str(&n.ref->first), cstr_str(&n.ref->second));
     }
+
+    // Add two new entries to the unordered map
+    cmap_str_emplace(&umap, "BLACK", "#000000");
+    cmap_str_emplace(&umap, "WHITE", "#FFFFFF");
+
+    // Output values by key
+    printf("The HEX of color RED is:[%s]\n", cstr_str(cmap_str_at(&umap, "RED")));
+    printf("The HEX of color BLACK is:[%s]\n", cstr_str(cmap_str_at(&umap, "BLACK")));
+
+    cmap_str_drop(&umap);
 }
 ```
 Output:
@@ -161,33 +160,33 @@ The HEX of color BLACK is:[#000000]
 This example uses a cmap with cstr as mapped value.
 ```c
 #include <stc/cstr.h>
-
+#define i_type IDMap
 #define i_key int
 #define i_val_str
-#define i_tag id
 #include <stc/cmap.h>
 
 int main()
 {
     uint32_t col = 0xcc7744ff;
 
-    c_auto (cmap_id, idnames)
-    {
-        c_forlist (i, cmap_id_raw, { {100, "Red"}, {110, "Blue"} })
-            cmap_id_emplace(&idnames, c_PAIR(i.ref));
-
-        // replace existing mapped value:
-        cmap_id_emplace_or_assign(&idnames, 110, "White");
-        
-        // insert a new constructed mapped string into map:
-        cmap_id_insert_or_assign(&idnames, 120, cstr_from_fmt("#%08x", col));
-        
-        // emplace/insert does nothing if key already exist:
-        cmap_id_emplace(&idnames, 100, "Green");
-
-        c_foreach (i, cmap_id, idnames)
-            printf("%d: %s\n", i.ref->first, cstr_str(&i.ref->second));
-    }
+    IDMap idnames = {0};
+
+    c_forlist (i, IDMap_raw, { {100, "Red"}, {110, "Blue"} })
+        IDMap_emplace(&idnames, i.ref->first, i.ref->second);
+
+    // replace existing mapped value:
+    IDMap_emplace_or_assign(&idnames, 110, "White");
+    
+    // insert a new constructed mapped string into map:
+    IDMap_insert_or_assign(&idnames, 120, cstr_from_fmt("#%08x", col));
+    
+    // emplace/insert does nothing if key already exist:
+    IDMap_emplace(&idnames, 100, "Green");
+
+    c_foreach (i, IDMap, idnames)
+        printf("%d: %s\n", i.ref->first, cstr_str(&i.ref->second));
+
+    IDMap_drop(&idnames);
 }
 ```
 Output:
@@ -212,16 +211,17 @@ typedef struct { int x, y, z; } Vec3i;
 int main()
 {
     // Define map with defered destruct
-    c_with (cmap_vi vecs = cmap_vi_init(), cmap_vi_drop(&vecs))
-    {
-        cmap_vi_insert(&vecs, (Vec3i){100,   0,   0}, 1);
-        cmap_vi_insert(&vecs, (Vec3i){  0, 100,   0}, 2);
-        cmap_vi_insert(&vecs, (Vec3i){  0,   0, 100}, 3);
-        cmap_vi_insert(&vecs, (Vec3i){100, 100, 100}, 4);
-
-        c_forpair (v3, num, cmap_vi, vecs)
-            printf("{ %3d, %3d, %3d }: %d\n", _.v3->x, _.v3->y, _.v3->z, *_.num);
-    }
+    cmap_vi vecs = {0};
+
+    cmap_vi_insert(&vecs, (Vec3i){100,   0,   0}, 1);
+    cmap_vi_insert(&vecs, (Vec3i){  0, 100,   0}, 2);
+    cmap_vi_insert(&vecs, (Vec3i){  0,   0, 100}, 3);
+    cmap_vi_insert(&vecs, (Vec3i){100, 100, 100}, 4);
+
+    c_forpair (v3, num, cmap_vi, vecs)
+        printf("{ %3d, %3d, %3d }: %d\n", _.v3->x, _.v3->y, _.v3->z, *_.num);
+
+    cmap_vi_drop(&vecs);
 }
 ```
 Output:
@@ -245,16 +245,17 @@ typedef struct { int x, y, z; } Vec3i;
 
 int main()
 {
-    c_auto (cmap_iv, vecs) // shorthand for c_with with _init(), _drop().
-    {
-        cmap_iv_insert(&vecs, 1, (Vec3i){100,   0,   0});
-        cmap_iv_insert(&vecs, 2, (Vec3i){  0, 100,   0});
-        cmap_iv_insert(&vecs, 3, (Vec3i){  0,   0, 100});
-        cmap_iv_insert(&vecs, 4, (Vec3i){100, 100, 100});
-
-        c_forpair (num, v3, cmap_iv, vecs)
-            printf("%d: { %3d, %3d, %3d }\n", *_.num, _.v3->x, _.v3->y, _.v3->z);
-    }
+    cmap_iv vecs = {0}
+
+    cmap_iv_insert(&vecs, 1, (Vec3i){100,   0,   0});
+    cmap_iv_insert(&vecs, 2, (Vec3i){  0, 100,   0});
+    cmap_iv_insert(&vecs, 3, (Vec3i){  0,   0, 100});
+    cmap_iv_insert(&vecs, 4, (Vec3i){100, 100, 100});
+
+    c_forpair (num, v3, cmap_iv, vecs)
+        printf("%d: { %3d, %3d, %3d }\n", *_.num, _.v3->x, _.v3->y, _.v3->z);
+
+    cmap_iv_drop(&vecs);
 }
 ```
 Output:
@@ -300,35 +301,27 @@ static inline void Viking_drop(Viking* vk) {
 #define i_type Vikings
 #define i_keyclass Viking
 #define i_val int
-/*
- i_keyclass implies these defines, unless they are already defined:
-   #define i_cmp Viking_cmp
-   #define i_hash Viking_hash
-   #define i_keyclone Viking_clone
-   #define i_keydrop Viking_drop
-*/
 #include <stc/cmap.h>
 
 int main()
 {
     // Use a HashMap to store the vikings' health points.
-    c_auto (Vikings, vikings) // uses Vikings_init(), Vikings_drop()
-    {
-        Vikings_insert(&vikings, (Viking){cstr_lit("Einar"), cstr_lit("Norway")}, 25);
-        Vikings_insert(&vikings, (Viking){cstr_lit("Olaf"), cstr_lit("Denmark")}, 24);
-        Vikings_insert(&vikings, (Viking){cstr_lit("Harald"), cstr_lit("Iceland")}, 12);
-        Vikings_insert(&vikings, (Viking){cstr_lit("Einar"), cstr_lit("Denmark")}, 21);
-        
-        c_auto (Viking, lookup) {
-            lookup = (Viking){cstr_lit("Einar"), cstr_lit("Norway")};
-            printf("Lookup: Einar of Norway has %d hp\n\n", *Vikings_at(&vikings, lookup));
-        }
-
-        // Print the status of the vikings.
-        c_forpair (vik, hp, Vikings, vikings) {
-            printf("%s of %s has %d hp\n", cstr_str(&_.vik->name), cstr_str(&_.vik->country), *_.hp);
-        }
+    Vikings vikings = {0};
+
+    Vikings_insert(&vikings, (Viking){cstr_lit("Einar"), cstr_lit("Norway")}, 25);
+    Vikings_insert(&vikings, (Viking){cstr_lit("Olaf"), cstr_lit("Denmark")}, 24);
+    Vikings_insert(&vikings, (Viking){cstr_lit("Harald"), cstr_lit("Iceland")}, 12);
+    Vikings_insert(&vikings, (Viking){cstr_lit("Einar"), cstr_lit("Denmark")}, 21);
+    
+    Viking lookup = (Viking){cstr_lit("Einar"), cstr_lit("Norway")};
+    printf("Lookup: Einar of Norway has %d hp\n\n", *Vikings_at(&vikings, lookup));
+    Viking_drop(&lookup);
+
+    // Print the status of the vikings.
+    c_forpair (vik, hp, Vikings, vikings) {
+        printf("%s of %s has %d hp\n", cstr_str(&_.vik->name), cstr_str(&_.vik->country), *_.hp);
     }
+    Vikings_drop(&vikings);
 }
 ```
 Output:
@@ -384,30 +377,22 @@ static inline RViking Viking_toraw(const Viking* vp) {
 #define i_hash(rp)  (cstrhash(rp->name) ^ cstrhash(rp->country))
 #define i_val       int
 #include <stc/cmap.h>
-/*
- i_keyclass implies these defines, unless they are already defined:
-   #define i_cmp      RViking_cmp
-   //#define i_hash   RViking_hash       // already defined above.
-   //#define i_keyclone Viking_clone     // not used because c_no_clone
-   #define i_keyto    Viking_toraw       // because i_keyraw type is defined
-   #define i_keydrop  Viking_drop
-*/
 
 int main()
 {
-    c_auto (Vikings, vikings)
-    {
-        Vikings_emplace(&vikings, (RViking){"Einar", "Norway"}, 20);
-        Vikings_emplace(&vikings, (RViking){"Olaf", "Denmark"}, 24);
-        Vikings_emplace(&vikings, (RViking){"Harald", "Iceland"}, 12);
-        Vikings_emplace(&vikings, (RViking){"Björn", "Sweden"}, 10);
-
-        Vikings_value *v = Vikings_get_mut(&vikings, (RViking){"Einar", "Norway"});
-        if (v) v->second += 3; // add 3 hp points to Einar
-
-        c_forpair (vk, hp, Vikings, vikings) {
-            printf("%s of %s has %d hp\n", cstr_str(&_.vk->name), cstr_str(&_.vk->country), *_.hp);
-        }
+    Vikings vikings = {0};
+
+    Vikings_emplace(&vikings, (RViking){"Einar", "Norway"}, 20);
+    Vikings_emplace(&vikings, (RViking){"Olaf", "Denmark"}, 24);
+    Vikings_emplace(&vikings, (RViking){"Harald", "Iceland"}, 12);
+    Vikings_emplace(&vikings, (RViking){"Björn", "Sweden"}, 10);
+
+    Vikings_value *v = Vikings_get_mut(&vikings, (RViking){"Einar", "Norway"});
+    if (v) v->second += 3; // add 3 hp points to Einar
+
+    c_forpair (vk, hp, Vikings, vikings) {
+        printf("%s of %s has %d hp\n", cstr_str(&_.vk->name), cstr_str(&_.vk->country), *_.hp);
     }
+    Vikings_drop(&vikings);
 }
 ```
diff --git a/docs/coption_api.md b/docs/coption_api.md
index be0d0978..1e85ac2a 100644
--- a/docs/coption_api.md
+++ b/docs/coption_api.md
@@ -66,6 +66,4 @@ int main(int argc, char *argv[]) {
         printf(" %s", argv[i]);
     putchar('\n');
 }
-    return 0;
-}
 ```
diff --git a/docs/cpque_api.md b/docs/cpque_api.md
index 991623d7..b3a1a9ec 100644
--- a/docs/cpque_api.md
+++ b/docs/cpque_api.md
@@ -75,24 +75,24 @@ int main()
     stc64_t rng = stc64_new(1234);
     stc64_uniform_t dist = stc64_uniform_new(0, N * 10);
 
-    // Declare heap, with defered drop()
-    c_auto (cpque_i, heap)
-    {
-        // Push ten million random numbers to priority queue.
-        c_forrange (N)
-            cpque_i_push(&heap, stc64_uniform(&rng, &dist));
-
-        // Add some negative ones.
-        int nums[] = {-231, -32, -873, -4, -343};
-        c_forrange (i, c_ARRAYLEN(nums)) 
-            cpque_i_push(&heap, nums[i]);
-
-        // Extract and display the fifty smallest.
-        c_forrange (50) {
-            printf("%" PRId64 " ", *cpque_i_top(&heap));
-            cpque_i_pop(&heap);
-        }
+    // Define heap
+    cpque_i heap = {0};
+
+    // Push ten million random numbers to priority queue.
+    c_forrange (N)
+        cpque_i_push(&heap, stc64_uniform(&rng, &dist));
+
+    // Add some negative ones.
+    int nums[] = {-231, -32, -873, -4, -343};
+    c_forrange (i, c_ARRAYLEN(nums)) 
+        cpque_i_push(&heap, nums[i]);
+
+    // Extract and display the fifty smallest.
+    c_forrange (50) {
+        printf("%" PRId64 " ", *cpque_i_top(&heap));
+        cpque_i_pop(&heap);
     }
+    cpque_i_drop(&heap);
 }
 ```
 Output:
diff --git a/docs/cset_api.md b/docs/cset_api.md
index 287f7636..a0af357f 100644
--- a/docs/cset_api.md
+++ b/docs/cset_api.md
@@ -80,37 +80,35 @@ cset_X_value        cset_X_value_clone(cset_X_value val);
 ## Example
 ```c
 #include <stc/cstr.h>
-
+#define i_type Strset
 #define i_key_str
 #include <stc/cset.h>
 
 int main ()
 {
-    c_auto (cset_str, fifth)
-    {
-        c_auto (cset_str, first, second)
-        c_auto (cset_str, third, fourth)
-        {
-            second = c_make(cset_str, {"red", "green", "blue"});
-
-            c_forlist (i, const char*, {"orange", "pink", "yellow"})
-                cset_str_emplace(&third, *i.ref);
-
-            cset_str_emplace(&fourth, "potatoes");
-            cset_str_emplace(&fourth, "milk");
-            cset_str_emplace(&fourth, "flour");
-
-            fifth = cset_str_clone(second);
-            c_foreach (i, cset_str, third)
-                cset_str_emplace(&fifth, cstr_str(i.ref));
-
-            c_foreach (i, cset_str, fourth)
-                cset_str_emplace(&fifth, cstr_str(i.ref));
-        }
-        printf("fifth contains:\n\n");
-        c_foreach (i, cset_str, fifth)
-            printf("%s\n", cstr_str(i.ref));
-    }
+    Strset first, second={0}, third={0}, fourth={0}, fifth;
+
+    first = c_make(Strset, {"red", "green", "blue"});
+    fifth = Strset_clone(second);
+
+    c_forlist (i, const char*, {"orange", "pink", "yellow"})
+        Strset_emplace(&third, *i.ref);
+
+    c_foreach (i, Strset, third)
+        Strset_insert(&fifth, cstr_clone(*i.ref));
+
+    Strset_emplace(&fourth, "potatoes");
+    Strset_emplace(&fourth, "milk");
+    Strset_emplace(&fourth, "flour");
+
+    c_foreach (i, Strset, fourth)
+        Strset_emplace(&fifth, cstr_str(i.ref));
+
+    printf("fifth contains:\n\n");
+    c_foreach (i, Strset, fifth)
+        printf("%s\n", cstr_str(i.ref));
+
+    c_drop(Strset, &first, &second, &third, &fourth, &fifth);
 }
 ```
 Output:
diff --git a/docs/csmap_api.md b/docs/csmap_api.md
index 8e5780e3..da0e6915 100644
--- a/docs/csmap_api.md
+++ b/docs/csmap_api.md
@@ -112,27 +112,26 @@ csmap_X_raw           csmap_X_value_toraw(csmap_X_value* pval);
 int main()
 {
     // Create a sorted map of three strings (maps to string)
-    c_auto (csmap_str, colors) // RAII
-    {
-        colors = c_make(csmap_str, {
-            {"RED", "#FF0000"},
-            {"GREEN", "#00FF00"},
-            {"BLUE", "#0000FF"}
-        });
-
-        // Iterate and print keys and values of sorted map
-        c_foreach (i, csmap_str, colors) {
-            printf("Key:[%s] Value:[%s]\n", cstr_str(&i.ref->first), cstr_str(&i.ref->second));
-        }
-
-        // Add two new entries to the sorted map
-        csmap_str_emplace(&colors, "BLACK", "#000000");
-        csmap_str_emplace(&colors, "WHITE", "#FFFFFF");
-
-        // Output values by key
-        printf("The HEX of color RED is:[%s]\n", cstr_str(csmap_str_at(&colors, "RED")));
-        printf("The HEX of color BLACK is:[%s]\n", cstr_str(csmap_str_at(&colors, "BLACK")));
+    csmap_str colors = c_make(csmap_str, {
+        {"RED", "#FF0000"},
+        {"GREEN", "#00FF00"},
+        {"BLUE", "#0000FF"}
+    });
+
+    // Iterate and print keys and values of sorted map
+    c_foreach (i, csmap_str, colors) {
+        printf("Key:[%s] Value:[%s]\n", cstr_str(&i.ref->first), cstr_str(&i.ref->second));
     }
+
+    // Add two new entries to the sorted map
+    csmap_str_emplace(&colors, "BLACK", "#000000");
+    csmap_str_emplace(&colors, "WHITE", "#FFFFFF");
+
+    // Output values by key
+    printf("The HEX of color RED is:[%s]\n", cstr_str(csmap_str_at(&colors, "RED")));
+    printf("The HEX of color BLACK is:[%s]\n", cstr_str(csmap_str_at(&colors, "BLACK")));
+
+    csmap_str_drop(&colors);
 }
 ```
 Output:
@@ -149,32 +148,29 @@ This example uses a csmap with cstr as mapped value.
 ```c
 #include <stc/cstr.h>
 
+#define i_type IDSMap
 #define i_key int
 #define i_val_str
-#define i_tag id
 #include <stc/csmap.h>
 
 int main()
 {
     uint32_t col = 0xcc7744ff;
-    csmap_id idnames = csmap_id_init();
-    c_defer (csmap_id_drop(&idnames)) 
-    {
-        c_forlist (i, csmap_id_raw, { {100, "Red"}, {110, "Blue"} })
-            csmap_id_emplace(&idnames, c_PAIR(i.ref));
+    IDSMap idnames = c_make(IDSMap, { {100, "Red"}, {110, "Blue"} });
 
-        // put replaces existing mapped value:
-        csmap_id_emplace_or_assign(&idnames, 110, "White");
+    // Assign/overwrite an existing mapped value with a const char*
+    IDSMap_emplace_or_assign(&idnames, 110, "White");
 
-        // put a constructed mapped value into map:
-        csmap_id_insert_or_assign(&idnames, 120, cstr_from_fmt("#%08x", col));
+    // Insert (or assign) a new cstr
+    IDSMap_insert_or_assign(&idnames, 120, cstr_from_fmt("#%08x", col));
 
-        // emplace adds only when key does not exist:
-        csmap_id_emplace(&idnames, 100, "Green");
+    // emplace() adds only when key does not already exist:
+    IDSMap_emplace(&idnames, 100, "Green"); // ignored
 
-        c_foreach (i, csmap_id, idnames)
-            printf("%d: %s\n", i.ref->first, cstr_str(&i.ref->second));
-    }
+    c_foreach (i, IDSMap, idnames)
+        printf("%d: %s\n", i.ref->first, cstr_str(&i.ref->second));
+
+    IDSMap_drop(&idnames);
 }
 ```
 Output:
@@ -205,16 +201,17 @@ static int Vec3i_cmp(const Vec3i* a, const Vec3i* b) {
 
 int main()
 {
-    c_auto (csmap_vi, vecs)
-    {
-      csmap_vi_insert(&vecs, (Vec3i){100, 0, 0}, 1);
-      csmap_vi_insert(&vecs, (Vec3i){0, 100, 0}, 2);
-      csmap_vi_insert(&vecs, (Vec3i){0, 0, 100}, 3);
-      csmap_vi_insert(&vecs, (Vec3i){100, 100, 100}, 4);
-
-      c_foreach (i, csmap_vi, vecs)
-          printf("{ %3d, %3d, %3d }: %d\n", i.ref->first.x, i.ref->first.y, i.ref->first.z, i.ref->second);
-    }
+    csmap_vi vmap = {0};
+
+    csmap_vi_insert(&vmap, (Vec3i){100, 0, 0}, 1);
+    csmap_vi_insert(&vmap, (Vec3i){0, 100, 0}, 2);
+    csmap_vi_insert(&vmap, (Vec3i){0, 0, 100}, 3);
+    csmap_vi_insert(&vmap, (Vec3i){100, 100, 100}, 4);
+
+    c_forpair (v, n, csmap_vi, vmap)
+        printf("{ %3d, %3d, %3d }: %d\n", _.v->x, _.v->y, _.v->z, *_.n);
+
+    csmap_vi_drop(&vmap)
 }
 ```
 Output:
@@ -238,17 +235,17 @@ typedef struct { int x, y, z; } Vec3i;
 
 int main()
 {
-    // equivalent to: c_auto (csmap_iv, vecs)
-    c_with (csmap_iv vecs = csmap_iv_init(), csmap_iv_drop(&vecs))
-    {
-        csmap_iv_insert(&vecs, 1, (Vec3i){100, 0, 0});
-        csmap_iv_insert(&vecs, 2, (Vec3i){0, 100, 0});
-        csmap_iv_insert(&vecs, 3, (Vec3i){0, 0, 100});
-        csmap_iv_insert(&vecs, 4, (Vec3i){100, 100, 100});
-
-        c_foreach (i, csmap_iv, vecs)
-            printf("%d: { %3d, %3d, %3d }\n", i.ref->first, i.ref->second.x, i.ref->second.y, i.ref->second.z);
-    }
+    csmap_iv imap = {0};
+
+    csmap_iv_insert(&imap, 1, (Vec3i){100, 0, 0});
+    csmap_iv_insert(&imap, 2, (Vec3i){0, 100, 0});
+    csmap_iv_insert(&imap, 3, (Vec3i){0, 0, 100});
+    csmap_iv_insert(&imap, 4, (Vec3i){100, 100, 100});
+
+    c_forpair (n, v, csmap_iv, imap)
+        printf("%d: { %3d, %3d, %3d }\n", *_.n, _.v->x, _.v->y, _.v->z);
+    
+    csmap_iv_drop(&imap);
 }
 ```
 Output:
diff --git a/docs/cspan_api.md b/docs/cspan_api.md
index 1e60a526..10565b0f 100644
--- a/docs/cspan_api.md
+++ b/docs/cspan_api.md
@@ -136,7 +136,7 @@ int main() {
 ## Example 2
 Slicing cspan without and with reducing the rank:
 ```c
-#include <c11/fmt.h>
+#include <c11/print.h>
 #include <stc/cspan.h>
 
 using_cspan3(Span, int); // Shorthand to define Span, Span2, and Span3
@@ -154,7 +154,7 @@ int main()
 
     puts("\niterate span2 flat:");
     c_foreach (i, Span2, span2)
-        fmt_print(" {}", *i.ref);
+        print(" {}", *i.ref);
     puts("");
 
     // slice without reducing rank:
@@ -164,26 +164,23 @@ int main()
     c_forrange (i, ss3.shape[0]) {
         c_forrange (j, ss3.shape[1]) {
             c_forrange (k, ss3.shape[2])
-                fmt_print(" {:2}", *cspan_at(&ss3, i, j, k));
-            fmt_print(" |");
+                print(" {:2}", *cspan_at(&ss3, i, j, k));
+            print(" |");
         }
-        puts("");
     }
     // slice and reduce rank:
     Span2 ss2 = cspan_slice(Span2, &span3, {c_ALL}, {3}, {c_ALL});
 
     puts("\niterate ss2 by dimensions:");
     c_forrange (i, ss2.shape[0]) {
-        c_forrange (j, ss2.shape[1]) {
-                fmt_print(" {:2}", *cspan_at(&ss2, i, j));
-            fmt_print(" |");
-        }
-        puts("");
+        c_forrange (j, ss2.shape[1])
+            print(" {:2}", *cspan_at(&ss2, i, j));
+        print(" |");
     }
 
     puts("\niterate ss2 flat:");
     c_foreach (i, Span2, ss2)
-        fmt_print(" {:2}", *i.ref);
+        print(" {:2}", *i.ref);
     puts("");
 }
 ```
diff --git a/docs/csset_api.md b/docs/csset_api.md
index 80ee1844..0989fd9b 100644
--- a/docs/csset_api.md
+++ b/docs/csset_api.md
@@ -80,33 +80,38 @@ csset_X_value        csset_X_value_clone(csset_X_value val);
 ```c
 #include <stc/cstr.h>
 
+#define i_type SSet
 #define i_key_str
 #include <stc/csset.h>
 
 int main ()
 {
-    c_auto (csset_str, first, second, third)
-    c_auto (csset_str, fourth, fifth)
-    {
-        second = c_make(csset_str, {"red", "green", "blue"});
-
-        c_forlist (i, const char*, {"orange", "pink", "yellow"})
-            csset_str_emplace(&third, *i.ref);
-
-        csset_str_emplace(&fourth, "potatoes");
-        csset_str_emplace(&fourth, "milk");
-        csset_str_emplace(&fourth, "flour");
-
-        fifth = csset_str_clone(second);
-        c_foreach (i, csset_str, third)
-            csset_str_emplace(&fifth, cstr_str(i.ref));
-        c_foreach (i, csset_str, fourth)
-            csset_str_emplace(&fifth, cstr_str(i.ref));
-
-        printf("fifth contains:\n\n");
-        c_foreach (i, csset_str, fifth)
-            printf("%s\n", cstr_str(i.ref));
-    }
+    SSet second={0}, third={0}, fourth={0}, fifth={0};
+
+    second = c_make(SSet, {"red", "green", "blue"});
+
+    c_forlist (i, const char*, {"orange", "pink", "yellow"})
+        SSet_emplace(&third, *i.ref);
+
+    SSet_emplace(&fourth, "potatoes");
+    SSet_emplace(&fourth, "milk");
+    SSet_emplace(&fourth, "flour");
+
+    // Copy all to fifth:
+    
+    fifth = SSet_clone(second);
+
+    c_foreach (i, SSet, third)
+        SSet_emplace(&fifth, cstr_str(i.ref));
+
+    c_foreach (i, SSet, fourth)
+        SSet_emplace(&fifth, cstr_str(i.ref));
+
+    printf("fifth contains:\n\n");
+    c_foreach (i, SSet, fifth)
+        printf("%s\n", cstr_str(i.ref));
+
+    c_drop(SSet, &second, &third, &fourth, &fifth);
 }
 ```
 Output:
diff --git a/docs/cstr_api.md b/docs/cstr_api.md
index 64099675..64ad002c 100644
--- a/docs/cstr_api.md
+++ b/docs/cstr_api.md
@@ -160,7 +160,12 @@ char*        cstrnstrn(const char* str, const char* search, intptr_t slen, intpt
 #include <stc/cstr.h>
 
 int main() {
-    c_auto (cstr, s0, s1, full_path) {
+    cstr s0, s1, full_path;
+    c_defer(
+        cstr_drop(&s0),
+        cstr_drop(&s1),
+        cstr_drop(&full_path)
+    ){
         s0 = cstr_lit("Initialization without using strlen().");
         printf("%s\nLength: %" c_ZI "\n\n", cstr_str(&s0), cstr_size(&s0));
 
diff --git a/docs/csview_api.md b/docs/csview_api.md
index 33e61f0e..ec3bf121 100644
--- a/docs/csview_api.md
+++ b/docs/csview_api.md
@@ -151,14 +151,15 @@ red Apples
 
 int main()
 {
-    c_auto (cstr, s1) {
-        s1 = cstr_lit("hell😀 w😀rld");
-        cstr_u8_replace_at(&s1, cstr_find(&s1, "😀rld"), 1, c_sv("ø"));
-        printf("%s\n", cstr_str(&s1));
-
-        c_foreach (i, cstr, s1)
-            printf("%.*s,", c_SV(i.u8.chr));
-    }
+    cstr s1 = cstr_lit("hell😀 w😀rld");
+
+    cstr_u8_replace_at(&s1, cstr_find(&s1, "😀rld"), 1, c_sv("ø"));
+    printf("%s\n", cstr_str(&s1));
+
+    c_foreach (i, cstr, s1)
+        printf("%.*s,", c_SV(i.u8.chr));
+
+    cstr_drop(&s1);
 }
 ```
 Output:
@@ -178,6 +179,7 @@ void print_split(csview input, const char* sep)
 {
     c_fortoken_sv (i, input, sep)
         printf("[%.*s]\n", c_SV(i.token));
+    puts("");
 }
 
 #include <stc/cstr.h>
@@ -197,13 +199,15 @@ cstack_str string_split(csview input, const char* sep)
 int main()
 {
     print_split(c_sv("//This is a//double-slash//separated//string"), "//");
-    puts("");
     print_split(c_sv("This has no matching separator"), "xx");
+
+    cstack_str s = string_split(c_sv("Split,this,,string,now,"), ",");
+
+    c_foreach (i, cstack_str, s)
+        printf("[%s]\n", cstr_str(i.ref));
     puts("");
 
-    c_with (cstack_str s = string_split(c_sv("Split,this,,string,now,"), ","), cstack_str_drop(&s))
-        c_foreach (i, cstack_str, s)
-            printf("[%s]\n", cstr_str(i.ref));
+    cstack_str_drop(&s);
 }
 ```
 Output:
diff --git a/docs/cvec_api.md b/docs/cvec_api.md
index 68e08cb2..5879bc1f 100644
--- a/docs/cvec_api.md
+++ b/docs/cvec_api.md
@@ -119,29 +119,29 @@ cvec_X_value        cvec_X_value_clone(cvec_X_value val);
 int main()
 {
     // Create a vector containing integers
-    c_auto (cvec_int, vec)
-    {
-        // Add two integers to vector
-        cvec_int_push(&vec, 25);
-        cvec_int_push(&vec, 13);
-
-        // Append a set of numbers
-        c_forlist (i, int, {7, 5, 16, 8})
-            cvec_int_push(&vec, *i.ref);
-
-        printf("initial:");
-        c_foreach (k, cvec_int, vec) {
-            printf(" %d", *k.ref);
-        }
-
-        // Sort the vector
-        cvec_int_sort(&vec);
-
-        printf("\nsorted:");
-        c_foreach (k, cvec_int, vec) {
-            printf(" %d", *k.ref);
-        }
+    cvec_int vec = {0};
+
+    // Add two integers to vector
+    cvec_int_push(&vec, 25);
+    cvec_int_push(&vec, 13);
+
+    // Append a set of numbers
+    c_forlist (i, int, {7, 5, 16, 8})
+        cvec_int_push(&vec, *i.ref);
+
+    printf("initial:");
+    c_foreach (k, cvec_int, vec) {
+        printf(" %d", *k.ref);
+    }
+
+    // Sort the vector
+    cvec_int_sort(&vec);
+
+    printf("\nsorted:");
+    c_foreach (k, cvec_int, vec) {
+        printf(" %d", *k.ref);
     }
+    cvec_int_drop(&vec);
 }
 ```
 Output:
@@ -212,7 +212,7 @@ User User_clone(User user) {
 #include <stc/cvec.h>
 
 int main(void) {
-    UVec vec = UVec_init();
+    UVec vec = {0};
     UVec_push(&vec, (User){cstr_lit("mary"), 0});
     UVec_push(&vec, (User){cstr_lit("joe"), 1});
     UVec_push(&vec, (User){cstr_lit("admin"), 2});