Merge pull request #60 from helixlang/compliance/current-to-new-standard

**Extended Description:**
This merge brings the `compiler-v0.0.1` branch into alignment with the evolving Helix language standard. The goal of this update is to unify syntax conventions, improve clarity of declarations, and expand the core runtime library with essential functionality for both developers and end-users.

The updates span parser refactors, runtime improvements, and new standard library APIs, making this one of the most substantial shifts since the compiler’s initial release. While most changes are backward-compatible, operator declarations introduce a breaking change that requires migration.

### Why These Changes?

* **Consistency:** Operator and interface syntax were updated to follow a single, predictable pattern (`impl` replaces `has`, operator functions now use `fn op`). This simplifies parsing and improves readability.
* **Ergonomics:** The shorthand `impl` and `derives` syntax reduces boilerplate, making generic constraints and trait usage more concise without sacrificing clarity.
* **Capability Expansion:** New corelib APIs (`std::process`, `std::system`, `std::Stacktrace`, `std::ABI`) provide critical runtime utilities for process management, debugging, and ABI-level symbol handling.
* **Error Handling Improvements:** Panics now default to throwing at the panic site, removing the need for explicit `?` returns while still surfacing clear diagnostics.

### Key Additions

* Operator declarations migrated to new form.
* Shorthand syntax for `impl` and `derives` added.
* New runtime APIs in `std`:

  * Process spawning (`Subprocess`, `ProcessOutput`).
  * Command execution (`system`).
  * Symbol mangling/demangling (`ABI`).
  * Runtime stacktraces.
* Updated test suite and build system to reflect new standards.
* Improved parsing for generics, `where` bounds, and declaration handling.

### Breaking Changes

* **Operator Declarations:**

  * **Old:** `op <symbol> fn <name>(...) -> <ret> {}`
  * **New:** `fn op <symbol>(...)[<alias>] -> <ret> {}`
* Requires clause update is **not** breaking — old syntax remains supported.

### Migration Notes

* All operator functions must be rewritten to the new `fn op` form.
* No changes required for `requires` clauses, but adopting the new form is recommended.
* Code relying on `has` must be updated to `impl`.

### Impact

This merge provides a cleaner, more consistent foundation for Helix going forward, while introducing key runtime and tooling capabilities necessary for real-world application development. Contributors should expect minor refactoring in existing codebases (mostly operator declarations), but otherwise migration is smooth.

Author: Ze7111

.vscode/launch.json

@@ -7,10 +7,9 @@
             "name": "Launch",
             "target": "helix",
             "args": [
-                "/Volumes/Development/Projects/Helix/helix-lang/tests/main.hlx",
-                "--emit-ast"
+                "tests/test.hlx"
             ],
-            "cwd": "${cwd}/helix-lang/",
+            "cwd": "${cwd}",
             "stopAtEntry": true
         }
     ]

assets/code/arc/async-example.hlx

@@ -6,8 +6,8 @@ async fn fetch_data() -> string {
 }
 
 fn main() {
-    let future: Future = spawn fetch_data(); // start a os-manged child process
-    let data = await future;
+    var future: Future = spawn fetch_data(); // start a os-manged child process
+    var data = await future;
 
     for i in data:
         print(f"{i=}", end=", ");

assets/code/arc/control-flow-example.hlx

@@ -1,4 +1,4 @@
-let x: int = 10;
+var x: int = 10;
 
 if x > 5 {
     print("x is greater than 5");
@@ -12,6 +12,6 @@ unless x < 5 { // unless is the same as if not
     print("x is 5 or less");
 }
 
-for let i: int = 0; i < 10; i += 1{
+for var i: int = 0; i < 10; i += 1{
     print(i);
 }

assets/code/arc/ffi-example.hlx

@@ -2,13 +2,13 @@ ffi "python" import sympy as sp;
 ffi "c++"    import "circle.hh";
 
 fn main() {
-    let eq1: sp::Eq  = sp::Eq(x + y, 10)
-    let eq2: sp::Eq  = sp::Eq(x - y, 4)
-    let solutions  = sp.solve((eq1, eq2), (x, y)); // type inferd by the compiler
+    var eq1: sp::Eq  = sp::Eq(x + y, 10)
+    var eq2: sp::Eq  = sp::Eq(x - y, 4)
+    var solutions  = sp.solve((eq1, eq2), (x, y)); // type inferd by the compiler
 
     print(solutions);
 
-    let circle = circle::Circle{10, 20};
+    var circle = circle::Circle{10, 20};
 
     print(circle->to_string());
 }

assets/code/arc/showcase.hlx

@@ -1,6 +1,6 @@
 class Point {
-    let x: int;
-    let y: int;
+    var x: int;
+    var y: int;
 
     eval fn Point(self, x: int, y: int) {
         self.x = x;
@@ -18,14 +18,14 @@ class Point {
 }
 
 fn main() {
-    let p = Point(0, 0);
+    var p = Point(0, 0);
 
     for i in 1..4 {
         p.move(i, i);
         p.display();
     }
 
-    let value: u32 = p.x as u32;
+    var value: u32 = p.x as u32;
 
     match value {
         0 -> print("The point is at the origin"),

assets/code/arc/type-bounds-example.hlx

@@ -4,7 +4,7 @@ interface Drawable {
 }
 
 class Circle derives Drawable {
-    let radius: float;
+    var radius: float;
 
     fn Circle(self, radius: float) {
         self.radius = radius;
@@ -20,7 +20,7 @@ class Circle derives Drawable {
 }
 
 class Square derives Drawable {
-    let side: float;
+    var side: float;
 
     fn Square(self, side: float) {
         self.side = side;
@@ -35,15 +35,15 @@ class Square derives Drawable {
     }
 }
 
-fn draw_all(...objects: T)
-  requires <T> if T is Drawable {
+fn <T> draw_all(...objects: T)
+  requires T impl Drawable {
     for obj in objects {
         obj.draw();
     }
 }
 
 fn main() {
-    let shapes = (Circle(1.0), Square(1.0), Circle(2.0)); // type of tuple
+    var shapes = (Circle(1.0), Square(1.0), Circle(2.0)); // type of tuple
 
     draw_all(shapes...);
 }

assets/code/language/types.hlx

@@ -14,15 +14,15 @@ fn main() -> i32 {
         delete int_holder
     }
 
-    // Helix has type inference, so theres no need to specify the type of value. But any modifiers
+    // Helix impl type inference, so theres no need to specify the type of value. But any modifiers
     // like pointers, questionable, etc. must be specified. (enforced for readability and safety)
     var *value? = int_holder.get(1)
 
     if !(value?) { // if value is null or panicked
         value = Heap::construct<int>(21) // Equivalent to new int(21) in C++
     }
 
-    // Helix has support for named parameters/default values
+    // Helix impl support for named parameters/default values
     var *invalid_value? = int_holder.get(index=100) // Attempt to fetch an out-of-bounds value
 
     if invalid_value?:
@@ -40,14 +40,14 @@ fn main() -> i32 {
 // Structs in Helix are data containers with no methods.
 // They can include: operator overloads, nested structs, destructors, enums, and fields.
 // All fields are public by default.
-struct Data {
+struct <T> Data {
     // Regular pointers: non-nullable, no arithmetic, and auto-dereferenced (like references in other languages).
     var value: *T?
 }
 
 // Classes in Helix support methods, fields, and constructors.
 // Fields are private by default, while methods and constructors are public by default.
-class Holder requires <T> {
+class <T> Holder {
     // Unsafe pointers: nullable, allow pointer arithmetic, and require manual dereferencing.
     var num_values:  usize
     var many_values: unsafe *Data
@@ -67,7 +67,7 @@ class Holder requires <T> {
         }
     }
 
-    op delete fn (self) {
+    fn op delete (self) {
         for i in 0..self.num_values {
             if self.many_values[i].value? {
                 Heap::drop(self.many_values[i].value)
@@ -77,8 +77,7 @@ class Holder requires <T> {
         Heap::drop(self.many_values)
     }
 
-    fn get(self, index: usize) -> *T?
-      requires <T> {
+    fn <T> get(self, index: usize) -> *T? {
         if index < self.num_values {
             return self.many_values[index].value
         } else {

build.hlx

@@ -0,0 +1,47 @@
+/*
+Everything in the api:
+fn set_target(name: string)
+fn end_target(name: string? = null)
+fn set_builddir(path: string)
+fn set_project(name: string)
+fn set_version(version: string)
+fn set_description(description: string)
+fn add_links(links: vec::<string>)
+fn add_link(link: string)
+fn add_include(include: string)
+fn add_includes(includes: vec::<string>)
+fn add_source(source: string)
+fn set_linkage(linkage: Linkage)
+fn after_build(callback: fn (*Target) -> void)
+fn before_build(callback: fn (*Target) -> void)
+fn set_cxxflags(flags: vec::<string>)
+fn add_define(name: string, value: string)
+
+*/
+import vial::rt::api::*;
+
+fn build() -> i32 {
+
+    set_target("vial_runtime");
+        add_source("vial/rt/api.hlx");
+        add_source("vial/rt/logger.hlx");
+        add_source("vial/rt/fs.hlx");
+
+        add_include("vial/");
+        set_cxxflags(["-std=c++20", "-Wall", "-Wextra", "-Werror"]);
+        add_define("USING_MSVC", "true");
+        add_define("USING_CLANG", "true");
+    end_target();
+
+    set_target("vial_build");
+        add_source("vial/vial.hlx");
+        add_include("vial/");
+        
+        set_cxxflags(["-std=c++20", "-Wall", "-Wextra", "-Werror"]);
+        
+        add_define("USING_MSVC", "true" );
+        add_define("USING_CLANG", "true" );
+    end_target();
+
+    return 0;
+}

lang/arc/.hlx

@@ -4,8 +4,8 @@
 
 
 class Point {
-    pub let x: f32
-    pub let y: f32
+    pub var x: f32
+    pub var y: f32
 }
 
 
@@ -15,7 +15,7 @@ class Shape {
 
 class Circle derives Shape {
     pub fn area() -> f32 { return 3.14 * radius * radius }
-    pub let radius: f32
+    pub var radius: f32
 }
 
 class Base {
@@ -53,12 +53,12 @@ fn make_noise(a: Box<Animal>) {
     print(a.speak()) // Uses v-table lookup
 }
 
-fn make_noise(a: T) requires <T> if T has Animal {
+fn <T> make_noise(a: T) requires T impl Animal {
     print(a.speak())  // No v-table lookup, method is inlined
 }
 
 class SecureData {
-    priv let key: str
+    priv var key: str
 
     pub fn get_key() -> str { return key }
 }