goose

C++ code that does what Goose does is a soup of pointer manipulation, casts and byte stuffing. You could write that, but Goose proves it to be safe at compile time, with simple readable code. The moment you write "reasonable" code in C++, it is actually a lot slower than Goose. For details on how, see https://github.com/aardappel/goose

As I mention at the end of https://github.com/aardappel/goose/blob/master/README.md I essentially had it use a previous compiler of mine (Lobster) as a template. Even if you don't have such an example, pick a project that you think has "good code" (even if it is not your own), point the LLM at it, tell it to have a deep read of the code, and come up with a very in-depth coding guideline in a .md file with code patterns etc. Then put that .md in your new project and tell it to follow it.

it's too late to edit but i saw the prior art on github now https://github.com/aardappel/goose/blob/master/docs/design/p... anyway, hope this project goes well! the secret of the arena allocator seems to be out now to the mainstream. I think this is also a strength of array programming languages in the tradition of APL/J/K/Q. As this project develops, I'll get to benefit from your public crowd sourced testing and design before having to publicize mine :P

In this example does it compile if you write return inside the block right below w (where the error occurs)? https://github.com/aardappel/goose#safe-references-no-annota... Hows the compile time? Do you have a number or is it similar to another language?

These are some downsides: https://github.com/aardappel/goose/blob/master/docs/tutorial...

https://github.com/aardappel/goose/blob/master/samples/18_js... Goose can store entire trees (of variable sized things) inside an array.

I'm not familiar with Goose, but I'm guessing you could define a single stack and put your dynamically sized values in it. Essentially rewriting a memory allocator on top of Goose's stacks. This is what they seem to be doing here: https://github.com/aardappel/goose/blob/master/samples/13_li...

Yes, ML Kit region inference is probably the closest prior art to Goose. Back then though, they couldn't lean on large 64-bit address spaces like Goose can. They implemented all of this with a chain of blocks of memory instead, and tracked most of it at runtime that Goose now does at compile time. https://github.com/aardappel/goose/blob/master/docs/design/p...

In this particular combination, most certainly. There is lots of prior art on the individual parts of the design, e.g. "regions" and various stack languages etc, see: https://github.com/aardappel/goose/blob/master/docs/design/p... Part of this is that 64-bit address spaces make this design practical, and almost all languages in use today were designed with the limitations of 32-bit in mind. Once you can assign arrays huge amounts of address space, you don't have to realloc, which gets you stable pointers, and a lot of the other Goose features.

Btw I made the language, AMA. repo: https://github.com/aardappel/goose