Compliance/current to new standard

.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 }
 }