kal VS effection

It's obsolete now, but before async/await was part of JS proper I worked on a compile-to-JS language that handled this by compiling to callbacks: https://github.com/rzimmerman/kal

It included try/catch support and fancy stuff, like loops. The source may be interesting for anyone interested in compilers: https://github.com/rzimmerman/kal/blob/master/source/generat...

The Kal compiler is written in Kal, but it's supposed to be easy to read. Surprisingly the browser demo still works: http://rzimmerman.github.io/kal/demo.html

Have a look at effection,which seems to share some ideas: https://frontside.com/effection

While working on effection (https://github.com/thefrontside/effection) we spent a bunch of time ensuring that our delimited continuations could handle deep recursive call stacks in Deno.

PR: https://github.com/thefrontside/continuation/pull/11

TCO would have definitely simplified this issue.

What’s worse is hitting maximum memory callstack exception is very tricky to catch and is not reliable across runtimes. So when a user hits it it can be tricky to track down.

`redux-saga` maintainer here.

I've been using `effection` to build a replacement for `redux-saga` over at https://github.com/neurosnap/starfx

Effection has demonstrated to me how truly powerful delimited continuations are and why structured concurrency is an incredible asset for anything that requires async flow control -- basically everything in TS/JS.

I know sometimes it's hard to imagine why someone would need structured concurrency or care about delimited continuations for a front-end application, but this is a game changer in terms of expressing async flow control.

Some things to note about Effection:

- API surface area is small https://github.com/thefrontside/effection/issues/851

- It tries to stay as close to JS constructs as possible so it will feel very familiar

- Resource cleanup is automatic (when a function passes out of scope all descendent tasks are shut down automatically)

- End-user doesn't need to think about delimited continuations

The only leap users need to "deal with" coming from async/await is the syntax.

    import { main, call } from "effection";

- https://github.com/thefrontside/continuation

- https://github.com/thefrontside/effection/tree/v3

- https://github.com/neurosnap/starfx

The last one intends to replace redux-saga using DCs.

Here’s a presentation I gave recently talking about DCs in typescript: https://youtu.be/uRbqLGj_6mI?si=XI0JNMKMoO2VHMvM

https://github.com/thefrontside/effection/tree/v3