marwood VS inko

https://github.com/strtok/marwood checkmate liberal

GitHub

I have implemented a Scheme R7 compiler & virtual machine in Rust called [Marwood](https://github.com/strtok/marwood/).

Check out this project marwood that started recently with is Scheme WASM compiler written in Rust. It's a new project so it probably will be simple to get familiar with.

The lexer can be found here and parser here.

Performance at the moment is a bit iffy. In theory Inko should be able to outperform Wren and Lua, but in practice method calls are a bit too expensive due to how stack frames are managed (see this issue for some details). Adding a set of benchmarks is definitely something I want to do, but I just haven't gotten to it yet.

You can use Inko as a reference, as its VM is written in Rust. I do recommend using this branch instead of the latest release, as there are a lot of upcoming changes to the language as a whole.

Code wise it requires either a ton of code, or a whole bunch of macros. I used the latter approach (see here). Even after optimising this, you'll still end up with a bucket of extra code/macros.

Various modules use VM instructions to access built-in functionality, such as adding integers. Here is an example. The compiler transforms these into actual instructions (bytecode wise). So _INKOC.foo_bar basically means "run the foo_bar instruction".

Probably the most common approach in a statically typed language is to use some form of pattern matching. For Inko I do exactly that in its type checker (example here). Prior to this I was using the visitor pattern using double dispatch, but this was painful to work with. The pattern matching approach is type-safe, quite easy to extend, and easy to wrap your head around.

I wrote some IPv4 and IPv6 parsing code before, but wasn't aware of the various crazy IPv4 formats.

Resuming a generator is pretty simple too: take the generator, swap it with the current one, then set its parent to the previous generator (the one we just swapped out).