Is event-based code possible?

[stefanos82]

If I wanted to write some code that gets executed asynchronously, like using async / await, how would I do that in Nelua?

Can coroutines be used in such way that could emulate such behavior?

[ryanford]

If you want to write evented code, you need an event loop. I think a way to do that in Nelua that would be idiomatic would involve a coroutine scheduler. If you're familiar with the Lua ecosystem, I think cqueues would be a good example of this.

[edubart]

If I wanted to write some code that gets executed asynchronously, like using async / await, how would I do that in Nelua?

Can coroutines be used in such way that could emulate such behavior?

I see three approaches to write asynchronous code:

• Callback hell (using plain callbacks)
• Stackless coroutines (async / await in some languages like Javascript/Nim)
• Stackful coroutines, also known as true coroutines (Lua/Nelua way)

Callback hell you can mostly do in any language, just use callbacks for your asynchronous code, this can work fine and probably is the most efficient way, the problem with it is that the code can become unreadable, and tracking state across state continuations can become a complex, leading to spaghetti code and bugs, it's not ideal to write asynchronous code using just callbacks, hence the name.

Stackless coroutines allows you to do continuations of functions, but you have limitations such as needing to explicit mark a function as async and then await can only be used in its scope following some rules, in many implementations this way will usually break when using some natural code, like when trying to await in a subroutine. While it has some limitations it's very lightweight approach as it doesn't have to allocate a true stack frame, switching coroutine context is trivial, and can be supported in any platform. In summary, stackless coroutines uses less memory, less instructions to do context switches, and is more portable, but usually you cannot write natural code, because under the hood async functions are not true functions, they are kind of "fake" functions.

Stackful coroutines like Lua and Nelua have via the coroutine module, in my biased opinion, are more powerful, clean and better to use than stackless coroutines. With stackful coroutines you can do continuations of functions, like stackless coroutines, but have the advantage of having a true "thread" stack frame for your coroutine, allowing to write natural code with your coroutines, so waiting in subroutines is possible and fine. But the price you pay is that each coroutine needs to allocate a full "thread" stack (that is about 64KB in Nelua by default) thus it uses more memory, also to switch a coroutine context costs more instructions to setup OS registers/stack state, it's not available in all platforms and supporting a new platform requires coding some assembly instructions. At the moment Nelua supports x86, ARM, RISC-V and WebAssembly platforms, and it is implemented via minicoro side project, its implementation was inspired by Mike Pall's (LuaJIT author) true C coroutines for Lua.

Nelua chooses stackful coroutines due to its Lua influence, and in my biased opinion the price pays off, as it can be simpler to use and powerful.

If you want to write _event_ed code, you need an event loop. I think a way to do that in Nelua that would be idiomatic would involve a coroutine scheduler. If you're familiar with the Lua ecosystem, I think cqueues would be a good example of this.

Like @ryanford said, to put coroutines to work you need some event loop first that generates callbacks so you can resume coroutines based on events.

A popular, cross platform, and widely available even loop library is libuv, for instance it is used by node.js in Javascript world and Luvit in the Lua ecosystem, there are bindings for it in nelua-decl, plus there is an example of using it with Nelua coroutines in this example.

A lightweight, popular among embedded devices, cross platform, easy to use event loop library for networking only is mongoose, it's used a lot in the IoT world, it's just a single C file thus very easy to setup. Again there are bindings for it in nelua-decl, plus there is an example of using it with Nelua coroutines in this example.

There are many other event loop library choices for C you could use, just generate the bindings. Or in the game development context, it's common to make your own event loop and scheduler, where you could use coroutines to do game logic based of events.

[stefanos82]

@ryanford and @edubart, thank you both for your informative replies.