From 900295256d825fc323149cd223c49787f32a3696 Mon Sep 17 00:00:00 2001
From: tylov <tylo@norceresearch.no>
Date: Thu, 20 Jul 2023 15:09:10 +0200
Subject: Moved examples to sub-directories. Added cotask1.c cotask2.c
 examples.

---
 misc/examples/coroutines/triples.c | 72 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 72 insertions(+)
 create mode 100644 misc/examples/coroutines/triples.c

(limited to 'misc/examples/coroutines/triples.c')

diff --git a/misc/examples/coroutines/triples.c b/misc/examples/coroutines/triples.c
new file mode 100644
index 00000000..9f2fcc1e
--- /dev/null
+++ b/misc/examples/coroutines/triples.c
@@ -0,0 +1,72 @@
+// https://quuxplusone.github.io/blog/2019/03/06/pythagorean-triples/
+
+#include <stc/algo/coroutine.h>
+#include <stdio.h>
+
+int gcd(int a, int b) {
+    while (b) {
+        int t = a % b;
+        a = b;
+        b = t;
+    }
+    return a;
+}
+
+void triples_vanilla(int n) {
+    for (int c = 5, i = 0; n; ++c) {
+        for (int a = 1; a < c; ++a) {
+            for (int b = a + 1; b < c; ++b) {
+                if ((int64_t)a*a + (int64_t)b*b == (int64_t)c*c && gcd(a, b) == 1) {
+                    printf("%d: {%d, %d, %d}\n", ++i, a, b, c);
+                    if (--n == 0) goto done;
+                }
+            }
+        }
+    }
+    done:;
+}
+
+struct triples {
+    int size, count;
+    int a, b, c;
+    int cco_state;
+};
+
+int triples_coro(struct triples* t) {
+    cco_routine(t) {
+        t->count = 0;
+        for (t->c = 5; t->size; ++t->c) {
+            for (t->a = 1; t->a < t->c; ++t->a) {
+                for (t->b = t->a + 1; t->b < t->c; ++t->b) {
+                    if ((int64_t)t->a*t->a + (int64_t)t->b*t->b == (int64_t)t->c*t->c) {
+                        if (t->count++ == t->size)
+                            cco_return;
+                        cco_yield();
+                    }
+                }
+            }
+        }
+        cco_cleanup:
+        puts("done");
+    }
+    return 0;
+}
+
+int main(void)
+{
+    puts("Vanilla triples:");
+    triples_vanilla(5);
+
+    puts("\nCoroutine triples:");
+    struct triples t = {.size=INT32_MAX};
+    int n = 0;
+
+    while (triples_coro(&t)) {
+        if (gcd(t.a, t.b) > 1)
+            continue;
+        if (t.c < 100)
+            printf("%d: {%d, %d, %d}\n", ++n, t.a, t.b, t.c);
+        else
+            cco_stop(&t);
+    }
+}
-- 
cgit v1.2.3


From 2d67f4040f6eecd41f1b864b43c62823ed75aff0 Mon Sep 17 00:00:00 2001
From: tylov <tylo@norceresearch.no>
Date: Fri, 21 Jul 2023 00:37:28 +0200
Subject: Renamed badly abbreviated names in crand.h. Moved coroutine.h from
 algo subfolder to stc. Updated coroutine.h and docs.

---
 docs/ccommon_api.md                            |   7 +-
 docs/cpque_api.md                              |   4 +-
 docs/crandom_api.md                            |  47 +++--
 include/stc/algo/coroutine.h                   | 274 -------------------------
 include/stc/algorithm.h                        |   8 +
 include/stc/calgo.h                            |   9 -
 include/stc/coroutine.h                        | 273 ++++++++++++++++++++++++
 include/stc/crand.h                            |  43 ++--
 misc/examples/algorithms/forfilter.c           |   3 +-
 misc/examples/algorithms/forloops.c            |   2 +-
 misc/examples/algorithms/random.c              |  20 +-
 misc/examples/bitsets/prime.c                  |  22 +-
 misc/examples/coroutines/cointerleave.c        |   2 +-
 misc/examples/coroutines/coread.c              |   2 +-
 misc/examples/coroutines/coroutines.c          |   2 +-
 misc/examples/coroutines/cotasks1.c            |   2 +-
 misc/examples/coroutines/cotasks2.c            |  12 +-
 misc/examples/coroutines/dining_philosophers.c |   2 +-
 misc/examples/coroutines/generator.c           |   2 +-
 misc/examples/coroutines/scheduler.c           |   2 +-
 misc/examples/coroutines/triples.c             |   2 +-
 misc/examples/linkedlists/list.c               |   2 +-
 misc/examples/make.sh                          |   8 +-
 misc/examples/priorityqueues/priority.c        |   6 +-
 misc/examples/queues/new_queue.c               |   6 +-
 misc/examples/queues/queue.c                   |   8 +-
 misc/examples/sortedmaps/gauss2.c              |   4 +-
 misc/examples/spans/mdspan.c                   |  51 +++++
 28 files changed, 436 insertions(+), 389 deletions(-)
 delete mode 100644 include/stc/algo/coroutine.h
 create mode 100644 include/stc/algorithm.h
 delete mode 100644 include/stc/calgo.h
 create mode 100644 include/stc/coroutine.h
 create mode 100644 misc/examples/spans/mdspan.c

(limited to 'misc/examples/coroutines/triples.c')

diff --git a/docs/ccommon_api.md b/docs/ccommon_api.md
index 1e1ae1aa..9189d7e8 100644
--- a/docs/ccommon_api.md
+++ b/docs/ccommon_api.md
@@ -392,8 +392,7 @@ cco_routine scope; Use `if-else-if` constructs instead.
 |           | `cco_return;`                        | Return from coroutine (inside cco_routine) |
 |           | Task objects:                        |                                         |
 |           | `cco_task_struct(Name, ...);`        | Define a coroutine task struct          |
-|           | `cco_await_task(task, ...);`         | Await for task to finish or optionally yield a value |
-|           | `cco_block_task(task);`              | Run blocking until task is finished (stackless) |
+|           | `cco_task_await(task, ...);`         | Await for task to finish or optionally yield a value |
 |           | Semaphores:                          |                                         | 
 |           | `cco_sem`                            | Semaphore type                          |
 | `cco_sem` | `cco_sem_from(long value)`           | Create semaphore                        |
@@ -414,7 +413,9 @@ cco_routine scope; Use `if-else-if` constructs instead.
 | `void`    | `cco_stop(co)`                       | Next call of coroutine finalizes        |
 | `void`    | `cco_reset(co)`                      | Reset state to initial (for reuse)      |
 | `void`    | `cco_block_on(cocall) { }`           | Run blocking until cocall is finished   |
-| `void`    | `cco_block_on(cocall, int *result) { }`| Run blocking until cocall is finished |
+| `void`    | `cco_block_on(cocall, int *result) {}`| Run blocking until cocall is finished |
+|           | `cco_task_block_on(task) {}`         | Run blocking until task is finished |
+|           | `cco_task_block_on(task, rt, STACKSZ) {}`| Run blocking until task is finished |
 |           | Time functions:                      |                                         |
 | `double`  | `cco_time(void)`                     | Return secs with usec prec. since Epoch |
 |           | `cco_sleep(double sec)`              | Sleep for seconds (msec or usec prec.)  |
diff --git a/docs/cpque_api.md b/docs/cpque_api.md
index 4cde927b..247424b4 100644
--- a/docs/cpque_api.md
+++ b/docs/cpque_api.md
@@ -72,14 +72,14 @@ int main(void)
 {
     intptr_t N = 10000000;
     crand_t rng = crand_init(1234);
-    crand_unif_t dist = crand_unif_init(0, N * 10);
+    crand_uniform_t dist = crand_uniform_init(0, N * 10);
 
     // Define heap
     cpque_i heap = {0};
 
     // Push ten million random numbers to priority queue.
     c_forrange (N)
-        cpque_i_push(&heap, crand_unif(&rng, &dist));
+        cpque_i_push(&heap, crand_uniform(&rng, &dist));
 
     // Add some negative ones.
     int nums[] = {-231, -32, -873, -4, -343};
diff --git a/docs/crandom_api.md b/docs/crandom_api.md
index 22a4f4dd..88924784 100644
--- a/docs/crandom_api.md
+++ b/docs/crandom_api.md
@@ -1,30 +1,29 @@
 # STC [crand](../include/stc/crand.h): Pseudo Random Number Generator
 ![Random](pics/random.jpg)
 
-This features a *64-bit PRNG* named **stc64**, and can generate bounded uniform and normal
+This features a *64-bit PRNG* named **crand64**, and can generate bounded uniform and normal
 distributed random numbers.
 
 See [random](https://en.cppreference.com/w/cpp/header/random) for similar c++ functionality.
 
 ## Description
 
-**stc64** is a novel, extremely fast PRNG by Tyge Løvset, suited for parallel usage. It features
-Weyl-sequences as part of its state. It is inspired on *sfc64*, but has a different output function
+**crand64** is a novel, very fast PRNG, suited for parallel usage. It features a
+Weyl-sequence as part of its state. It is based on *sfc64*, but has a different output function
 and state size.
 
-**sfc64** is the fastest among *pcg*, *xoshiro`**`*, and *lehmer*. It is equally fast as *sfc64* on
-most platforms. *wyrand* is faster on platforms with fast 128-bit multiplication, and has 2^64 period
-length (https://github.com/lemire/SwiftWyhash/issues/10). However, *wyrand* is not suited for massive
-parallel usage due to its limited total minimal period length.
+**sfc64** is the fastest among *pcg*, *xoshiro`**`*, and *lehmer*. It is equally fast or faster than
+*sfc64* on most platforms. *wyrand* is faster on platforms with fast 128-bit multiplication, and has
+2^64 period (https://github.com/lemire/SwiftWyhash/issues/10). *wyrand* is not suited for massive
+parallel usage due to its limited minimal period.
 
-**stc64** does not require multiplication or 128-bit integer operations. It has 320 bit state,
-but updates only 256 bit per generated number.
+**crand64** does not require multiplication or 128-bit integer operations. It has 320 bit state,
+where 64-bits are constant per prng instance created.
 
 There is no *jump function*, but each odd number Weyl-increment (state[4]) starts a new
-unique 2^64 *minimum* length period. For a single thread, a minimum period of 2^127 is generated
-when the Weyl-increment is incremented by 2 every 2^64 output.
+unique 2^64 *minimum* length period, i.e. virtually unlimitied number of unique threads.
 
-**stc64** passes *PractRand* (tested up to 8TB output), Vigna's Hamming weight test, and simple
+**crand64** passes *PractRand* (tested up to 8TB output), Vigna's Hamming weight test, and simple
 correlation tests, i.e. *n* interleaved streams with only one-bit differences in initial state.
 Also 32-bit and 16-bit versions passes PractRand up to their size limits.
 
@@ -41,27 +40,27 @@ All crand definitions and prototypes are available by including a single header
 ## Methods
 
 ```c
-void                csrand(uint64_t seed);                                // seed global stc64 prng
+void                csrand(uint64_t seed);                                // seed global crand64 prng
 uint64_t            crand(void);                                          // global crand_u64(rng)
 double              crandf(void);                                         // global crand_f64(rng)
 
-crand_t             crand_init(uint64_t seed);                            // stc64_init(s) is deprecated
+crand_t             crand_init(uint64_t seed);
 uint64_t            crand_u64(crand_t* rng);                              // range [0, 2^64 - 1]
 double              crand_f64(crand_t* rng);                              // range [0.0, 1.0)
 
-crand_unif_t        crand_unif_init(int64_t low, int64_t high);           // uniform-distribution
-int64_t             crand_unif(crand_t* rng, crand_unif_t* dist);         // range [low, high]
+crand_uniform_t     crand_uniform_init(int64_t low, int64_t high);        // uniform-distribution range
+int64_t             crand_uniform(crand_t* rng, crand_uniform_t* dist);
 
-crand_norm_t        crand_norm_init(double mean, double stddev);          // normal-distribution
-double              crand_norm(crand_t* rng, crand_norm_t* dist);
+crand_normal_t      crand_normal_init(double mean, double stddev);        // normal-gauss distribution
+double              crand_normal(crand_t* rng, crand_normal_t* dist);
 ```
 ## Types
 
 | Name               | Type definition                           | Used to represent...         |
 |:-------------------|:------------------------------------------|:-----------------------------|
 | `crand_t`          | `struct {uint64_t state[4];}`             | The PRNG engine type         |
-| `crand_unif_t`     | `struct {int64_t lower; uint64_t range;}` | Integer uniform distribution |
-| `crand_norm_t`     | `struct {double mean, stddev;}`           | Normal distribution type     |
+| `crand_uniform_t`  | `struct {int64_t lower; uint64_t range;}` | Integer uniform distribution |
+| `crand_normal_t`   | `struct {double mean, stddev;}`           | Normal distribution type     |
 
 ## Example
 ```c
@@ -86,17 +85,17 @@ int main(void)
     // Setup random engine with normal distribution.
     uint64_t seed = time(NULL);
     crand_t rng = crand_init(seed);
-    crand_norm_t dist = crand_norm_init(Mean, StdDev);
+    crand_normal_t dist = crand_normal_init(Mean, StdDev);
 
     // Create histogram map
-    csmap_i mhist = csmap_i_init();
+    csmap_i mhist = {0};
     c_forrange (N) {
-        int index = (int)round(crand_norm(&rng, &dist));
+        int index = (int)round(crand_normal(&rng, &dist));
         csmap_i_emplace(&mhist, index, 0).ref->second += 1;
     }
 
     // Print the gaussian bar chart
-    cstr bar = cstr_init();
+    cstr bar = {0};
     c_foreach (i, csmap_i, mhist) {
         int n = (int)(i.ref->second * StdDev * Scale * 2.5 / N);
         if (n > 0) {
diff --git a/include/stc/algo/coroutine.h b/include/stc/algo/coroutine.h
deleted file mode 100644
index 7c6989c3..00000000
--- a/include/stc/algo/coroutine.h
+++ /dev/null
@@ -1,274 +0,0 @@
-/* MIT License
- *
- * Copyright (c) 2023 Tyge Løvset
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#ifndef STC_COROUTINE_INCLUDED
-#define STC_COROUTINE_INCLUDED
-/*
-#include <stdio.h>
-#include <stc/algo/coroutine.h>
-
-struct iterpair {
-    int max_x, max_y;
-    int x, y;
-    int cco_state; // required member
-};
-
-int iterpair(struct iterpair* I) {
-    cco_routine(I) {
-        for (I->x = 0; I->x < I->max_x; I->x++)
-            for (I->y = 0; I->y < I->max_y; I->y++)
-                cco_yield();
-
-        cco_cleanup: // required if there is cleanup code
-        puts("final");
-    }
-    return 0; // CCO_DONE
-}
-
-int main(void) {
-    struct iterpair it = {.max_x=3, .max_y=3};
-    int n = 0;
-    while (iterpair(&it))
-    {
-        printf("%d %d\n", it.x, it.y);
-        // example of early stop:
-        if (++n == 7) cco_stop(&it); // signal to stop/finalize in next
-    }
-    return 0;
-}
-*/
-#include "../ccommon.h"
-
-enum {
-    CCO_STATE_CLEANUP = -1,
-    CCO_STATE_DONE = -2,
-};
-typedef enum {
-    CCO_DONE = 0,
-    CCO_AWAIT = 1<<0,
-    CCO_YIELD = 1<<1,
-} cco_result;
-
-#define cco_initial(co) ((co)->cco_state == 0)
-#define cco_suspended(co) ((co)->cco_state > 0)
-#define cco_done(co) ((co)->cco_state == CCO_STATE_DONE)
-
-#define cco_routine(co) \
-    for (int *_state = &(co)->cco_state; *_state != CCO_STATE_DONE; *_state = CCO_STATE_DONE) \
-        _resume: switch (*_state) case 0: // thanks, @liigo!
-
-#define cco_yield() cco_yield_v(CCO_YIELD)
-#define cco_yield_v(ret) \
-    do { \
-        *_state = __LINE__; return ret; goto _resume; \
-        case __LINE__:; \
-    } while (0)
-
-#define cco_await(promise) cco_await_v_2(promise, CCO_AWAIT)
-#define cco_await_v(...) c_MACRO_OVERLOAD(cco_await_v, __VA_ARGS__)
-#define cco_await_v_1(promise) cco_await_v_2(promise, )
-#define cco_await_v_2(promise, ret) \
-    do { \
-        *_state = __LINE__; \
-        case __LINE__: if (!(promise)) {return ret; goto _resume;} \
-    } while (0)
-
-/* cco_await_on(): assumes coroutine returns a cco_result value (int) */
-#define cco_await_on(corocall) \
-    do { \
-        *_state = __LINE__; \
-        case __LINE__: { int _r = corocall; if (_r != CCO_DONE) {return _r; goto _resume;} } \
-    } while (0)
-
-/* cco_block_on(): assumes coroutine returns a cco_result value (int) */
-#define cco_block_on(...) c_MACRO_OVERLOAD(cco_block_on, __VA_ARGS__)
-#define cco_block_on_1(corocall) while ((corocall) != CCO_DONE)
-#define cco_block_on_2(corocall, result) while ((*(result) = (corocall)) != CCO_DONE)
-
-#define cco_cleanup \
-    *_state = CCO_STATE_CLEANUP; case CCO_STATE_CLEANUP
-
-#define cco_return \
-    do { \
-        *_state = *_state >= 0 ? CCO_STATE_CLEANUP : CCO_STATE_DONE; \
-        goto _resume; \
-    } while (0)
-
-#define cco_yield_final() cco_yield_final_v(CCO_YIELD)
-#define cco_yield_final_v(value) \
-    do { \
-        *_state = *_state >= 0 ? CCO_STATE_CLEANUP : CCO_STATE_DONE; \
-        return value; \
-    } while (0)
-
-#define cco_stop(co) \
-    do { \
-        int* _s = &(co)->cco_state; \
-        if (*_s > 0) *_s = CCO_STATE_CLEANUP; \
-        else if (*_s == 0) *_s = CCO_STATE_DONE; \
-    } while (0)
-
-#define cco_reset(co) \
-    (void)((co)->cco_state = 0)
-
-/*
- * Tasks (optional)
- */
-
-struct cco_runtime;
-
-#define cco_task_struct(Name, ...) \
-    struct Name { \
-        int (*cco_fn)(struct Name*, struct cco_runtime*); \
-        int cco_state, cco_expect; \
-        __VA_ARGS__ \
-    }
-
-typedef cco_task_struct(cco_task, /**/) cco_task;
-
-typedef struct cco_runtime { 
-    int result, top;
-    cco_task* stack[];
-} cco_runtime;
-
-#define cco_cast_task(task) \
-    ((cco_task *)(task) + 0*sizeof((task)->cco_fn(task, (cco_runtime*)0) + ((int*)0 == &(task)->cco_state)))
-
-#define cco_resume(task, rt) \
-    (task)->cco_fn(task, rt)
-
-#define cco_block_task(...) c_MACRO_OVERLOAD(cco_block_task, __VA_ARGS__)
-#define cco_block_task_1(task) cco_block_task_3(task, rt, 16)
-#define cco_block_task_3(task, rt, STACKDEPTH) \
-    for (struct { int result, top; cco_task* stack[STACKDEPTH]; } rt = {.stack={cco_cast_task(task)}}; \
-         (((rt.result = cco_resume(rt.stack[rt.top], (cco_runtime*)&rt)) & rt.stack[rt.top]->cco_expect) || --rt.top >= 0); )
-
-#define cco_await_task(...) c_MACRO_OVERLOAD(cco_await_task, __VA_ARGS__)
-#define cco_await_task_2(task, rt) cco_await_task_3(task, rt, CCO_DONE)
-#define cco_await_task_3(task, rt, resultbits) \
-    do { \
-        cco_runtime* _rt = rt; \
-        (_rt->stack[++_rt->top] = cco_cast_task(task))->cco_expect = ~(resultbits); \
-        cco_yield_v(CCO_AWAIT); \
-    } while (0)
-
-/*
- * Semaphore
- */
-
-typedef struct { intptr_t count; } cco_sem;
-
-#define cco_sem_await(sem) cco_sem_await_v_2(sem, CCO_AWAIT)
-#define cco_sem_await_v(...) c_MACRO_OVERLOAD(cco_sem_await_v, __VA_ARGS__)
-#define cco_sem_await_v_1(sem) cco_sem_await_v_2(sem, )
-#define cco_sem_await_v_2(sem, ret) \
-    do { \
-        cco_await_v_2((sem)->count > 0, ret); \
-        --(sem)->count; \
-    } while (0)
-
-#define cco_sem_release(sem) ++(sem)->count
-#define cco_sem_from(value) ((cco_sem){value})
-#define cco_sem_set(sem, value) ((sem)->count = value)
-
-/*
- * Timer
- */
-
-#ifdef _WIN32
-    #ifdef __cplusplus
-      #define _c_LINKC extern "C" __declspec(dllimport)
-    #else
-      #define _c_LINKC __declspec(dllimport) 
-    #endif
-    #if 1 // _WIN32_WINNT < _WIN32_WINNT_WIN8 || defined __TINYC__
-      #define _c_getsystime GetSystemTimeAsFileTime
-    #else
-      #define _c_getsystime GetSystemTimePreciseAsFileTime
-    #endif
-    struct _FILETIME;
-    _c_LINKC void _c_getsystime(struct _FILETIME*);
-    _c_LINKC void Sleep(unsigned long);
-
-    static inline double cco_time(void) { /* seconds since epoch */
-        unsigned long long quad;          /* 64-bit value representing 1/10th usecs since Jan 1 1601, 00:00 UTC */
-        _c_getsystime((struct _FILETIME*)&quad);
-        return (double)(quad - 116444736000000000ULL)*1e-7;  /* time diff Jan 1 1601-Jan 1 1970 in 1/10th usecs */
-    }
-
-    static inline void cco_sleep(double sec) {
-        Sleep((unsigned long)(sec*1000.0));
-    }
-#else
-    #include <sys/time.h>
-    static inline double cco_time(void) { /* seconds since epoch */
-        struct timeval tv;
-        gettimeofday(&tv, NULL);
-        return (double)tv.tv_sec + (double)tv.tv_usec*1e-6;
-    }
-
-    static inline void cco_sleep(double sec) {
-        struct timeval tv;
-        tv.tv_sec = (time_t)sec;
-        tv.tv_usec = (suseconds_t)((sec - (double)(long)sec)*1e6);
-        select(0, NULL, NULL, NULL, &tv);
-    }
-#endif
-
-typedef struct { double interval, start; } cco_timer;
-
-#define cco_timer_await(tm, sec) cco_timer_await_v_3(tm, sec, CCO_AWAIT)
-#define cco_timer_await_v(...) c_MACRO_OVERLOAD(cco_timer_await_v, __VA_ARGS__)
-#define cco_timer_await_v_2(tm, sec) cco_timer_await_v_3(tm, sec, )
-#define cco_timer_await_v_3(tm, sec, ret) \
-    do { \
-        cco_timer_start(tm, sec); \
-        cco_await_v_2(cco_timer_expired(tm), ret); \
-    } while (0)
-
-static inline void cco_timer_start(cco_timer* tm, double sec) {
-    tm->interval = sec;
-    tm->start = cco_time();
-}
-
-static inline cco_timer cco_timer_from(double sec) {
-    cco_timer tm = {.interval=sec, .start=cco_time()};
-    return tm;
-}
-
-static inline void cco_timer_restart(cco_timer* tm) {
-    tm->start = cco_time();
-}
-
-static inline bool cco_timer_expired(cco_timer* tm) {
-    return cco_time() - tm->start >= tm->interval;
-}
-
-static inline double cco_timer_elapsed(cco_timer* tm) {
-    return cco_time() - tm->start;
-}
-
-static inline double cco_timer_remaining(cco_timer* tm) {
-    return tm->start + tm->interval - cco_time();
-}
-
-#endif
diff --git a/include/stc/algorithm.h b/include/stc/algorithm.h
new file mode 100644
index 00000000..cf3ab328
--- /dev/null
+++ b/include/stc/algorithm.h
@@ -0,0 +1,8 @@
+#ifndef STC_CALGO_INCLUDED
+#define STC_CALGO_INCLUDED
+
+#include "algo/raii.h"
+#include "algo/crange.h"
+#include "algo/filter.h"
+
+#endif
diff --git a/include/stc/calgo.h b/include/stc/calgo.h
deleted file mode 100644
index 63ef97b9..00000000
--- a/include/stc/calgo.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#ifndef STC_CALGO_INCLUDED
-#define STC_CALGO_INCLUDED
-
-#include "algo/raii.h"
-#include "algo/crange.h"
-#include "algo/filter.h"
-#include "algo/coroutine.h"
-
-#endif
diff --git a/include/stc/coroutine.h b/include/stc/coroutine.h
new file mode 100644
index 00000000..f89d20af
--- /dev/null
+++ b/include/stc/coroutine.h
@@ -0,0 +1,273 @@
+/* MIT License
+ *
+ * Copyright (c) 2023 Tyge Løvset
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef STC_COROUTINE_INCLUDED
+#define STC_COROUTINE_INCLUDED
+/*
+#include <stdio.h>
+#include <stc/coroutine.h>
+
+struct iterpair {
+    int max_x, max_y;
+    int x, y;
+    int cco_state; // required member
+};
+
+int iterpair(struct iterpair* I) {
+    cco_routine(I) {
+        for (I->x = 0; I->x < I->max_x; I->x++)
+            for (I->y = 0; I->y < I->max_y; I->y++)
+                cco_yield();
+
+        cco_cleanup: // required if there is cleanup code
+        puts("final");
+    }
+    return 0; // CCO_DONE
+}
+
+int main(void) {
+    struct iterpair it = {.max_x=3, .max_y=3};
+    int n = 0;
+    while (iterpair(&it))
+    {
+        printf("%d %d\n", it.x, it.y);
+        // example of early stop:
+        if (++n == 7) cco_stop(&it); // signal to stop/finalize in next
+    }
+    return 0;
+}
+*/
+#include "ccommon.h"
+
+enum {
+    CCO_STATE_CLEANUP = -1,
+    CCO_STATE_DONE = -2,
+};
+typedef enum {
+    CCO_DONE = 0,
+    CCO_AWAIT = 1<<0,
+    CCO_YIELD = 1<<1,
+} cco_result;
+
+#define cco_initial(co) ((co)->cco_state == 0)
+#define cco_suspended(co) ((co)->cco_state > 0)
+#define cco_done(co) ((co)->cco_state == CCO_STATE_DONE)
+
+#define cco_routine(co) \
+    for (int* _state = &(co)->cco_state; *_state != CCO_STATE_DONE; *_state = CCO_STATE_DONE) \
+        _resume: switch (*_state) case 0: // thanks, @liigo!
+
+#define cco_yield() cco_yield_v(CCO_YIELD)
+#define cco_yield_v(ret) \
+    do { \
+        *_state = __LINE__; return ret; goto _resume; \
+        case __LINE__:; \
+    } while (0)
+
+#define cco_await(promise) cco_await_v_2(promise, CCO_AWAIT)
+#define cco_await_v(...) c_MACRO_OVERLOAD(cco_await_v, __VA_ARGS__)
+#define cco_await_v_1(promise) cco_await_v_2(promise, )
+#define cco_await_v_2(promise, ret) \
+    do { \
+        *_state = __LINE__; \
+        case __LINE__: if (!(promise)) {return ret; goto _resume;} \
+    } while (0)
+
+/* cco_await_on(): assumes coroutine returns a cco_result value (int) */
+#define cco_await_on(corocall) \
+    do { \
+        *_state = __LINE__; \
+        case __LINE__: { int _r = corocall; if (_r != CCO_DONE) {return _r; goto _resume;} } \
+    } while (0)
+
+/* cco_block_on(): assumes coroutine returns a cco_result value (int) */
+#define cco_block_on(...) c_MACRO_OVERLOAD(cco_block_on, __VA_ARGS__)
+#define cco_block_on_1(corocall) while ((corocall) != CCO_DONE)
+#define cco_block_on_2(corocall, result) while ((*(result) = (corocall)) != CCO_DONE)
+
+#define cco_cleanup \
+    *_state = CCO_STATE_CLEANUP; case CCO_STATE_CLEANUP
+
+#define cco_return \
+    do { \
+        *_state = *_state >= 0 ? CCO_STATE_CLEANUP : CCO_STATE_DONE; \
+        goto _resume; \
+    } while (0)
+
+#define cco_yield_final() cco_yield_final_v(CCO_YIELD)
+#define cco_yield_final_v(value) \
+    do { \
+        *_state = *_state >= 0 ? CCO_STATE_CLEANUP : CCO_STATE_DONE; \
+        return value; \
+    } while (0)
+
+#define cco_stop(co) \
+    do { \
+        int* _s = &(co)->cco_state; \
+        if (*_s > 0) *_s = CCO_STATE_CLEANUP; \
+        else if (*_s == 0) *_s = CCO_STATE_DONE; \
+    } while (0)
+
+#define cco_reset(co) \
+    (void)((co)->cco_state = 0)
+
+/*
+ * Tasks (optional)
+ */
+
+struct cco_runtime;
+
+#define cco_task_struct(Name, ...) \
+    struct Name { \
+        int (*cco_func)(struct Name*, struct cco_runtime*); \
+        int cco_state, cco_expect; \
+        __VA_ARGS__ \
+    }
+
+typedef cco_task_struct(cco_task, /**/) cco_task;
+
+typedef struct cco_runtime { 
+    int result, top; cco_task* stack[];
+} cco_runtime;
+
+#define cco_cast_task(task) \
+    ((cco_task *)(task) + 0*sizeof((task)->cco_func(task, (cco_runtime*)0) + ((int*)0 == &(task)->cco_state)))
+
+#define cco_resume(task, rt) \
+    (task)->cco_func(task, rt)
+
+#define cco_task_await(...) c_MACRO_OVERLOAD(cco_task_await, __VA_ARGS__)
+#define cco_task_await_2(task, rt) cco_task_await_3(task, rt, CCO_DONE)
+#define cco_task_await_3(task, rt, resultbits) \
+    do { \
+        cco_runtime* _rt = rt; \
+        (_rt->stack[++_rt->top] = cco_cast_task(task))->cco_expect = (resultbits); \
+        cco_yield_v(CCO_AWAIT); \
+    } while (0)
+
+#define cco_task_block_on(...) c_MACRO_OVERLOAD(cco_task_block_on, __VA_ARGS__)
+#define cco_task_block_on_1(task) cco_task_block_on_3(task, _rt, 16)
+#define cco_task_block_on_3(task, rt, STACKDEPTH) \
+    for (struct { int result, top; cco_task* stack[STACKDEPTH]; } rt = {.stack={cco_cast_task(task)}}; \
+         (((rt.result = cco_resume(rt.stack[rt.top], (cco_runtime*)&rt)) & ~rt.stack[rt.top]->cco_expect) || --rt.top >= 0); )
+
+/*
+ * Semaphore
+ */
+
+typedef struct { intptr_t count; } cco_sem;
+
+#define cco_sem_await(sem) cco_sem_await_v_2(sem, CCO_AWAIT)
+#define cco_sem_await_v(...) c_MACRO_OVERLOAD(cco_sem_await_v, __VA_ARGS__)
+#define cco_sem_await_v_1(sem) cco_sem_await_v_2(sem, )
+#define cco_sem_await_v_2(sem, ret) \
+    do { \
+        cco_await_v_2((sem)->count > 0, ret); \
+        --(sem)->count; \
+    } while (0)
+
+#define cco_sem_release(sem) ++(sem)->count
+#define cco_sem_from(value) ((cco_sem){value})
+#define cco_sem_set(sem, value) ((sem)->count = value)
+
+/*
+ * Timer
+ */
+
+#ifdef _WIN32
+    #ifdef __cplusplus
+      #define _c_LINKC extern "C" __declspec(dllimport)
+    #else
+      #define _c_LINKC __declspec(dllimport) 
+    #endif
+    #if 1 // _WIN32_WINNT < _WIN32_WINNT_WIN8 || defined __TINYC__
+      #define _c_getsystime GetSystemTimeAsFileTime
+    #else
+      #define _c_getsystime GetSystemTimePreciseAsFileTime
+    #endif
+    struct _FILETIME;
+    _c_LINKC void _c_getsystime(struct _FILETIME*);
+    _c_LINKC void Sleep(unsigned long);
+
+    static inline double cco_time(void) { /* seconds since epoch */
+        unsigned long long quad;          /* 64-bit value representing 1/10th usecs since Jan 1 1601, 00:00 UTC */
+        _c_getsystime((struct _FILETIME*)&quad);
+        return (double)(quad - 116444736000000000ULL)*1e-7;  /* time diff Jan 1 1601-Jan 1 1970 in 1/10th usecs */
+    }
+
+    static inline void cco_sleep(double sec) {
+        Sleep((unsigned long)(sec*1000.0));
+    }
+#else
+    #include <sys/time.h>
+    static inline double cco_time(void) { /* seconds since epoch */
+        struct timeval tv;
+        gettimeofday(&tv, NULL);
+        return (double)tv.tv_sec + (double)tv.tv_usec*1e-6;
+    }
+
+    static inline void cco_sleep(double sec) {
+        struct timeval tv;
+        tv.tv_sec = (time_t)sec;
+        tv.tv_usec = (suseconds_t)((sec - (double)(long)sec)*1e6);
+        select(0, NULL, NULL, NULL, &tv);
+    }
+#endif
+
+typedef struct { double interval, start; } cco_timer;
+
+#define cco_timer_await(tm, sec) cco_timer_await_v_3(tm, sec, CCO_AWAIT)
+#define cco_timer_await_v(...) c_MACRO_OVERLOAD(cco_timer_await_v, __VA_ARGS__)
+#define cco_timer_await_v_2(tm, sec) cco_timer_await_v_3(tm, sec, )
+#define cco_timer_await_v_3(tm, sec, ret) \
+    do { \
+        cco_timer_start(tm, sec); \
+        cco_await_v_2(cco_timer_expired(tm), ret); \
+    } while (0)
+
+static inline void cco_timer_start(cco_timer* tm, double sec) {
+    tm->interval = sec;
+    tm->start = cco_time();
+}
+
+static inline cco_timer cco_timer_from(double sec) {
+    cco_timer tm = {.interval=sec, .start=cco_time()};
+    return tm;
+}
+
+static inline void cco_timer_restart(cco_timer* tm) {
+    tm->start = cco_time();
+}
+
+static inline bool cco_timer_expired(cco_timer* tm) {
+    return cco_time() - tm->start >= tm->interval;
+}
+
+static inline double cco_timer_elapsed(cco_timer* tm) {
+    return cco_time() - tm->start;
+}
+
+static inline double cco_timer_remaining(cco_timer* tm) {
+    return tm->start + tm->interval - cco_time();
+}
+
+#endif
diff --git a/include/stc/crand.h b/include/stc/crand.h
index 0a6aa9e0..32722762 100644
--- a/include/stc/crand.h
+++ b/include/stc/crand.h
@@ -32,20 +32,20 @@
 int main(void) {
     uint64_t seed = 123456789;
     crand_t rng = crand_init(seed);
-    crand_unif_t dist1 = crand_unif_init(1, 6);
-    crand_norm_t dist3 = crand_norm_init(1.0, 10.0);
+    crand_uniform_t dist1 = crand_uniform_init(1, 6);
+    crand_normal_t dist3 = crand_normal_init(1.0, 10.0);
 
     uint64_t i = crand_u64(&rng);
-    int64_t iu = crand_unif(&rng, &dist1);
-    double xn = crand_norm(&rng, &dist3);
+    int64_t iu = crand_uniform(&rng, &dist1);
+    double xn = crand_normal(&rng, &dist3);
 }
 */
 #include <string.h>
 #include <math.h>
 
 typedef struct crand { uint64_t state[5]; } crand_t;
-typedef struct crand_unif { int64_t lower; uint64_t range, threshold; } crand_unif_t;
-typedef struct crand_norm { double mean, stddev, next; int has_next; } crand_norm_t;
+typedef struct crand_uniform { int64_t lower; uint64_t range, threshold; } crand_uniform_t;
+typedef struct crand_normal { double mean, stddev, next; int has_next; } crand_normal_t;
 
 /* PRNG crand_t.
  * Very fast PRNG suited for parallel usage with Weyl-sequence parameter.
@@ -67,14 +67,14 @@ STC_API double crandf(void);
 STC_API crand_t crand_init(uint64_t seed);
 
 /* Unbiased bounded uniform distribution. range [low, high] */
-STC_API crand_unif_t crand_unif_init(int64_t low, int64_t high);
-STC_API int64_t crand_unif(crand_t* rng, crand_unif_t* dist);
+STC_API crand_uniform_t crand_uniform_init(int64_t low, int64_t high);
+STC_API int64_t crand_uniform(crand_t* rng, crand_uniform_t* dist);
 
 /* Normal/gaussian distribution. */
-STC_INLINE crand_norm_t crand_norm_init(double mean, double stddev)
-    { crand_norm_t r = {mean, stddev, 0.0, 0}; return r; }
+STC_INLINE crand_normal_t crand_normal_init(double mean, double stddev)
+    { crand_normal_t r = {mean, stddev, 0.0, 0}; return r; }
 
-STC_API double crand_norm(crand_t* rng, crand_norm_t* dist);
+STC_API double crand_normal(crand_t* rng, crand_normal_t* dist);
 
 /* Main crand_t prng */
 STC_INLINE uint64_t crand_u64(crand_t* rng) {
@@ -95,11 +95,10 @@ STC_INLINE double crand_f64(crand_t* rng) {
 /* -------------------------- IMPLEMENTATION ------------------------- */
 #if defined(i_implement) || defined(i_static)
 
-/* Global random() */
-static crand_t crand_global = {{
-    0x26aa069ea2fb1a4d, 0x70c72c95cd592d04,
-    0x504f333d3aa0b359, 0x9e3779b97f4a7c15,
-    0x6a09e667a754166b
+/* Global random seed */
+static crand_t crand_global = {{ // csrand(0)
+    0x9e3779b97f4a7c15, 0x6f68261b57e7a770,
+    0xe220a838bf5c9dde, 0x7c17d1800457b1ba, 0x1,
 }};
 
 STC_DEF void csrand(uint64_t seed)
@@ -116,20 +115,20 @@ STC_DEF crand_t crand_init(uint64_t seed) {
     s[0] = seed + 0x9e3779b97f4a7c15;
     s[1] = (s[0] ^ (s[0] >> 30))*0xbf58476d1ce4e5b9;
     s[2] = (s[1] ^ (s[1] >> 27))*0x94d049bb133111eb;
-    s[3] = (s[2] ^ (s[2] >> 31));
-    s[4] = ((seed + 0x6aa069ea2fb1a4d) << 1) | 1;
+    s[3] = s[0] ^ s[2] ^ (s[2] >> 31);
+    s[4] = (seed << 1) | 1;
     return rng;
 }
 
 /* Init unbiased uniform uint RNG with bounds [low, high] */
-STC_DEF crand_unif_t crand_unif_init(int64_t low, int64_t high) {
-    crand_unif_t dist = {low, (uint64_t) (high - low + 1)};
+STC_DEF crand_uniform_t crand_uniform_init(int64_t low, int64_t high) {
+    crand_uniform_t dist = {low, (uint64_t) (high - low + 1)};
     dist.threshold = (uint64_t)(0 - dist.range) % dist.range;
     return dist;
 }
 
 /* Int64 uniform distributed RNG, range [low, high]. */
-STC_DEF int64_t crand_unif(crand_t* rng, crand_unif_t* d) {
+STC_DEF int64_t crand_uniform(crand_t* rng, crand_uniform_t* d) {
     uint64_t lo, hi;
 #ifdef c_umul128
     do { c_umul128(crand_u64(rng), d->range, &lo, &hi); } while (lo < d->threshold);
@@ -140,7 +139,7 @@ STC_DEF int64_t crand_unif(crand_t* rng, crand_unif_t* d) {
 }
 
 /* Normal distribution PRNG. Marsaglia polar method */
-STC_DEF double crand_norm(crand_t* rng, crand_norm_t* dist) {
+STC_DEF double crand_normal(crand_t* rng, crand_normal_t* dist) {
     double u1, u2, s, m;
     if (dist->has_next++ & 1)
         return dist->next*dist->stddev + dist->mean;
diff --git a/misc/examples/algorithms/forfilter.c b/misc/examples/algorithms/forfilter.c
index f3c008b3..644b8459 100644
--- a/misc/examples/algorithms/forfilter.c
+++ b/misc/examples/algorithms/forfilter.c
@@ -3,8 +3,7 @@
 #include <stc/cstr.h>
 #define i_implement
 #include <stc/csview.h>
-#include <stc/algo/filter.h>
-#include <stc/algo/crange.h>
+#include <stc/algorithm.h>
 
 #define i_type IVec
 #define i_key int
diff --git a/misc/examples/algorithms/forloops.c b/misc/examples/algorithms/forloops.c
index 72d745f8..300eee18 100644
--- a/misc/examples/algorithms/forloops.c
+++ b/misc/examples/algorithms/forloops.c
@@ -1,5 +1,5 @@
 #include <stdio.h>
-#include <stc/algo/filter.h>
+#include <stc/algorithm.h>
 
 #define i_type IVec
 #define i_key int
diff --git a/misc/examples/algorithms/random.c b/misc/examples/algorithms/random.c
index b7c0f277..ccd0711d 100644
--- a/misc/examples/algorithms/random.c
+++ b/misc/examples/algorithms/random.c
@@ -4,11 +4,11 @@
 
 int main(void)
 {
-    const int N = 1000000000;
+    long long N = 1000000000;
     const uint64_t seed = (uint64_t)time(NULL), range = 1000000;
     crand_t rng = crand_init(seed);
 
-    int64_t sum;
+    long long sum;
     clock_t diff, before;
 
     printf("Compare speed of full and unbiased ranged random numbers...\n");
@@ -18,19 +18,19 @@ int main(void)
         sum += (uint32_t)crand_u64(&rng);
     }
     diff = clock() - before;
-    printf("full range\t\t: %f secs, %d, avg: %f\n",
-           (double)diff/CLOCKS_PER_SEC, N, (double)sum/N);
+    printf("full range\t\t: %f secs, %lld, avg: %f\n",
+           (double)diff/CLOCKS_PER_SEC, N, (double)(sum/N));
 
-    crand_unif_t dist1 = crand_unif_init(0, range);
+    crand_uniform_t dist1 = crand_uniform_init(0, range);
     rng = crand_init(seed);
     sum = 0;
     before = clock();
     c_forrange (N)  {
-        sum += crand_unif(&rng, &dist1); // unbiased
+        sum += crand_uniform(&rng, &dist1); // unbiased
     }
     diff = clock() - before;
-    printf("unbiased 0-%" PRIu64 "\t: %f secs, %d, avg: %f\n",
-            range, (double)diff/CLOCKS_PER_SEC, N, (double)sum/N);
+    printf("unbiased 0-%" PRIu64 "\t: %f secs, %lld, avg: %f\n",
+            range, (double)diff/CLOCKS_PER_SEC, N, (double)(sum/N));
 
     sum = 0;
     rng = crand_init(seed);
@@ -39,7 +39,7 @@ int main(void)
         sum += (int64_t)(crand_u64(&rng) % (range + 1)); // biased
     }
     diff = clock() - before;
-    printf("biased 0-%" PRIu64 "  \t: %f secs, %d, avg: %f\n",
-            range, (double)diff/CLOCKS_PER_SEC, N, (double)sum/N);
+    printf("biased 0-%" PRIu64 "  \t: %f secs, %lld, avg: %f\n",
+            range, (double)diff/CLOCKS_PER_SEC, N, (double)(sum/N));
 
 }
diff --git a/misc/examples/bitsets/prime.c b/misc/examples/bitsets/prime.c
index cb3b095a..e5764d83 100644
--- a/misc/examples/bitsets/prime.c
+++ b/misc/examples/bitsets/prime.c
@@ -2,23 +2,23 @@
 #include <math.h>
 #include <time.h>
 #include <stc/cbits.h>
-#include <stc/algo/filter.h>
-#include <stc/algo/crange.h>
+#include <stc/algorithm.h>
 
+typedef long long llong;
 
-cbits sieveOfEratosthenes(int64_t n)
+cbits sieveOfEratosthenes(llong n)
 {
     cbits bits = cbits_with_size(n/2 + 1, true);
-    int64_t q = (int64_t)sqrt((double) n) + 1;
-    for (int64_t i = 3; i < q; i += 2) {
-        int64_t j = i;
+    llong q = (llong)sqrt((double) n) + 1;
+    for (llong i = 3; i < q; i += 2) {
+        llong j = i;
         for (; j < n; j += 2) {
             if (cbits_test(&bits, j>>1)) {
                 i = j;
                 break;
             }
         }
-        for (int64_t j = i*i; j < n; j += i*2)
+        for (llong j = i*i; j < n; j += i*2)
             cbits_reset(&bits, j>>1);
     }
     return bits;
@@ -26,12 +26,12 @@ cbits sieveOfEratosthenes(int64_t n)
 
 int main(void)
 {
-    int n = 1000000000;
-    printf("Computing prime numbers up to %d\n", n);
+    llong n = 100000000;
+    printf("Computing prime numbers up to %lld\n", n);
 
     clock_t t = clock();
     cbits primes = sieveOfEratosthenes(n + 1);
-    int np = (int)cbits_count(&primes);
+    llong np = cbits_count(&primes);
     t = clock() - t;
 
     puts("Show all the primes in the range [2, 1000):");
@@ -50,7 +50,7 @@ int main(void)
         printf("%lld ", *i.ref);
         if (c_flt_getcount(i) % 10 == 0) puts("");
     }
-    printf("Number of primes: %d, time: %.2f\n\n", np, (double)t/CLOCKS_PER_SEC);
+    printf("Number of primes: %lld, time: %.2f\n\n", np, (double)t/CLOCKS_PER_SEC);
 
     cbits_drop(&primes);
 }
diff --git a/misc/examples/coroutines/cointerleave.c b/misc/examples/coroutines/cointerleave.c
index 599ceaab..ea0d4dac 100644
--- a/misc/examples/coroutines/cointerleave.c
+++ b/misc/examples/coroutines/cointerleave.c
@@ -1,6 +1,6 @@
 // https://www.youtube.com/watch?v=8sEe-4tig_A
 #include <stdio.h>
-#include <stc/calgo.h>
+#include <stc/coroutine.h>
 #define i_type IVec
 #define i_key int
 #include <stc/cvec.h>
diff --git a/misc/examples/coroutines/coread.c b/misc/examples/coroutines/coread.c
index a13f6be5..56248108 100644
--- a/misc/examples/coroutines/coread.c
+++ b/misc/examples/coroutines/coread.c
@@ -1,6 +1,6 @@
 #define i_implement
 #include <stc/cstr.h>
-#include <stc/algo/coroutine.h>
+#include <stc/coroutine.h>
 #include <errno.h>
 
 // Read file line by line using coroutines:
diff --git a/misc/examples/coroutines/coroutines.c b/misc/examples/coroutines/coroutines.c
index b8dfaa13..de0fcda5 100644
--- a/misc/examples/coroutines/coroutines.c
+++ b/misc/examples/coroutines/coroutines.c
@@ -1,4 +1,4 @@
-#include <stc/algo/coroutine.h>
+#include <stc/coroutine.h>
 #include <stdio.h>
 #include <stdint.h>
 
diff --git a/misc/examples/coroutines/cotasks1.c b/misc/examples/coroutines/cotasks1.c
index c87582f1..27999ccf 100644
--- a/misc/examples/coroutines/cotasks1.c
+++ b/misc/examples/coroutines/cotasks1.c
@@ -4,7 +4,7 @@
 #include <stdio.h>
 #define i_static
 #include <stc/cstr.h>
-#include <stc/algo/coroutine.h>
+#include <stc/coroutine.h>
 
 struct next_value { 
     int val;
diff --git a/misc/examples/coroutines/cotasks2.c b/misc/examples/coroutines/cotasks2.c
index 293583bc..9ca69bda 100644
--- a/misc/examples/coroutines/cotasks2.c
+++ b/misc/examples/coroutines/cotasks2.c
@@ -4,7 +4,7 @@
 #include <stdio.h>
 #define i_static
 #include <stc/cstr.h>
-#include <stc/algo/coroutine.h>
+#include <stc/coroutine.h>
 
 cco_task_struct (next_value,
     int val;
@@ -45,7 +45,7 @@ int produce_items(struct produce_items* p, cco_runtime* rt)
         while (true)
         {
             // await for next CCO_YIELD in next_value()
-            cco_await_task(&p->next, rt, CCO_YIELD);
+            cco_task_await(&p->next, rt, CCO_YIELD);
             cstr_printf(&p->str, "item %d", p->next.val);
             print_time();
             printf("produced %s\n", cstr_str(&p->str));
@@ -71,7 +71,7 @@ int consume_items(struct consume_items* c, cco_runtime* rt)
         for (c->i = 1; c->i <= c->n; ++c->i)
         {
             printf("consume #%d\n", c->i);
-            cco_await_task(&c->produce, rt, CCO_YIELD);
+            cco_task_await(&c->produce, rt, CCO_YIELD);
             print_time();
             printf("consumed %s\n", cstr_str(&c->produce.str));
         }
@@ -87,12 +87,12 @@ int main(void)
 {
     struct consume_items consume = {
         .n=5,
-        .cco_fn=consume_items,
-        .produce={.cco_fn=produce_items, .next={.cco_fn=next_value}},
+        .cco_func=consume_items,
+        .produce={.cco_func=produce_items, .next={.cco_func=next_value}},
     };
     int count = 0;
 
-    cco_block_task(&consume)
+    cco_task_block_on(&consume)
     {
         ++count;
         //cco_sleep(0.001);
diff --git a/misc/examples/coroutines/dining_philosophers.c b/misc/examples/coroutines/dining_philosophers.c
index a5063a42..abe09204 100644
--- a/misc/examples/coroutines/dining_philosophers.c
+++ b/misc/examples/coroutines/dining_philosophers.c
@@ -2,7 +2,7 @@
 #include <stdio.h>
 #include <time.h>
 #include <stc/crand.h>
-#include <stc/algo/coroutine.h>
+#include <stc/coroutine.h>
  
 // Define the number of philosophers and forks
 enum {
diff --git a/misc/examples/coroutines/generator.c b/misc/examples/coroutines/generator.c
index a15f9ba5..f9e59fea 100644
--- a/misc/examples/coroutines/generator.c
+++ b/misc/examples/coroutines/generator.c
@@ -1,7 +1,7 @@
 // https://quuxplusone.github.io/blog/2019/03/06/pythagorean-triples/
 
-#include <stc/algo/coroutine.h>
 #include <stdio.h>
+#include <stc/coroutine.h>
 
 typedef struct {
     int size;
diff --git a/misc/examples/coroutines/scheduler.c b/misc/examples/coroutines/scheduler.c
index 38defd0f..78461277 100644
--- a/misc/examples/coroutines/scheduler.c
+++ b/misc/examples/coroutines/scheduler.c
@@ -1,6 +1,6 @@
 // https://www.youtube.com/watch?v=8sEe-4tig_A
 #include <stdio.h>
-#include <stc/calgo.h>
+#include <stc/coroutine.h>
 
 struct Task {
     int (*fn)(struct Task*);
diff --git a/misc/examples/coroutines/triples.c b/misc/examples/coroutines/triples.c
index 9f2fcc1e..fe1ca7c3 100644
--- a/misc/examples/coroutines/triples.c
+++ b/misc/examples/coroutines/triples.c
@@ -1,7 +1,7 @@
 // https://quuxplusone.github.io/blog/2019/03/06/pythagorean-triples/
 
-#include <stc/algo/coroutine.h>
 #include <stdio.h>
+#include <stc/coroutine.h>
 
 int gcd(int a, int b) {
     while (b) {
diff --git a/misc/examples/linkedlists/list.c b/misc/examples/linkedlists/list.c
index ad8bebb8..09591314 100644
--- a/misc/examples/linkedlists/list.c
+++ b/misc/examples/linkedlists/list.c
@@ -1,6 +1,6 @@
 #include <stdio.h>
 #include <time.h>
-#include <stc/algo/filter.h>
+#include <stc/algorithm.h>
 #include <stc/crand.h>
 
 #define i_type DList
diff --git a/misc/examples/make.sh b/misc/examples/make.sh
index 7135ffdf..b362f275 100755
--- a/misc/examples/make.sh
+++ b/misc/examples/make.sh
@@ -38,8 +38,8 @@ fi
 
 if [ $run = 0 ] ; then
     for i in */*.c ; do
-        #out=$(basename $i .c).exe
-        out=$(dirname $i)/$(basename $i .c).exe
+        out=$(basename $i .c).exe
+        #out=$(dirname $i)/$(basename $i .c).exe
         echo $comp -I../../include $i $clibs $oflag$out
         $comp -I../../include $i $clibs $oflag$out
     done
@@ -47,8 +47,8 @@ else
     for i in */*.c ; do
         echo $comp -I../../include $i $clibs
         $comp -I../../include $i $clibs
-        #out=$(basename $i .c).exe
-        out=$(dirname $i)/$(basename $i .c).exe
+        out=$(basename $i .c).exe
+        #out=$(dirname $i)/$(basename $i .c).exe
         if [ -f $out ]; then ./$out; fi
     done
 fi
diff --git a/misc/examples/priorityqueues/priority.c b/misc/examples/priorityqueues/priority.c
index bf2e188a..18684e73 100644
--- a/misc/examples/priorityqueues/priority.c
+++ b/misc/examples/priorityqueues/priority.c
@@ -11,21 +11,21 @@
 int main(void) {
     intptr_t N = 10000000;
     crand_t rng = crand_init((uint64_t)time(NULL));
-    crand_unif_t dist = crand_unif_init(0, N * 10);
+    crand_uniform_t dist = crand_uniform_init(0, N * 10);
 
     cpque_i heap = {0};
 
     // Push ten million random numbers to priority queue
     printf("Push %" c_ZI " numbers\n", N);
     c_forrange (N)
-        cpque_i_push(&heap, crand_unif(&rng, &dist));
+        cpque_i_push(&heap, crand_uniform(&rng, &dist));
 
     // push some negative numbers too.
     c_forlist (i, int, {-231, -32, -873, -4, -343})
         cpque_i_push(&heap, *i.ref);
 
     c_forrange (N)
-        cpque_i_push(&heap, crand_unif(&rng, &dist));
+        cpque_i_push(&heap, crand_uniform(&rng, &dist));
 
     puts("Extract the hundred smallest.");
     c_forrange (100) {
diff --git a/misc/examples/queues/new_queue.c b/misc/examples/queues/new_queue.c
index f3592df6..3904c50c 100644
--- a/misc/examples/queues/new_queue.c
+++ b/misc/examples/queues/new_queue.c
@@ -23,19 +23,19 @@ int point_cmp(const Point* a, const Point* b) {
 int main(void) {
     int n = 50000000;
     crand_t rng = crand_init((uint64_t)time(NULL));
-    crand_unif_t dist = crand_unif_init(0, n);
+    crand_uniform_t dist = crand_uniform_init(0, n);
 
     IQ Q = {0};
 
     // Push 50'000'000 random numbers onto the queue.
     c_forrange (n)
-        IQ_push(&Q, (int)crand_unif(&rng, &dist));
+        IQ_push(&Q, (int)crand_uniform(&rng, &dist));
 
     // Push or pop on the queue 50 million times
     printf("befor: size %" c_ZI ", capacity %" c_ZI "\n", IQ_size(&Q), IQ_capacity(&Q));
     
     c_forrange (n) {
-        int r = (int)crand_unif(&rng, &dist);
+        int r = (int)crand_uniform(&rng, &dist);
         if (r & 3)
             IQ_push(&Q, r);
         else
diff --git a/misc/examples/queues/queue.c b/misc/examples/queues/queue.c
index 56b5beb9..913524cc 100644
--- a/misc/examples/queues/queue.c
+++ b/misc/examples/queues/queue.c
@@ -7,20 +7,20 @@
 
 int main(void) {
     int n = 100000000;
-    crand_unif_t dist;
+    crand_uniform_t dist;
     crand_t rng = crand_init(1234);
-    dist = crand_unif_init(0, n);
+    dist = crand_uniform_init(0, n);
 
     cqueue_i queue = {0};
 
     // Push ten million random numbers onto the queue.
     c_forrange (n)
-        cqueue_i_push(&queue, (int)crand_unif(&rng, &dist));
+        cqueue_i_push(&queue, (int)crand_uniform(&rng, &dist));
 
     // Push or pop on the queue ten million times
     printf("%d\n", n);
     c_forrange (n) { // forrange uses initial n only.
-        int r = (int)crand_unif(&rng, &dist);
+        int r = (int)crand_uniform(&rng, &dist);
         if (r & 1)
             ++n, cqueue_i_push(&queue, r);
         else
diff --git a/misc/examples/sortedmaps/gauss2.c b/misc/examples/sortedmaps/gauss2.c
index 1ab8ade5..02ce4bc5 100644
--- a/misc/examples/sortedmaps/gauss2.c
+++ b/misc/examples/sortedmaps/gauss2.c
@@ -21,14 +21,14 @@ int main(void)
     printf("Mean %f, StdDev %f\n", Mean, StdDev);
 
     // Setup random engine with normal distribution.
-    crand_norm_t dist = crand_norm_init(Mean, StdDev);
+    crand_normal_t dist = crand_normal_init(Mean, StdDev);
 
     // Create and init histogram map with defered destruct
     csmap_int hist = {0};
     cstr bar = {0};
 
     c_forrange (N) {
-        int index = (int)round(crand_norm(&rng, &dist));
+        int index = (int)round(crand_normal(&rng, &dist));
         csmap_int_insert(&hist, index, 0).ref->second += 1;
     }
 
diff --git a/misc/examples/spans/mdspan.c b/misc/examples/spans/mdspan.c
new file mode 100644
index 00000000..4427299c
--- /dev/null
+++ b/misc/examples/spans/mdspan.c
@@ -0,0 +1,51 @@
+#include <stdio.h>
+#include <stc/cspan.h>
+#include <stdlib.h>
+
+using_cspan3(DSpan, double);
+
+int main(void) {
+    const int nx=5, ny=4, nz=3;
+    double* data = c_new_n(double, nx*ny*nz);
+
+    printf("\nMultidim span ms[5, 4, 3], fortran ordered");
+    DSpan3 ms = cspan_md_order('F', data, nx, ny, nz); // Fortran, not 'C'
+
+    int idx = 0;
+    c_forrange (i, ms.shape[0])
+        c_forrange (j, ms.shape[1])
+            c_forrange (k, ms.shape[2]) 
+                *cspan_at(&ms, i, j, k) = ++idx;
+
+    cspan_transpose(&ms);
+
+    printf(", transposed:\n\n");
+    c_forrange (i, ms.shape[0]) {
+        c_forrange (j, ms.shape[1]) {
+            c_forrange (k, ms.shape[2])
+                printf(" %3g", *cspan_at(&ms, i, j, k));
+            puts("");
+        }
+        puts("");
+    }
+
+    DSpan2 sub;
+
+    puts("Slicing:");
+    printf("\nms[0, :, :] ");
+    sub = cspan_slice(DSpan2, &ms, {0}, {c_ALL}, {c_ALL});
+    c_foreach (i, DSpan2, sub) printf(" %g", *i.ref);
+    puts("");
+
+    printf("\nms[:, 0, :] ");
+    sub = cspan_slice(DSpan2, &ms, {c_ALL}, {0}, {c_ALL});
+    c_foreach (i, DSpan2, sub) printf(" %g", *i.ref);
+    puts("");
+
+    sub = cspan_slice(DSpan2, &ms, {c_ALL}, {c_ALL}, {0});
+    printf("\nms[:, :, 0] ");
+    c_foreach (i, DSpan2, sub) printf(" %g", *i.ref);
+    puts("");
+
+    free(data);
+}
-- 
cgit v1.2.3


From dd87a488eeeffa41a06757dda2220da21337a35e Mon Sep 17 00:00:00 2001
From: tylov <tylo@norceresearch.no>
Date: Sun, 23 Jul 2023 23:51:02 +0200
Subject: - algo/sort.h: Use plural form of i_key (or i_val) to define default
 name for sort, like: <i_key>s_sort_n(data, n). - Updated some examples.

---
 include/stc/algo/sort.h                 |  2 +-
 misc/examples/coroutines/cotasks2.c     | 35 ++++++++++------------
 misc/examples/coroutines/triples.c      | 51 +++++++++++++++++----------------
 misc/examples/smartpointers/music_arc.c | 12 ++++----
 4 files changed, 49 insertions(+), 51 deletions(-)

(limited to 'misc/examples/coroutines/triples.c')

diff --git a/include/stc/algo/sort.h b/include/stc/algo/sort.h
index 06d7395f..86c9b9f1 100644
--- a/include/stc/algo/sort.h
+++ b/include/stc/algo/sort.h
@@ -70,7 +70,7 @@ int main(void) {
   #ifndef i_tag
     #define i_tag i_key
   #endif
-  #define i_type c_PASTE(i_tag, array)
+  #define i_type c_PASTE(i_tag, s)
   typedef i_key i_type;
 #endif
 #ifndef i_at
diff --git a/misc/examples/coroutines/cotasks2.c b/misc/examples/coroutines/cotasks2.c
index 24a9f23f..4fdf98d9 100644
--- a/misc/examples/coroutines/cotasks2.c
+++ b/misc/examples/coroutines/cotasks2.c
@@ -42,18 +42,20 @@ int produce_items(struct produce_items* p, cco_runtime* rt)
 {
     cco_routine (p) {
         p->str = cstr_null;
+        p->next.cco_func = next_value;
         while (true)
         {
-            // await for next CCO_YIELD in next_value()
+            // await for next CCO_YIELD (or CCO_DONE) in next_value
             cco_task_await(&p->next, rt, CCO_YIELD);
             cstr_printf(&p->str, "item %d", p->next.val);
             print_time();
             printf("produced %s\n", cstr_str(&p->str));
             cco_yield();
         }
+
         cco_cleanup:
-            cstr_drop(&p->str);
-            puts("done produce");
+        cstr_drop(&p->str);
+        puts("done produce");
     }
     return 0;
 }
@@ -68,6 +70,8 @@ cco_task_struct (consume_items,
 int consume_items(struct consume_items* c, cco_runtime* rt)
 {
    cco_routine (c) {
+        c->produce.cco_func = produce_items;
+
         for (c->i = 1; c->i <= c->n; ++c->i)
         {
             printf("consume #%d\n", c->i);
@@ -75,10 +79,11 @@ int consume_items(struct consume_items* c, cco_runtime* rt)
             print_time();
             printf("consumed %s\n", cstr_str(&c->produce.str));
         }
+
         cco_cleanup:
-            cco_stop(&c->produce);
-            cco_task_resume(&c->produce, rt);
-            puts("done consume");
+        cco_stop(&c->produce);
+        cco_task_resume(&c->produce, rt);
+        puts("done consume");
     }
     return 0;
 }
@@ -86,18 +91,8 @@ int consume_items(struct consume_items* c, cco_runtime* rt)
 int main(void)
 {
     struct consume_items consume = {
-        .n=5,
-        .cco_func=consume_items,
-        .produce={.cco_func=produce_items, .next={.cco_func=next_value}},
+        .cco_func = consume_items,
+        .n = 5,
     };
-    int count = 0;
-
-    cco_task_blocking(&consume)
-    {
-        ++count;
-        //cco_sleep(0.001);
-        //if (consume.i == 3)
-        //    cco_stop(&consume);
-    }
-    printf("count: %d\n", count);
-}
\ No newline at end of file
+    cco_task_blocking(&consume);
+}
diff --git a/misc/examples/coroutines/triples.c b/misc/examples/coroutines/triples.c
index fe1ca7c3..9fd771ce 100644
--- a/misc/examples/coroutines/triples.c
+++ b/misc/examples/coroutines/triples.c
@@ -3,22 +3,14 @@
 #include <stdio.h>
 #include <stc/coroutine.h>
 
-int gcd(int a, int b) {
-    while (b) {
-        int t = a % b;
-        a = b;
-        b = t;
-    }
-    return a;
-}
-
-void triples_vanilla(int n) {
-    for (int c = 5, i = 0; n; ++c) {
+void triples_vanilla(int max_c) {
+    for (int c = 5, i = 0;; ++c) {
         for (int a = 1; a < c; ++a) {
             for (int b = a + 1; b < c; ++b) {
-                if ((int64_t)a*a + (int64_t)b*b == (int64_t)c*c && gcd(a, b) == 1) {
+                if ((int64_t)a*a + (int64_t)b*b == (int64_t)c*c) {
+                    if (c > max_c)
+                        goto done;
                     printf("%d: {%d, %d, %d}\n", ++i, a, b, c);
-                    if (--n == 0) goto done;
                 }
             }
         }
@@ -27,19 +19,21 @@ void triples_vanilla(int n) {
 }
 
 struct triples {
-    int size, count;
+    int max_c;
     int a, b, c;
     int cco_state;
 };
 
 int triples_coro(struct triples* t) {
     cco_routine(t) {
-        t->count = 0;
-        for (t->c = 5; t->size; ++t->c) {
+        for (t->c = 5;; ++t->c) {
             for (t->a = 1; t->a < t->c; ++t->a) {
                 for (t->b = t->a + 1; t->b < t->c; ++t->b) {
-                    if ((int64_t)t->a*t->a + (int64_t)t->b*t->b == (int64_t)t->c*t->c) {
-                        if (t->count++ == t->size)
+                    if ((int64_t)t->a * t->a +
+                        (int64_t)t->b * t->b ==
+                        (int64_t)t->c * t->c)
+                    {
+                        if (t->c > t->max_c)
                             cco_return;
                         cco_yield();
                     }
@@ -52,20 +46,29 @@ int triples_coro(struct triples* t) {
     return 0;
 }
 
+int gcd(int a, int b) {
+    while (b) {
+        int t = a % b;
+        a = b;
+        b = t;
+    }
+    return a;
+}
+
 int main(void)
 {
     puts("Vanilla triples:");
-    triples_vanilla(5);
+    triples_vanilla(20);
 
-    puts("\nCoroutine triples:");
-    struct triples t = {.size=INT32_MAX};
+    puts("\nCoroutine triples with GCD = 1:");
+    struct triples t = {.max_c = 100};
     int n = 0;
 
-    while (triples_coro(&t)) {
+    cco_call_blocking(triples_coro(&t)) {
         if (gcd(t.a, t.b) > 1)
             continue;
-        if (t.c < 100)
-            printf("%d: {%d, %d, %d}\n", ++n, t.a, t.b, t.c);
+        if (++n <= 20)
+            printf("%d: {%d, %d, %d}\n", n, t.a, t.b, t.c);
         else
             cco_stop(&t);
     }
diff --git a/misc/examples/smartpointers/music_arc.c b/misc/examples/smartpointers/music_arc.c
index 16111b0b..13d368c3 100644
--- a/misc/examples/smartpointers/music_arc.c
+++ b/misc/examples/smartpointers/music_arc.c
@@ -12,7 +12,7 @@ typedef struct
 int Song_cmp(const Song* x, const Song* y)
     { return cstr_cmp(&x->title, &y->title); }
 
-Song Song_make(const char* artist, const char* title)
+Song Song_init(const char* artist, const char* title)
     { return c_LITERAL(Song){cstr_from(artist), cstr_from(title)}; }
 
 void Song_drop(Song* s) {
@@ -34,9 +34,9 @@ void Song_drop(Song* s) {
 void example3(void)
 {
     SongVec vec1 = c_init(SongVec, {
-        Song_make("Bob Dylan", "The Times They Are A Changing"),
-        Song_make("Aretha Franklin", "Bridge Over Troubled Water"),
-        Song_make("Thalia", "Entre El Mar y Una Estrella")
+        Song_init("Bob Dylan", "The Times They Are A Changing"),
+        Song_init("Aretha Franklin", "Bridge Over Troubled Water"),
+        Song_init("Thalia", "Entre El Mar y Una Estrella")
     });
 
     SongVec vec2 = {0};
@@ -47,8 +47,8 @@ void example3(void)
 
     // Add a few more to vec2. We can use emplace when creating new entries
     // Emplace calls SongArc_from() on the argument to create the Arc:
-    SongVec_emplace(&vec2, Song_make("Michael Jackson", "Billie Jean"));
-    SongVec_emplace(&vec2, Song_make("Rihanna", "Stay"));
+    SongVec_emplace(&vec2, Song_init("Michael Jackson", "Billie Jean"));
+    SongVec_emplace(&vec2, Song_init("Rihanna", "Stay"));
 
     // We now have two vectors with some shared, some unique entries.
     c_forlist (i, SongVec, {vec1, vec2}) {
-- 
cgit v1.2.3


From 94391527ef50cbee073a4b427f6fe839c010ecb1 Mon Sep 17 00:00:00 2001
From: Tyge Løvset <tylo@norceresearch.no>
Date: Tue, 1 Aug 2023 16:47:38 +0200
Subject: Last minute API change for coroutines before V4.3 release: - Renamed
 cco_xxxx_await() => cco_await_xxxx()       (call, task, sem, timer) - Renamed
 cco_xxxx_blocking() => cco_blocking_xxxx() (call, task) - Renamed
 cco_task_resume() => cco_resume_task() - Simplified cco_blocking_call()

---
 docs/coroutine_api.md                          | 46 +++++++++++++-------------
 include/stc/coroutine.h                        | 44 ++++++++++++------------
 misc/examples/coroutines/cointerleave.c        |  2 +-
 misc/examples/coroutines/coread.c              |  2 +-
 misc/examples/coroutines/coroutines.c          |  8 ++---
 misc/examples/coroutines/cotasks1.c            |  4 +--
 misc/examples/coroutines/cotasks2.c            | 10 +++---
 misc/examples/coroutines/dining_philosophers.c | 14 ++++----
 misc/examples/coroutines/filetask.c            |  6 ++--
 misc/examples/coroutines/triples.c             |  2 +-
 10 files changed, 68 insertions(+), 70 deletions(-)

(limited to 'misc/examples/coroutines/triples.c')

diff --git a/docs/coroutine_api.md b/docs/coroutine_api.md
index 30b85640..b356dcf0 100644
--- a/docs/coroutine_api.md
+++ b/docs/coroutine_api.md
@@ -24,23 +24,24 @@ NB! ***cco_yield\*()*** / ***cco_await\*()*** may not be called from within a `s
 |           | `cco_yield_final();`                 | Yield final suspend, enter cleanup-state |
 |           | `cco_yield_final(ret);`              | Yield a final value                     |
 |           | `cco_await(condition);`              | Suspend until condition is true (return CCO_AWAIT)|
-|           | `cco_call_await(cocall);`            | Await for subcoro to finish (returns its ret value) |
-|           | `cco_call_await(cocall, retbit);`    | Await for subcoro's return to be in (retbit \| CCO_DONE)  |
+|           | `cco_await_call(cocall);`            | Await for subcoro to finish (returns its ret value) |
+|           | `cco_await_call(cocall, retbit);`    | Await for subcoro's return to be in (retbit \| CCO_DONE)  |
 |           | `cco_return;`                        | Return from coroutine (inside cco_routine) |
 |           | Task objects:                        |                                         |
 |           | `cco_task_struct(Name, ...);`        | Define a coroutine task struct          |
-|           | `cco_task_await(task, cco_runtime* rt);`| Await for task to finish             |
-|           | `cco_task_await(task, rt, retbit);`  | Await for task's return to be in (retbit \| CCO_DONE) |
-|`cco_result`| `cco_task_resume(task, rt);`       | Resume suspended task                   |
+|           | `cco_await_task(task, cco_runtime* rt);`| Await for task to finish             |
+|           | `cco_await_task(task, rt, retbit);`  | Await for task's return to be in (retbit \| CCO_DONE) |
+|`cco_result`| `cco_resume_task(task, rt);`        | Resume suspended task                   |
 |           | Semaphores:                          |                                         | 
 |           | `cco_sem`                            | Semaphore type                          |
+|           | `cco_await_sem(sem)`                 | Await for the semaphore count > 0       |
 | `cco_sem` | `cco_sem_from(long value)`           | Create semaphore                        |
 |           | `cco_sem_set(sem, long value)`       | Set semaphore value                     |
-|           | `cco_sem_await(sem)`                 | Await for the semaphore count > 0       |
+
 |           | `cco_sem_release(sem)`               | Signal the semaphore (count += 1)       |
 |           | Timers:                              |                                         | 
 |           | `cco_timer`                          | Timer type                              |
-|           | `cco_timer_await(tm, double sec)`    | Await secs for timer to expire (usec prec.)|
+|           | `cco_await_timer(tm, double sec)`    | Await secs for timer to expire (usec prec.)|
 |           | `cco_timer_start(tm, double sec)`    | Start timer for secs duration           |
 |           | `cco_timer_restart(tm)`              | Restart timer with same duration        |
 | `bool`    | `cco_timer_expired(tm)`              | Return true if timer is expired         |
@@ -49,10 +50,9 @@ NB! ***cco_yield\*()*** / ***cco_await\*()*** may not be called from within a `s
 |           | From caller side:                    |                                         | 
 | `void`    | `cco_stop(co)`                       | Next call of coroutine finalizes        |
 | `void`    | `cco_reset(co)`                      | Reset state to initial (for reuse)      |
-| `void`    | `cco_call_blocking(cocall) {}`       | Run blocking until cocall is finished   |
-| `void`    | `cco_call_blocking(cocall, int* outres) {}`| Run blocking until cocall is finished |
-|           | `cco_task_blocking(task) {}`         | Run blocking until task is finished |
-|           | `cco_task_blocking(task, rt, STACKSZ) {}`| Run blocking until task is finished |
+| `void`    | `cco_blocking_call(cocall) {}`       | Run blocking until cocall is finished   |
+|           | `cco_blocking_task(task) {}`         | Run blocking until task is finished |
+|           | `cco_blocking_task(task, rt, STACKSZ) {}`| Run blocking until task is finished |
 |           | Time functions:                      |                                         |
 | `double`  | `cco_time(void)`                     | Return secs with usec prec. since Epoch |
 |           | `cco_sleep(double sec)`              | Sleep for seconds (msec or usec prec.)  |
@@ -117,7 +117,7 @@ int main(void) {
     struct triples co = {.max_c = 25};
     int n = 0;
 
-    cco_call_blocking(triples(&co)) {
+    cco_blocking_call(triples(&co)) {
         printf("%d: [%d, %d, %d]\n", ++n, co.a, co.b, co.c);
     }
 }
@@ -171,26 +171,26 @@ int main(void) {
     struct gcd1_triples co = {.max_n = 100, .max_c = 100};
     int n = 0;
 
-    cco_call_blocking(gcd1_triples(&co)) {
+    cco_blocking_call(gcd1_triples(&co)) {
         printf("%d: [%d, %d, %d]\n", ++n, co.tri.a, co.tri.b, co.tri.c);
     }
 }
 ```
-When using ***cco_call_blocking()***, the coroutine is continuously resumed after each yield suspension.
+When using ***cco_blocking_call()***, the coroutine is continuously resumed after each yield suspension.
 However, this means that it first calls ***gcd1_triples()***, which immediately jumps to after the `cco_yield`
 -statement and calls ***triples()***, which again jumps and resumes after its `cco_yield`-statement. This
 is efficient only when yielding or awaiting from the top- or second-level call like here, but naturally not
 when couroutine calls are more deeply nested or recursive.
 
 The STC coroutine implementation therefore also contains task-objects (`cco_task`), which are base-coroutine 
-objects/enclosures. These can be executed using ***cco_task_blocking()*** instead of ***cco_call_blocking()***.
-Inner coroutine calls are done by ***cco_task_await()***, where you may await for a certain return value, normally CCO_YIELD or just CCO_DONE. It uses a stack of pointers of task-enclosures to call the current
+objects/enclosures. These can be executed using ***cco_blocking_task()*** instead of ***cco_blocking_call()***.
+Inner coroutine calls are done by ***cco_await_task()***, where you may await for a certain return value, normally CCO_YIELD or just CCO_DONE. It uses a stack of pointers of task-enclosures to call the current
 inner-level function directly. The task-objects have the added benefit that coroutines can be managed
 by a scheduler, which is useful when dealing with large numbers of coroutines (like in many games and
 simulations).
 
 Note that these two modes may be mixed, and that for short-lived coroutines (only a few suspends),
-it is often beneficial to call the sub-coroutine directly rather than via ***cco_task_await()***
+it is often beneficial to call the sub-coroutine directly rather than via ***cco_await_task()***
 (which pushes the task on top of the runtime stack and yields - then executed on next resume).
 
 The following example uses task-objects with 3-levels deep coroutine calls. It emulates an async generator
@@ -212,7 +212,7 @@ int next_value(struct next_value* co, cco_runtime* rt)
 {
     cco_routine (co) {
         while (true) {
-            cco_timer_await(&co->tm, 1 + rand() % 2); // suspend with CCO_AWAIT
+            cco_await_timer(&co->tm, 1 + rand() % 2); // suspend with CCO_AWAIT
             co->val = rand();
             cco_yield();                              // suspend with CCO_YIELD
         }
@@ -242,7 +242,7 @@ int produce_items(struct produce_items* p, cco_runtime* rt)
         while (true)
         {
             // await for CCO_YIELD (or CCO_DONE)
-            cco_task_await(&p->next, rt, CCO_YIELD);
+            cco_await_task(&p->next, rt, CCO_YIELD);
             cstr_printf(&p->str, "item %d", p->next.val);
             print_time();
             printf("produced %s\n", cstr_str(&p->str));
@@ -269,13 +269,13 @@ int consume_items(struct consume_items* c, cco_runtime* rt)
         for (c->i = 1; c->i <= c->n; ++c->i)
         {
             printf("consume #%d\n", c->i);
-            cco_task_await(&c->produce, rt, CCO_YIELD);
+            cco_await_task(&c->produce, rt, CCO_YIELD);
             print_time();
             printf("consumed %s\n", cstr_str(&c->produce.str));
         }
         cco_cleanup:
             cco_stop(&c->produce);
-            cco_task_resume(&c->produce, rt);
+            cco_resume_task(&c->produce, rt);
             puts("done consume");
     }
     return 0;
@@ -287,6 +287,6 @@ int main(void)
         .n = 5,
         .cco_func = consume_items,
     };
-    cco_task_blocking(&consume);
+    cco_blocking_task(&consume);
 }
-```
\ No newline at end of file
+```
diff --git a/include/stc/coroutine.h b/include/stc/coroutine.h
index 4a7fd6aa..0e592bae 100644
--- a/include/stc/coroutine.h
+++ b/include/stc/coroutine.h
@@ -91,19 +91,17 @@ typedef enum {
         case __LINE__: if (!(promise)) {return ret; goto _resume;} \
     } while (0)
 
-/* cco_call_await(): assumes coroutine returns a cco_result value (int) */
-#define cco_call_await(...) c_MACRO_OVERLOAD(cco_call_await, __VA_ARGS__)
-#define cco_call_await_1(corocall) cco_call_await_2(corocall, CCO_DONE)
-#define cco_call_await_2(corocall, awaitbits) \
+/* cco_await_call(): assumes coroutine returns a cco_result value (int) */
+#define cco_await_call(...) c_MACRO_OVERLOAD(cco_await_call, __VA_ARGS__)
+#define cco_await_call_1(corocall) cco_await_call_2(corocall, CCO_DONE)
+#define cco_await_call_2(corocall, awaitbits) \
     do { \
         *_state = __LINE__; \
         case __LINE__: { int _r = corocall; if (_r & ~(awaitbits)) {return _r; goto _resume;} } \
     } while (0)
 
-/* cco_call_blocking(): assumes coroutine returns a cco_result value (int) */
-#define cco_call_blocking(...) c_MACRO_OVERLOAD(cco_call_blocking, __VA_ARGS__)
-#define cco_call_blocking_1(corocall) while ((corocall) != CCO_DONE)
-#define cco_call_blocking_2(corocall, result) while ((*(result) = (corocall)) != CCO_DONE)
+/* cco_blocking_call(): assumes coroutine returns a cco_result value (int) */
+#define cco_blocking_call(corocall) while ((corocall) != CCO_DONE)
 
 #define cco_cleanup \
     *_state = CCO_STATE_CLEANUP; case CCO_STATE_CLEANUP
@@ -165,23 +163,23 @@ typedef struct cco_runtime {
 #define cco_cast_task(task) \
     ((cco_task *)(task) + 0*sizeof((task)->cco_func(task, (cco_runtime*)0) + ((int*)0 == &(task)->cco_state)))
 
-#define cco_task_resume(task, rt) \
+#define cco_resume_task(task, rt) \
     (task)->cco_func(task, rt)
 
-#define cco_task_await(...) c_MACRO_OVERLOAD(cco_task_await, __VA_ARGS__)
-#define cco_task_await_2(task, rt) cco_task_await_3(task, rt, CCO_DONE)
-#define cco_task_await_3(task, rt, awaitbits) \
+#define cco_await_task(...) c_MACRO_OVERLOAD(cco_await_task, __VA_ARGS__)
+#define cco_await_task_2(task, rt) cco_await_task_3(task, rt, CCO_DONE)
+#define cco_await_task_3(task, rt, awaitbits) \
     do { \
         cco_runtime* _rt = rt; \
         (_rt->stack[++_rt->top] = cco_cast_task(task))->cco_expect = (awaitbits); \
         cco_yield_v(CCO_AWAIT); \
     } while (0)
 
-#define cco_task_blocking(...) c_MACRO_OVERLOAD(cco_task_blocking, __VA_ARGS__)
-#define cco_task_blocking_1(task) cco_task_blocking_3(task, _rt, 16)
-#define cco_task_blocking_3(task, rt, STACKDEPTH) \
+#define cco_blocking_task(...) c_MACRO_OVERLOAD(cco_blocking_task, __VA_ARGS__)
+#define cco_blocking_task_1(task) cco_blocking_task_3(task, _rt, 16)
+#define cco_blocking_task_3(task, rt, STACKDEPTH) \
     for (struct { int result, top; cco_task* stack[STACKDEPTH]; } rt = {.stack={cco_cast_task(task)}}; \
-         (((rt.result = cco_task_resume(rt.stack[rt.top], (cco_runtime*)&rt)) & \
+         (((rt.result = cco_resume_task(rt.stack[rt.top], (cco_runtime*)&rt)) & \
            ~rt.stack[rt.top]->cco_expect) || --rt.top >= 0); )
 
 /*
@@ -190,9 +188,9 @@ typedef struct cco_runtime {
 
 typedef struct { intptr_t count; } cco_sem;
 
-#define cco_sem_await(sem) cco_sem_await_and_return(sem, CCO_AWAIT)
-#define cco_sem_await_v(sem) cco_sem_await_and_return(sem, )
-#define cco_sem_await_and_return(sem, ret) \
+#define cco_await_sem(sem) cco_await_sem_and_return(sem, CCO_AWAIT)
+#define cco_await_sem_v(sem) cco_await_sem_and_return(sem, )
+#define cco_await_sem_and_return(sem, ret) \
     do { \
         cco_await_and_return((sem)->count > 0, ret); \
         --(sem)->count; \
@@ -248,10 +246,10 @@ typedef struct { intptr_t count; } cco_sem;
 
 typedef struct { double interval, start; } cco_timer;
 
-#define cco_timer_await(tm, sec) cco_timer_await_v_3(tm, sec, CCO_AWAIT)
-#define cco_timer_await_v(...) c_MACRO_OVERLOAD(cco_timer_await_v, __VA_ARGS__)
-#define cco_timer_await_v_2(tm, sec) cco_timer_await_v_3(tm, sec, )
-#define cco_timer_await_v_3(tm, sec, ret) \
+#define cco_await_timer(tm, sec) cco_await_timer_v_3(tm, sec, CCO_AWAIT)
+#define cco_await_timer_v(...) c_MACRO_OVERLOAD(cco_await_timer_v, __VA_ARGS__)
+#define cco_await_timer_v_2(tm, sec) cco_await_timer_v_3(tm, sec, )
+#define cco_await_timer_v_3(tm, sec, ret) \
     do { \
         cco_timer_start(tm, sec); \
         cco_await_and_return(cco_timer_expired(tm), ret); \
diff --git a/misc/examples/coroutines/cointerleave.c b/misc/examples/coroutines/cointerleave.c
index f3710ba3..80494176 100644
--- a/misc/examples/coroutines/cointerleave.c
+++ b/misc/examples/coroutines/cointerleave.c
@@ -49,7 +49,7 @@ void Use(void)
 
     struct Generator g = {{&a}, {&b}};
 
-    cco_call_blocking(interleaved(&g)) {
+    cco_blocking_call(interleaved(&g)) {
         printf("%d ", g.value);
     }
     puts("");
diff --git a/misc/examples/coroutines/coread.c b/misc/examples/coroutines/coread.c
index ebaaf19d..359ca85d 100644
--- a/misc/examples/coroutines/coread.c
+++ b/misc/examples/coroutines/coread.c
@@ -33,7 +33,7 @@ int main(void)
 {
     struct file_read g = {__FILE__};
     int n = 0;
-    cco_call_blocking(file_read(&g))
+    cco_blocking_call(file_read(&g))
     {
         printf("%3d %s\n", ++n, cstr_str(&g.line));
         //if (n == 10) cco_stop(&g);
diff --git a/misc/examples/coroutines/coroutines.c b/misc/examples/coroutines/coroutines.c
index 489c3ed6..faeb71f6 100644
--- a/misc/examples/coroutines/coroutines.c
+++ b/misc/examples/coroutines/coroutines.c
@@ -84,13 +84,13 @@ struct combined {
 
 int combined(struct combined* g) {
     cco_routine(g) {
-        cco_call_await(prime(&g->prm));
-        cco_call_await(fibonacci(&g->fib));
+        cco_await_call(prime(&g->prm));
+        cco_await_call(fibonacci(&g->fib));
 
         // Reuse the g->prm context and extend the count:
         g->prm.count = 8, g->prm.result += 2;
         cco_reset(&g->prm);
-        cco_call_await(prime(&g->prm));
+        cco_await_call(prime(&g->prm));
 
         cco_cleanup:
         puts("final combined");
@@ -103,7 +103,7 @@ int main(void)
     struct combined c = {.prm={.count=8}, .fib={14}};
     int res;
 
-    cco_call_blocking(combined(&c), &res) {
+    cco_blocking_call(res = combined(&c)) {
         if (res == CCO_YIELD)
             printf("Prime(%d)=%lld, Fib(%d)=%lld\n", 
                 c.prm.idx, c.prm.result, 
diff --git a/misc/examples/coroutines/cotasks1.c b/misc/examples/coroutines/cotasks1.c
index e4afbe2b..230bd62b 100644
--- a/misc/examples/coroutines/cotasks1.c
+++ b/misc/examples/coroutines/cotasks1.c
@@ -16,7 +16,7 @@ int next_value(struct next_value* co)
 {
     cco_routine (co) {
         while (true) {
-            cco_timer_await(&co->tm, 1 + rand() % 2);
+            cco_await_timer(&co->tm, 1 + rand() % 2);
             co->val = rand();
             cco_yield();
         }
@@ -88,7 +88,7 @@ int main(void)
     struct consume_items consume = {.n=5};
     int count = 0;
 
-    cco_call_blocking(consume_items(&consume, &produce))
+    cco_blocking_call(consume_items(&consume, &produce))
     {
         ++count;
         //cco_sleep(0.001);
diff --git a/misc/examples/coroutines/cotasks2.c b/misc/examples/coroutines/cotasks2.c
index 4fdf98d9..d77a28bc 100644
--- a/misc/examples/coroutines/cotasks2.c
+++ b/misc/examples/coroutines/cotasks2.c
@@ -15,7 +15,7 @@ int next_value(struct next_value* co, cco_runtime* rt)
 {
     cco_routine (co) {
         while (true) {
-            cco_timer_await(&co->tm, 1 + rand() % 2);
+            cco_await_timer(&co->tm, 1 + rand() % 2);
             co->val = rand();
             cco_yield();
         }
@@ -46,7 +46,7 @@ int produce_items(struct produce_items* p, cco_runtime* rt)
         while (true)
         {
             // await for next CCO_YIELD (or CCO_DONE) in next_value
-            cco_task_await(&p->next, rt, CCO_YIELD);
+            cco_await_task(&p->next, rt, CCO_YIELD);
             cstr_printf(&p->str, "item %d", p->next.val);
             print_time();
             printf("produced %s\n", cstr_str(&p->str));
@@ -75,14 +75,14 @@ int consume_items(struct consume_items* c, cco_runtime* rt)
         for (c->i = 1; c->i <= c->n; ++c->i)
         {
             printf("consume #%d\n", c->i);
-            cco_task_await(&c->produce, rt, CCO_YIELD);
+            cco_await_task(&c->produce, rt, CCO_YIELD);
             print_time();
             printf("consumed %s\n", cstr_str(&c->produce.str));
         }
 
         cco_cleanup:
         cco_stop(&c->produce);
-        cco_task_resume(&c->produce, rt);
+        cco_resume_task(&c->produce, rt);
         puts("done consume");
     }
     return 0;
@@ -94,5 +94,5 @@ int main(void)
         .cco_func = consume_items,
         .n = 5,
     };
-    cco_task_blocking(&consume);
+    cco_blocking_task(&consume);
 }
diff --git a/misc/examples/coroutines/dining_philosophers.c b/misc/examples/coroutines/dining_philosophers.c
index abe09204..e917c303 100644
--- a/misc/examples/coroutines/dining_philosophers.c
+++ b/misc/examples/coroutines/dining_philosophers.c
@@ -34,15 +34,15 @@ int philosopher(struct Philosopher* p)
         while (1) {
             duration = 1.0 + crandf()*2.0;
             printf("Philosopher %d is thinking for %.0f minutes...\n", p->id, duration*10);
-            cco_timer_await(&p->tm, duration);
+            cco_await_timer(&p->tm, duration);
 
             printf("Philosopher %d is hungry...\n", p->id);
-            cco_sem_await(p->left_fork);
-            cco_sem_await(p->right_fork);
-            
+            cco_await_sem(p->left_fork);
+            cco_await_sem(p->right_fork);
+
             duration = 0.5 + crandf();
             printf("Philosopher %d is eating for %.0f minutes...\n", p->id, duration*10);
-            cco_timer_await(&p->tm, duration);
+            cco_await_timer(&p->tm, duration);
 
             cco_sem_release(p->left_fork);
             cco_sem_release(p->right_fork);
@@ -94,10 +94,10 @@ int main(void)
     cco_timer tm = cco_timer_from(15.0); // seconds
     csrand((uint64_t)time(NULL));
 
-    while (!cco_done(&dine)) {
+    cco_blocking_call(dining(&dine))
+    {
         if (cco_timer_expired(&tm))
             cco_stop(&dine);
-        dining(&dine); // resume
         cco_sleep(0.001);
         ++n;
     }
diff --git a/misc/examples/coroutines/filetask.c b/misc/examples/coroutines/filetask.c
index bfce7810..28292801 100644
--- a/misc/examples/coroutines/filetask.c
+++ b/misc/examples/coroutines/filetask.c
@@ -21,7 +21,7 @@ int file_read(struct file_read* co, cco_runtime* rt)
 
         while (true) {
             // emulate async io: await 10ms per line
-            cco_timer_await(&co->tm, 0.003);
+            cco_await_timer(&co->tm, 0.003);
 
             if (!cstr_getline(&co->line, co->fp))
                 break;
@@ -50,7 +50,7 @@ int count_line(struct count_line* co, cco_runtime* rt)
         while (true)
         {
             // await for next CCO_YIELD (or CCO_DONE) in file_read()
-            cco_task_await(&co->reader, rt, CCO_YIELD);
+            cco_await_task(&co->reader, rt, CCO_YIELD);
             if (rt->result == CCO_DONE) break;
             co->lineCount += 1;
             cco_yield();
@@ -73,7 +73,7 @@ int main(void)
 
     // Execute coroutine as top-level blocking
     int loop = 0;
-    cco_task_blocking(&countTask) { ++loop; }
+    cco_blocking_task(&countTask) { ++loop; }
 
     printf("line count = %d\n", countTask.lineCount);
     printf("exec count = %d\n", loop);
diff --git a/misc/examples/coroutines/triples.c b/misc/examples/coroutines/triples.c
index 9fd771ce..22914c2b 100644
--- a/misc/examples/coroutines/triples.c
+++ b/misc/examples/coroutines/triples.c
@@ -64,7 +64,7 @@ int main(void)
     struct triples t = {.max_c = 100};
     int n = 0;
 
-    cco_call_blocking(triples_coro(&t)) {
+    cco_blocking_call(triples_coro(&t)) {
         if (gcd(t.a, t.b) > 1)
             continue;
         if (++n <= 20)
-- 
cgit v1.2.3


From c27c266b6c4ae0e5e535b18c3790ee97416412b9 Mon Sep 17 00:00:00 2001
From: Tyge Løvset <tylo@norceresearch.no>
Date: Tue, 8 Aug 2023 12:28:15 +0200
Subject: Reverted cco_cleanup => cco_final. (cco_cleanup deprecated). Updated
 generator.c example. Misc internal refactoring.

---
 docs/coroutine_api.md                          | 12 +++++------
 include/stc/cmap.h                             | 16 +++++++--------
 include/stc/coroutine.h                        |  5 +++--
 include/stc/forward.h                          |  6 ++----
 include/stc/priv/cqueue_hdr.h                  |  4 ++--
 misc/examples/coroutines/coread.c              |  2 +-
 misc/examples/coroutines/coroutines.c          |  6 +++---
 misc/examples/coroutines/cotasks1.c            |  4 ++--
 misc/examples/coroutines/cotasks2.c            |  4 ++--
 misc/examples/coroutines/dining_philosophers.c |  4 ++--
 misc/examples/coroutines/filetask.c            |  4 ++--
 misc/examples/coroutines/generator.c           | 28 ++++++++++++++++++--------
 misc/examples/coroutines/triples.c             |  2 +-
 13 files changed, 54 insertions(+), 43 deletions(-)

(limited to 'misc/examples/coroutines/triples.c')

diff --git a/docs/coroutine_api.md b/docs/coroutine_api.md
index b356dcf0..6bd558f2 100644
--- a/docs/coroutine_api.md
+++ b/docs/coroutine_api.md
@@ -16,7 +16,7 @@ NB! ***cco_yield\*()*** / ***cco_await\*()*** may not be called from within a `s
 |           |  Function / operator                 | Description                             |
 |:----------|:-------------------------------------|:----------------------------------------|
 |`cco_result` | `CCO_DONE`, `CCO_AWAIT`, `CCO_YIELD` | Default set of return values from coroutines |
-|           | `cco_cleanup:`                       | Label for cleanup position in coroutine |
+|           | `cco_final:`                         | Label for cleanup position in coroutine |
 | `bool`    | `cco_done(co)`                       | Is coroutine done?                      |
 |           | `cco_routine(co) {}`                 | The coroutine scope                     |
 |           | `cco_yield();`                       | Yield/suspend execution (return CCO_YIELD)|
@@ -101,13 +101,13 @@ int triples(struct triples* i) {
                         (int64_t)i->c * i->c)
                     {
                         if (i->c > i->max_c)
-                            cco_return; // "jump" to cco_cleanup if defined, else exit scope.
+                            cco_return; // "jump" to cco_final if defined, else exit scope.
                         cco_yield();
                     }
                 }
             }
         }
-        cco_cleanup:
+        cco_final:
         puts("done");
     }
     return 0; // CCO_DONE
@@ -160,7 +160,7 @@ int gcd1_triples(struct gcd1_triples* i)
             else
                 cco_yield();
         }
-        cco_cleanup:
+        cco_final:
         cco_stop(&i->tri); // to cleanup state if still active
         triples(&i->tri);  // do cleanup (or no-op if done)
     }
@@ -248,7 +248,7 @@ int produce_items(struct produce_items* p, cco_runtime* rt)
             printf("produced %s\n", cstr_str(&p->str));
             cco_yield();
         }
-        cco_cleanup:
+        cco_final:
         cstr_drop(&p->str);
         puts("done produce");
     }
@@ -273,7 +273,7 @@ int consume_items(struct consume_items* c, cco_runtime* rt)
             print_time();
             printf("consumed %s\n", cstr_str(&c->produce.str));
         }
-        cco_cleanup:
+        cco_final:
             cco_stop(&c->produce);
             cco_resume_task(&c->produce, rt);
             puts("done consume");
diff --git a/include/stc/cmap.h b/include/stc/cmap.h
index cd7430ba..e0134964 100644
--- a/include/stc/cmap.h
+++ b/include/stc/cmap.h
@@ -306,7 +306,7 @@ STC_INLINE void _cx_MEMB(_wipe_)(_cx_Self* self) {
     if (self->size == 0)
         return;
     _cx_value* d = self->data, *_end = d + self->bucket_count;
-    chash_slot* s = self->slot;
+    struct chash_slot* s = self->slot;
     for (; d != _end; ++d)
         if ((s++)->hashx)
             _cx_MEMB(_value_drop)(d);
@@ -321,7 +321,7 @@ STC_DEF void _cx_MEMB(_drop)(_cx_Self* self) {
 STC_DEF void _cx_MEMB(_clear)(_cx_Self* self) {
     _cx_MEMB(_wipe_)(self);
     self->size = 0;
-    c_memset(self->slot, 0, c_sizeof(chash_slot)*self->bucket_count);
+    c_memset(self->slot, 0, c_sizeof(struct chash_slot)*self->bucket_count);
 }
 
 #ifdef _i_ismap
@@ -359,7 +359,7 @@ _cx_MEMB(_bucket_)(const _cx_Self* self, const _cx_keyraw* rkeyptr) {
     intptr_t _cap = self->bucket_count;
     intptr_t _idx = fastrange_2(_hash, _cap);
     _cx_result b = {NULL, true, (uint8_t)(_hash | 0x80)};
-    const chash_slot* s = self->slot;
+    const struct chash_slot* s = self->slot;
     while (s[_idx].hashx) {
         if (s[_idx].hashx == b.hashx) {
             const _cx_keyraw _raw = i_keyto(_i_keyref(self->data + _idx));
@@ -394,8 +394,8 @@ _cx_MEMB(_clone)(_cx_Self m) {
     if (m.data) {
         _cx_value *d = (_cx_value *)i_malloc(c_sizeof(_cx_value)*m.bucket_count),
                   *_dst = d, *_end = m.data + m.bucket_count;
-        const intptr_t _mem = c_sizeof(chash_slot)*(m.bucket_count + 1);
-        chash_slot *s = (chash_slot *)c_memcpy(i_malloc(_mem), m.slot, _mem);
+        const intptr_t _mem = c_sizeof(struct chash_slot)*(m.bucket_count + 1);
+        struct chash_slot *s = (struct chash_slot *)c_memcpy(i_malloc(_mem), m.slot, _mem);
         if (!(d && s)) 
             { i_free(d), i_free(s), d = 0, s = 0, m.bucket_count = 0; }
         else
@@ -417,14 +417,14 @@ _cx_MEMB(_reserve)(_cx_Self* self, const intptr_t _newcap) {
     _newbucks = cnextpow2(_newbucks);
     _cx_Self m = {
         (_cx_value *)i_malloc(_newbucks*c_sizeof(_cx_value)),
-        (chash_slot *)i_calloc(_newbucks + 1, sizeof(chash_slot)),
+        (struct chash_slot *)i_calloc(_newbucks + 1, sizeof(struct chash_slot)),
         self->size, _newbucks
     };
     bool ok = m.data && m.slot;
     if (ok) {  // Rehash:
         m.slot[_newbucks].hashx = 0xff;
         const _cx_value* d = self->data;
-        const chash_slot* s = self->slot;
+        const struct chash_slot* s = self->slot;
         for (intptr_t i = 0; i < _oldbucks; ++i, ++d) if ((s++)->hashx) {
             _cx_keyraw r = i_keyto(_i_keyref(d));
             _cx_result b = _cx_MEMB(_bucket_)(&m, &r);
@@ -441,7 +441,7 @@ _cx_MEMB(_reserve)(_cx_Self* self, const intptr_t _newcap) {
 STC_DEF void
 _cx_MEMB(_erase_entry)(_cx_Self* self, _cx_value* _val) {
     _cx_value* d = self->data;
-    chash_slot* s = self->slot;
+    struct chash_slot* s = self->slot;
     intptr_t i = _val - d, j = i, k;
     const intptr_t _cap = self->bucket_count;
     _cx_MEMB(_value_drop)(_val);
diff --git a/include/stc/coroutine.h b/include/stc/coroutine.h
index 0e592bae..cecd4002 100644
--- a/include/stc/coroutine.h
+++ b/include/stc/coroutine.h
@@ -38,7 +38,7 @@ int iterpair(struct iterpair* I) {
             for (I->y = 0; I->y < I->max_y; I->y++)
                 cco_yield();
 
-        cco_cleanup: // required if there is cleanup code
+        cco_final: // required if there is cleanup code
         puts("final");
     }
     return 0; // CCO_DONE
@@ -103,7 +103,8 @@ typedef enum {
 /* cco_blocking_call(): assumes coroutine returns a cco_result value (int) */
 #define cco_blocking_call(corocall) while ((corocall) != CCO_DONE)
 
-#define cco_cleanup \
+#define cco_cleanup cco_final // [deprecated]
+#define cco_final \
     *_state = CCO_STATE_CLEANUP; case CCO_STATE_CLEANUP
 
 #define cco_return \
diff --git a/include/stc/forward.h b/include/stc/forward.h
index 085205cf..572a319f 100644
--- a/include/stc/forward.h
+++ b/include/stc/forward.h
@@ -107,8 +107,6 @@ typedef union {
         SELF##_node *last; \
     } SELF
 
-typedef struct chash_slot chash_slot;
-
 #define _c_chash_types(SELF, KEY, VAL, MAP_ONLY, SET_ONLY) \
     typedef KEY SELF##_key; \
     typedef VAL SELF##_mapped; \
@@ -125,12 +123,12 @@ typedef struct chash_slot chash_slot;
 \
     typedef struct { \
         SELF##_value *ref, *_end; \
-        chash_slot* sref; \
+        struct chash_slot* sref; \
     } SELF##_iter; \
 \
     typedef struct SELF { \
         SELF##_value* data; \
-        chash_slot* slot; \
+        struct chash_slot* slot; \
         intptr_t size, bucket_count; \
     } SELF
 
diff --git a/include/stc/priv/cqueue_hdr.h b/include/stc/priv/cqueue_hdr.h
index 90539f36..1cad8684 100644
--- a/include/stc/priv/cqueue_hdr.h
+++ b/include/stc/priv/cqueue_hdr.h
@@ -96,8 +96,8 @@ STC_INLINE void _cx_MEMB(_copy)(_cx_Self* self, const _cx_Self* other) {
 
 STC_INLINE _cx_iter _cx_MEMB(_begin)(const _cx_Self* self) {
     return c_LITERAL(_cx_iter){
-        _cx_MEMB(_empty)(self) ? NULL : self->data + self->start,
-        self->start, self
+        .ref=_cx_MEMB(_empty)(self) ? NULL : self->data + self->start,
+        .pos=self->start, ._s=self
     };
 }
 
diff --git a/misc/examples/coroutines/coread.c b/misc/examples/coroutines/coread.c
index 359ca85d..6d3acdd7 100644
--- a/misc/examples/coroutines/coread.c
+++ b/misc/examples/coroutines/coread.c
@@ -21,7 +21,7 @@ int file_read(struct file_read* g)
 
         cco_await(!cstr_getline(&g->line, g->fp));
 
-        cco_cleanup:
+        cco_final:
         printf("finish\n");
         cstr_drop(&g->line);
         if (g->fp) fclose(g->fp);
diff --git a/misc/examples/coroutines/coroutines.c b/misc/examples/coroutines/coroutines.c
index faeb71f6..802a976a 100644
--- a/misc/examples/coroutines/coroutines.c
+++ b/misc/examples/coroutines/coroutines.c
@@ -34,7 +34,7 @@ int prime(struct prime* g) {
                 cco_yield();
             }
         }
-        cco_cleanup:
+        cco_final:
         printf("final prm\n");
     }
     return 0;
@@ -68,7 +68,7 @@ int fibonacci(struct fibonacci* g) {
             }
             cco_yield();
         }
-        cco_cleanup:
+        cco_final:
         printf("final fib\n");
     }
     return 0;
@@ -92,7 +92,7 @@ int combined(struct combined* g) {
         cco_reset(&g->prm);
         cco_await_call(prime(&g->prm));
 
-        cco_cleanup:
+        cco_final:
         puts("final combined");
     }
     return 0;
diff --git a/misc/examples/coroutines/cotasks1.c b/misc/examples/coroutines/cotasks1.c
index 230bd62b..7df4eb34 100644
--- a/misc/examples/coroutines/cotasks1.c
+++ b/misc/examples/coroutines/cotasks1.c
@@ -52,7 +52,7 @@ int produce_items(struct produce_items* p)
             printf("produced %s\n", cstr_str(&p->str));
             cco_yield();
         }
-        cco_cleanup:
+        cco_final:
             cstr_drop(&p->str);
             puts("done produce");
     }
@@ -76,7 +76,7 @@ int consume_items(struct consume_items* c, struct produce_items* p)
             print_time();
             printf("consumed %s\n", cstr_str(&p->str));
         }
-        cco_cleanup:
+        cco_final:
         puts("done consume");
     }
     return 0;
diff --git a/misc/examples/coroutines/cotasks2.c b/misc/examples/coroutines/cotasks2.c
index d77a28bc..f6257a7e 100644
--- a/misc/examples/coroutines/cotasks2.c
+++ b/misc/examples/coroutines/cotasks2.c
@@ -53,7 +53,7 @@ int produce_items(struct produce_items* p, cco_runtime* rt)
             cco_yield();
         }
 
-        cco_cleanup:
+        cco_final:
         cstr_drop(&p->str);
         puts("done produce");
     }
@@ -80,7 +80,7 @@ int consume_items(struct consume_items* c, cco_runtime* rt)
             printf("consumed %s\n", cstr_str(&c->produce.str));
         }
 
-        cco_cleanup:
+        cco_final:
         cco_stop(&c->produce);
         cco_resume_task(&c->produce, rt);
         puts("done consume");
diff --git a/misc/examples/coroutines/dining_philosophers.c b/misc/examples/coroutines/dining_philosophers.c
index e917c303..d353b3b9 100644
--- a/misc/examples/coroutines/dining_philosophers.c
+++ b/misc/examples/coroutines/dining_philosophers.c
@@ -48,7 +48,7 @@ int philosopher(struct Philosopher* p)
             cco_sem_release(p->right_fork);
         }
 
-        cco_cleanup:
+        cco_final:
         printf("Philosopher %d finished\n", p->id);
     }
     return 0;
@@ -76,7 +76,7 @@ int dining(struct Dining* d)
             cco_yield(); // suspend, return control back to main
         }
 
-        cco_cleanup:
+        cco_final:
         for (int i = 0; i < num_philosophers; ++i) {
             cco_stop(&d->ph[i]);
             philosopher(&d->ph[i]);
diff --git a/misc/examples/coroutines/filetask.c b/misc/examples/coroutines/filetask.c
index 0607442d..74388359 100644
--- a/misc/examples/coroutines/filetask.c
+++ b/misc/examples/coroutines/filetask.c
@@ -28,7 +28,7 @@ int file_read(struct file_read* co, cco_runtime* rt)
             cco_yield();
         }
         
-        cco_cleanup:
+        cco_final:
         fclose(co->fp);
         cstr_drop(&co->line);
         puts("done file_read");
@@ -56,7 +56,7 @@ int count_line(struct count_line* co, cco_runtime* rt)
             cco_yield();
         }
         
-        cco_cleanup:
+        cco_final:
         cstr_drop(&co->path);
         puts("done count_line");
     }
diff --git a/misc/examples/coroutines/generator.c b/misc/examples/coroutines/generator.c
index 3f51ce9c..96498498 100644
--- a/misc/examples/coroutines/generator.c
+++ b/misc/examples/coroutines/generator.c
@@ -2,12 +2,15 @@
 
 #include <stdio.h>
 #include <stc/coroutine.h>
+#include <stc/algorithm.h>
 
 typedef struct {
-    int size;
+    int max_triples;
     int a, b, c;
 } Triple;
 
+// Create an iterable generator over Triple with count items.
+// Requires coroutine Triple_next() and function Triple_begin() to be defined.
 cco_iter_struct(Triple,
     int count;
 );
@@ -20,16 +23,15 @@ int Triple_next(Triple_iter* it) {
             for (g->a = 1; g->a < g->c; ++g->a) {
                 for (g->b = g->a; g->b < g->c; ++g->b) {
                     if (g->a*g->a + g->b*g->b == g->c*g->c) {
-                        if (it->count++ == g->size)
+                        if (it->count++ == g->max_triples)
                             cco_return;
                         cco_yield();
                     }
                 }
             }
         }
-        cco_cleanup:
-        it->ref = NULL;
-        puts("done");
+        cco_final:
+        it->ref = NULL; // stop the iterator
     }
     return 0;
 }
@@ -43,12 +45,22 @@ Triple_iter Triple_begin(Triple* g) {
 
 int main(void)
 {
-    puts("Pythagorean triples; stops at 100 triples or c >= 100:");
-    Triple triple = {.size=100};
+    puts("Pythagorean triples.\nGet max 200 triples with c < 50:");
+    Triple triple = {.max_triples=200};
+
     c_foreach (i, Triple, triple) {
-        if (i.ref->c < 100)
+        if (i.ref->c < 50)
             printf("%u: (%d, %d, %d)\n", i.count, i.ref->a, i.ref->b, i.ref->c);
         else
             cco_stop(&i);
     }
+
+    puts("\nGet the 10 first triples with odd a's and a <= 20:");
+    c_forfilter (i, Triple, triple,
+                    i.ref->a <= 20 &&
+                    (i.ref->a & 1) &&
+                    c_flt_take(i, 10)
+    ){
+        printf("%d: (%d, %d, %d)\n", c_flt_getcount(i), i.ref->a, i.ref->b, i.ref->c);
+    }
 }
diff --git a/misc/examples/coroutines/triples.c b/misc/examples/coroutines/triples.c
index 22914c2b..d6ce2791 100644
--- a/misc/examples/coroutines/triples.c
+++ b/misc/examples/coroutines/triples.c
@@ -40,7 +40,7 @@ int triples_coro(struct triples* t) {
                 }
             }
         }
-        cco_cleanup:
+        cco_final:
         puts("done");
     }
     return 0;
-- 
cgit v1.2.3