free idea please steal, a goose inspired d preprocessor

[monkyyy]

background: goose won this bench mark there was twitter drama
https://kostya.github.io/LangArena/ language benchmarks still 
need to ask the languages for their best work. blah blah blah.

A vibe coded language(ive heard using "only" a 200$ month plan), 
added templates, nullables, sumtypes, and a opinionated default 
slicable data structure that compiles down to C

D still has the fundamental issues around slices being both a 
dynamic array and reference, that spookily breaks unnecessarily.

it uses syntax like `T[>..256]` "this is an array of 256 that may 
shrink from the front", aint that interesting, wonder if that 
related to ranges. :bigthink:

It uses ? to mean nullable

and rust enums for sumtypes; 
https://forum.dlang.org/thread/smnagrlaaddffxtphbks@forum.dlang.org (hmmm a full parser to do that.... hmmmmmm)

I think someone with 200$ of ai should try this sort of prompt:

```
using https://code.dlang.org/packages/bettersum and 
https://github.com/aardappel/goose as reference material

make a dlang preprocessor with:
1. opinionated slicing
2. nullable as a `?`
3. rust-style sumtype syntax

collect 5 or so good dataoriented design approved datastructures, 
keep track of usage of appends, deletes, popfront, popback, 
random access, etc.

define a syntax for `T[>..256]` that takes the best ideas between 
goose and dlangs ranges

if user defines a type "ball", assume a datastructure "balls" 
will need to exist and the user will need to do range-like 
operation on the "balls", collect these requirements in the 
processor then using heuristics pick the best matching 
datastructure for the job
```

it might work