| GoLang | C89 |
|---|---|
| ```go package main import ( "fmt" "time" ) func main() { fmt.Println("Start of main Goroutine") go greetings("John") go greetings("Mary") time.Sleep(time.Second * 10) fmt.Println("End of main Goroutine") } func greetings(name string) { for i := 0; i < 3; i++ { fmt.Println(i, "==>", name) time.Sleep(time.Millisecond) } } ``` | ```c # include "coroutine.h" void_t greetings(void_t arg) { const char *name = c_const_char(arg); for (int i = 0; i < 3; i++) { printf("%d ==> %s\n", i, name); sleep_for(1); } return 0; } int co_main(int argc, char **argv) { puts("Start of main Goroutine"); go(greetings, "John"); go(greetings, "Mary"); sleep_for(1000); puts("End of main Goroutine"); return 0; } ``` |
| GoLang | C89 |
|---|---|
| ```go package main import "fmt" func main() { // create channel ch := make(chan string) // function call with goroutine go sendData(ch) // receive channel data fmt.Println(<-ch) } func sendData(ch chan string) { // data sent to the channel ch <- "Received. Send Operation Successful" fmt.Println("No receiver! Send Operation Blocked") } ``` | ```c #include "coroutine.h" void_t sendData(void_t arg) { channel_t *ch = (channel_t *)arg; // data sent to the channel chan_send(ch, "Received. Send Operation Successful"); puts("No receiver! Send Operation Blocked"); return 0; } int co_main(int argc, char **argv) { // create channel channel_t *ch = channel(); // function call with goroutine go(sendData, ch); // receive channel data printf("%s\n", chan_recv(ch)->value.str); return 0; } ``` |
| GoLang | C89 |
|---|---|
| ```go package main import "fmt" func fibonacci(c, quit chan int) { x, y := 0, 1 for { select { case c <- x: x, y = y, x+y case <-quit: fmt.Println("quit") return } } } func main() { c := make(chan int) quit := make(chan int) go func() { for i := 0; i < 10; i++ { fmt.Println(<-c) } quit <- 0 }() fibonacci(c, quit) } ``` | ```c #include "coroutine.h" int fibonacci(channel_t *c, channel_t *quit) { int x = 0; int y = 1; for_select { select_case(c) { chan_send(c, &x); unsigned long tmp = x + y; x = y; y = tmp; } select_case_if(quit) { chan_recv(quit); puts("quit"); return 0; } select_break; } select_end; } void_t func(void_t args) { channel_t *c = ((channel_t **)args)[0]; channel_t *quit = ((channel_t **)args)[1]; for (int i = 0; i < 10; i++) { printf("%d\n", chan_recv(c).integer); } chan_send(quit, 0); return 0; } int co_main(int argc, char **argv) { channel_t *args[2]; channel_t *c = channel(); channel_t *quit = channel(); args[0] = c; args[1] = quit; go(func, args); return fibonacci(c, quit); } ``` |
| GoLang | C89 |
|---|---|
| ```go package main import ( "fmt" "log" ) func main() { divByZero() fmt.Println("Although panicked. We recovered. We call mul() func") fmt.Println("mul func result: ", mul(5, 10)) } func div(x, y int) int { return x / y } func mul(x, y int) int { return x * y } func divByZero() { defer func() { if err := recover(); err != nil { log.Println("panic occurred:", err) } }() fmt.Println(div(1, 0)) } ``` | ```c #include "coroutine.h" int div_err(int x, int y) { return x / y; } int mul(int x, int y) { return x * y; } void func(void *arg) { if (co_catch(co_message())) printf("panic occurred: %s\n", co_message()); } void divByZero(void *arg) { co_recover(func, arg); printf("%d", div_err(1, 0)); } int co_main(int argc, char **argv) { launch(divByZero, NULL); printf("Although panicked. We recovered. We call mul() func\n"); printf("mul func result: %d\n", mul(5, 10)); return 0; } ``` |
| GoLang | C89 |
|---|---|
| ```go package main import ( "fmt" "sync" "time" ) func worker(id int) { fmt.Printf("Worker %d starting\n", id) time.Sleep(time.Second) fmt.Printf("Worker %d done\n", id) } func main() { var wg sync.WaitGroup for i := 1; i <= 5; i++ { wg.Add(1) i := i go func() { defer wg.Done() worker(i) }() } wg.Wait() } ``` | ```c #include "coroutine.h" void_t worker(void_t arg) { // int id = c_int(arg); int id = co_id(); printf("Worker %d starting\n", id); sleep_for(1000); printf("Worker %d done\n", id); if (id == 4) return (void_t)32; else if (id == 3) return (void_t)"hello world\0"; return 0; } int co_main(int argc, char **argv) { int cid[5]; wait_group_t wg = wait_group(); for (int i = 1; i <= 5; i++) { cid[i-1] = go(worker, &i); } wait_result_t wgr = wait_for(wg); printf("\nWorker # %d returned: %d\n", cid[2], wait_result(wgr, cid[2]).integer); printf("\nWorker # %d returned: %s\n", cid[1], wait_result(wgr, cid[1]).string); return 0; } ``` |
| C++ 20 | C89 |
|---|---|
|
```c++
// future::wait
#include |
```c #include "coroutine.h" // a non-optimized way of checking for prime numbers: void *is_prime(args_t arg) { int i, x = get_arg(arg).integer; for (i = 2; i < x; ++i) if (x % i == 0) return thrd_value(false); return thrd_value(true); } int co_main(int argc, char **argv) { int prime = 194232491; // call function asynchronously: future fut = thrd_async(is_prime, thrd_value(prime)); printf("checking...\n"); // Pause and run other coroutines // until thread state changes. thrd_wait(fut, co_yield_info); printf("\n194232491 "); if (thrd_get(fut).boolean) // guaranteed to be ready (and not block) after wait returns printf("is prime.\n"); else printf("is not prime.\n"); return 0; } ``` |