'let' it be

12 files changed, 133 insertions, 133 deletions

diff --git a/tests/std/test_env.zc b/tests/std/test_env.zc
index 75bba3b..25d5bc1 100644
--- a/tests/std/test_env.zc
+++ b/tests/std/test_env.zc
@@ -2,34 +2,34 @@ import "std.zc"
 import "std/env.zc"
 
 test "test_std_env_set_and_get" {
-    var res = Env::set("TEST1", "ok1");
+    let res = Env::set("TEST1", "ok1");
     assert(res == EnvRes::OK(), "result should be EnvRes::OK()");
 
-    var env_var = Env::get("TEST1");
+    let env_var = Env::get("TEST1");
     assert(env_var.is_some(), "env_var should have a value");
     assert(env_var.unwrap() == "ok1", "env_var should be ok1");
 }
 
 test "test_std_env_set_with_overwrite" {
-    var res = Env::set("TEST2", "ok2");
+    let res = Env::set("TEST2", "ok2");
     assert(res == EnvRes::OK(), "res should be EnvRes::OK()");
 
-    var res2 = Env::set("TEST2", "ok2-ovwr");
+    let res2 = Env::set("TEST2", "ok2-ovwr");
     assert(res2 == EnvRes::OK(), "res2 should be EnvRes::OK()");
 
-    var env_var = Env::get("TEST2");
+    let env_var = Env::get("TEST2");
     assert(env_var.is_some(), "env_var should have a value");
     assert(env_var.unwrap() == "ok2-ovwr", "env_var should be ok2-ovwr");
 }
 
 test "test_std_env_get_dup" {
-    var res = Env::set("TEST3", "ok3");
+    let res = Env::set("TEST3", "ok3");
     assert(res == EnvRes::OK(), "result should be EnvRes::OK()");
 
-    var env_var = Env::get_dup("TEST3");
+    let env_var = Env::get_dup("TEST3");
     assert(env_var.is_some(), "env_var should have a value");
 
-    var value = env_var.unwrap();
+    let value = env_var.unwrap();
     assert(value.c_str() == "ok3", "value should be ok3");
 
     value.free();
@@ -38,24 +38,24 @@ test "test_std_env_get_dup" {
 }
 
 test "test_std_env_get_and_get_dup_with_invalid" {
-    var env_var = Env::get("TEST4");
+    let env_var = Env::get("TEST4");
     assert(env_var.is_none(), "env_var should not have a value");
 
-    var env_var2 = Env::get_dup("TEST4");
+    let env_var2 = Env::get_dup("TEST4");
     assert(env_var2.is_none(), "env_var2 should not have a value");
 }
 
 test "test_std_env_unset" {
-    var res = Env::set("TEST5", "ok5");
+    let res = Env::set("TEST5", "ok5");
     assert(res == EnvRes::OK(), "res should be EnvRes::OK()");
 
-    var env_var = Env::get("TEST5");
+    let env_var = Env::get("TEST5");
     assert(env_var.is_some(), "env_var should have a value");
     assert(env_var.unwrap() == "ok5", "env_var should be ok5");
 
-    var res2 = Env::unset("TEST5");
+    let res2 = Env::unset("TEST5");
     assert(res2 == EnvRes::OK(), "res2 should be EnvRes::OK()");
 
-    var env_var2 = Env::get("TEST5");
+    let env_var2 = Env::get("TEST5");
     assert(env_var2.is_none(), "env_var2 should not have a value");
 }
diff --git a/tests/std/test_fs.zc b/tests/std/test_fs.zc
index 1b6eb56..8a2c5f5 100644
--- a/tests/std/test_fs.zc
+++ b/tests/std/test_fs.zc
@@ -6,64 +6,64 @@ test "test_std_fs_extended" {
     "Testing FS Extension...";
     
     "Testing Path...";
-    var p = Path::new("/var/log");
-    var p2 = p.join("syslog");
-    assert(strcmp(p2.c_str(), "/var/log/syslog") == 0, "Join failed");
+    let p = Path::new("/let/log");
+    let p2 = p.join("syslog");
+    assert(strcmp(p2.c_str(), "/let/log/syslog") == 0, "Join failed");
     
-    var p3 = Path::new("file.txt");
-    var ext = p3.extension();
+    let p3 = Path::new("file.txt");
+    let ext = p3.extension();
     assert(ext.is_some(), "Extension missed");
     assert(strcmp(ext.unwrap_ref().c_str(), "txt") == 0, "Wrong extension");
     
-    var p4 = Path::new("/usr/bin/gcc");
-    var parent = p4.parent();
+    let p4 = Path::new("/usr/bin/gcc");
+    let parent = p4.parent();
     assert(parent.is_some(), "Parent missed");
     assert(strcmp(parent.unwrap_ref().c_str(), "/usr/bin") == 0, "Wrong parent");
     
-    var fname = p4.file_name();
+    let fname = p4.file_name();
     assert(fname.is_some(), "Filename missed");
     assert(strcmp(fname.unwrap_ref().c_str(), "gcc") == 0, "Wrong filename");
     
     "Testing FS...";
-    var test_dir = "tests/test_fs_sandbox";
+    let test_dir = "tests/test_fs_sandbox";
     
     if (File::exists(test_dir)) {
         File::remove_dir(test_dir); 
     }
     
     "Create Dir";
-    var res = File::create_dir(test_dir);
+    let res = File::create_dir(test_dir);
     if (res.is_err()) {
         "Dir create failed";
     }
     assert(File::exists(test_dir), "Dir create failed");
     
     "Write File";
-    var tmp_path = Path::new(test_dir);
-    var p_file = tmp_path.join("hello.txt");
-    var fpath = p_file.c_str();
-    var f_res = File::open(fpath, "w");
+    let tmp_path = Path::new(test_dir);
+    let p_file = tmp_path.join("hello.txt");
+    let fpath = p_file.c_str();
+    let f_res = File::open(fpath, "w");
     assert(f_res.is_ok(), "File create failed");
-    var f = f_res.unwrap();
+    let f = f_res.unwrap();
     f.write_string("Hello World");
     f.close();
     
     assert(File::exists(fpath), "File exists check failed");
     
     "Metadata";
-    var meta_res = File::metadata(fpath);
+    let meta_res = File::metadata(fpath);
     assert(meta_res.is_ok(), "Metadata failed");
-    var meta = meta_res.unwrap();
+    let meta = meta_res.unwrap();
     assert(meta.is_file, "Is file check failed");
     assert(!meta.is_dir, "Is dir check failed");
     assert(meta.size == 11, "Size check failed");
     
     "Read Dir";
-    var list_res = File::read_dir(test_dir);
+    let list_res = File::read_dir(test_dir);
     assert(list_res.is_ok(), "Read dir failed");
     
-    var entries = list_res.unwrap();
-    var found_idx = -1;
+    let entries = list_res.unwrap();
+    let found_idx = -1;
     for entry in &entries {
         if (strcmp((*entry).name.c_str(), "hello.txt") == 0) {
             found_idx = 1;
diff --git a/tests/std/test_map_iter.zc b/tests/std/test_map_iter.zc
index efce356..a366854 100644
--- a/tests/std/test_map_iter.zc
+++ b/tests/std/test_map_iter.zc
@@ -2,14 +2,14 @@ import "std/map.zc"
 import "std/string.zc"
 
 test "map_iterator" {
-    var m = Map<int>::new();
+    let m = Map<int>::new();
     
     m.put("one", 1);
     m.put("two", 2);
     m.put("three", 3);
     
-    var count = 0;
-    var sum = 0;
+    let count = 0;
+    let sum = 0;
     
     for entry in m {
         count = count + 1;
diff --git a/tests/std/test_net.zc b/tests/std/test_net.zc
index 98ba32f..638bace 100644
--- a/tests/std/test_net.zc
+++ b/tests/std/test_net.zc
@@ -9,29 +9,29 @@ import "std/result.zc"
 test "test_net" {
     "Testing Networking...";
     
-    var t = Thread::spawn(fn() {
-        var listener = TcpListener::bind("127.0.0.1", 9090);
+    let t = Thread::spawn(fn() {
+        let listener = TcpListener::bind("127.0.0.1", 9090);
         if (listener.is_err()) {
             !"Server bind failed"; 
             return;
         }
         
-        var l = listener.unwrap();
+        let l = listener.unwrap();
         
-        var client_res = l.accept();
+        let client_res = l.accept();
         if (client_res.is_err()) {
             !"Accept failed";
             l.close();
             return;
         }
         
-        var client = client_res.unwrap();
+        let client = client_res.unwrap();
         
-        var buf: char* = malloc(100);
-        var n_res = client.read(buf, 100);
+        let buf: char* = malloc(100);
+        let n_res = client.read(buf, 100);
         
         if (n_res.is_ok()) {
-            var n = n_res.unwrap();
+            let n = n_res.unwrap();
             buf[n] = 0;
             if (strcmp(buf, "Ping") == 0) {
                 client.write("Pong", 4);
@@ -50,17 +50,17 @@ test "test_net" {
     
     sleep_ms(100);
     
-    var stream_res = TcpStream::connect("127.0.0.1", 9090);
+    let stream_res = TcpStream::connect("127.0.0.1", 9090);
     if (stream_res.is_err()) {
         !"Client connect failed";
         exit(1);
     }
     
-    var stream = stream_res.unwrap();
+    let stream = stream_res.unwrap();
     stream.write("Ping", 4);
     
-    var buf2: char* = malloc(100);
-    var n2_res = stream.read(buf2, 100);
+    let buf2: char* = malloc(100);
+    let n2_res = stream.read(buf2, 100);
     
     if (n2_res.is_ok()) {
         buf2[n2_res.unwrap()] = 0;
diff --git a/tests/std/test_queue.zc b/tests/std/test_queue.zc
index d8895b8..3316323 100644
--- a/tests/std/test_queue.zc
+++ b/tests/std/test_queue.zc
@@ -2,11 +2,11 @@ import "std/queue.zc"
 
 test "Queue Push/Pop" {
   println "Testing Queue Push/Pop";
-  var queue = Queue<i32>::new();
+  let queue = Queue<i32>::new();
   defer queue.free();
 
   println "Popping on an empty queue without pushing anything prior"
-  var v = queue.pop();
+  let v = queue.pop();
   assert(v.is_none(), "v should not have a valid value");
 
   println "Pushing in three values..."
@@ -30,7 +30,7 @@ test "Queue Push/Pop" {
 
 test "Queue Length and Clear" {
   println "Testing Queue clear";
-  var queue = Queue<i32>::new();
+  let queue = Queue<i32>::new();
   defer queue.free();
 
   assert(queue.is_empty() && queue.length() == 0, "queue should be empty");
@@ -44,13 +44,13 @@ test "Queue Length and Clear" {
 
 test "Queue Clone" {
   println "Testing Queue Cloning";
-  var queue = Queue<i32>::new();
+  let queue = Queue<i32>::new();
   defer queue.free();
   queue.push(123);
-  var queue2 = queue.clone();
+  let queue2 = queue.clone();
   defer queue2.free();
 
-  var v = queue2.pop();
+  let v = queue2.pop();
   assert(v.is_some() && v.unwrap() == 123, "v's value should be 123");
   v = queue2.pop();
   assert(v.is_none(), "v should not have a valid value");
@@ -62,7 +62,7 @@ test "Queue Clone" {
 }
 
 test "Queue Ring Buffer (Advanced)" {
-    var q = Queue<int>::new();
+    let q = Queue<int>::new();
     
     println "Fill slightly"
     q.push(1);
@@ -91,10 +91,10 @@ test "Queue Ring Buffer (Advanced)" {
     assert(q.is_empty());
     
     println "Large scale test"
-    for (var i = 0; i < 100; i=i+1) {
+    for (let i = 0; i < 100; i=i+1) {
         q.push(i);
     }
-    for (var i = 0; i < 100; i=i+1) {
+    for (let i = 0; i < 100; i=i+1) {
         assert(*q.pop().unwrap_ref() == i);
     }
     
diff --git a/tests/std/test_readln_scan.zc b/tests/std/test_readln_scan.zc
index 5ea196d..f138c2c 100644
--- a/tests/std/test_readln_scan.zc
+++ b/tests/std/test_readln_scan.zc
@@ -2,18 +2,18 @@
 test "test_readln_scan" {
     "Testing readln compilation...";
     
-    var x: int = 0;
-    var f: float = 0.0;
+    let x: int = 0;
+    let f: float = 0.0;
     
     if (1 == 0) {
-        var s = readln();
+        let s = readln();
         
-        var count = readln(x);  
+        let count = readln(x);  
         readln(f);
         
         readln(x, f);
         
-        var count2 = ?"Age? "(x);
+        let count2 = ?"Age? "(x);
         ?"Coords? "(x, f);
     }
     
diff --git a/tests/std/test_stack.zc b/tests/std/test_stack.zc
index 03e51a4..1116f8d 100644
--- a/tests/std/test_stack.zc
+++ b/tests/std/test_stack.zc
@@ -2,11 +2,11 @@ import "std/stack.zc"
 
 test "Stack Push/Pop" {
   print "Testing Stack Push/Pop";
-  var stack = Stack<i32>::new();
+  let stack = Stack<i32>::new();
   defer stack.free();
 
   print "Popping on an empty stack without pushing anything prior"
-  var v = stack.pop();
+  let v = stack.pop();
   assert(v.is_none(), "v should not have a valid value");
 
   print "Pushing in three values..."
@@ -30,7 +30,7 @@ test "Stack Push/Pop" {
 
 test "Stack Length and Clear" {
   print "Testing Stack clear";
-  var stack = Stack<i32>::new();
+  let stack = Stack<i32>::new();
   defer stack.free();
 
   assert(stack.is_empty() && stack.length() == 0, "Stack should be empty");
@@ -44,13 +44,13 @@ test "Stack Length and Clear" {
 
 test "Stack Clone" {
   print "Testing Stack Cloning";
-  var stack = Stack<i32>::new();
+  let stack = Stack<i32>::new();
   defer stack.free();
   stack.push(123);
-  var stack2 = stack.clone();
+  let stack2 = stack.clone();
   defer stack2.free();
 
-  var v = stack2.pop();
+  let v = stack2.pop();
   assert(v.is_some() && v.unwrap() == 123, "v's value should be 123");
   v = stack2.pop();
   assert(v.is_none(), "v should not have a valid value");
diff --git a/tests/std/test_std_expansion.zc b/tests/std/test_std_expansion.zc
index 764e0ac..fbb6d6b 100644
--- a/tests/std/test_std_expansion.zc
+++ b/tests/std/test_std_expansion.zc
@@ -4,7 +4,7 @@ test "test_std_expansion" {
     "Testing Standard Library Expansion...";
     
     "Testing Map...";
-    var m = Map<int>::new();
+    let m = Map<int>::new();
     m.put("one", 1);
     m.put("two", 2);
     
@@ -17,14 +17,14 @@ test "test_std_expansion" {
     assert(!m.contains("one"), "Map remove failed");
     
     "Testing Time...";
-    var t1 = Time::now();
+    let t1 = Time::now();
     Time::sleep_ms(10);
-    var t2 = Time::now();
+    let t2 = Time::now();
     assert(t2 >= t1, "Time went backwards!");
     "Time passed: {t2 - t1} ms";
     
     "Testing FS...";
-    var content_res = File::read_all("tests/test_0.zc");
+    let content_res = File::read_all("tests/test_0.zc");
     if (content_res.is_ok()) {
         "Read file successfully.";
     } else {
@@ -32,7 +32,7 @@ test "test_std_expansion" {
     }
     
     "Testing JSON...";
-    var j = JsonValue::string("hello");
+    let j = JsonValue::string("hello");
     assert(j.kind == JsonType::JSON_STRING(), "Json string kind failed");
     
     "All expansion tests passed!";
diff --git a/tests/std/test_string_split.zc b/tests/std/test_string_split.zc
index 496dbd1..74bc624 100644
--- a/tests/std/test_string_split.zc
+++ b/tests/std/test_string_split.zc
@@ -1,24 +1,24 @@
 import "std/string.zc"
 
 test "string_split_basic" {
-    var s = String::from("a,b,c");
-    var parts = s.split(',');
+    let s = String::from("a,b,c");
+    let parts = s.split(',');
     
     if (parts.length() != 3) {
         println "Split length fail: {parts.length()}";
         exit(1);
     }
     
-    var p0 = parts.get(0);
-    var t0 = String::from("a");
+    let p0 = parts.get(0);
+    let t0 = String::from("a");
     if (!p0.eq(&t0)) exit(1);
     
-    var p1 = parts.get(1);
-    var t1 = String::from("b");
+    let p1 = parts.get(1);
+    let t1 = String::from("b");
     if (!p1.eq(&t1)) exit(1);
     
-    var p2 = parts.get(2);
-    var t2 = String::from("c");
+    let p2 = parts.get(2);
+    let t2 = String::from("c");
     if (!p2.eq(&t2)) exit(1);
     
     for p in &parts {
@@ -28,28 +28,28 @@ test "string_split_basic" {
 }
 
 test "string_split_edge" {
-    var s = String::from("hello");
-    var parts = s.split(' '); // Not found
+    let s = String::from("hello");
+    let parts = s.split(' '); // Not found
     
     if (parts.length() != 1) {
         println "Split edge 1 failed";
         exit(1);
     }
     
-    var p0 = parts.get(0);
+    let p0 = parts.get(0);
     if (!p0.eq(&s)) exit(1);
     
     p0.free();
     parts.free();
     
-    var s2 = String::from("a,,b");
-    var parts2 = s2.split(',');
+    let s2 = String::from("a,,b");
+    let parts2 = s2.split(',');
     if (parts2.length() != 3) {
         println "Split edge 2 failed: {parts2.length()}";
         exit(1);
     }
     
-    var empty = parts2.get(1);
+    let empty = parts2.get(1);
     if (!empty.is_empty()) exit(1);
     
     for p in &parts2 { p.free(); }
diff --git a/tests/std/test_string_utf8.zc b/tests/std/test_string_utf8.zc
index a4d2095..a8f6272 100644
--- a/tests/std/test_string_utf8.zc
+++ b/tests/std/test_string_utf8.zc
@@ -1,22 +1,22 @@
 import "std/string.zc"
 
 test "utf8_basic_ascii" {
-    var s = String::from("Hello");
+    let s = String::from("Hello");
     
     if (s.utf8_len() != 5) {
         println "ASCII Len failed";
         exit(1);
     }
     
-    var h = s.utf8_at(0);
-    var t1 = String::from("H");
+    let h = s.utf8_at(0);
+    let t1 = String::from("H");
     if (!h.eq(&t1)) {
         println "ASCII At failed";
         exit(1);
     }
     
-    var sub = s.utf8_substr(1, 4);
-    var t2 = String::from("ello");
+    let sub = s.utf8_substr(1, 4);
+    let t2 = String::from("ello");
     if (!sub.eq(&t2)) {
         println "ASCII Substr failed";
         exit(1);
@@ -28,7 +28,7 @@ test "utf8_multibyte" {
     // Bytes: H(1) e(1) y(1)  (1) 🌎(4) !(1) = 9 bytes?
     // 🌎 is approx F0 9F 8C 8D (4 bytes)
     
-    var s = String::from("Hey 🌎!");
+    let s = String::from("Hey 🌎!");
     
     if (s.length() != 9) {
         println "Byte length unexpected: {s.length()}";
@@ -40,15 +40,15 @@ test "utf8_multibyte" {
         exit(1);
     }
     
-    var globe = s.utf8_at(4);
-    var t3 = String::from("🌎");
+    let globe = s.utf8_at(4);
+    let t3 = String::from("🌎");
     if (!globe.eq(&t3)) {
         println "UTF8 At failed";
         exit(1);
     }
     
-    var sub = s.utf8_substr(4, 2); // "🌎!"
-    var t4 = String::from("🌎!");
+    let sub = s.utf8_substr(4, 2); // "🌎!"
+    let t4 = String::from("🌎!");
     if (!sub.eq(&t4)) {
         println "UTF8 Substr failed";
         exit(1);
diff --git a/tests/std/test_string_utils.zc b/tests/std/test_string_utils.zc
index 212bac1..c001ef4 100644
--- a/tests/std/test_string_utils.zc
+++ b/tests/std/test_string_utils.zc
@@ -1,46 +1,46 @@
 import "std/string.zc"
 
 test "string trim" {
-    var s1 = String::from("  hello  ");
-    var t1 = s1.trim();
-    var e1 = String::from("hello");
+    let s1 = String::from("  hello  ");
+    let t1 = s1.trim();
+    let e1 = String::from("hello");
     assert(t1.eq(&e1));
     t1.free(); s1.free(); e1.free();
 
-    var s2 = String::from("\n\t  world \r ");
-    var t2 = s2.trim();
-    var e2 = String::from("world");
+    let s2 = String::from("\n\t  world \r ");
+    let t2 = s2.trim();
+    let e2 = String::from("world");
     assert(t2.eq(&e2));
     t2.free(); s2.free(); e2.free();
     
-    var s3 = String::from("no_trim");
-    var t3 = s3.trim();
-    var e3 = String::from("no_trim");
+    let s3 = String::from("no_trim");
+    let t3 = s3.trim();
+    let e3 = String::from("no_trim");
     assert(t3.eq(&e3));
     t3.free(); s3.free(); e3.free();
     
-    var s4 = String::from("   ");
-    var t4 = s4.trim();
+    let s4 = String::from("   ");
+    let t4 = s4.trim();
     assert(t4.is_empty());
     t4.free(); s4.free();
 }
 
 test "string replace" {
-    var s1 = String::from("foo bar foo");
-    var r1 = s1.replace("foo", "baz");
-    var e1 = String::from("baz bar baz");
+    let s1 = String::from("foo bar foo");
+    let r1 = s1.replace("foo", "baz");
+    let e1 = String::from("baz bar baz");
     assert(r1.eq(&e1));
     r1.free(); s1.free(); e1.free();
     
-    var s2 = String::from("hello world");
-    var r2 = s2.replace("world", "ZenC");
-    var e2 = String::from("hello ZenC");
+    let s2 = String::from("hello world");
+    let r2 = s2.replace("world", "ZenC");
+    let e2 = String::from("hello ZenC");
     assert(r2.eq(&e2));
     r2.free(); s2.free(); e2.free();
     
-    var s3 = String::from("aaaa");
-    var r3 = s3.replace("aa", "b");
-    var e3 = String::from("bb");
+    let s3 = String::from("aaaa");
+    let r3 = s3.replace("aa", "b");
+    let e3 = String::from("bb");
     assert(r3.eq(&e3));
     r3.free(); s3.free(); e3.free();
 }
diff --git a/tests/std/test_vec.zc b/tests/std/test_vec.zc
index 5e3dddf..89086f6 100644
--- a/tests/std/test_vec.zc
+++ b/tests/std/test_vec.zc
@@ -24,7 +24,7 @@ struct Point {
 
 test "Vec Basics (Construction, Push, Pop, Access)" {
     print "Testing Vec basics...\n";
-    var v = Vec<int>::new();
+    let v = Vec<int>::new();
     assert_eq(v.len, 0, "Initial len");
     assert_eq(v.cap, 0, "Initial cap");
 
@@ -53,16 +53,16 @@ test "Vec Basics (Construction, Push, Pop, Access)" {
 test "Vec Capacity and Allocation" {
     print "Testing Vec capacity...\n";
     // with_capacity
-    var v1 = Vec<int>::with_capacity(10);
+    let v1 = Vec<int>::with_capacity(10);
     assert_eq(v1.len, 0, "with_capacity len");
     assert_eq(v1.cap, 10, "with_capacity cap");
     v1.push(1);
     assert_eq(v1.cap, 10, "Cap should not change yet");
 
     // Implicit grow
-    var v2 = Vec<int>::new();
+    let v2 = Vec<int>::new();
     // Force grow logic: 0 -> 8 -> 16...
-    var i = 0;
+    let i = 0;
     while i < 9 {
         v2.push(i);
         i = i + 1;
@@ -74,7 +74,7 @@ test "Vec Capacity and Allocation" {
 
 test "Vec Modification (Insert, Append, Remove, Clear)" {
     print "Testing Vec modification...\n";
-    var v = Vec<int>::new();
+    let v = Vec<int>::new();
     v.push(1);
     v.push(3);
     
@@ -82,7 +82,7 @@ test "Vec Modification (Insert, Append, Remove, Clear)" {
     assert_eq(v.get(1), 2, "insert middle");
     assert_eq(v.len, 3, "insert len");
 
-    var v2 = Vec<int>::new();
+    let v2 = Vec<int>::new();
     v2.push(4);
     v2.push(5);
     v.append(v2);
@@ -91,7 +91,7 @@ test "Vec Modification (Insert, Append, Remove, Clear)" {
         assert_eq(v.get(i), i + 1, "append value");
     }
 
-    var val = v.remove(0); // [2, 3, 4, 5]
+    let val = v.remove(0); // [2, 3, 4, 5]
     assert_eq(val, 1, "remove return");
     assert_eq(v.get(0), 2, "remove shift");
     assert_eq(v.len, 4, "remove len");
@@ -103,25 +103,25 @@ test "Vec Modification (Insert, Append, Remove, Clear)" {
 
 test "Vec Extensions (pop_opt)" {
     print "Testing Vec extensions...\n";
-    var v = Vec<int>::new();
+    let v = Vec<int>::new();
     v.push(42);
     
-    var opt = v.pop_opt();
+    let opt = v.pop_opt();
     assert_true(!opt.is_none(), "pop_opt some");
     assert_eq(opt.unwrap(), 42, "pop_opt val");
     
-    var empty = v.pop_opt();
+    let empty = v.pop_opt();
     assert_true(empty.is_none(), "pop_opt none");
 }
 
 test "Vec Iteration (Reference and Value)" {
     print "Testing Vec iteration...\n";
-    var v = Vec<Point>::new();
+    let v = Vec<Point>::new();
     v.push(Point { x: 10, y: 10 });
     v.push(Point { x: 20, y: 20 });
 
     // 1. Value Iteration
-    var sum_val = 0;
+    let sum_val = 0;
     for p in v {
         sum_val = sum_val + p.x;
     }
@@ -144,11 +144,11 @@ test "Vec Iteration (Reference and Value)" {
 
 test "Vec Clone and Drop" {
     print "Testing Vec clone and drop...\n";
-    var v = Vec<int>::new();
+    let v = Vec<int>::new();
     v.push(100);
     v.push(200);
 
-    var v2 = v.clone();
+    let v2 = v.clone();
     assert_eq(v2.len, 2, "Clone len");
     assert_eq(v2.get(0), 100, "Clone val 0");
     
@@ -163,7 +163,7 @@ test "Vec Clone and Drop" {
 
 test "Vec Utils (Reverse, Contains)" {
     print "Testing Vec utils...\n";
-    var v = Vec<int>::new();
+    let v = Vec<int>::new();
     v.push(1);
     v.push(2);
     v.push(3);