cps

If your language has macros, you don't need to wait for it to gain async/await (and it was quite a wait even in Python and JS, while Java got its virtual threads very recently); you can just[1] implement a CPS transform as a macro: https://github.com/nim-works/cps/blob/master/docs/cps.svg [1] Yeah, I know, this word is extremely overworked in that sentence. Sorry, that's an exaggeration for effect. In reality, it's not that simple, and not always possible: it depends on the language and macro system. It's still more likely to be implementable in library code if there is a macro system, though.

This'll get you closer: https://github.com/nim-works/cps Sorry, I was in a hurry.

`when myCondition():` instead of `if myCondition:` is done at compile-time. Alternatively you can use a `static:` code block to force compile time evaluation. Or tag a function {.compileTime.} or tag function inputs with `static` modifier. It is possible to create a compiler or an assembler running fully in Nim macros as well: - https://github.com/mratsim/constantine/blob/master/constanti... (all that file runs at compile-time) You can also implement Continuation-Passing-Style transformation at compile-time: - https://github.com/nim-works/cps Or a neural network DSL or for a self-contained example, einsum: - https://github.com/mratsim/Arraymancer/blob/master/src/array... It's worth noting that nim async/await transformation is fully implemented as a library in macros.

There has been a more-or-less working CPS implementation for Nim for a few years now: https://github.com/nim-works/cps https://github.com/nim-works/cps/tree/master/docs Nobody seems to care though, as it has gained no traction at all and it has been mostly ignored by the core team.

Ones that have not been mentioned so far: - npeg lets you write PEGs inline in almost normal notation: https://github.com/zevv/npeg - owlkettle is a declarative macro-oriented library for GTK: https://github.com/can-lehmann/owlkettle - ratel is a framework for embedded programming: https://github.com/PMunch/ratel - futhark provides for much more automatic C interop: https://github.com/PMunch/futhark - nimpy allows calling Python code from Nim and vice versa: https://github.com/yglukhov/nimpy - questionable provides a lot of syntax sugar surrounding Option/Result types: https://github.com/codex-storage/questionable - nlvm is an unofficial LLVM backend: https://github.com/arnetheduck/nlvm - chronos is an alternative async/await backend: https://github.com/status-im/nim-chronos - cps allows arbitrary procedure rewriting in continuation passi

I think the CPS attempt in Nim could do this https://github.com/nim-works/cps

* Goroutines are probably a lot more easier to use. Work is being done to make Nim even better in that area: https://github.com/nim-works/cps but don't expect it soonish. * I feel like Go has less 'edge cases', but the Nim compiler is steadily getting more stable, especially consider it's not backed up by a major company! * Metaprogramming is really powerful, but not beginner friendly. The documentation says use macros when necessary, but personally I don't think that really happens in practice. The advantages by far outweigh the disadvantages, especially if you are looking for a clean Go alternative(except maaaaaaybeee web application). EDIT: my own wishlist, but they aren't relevant compared to Go: * Better sum types * Builtin pattern matching