No need for that, I checked it, it's a good little language but not near Rust or Nim
The way you designed bound checking, parameter inferences is more a source of bugs than anything
I didn't see support for advanced closures and how it's integrated with the borrow checker (since you claim not having lifetimes, there are tons of unanswered questions in your thing)
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
Finally I don't understand whant Stricta is supposed to achieve.
Is it a stricter python ? If it's the case then why doesn't talk about compatibility ? why does it diverge from python on the semantic side ?
If it's just python like... then why the pythonish choices ? like hardcoded python types and OOP ?
Does it suffer from the same trap as Dlang, in that their GC is also optional, but you lose the many of the conveniences from the standard library if you forgo completely with it?
GC is optional in the sense "don't use `ref` types and there will be no GC"
Value types (`object`) use mutable value semantics and scope based destructors, so there are safe without GC
I don't think we can call that transpilation as it's not a 1:1 conversion
But yeah, the native backend and LLVM backend definitively close the "transpilation" door
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
Finally I don't understand whant Stricta is supposed to achieve. Is it a stricter python ? If it's the case then why doesn't talk about compatibility ? why does it diverge from python on the semantic side ? If it's just python like... then why the pythonish choices ? like hardcoded python types and OOP ?
reply