Your desing of generic instantiation is just a compile time pit. You don't constraint type so you need to check the body of every instance
You have NLL yeah, but not partial borrows nor the capacity for a proc to return one of it's parameters (the famous example
```rs
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { if x.len() > y.len() { x } else { y } }
```
since you don't have lifetimes, either you refuse this case or it's a bug if you do a copy then your language asks it's user to use value semantics
But if your language mostly push users to value semantics (a.k.a copying tons of things) then why all the borrow stuff ? If there is no lifetime how is one suposed to store references ? why is there a ref, ref_mut type ?
Those are overly convoluted choices for a value based language So it's a bit of an incoherence
Next there is the way you handle indexing your spec state that undecided index access generate stricta_bounds_fail, but this function just output an error and exit the process, it doesn't insert a runtime check
So undecided index access act as nuke in the codebase, the users is not even aware that one of it's access is undecided, and when he expect it the less he just get the process stopped, no exceptions, just a crash
Then you don't even correctly handle cyclic data type structure, you defined in the codebase an arbitrary depth of 16 instead of checking type cycle (and what you stated in your spec just worked auto referencing types like type A with a field of type A again
There is either a catch here or you(r LLM) has solved multiple open research problems.