test -> self & update examples

Author: aceinetx

examples/class.zen

@@ -3,30 +3,36 @@ mod stdlib;
 // ZenLang is not object oriented - therefore it doesn't have classes
 // But you can make something similar
 fn class_new {
-    let inst = {"a" = 0, "b" = 0};
+    let inst = {
+			"add_a" = class_add_a,
+			"add_b" = class_add_b,
+			"print" = class_print,
+			"a" = 0, 
+			"b" = 0
+		};
     return inst;
 }
 
-fn class_add_a self n {
+fn class_add_a n {
     let self.a = self.a + n;
     return null;
 }
 
-fn class_add_b self n {
+fn class_add_b n {
     let self.b = self.b + n;
     return null;
 }
 
-fn class_print self {
+fn class_print {
     let res = self.a + self.b;
     println(res);
     return null;
 }
 
 fn main {
     let class = class_new();
-    class_add_a(class, 42);
-    class_add_b(class, 69);
-    class_print(class);
+		class.add_a(42);
+		class.add_b(69);
+		class.print();
     return null;
 }

examples/stack.zen

@@ -1,34 +1,41 @@
 mod stdlib;
 
 fn stack_new {
-    return {"data" = []};
+    return {
+			"top" = stack_top,
+			"push" = stack_push,
+			"pop" = stack_pop,
+			"size" = stack_size,
+			"is_empty" = stack_is_empty,
+			"data" = []
+		};
 }
 
-fn stack_top self {
+fn stack_top {
     return array_last(self.data);
 }
 
-fn stack_push self element {
+fn stack_push element {
     let self.data = array_push(self.data, element);
     return null;
 }
 
-fn stack_pop self {
+fn stack_pop {
     let self.data = array_pop(self.data);
     return null;
 }
 
-fn stack_size self {
+fn stack_size {
     return array_size(self.data);
 }
 
-fn stack_is_empty self {
-    return stack_size(self) == 0;
+fn stack_is_empty {
+    return self.size() == 0;
 }
 
 fn main {
     let stack = stack_new();
-  	stack_push(stack, 69);
-    println(stack_top(stack));
-    return stack_is_empty(stack);
+		stack.push(69);
+    println(stack.top());
+    return stack.is_empty();
 }

zenlang/src/vm/opcodes/vm_call.rs

@@ -14,10 +14,10 @@ impl VM {
                 self.pc.sub_low(1);
                 self.add_scope();
 
-                let this_name = &String::from("this");
+                let this_name = &String::from("self");
                 let scope = self.scopes.last_mut().unwrap();
                 scope.create_if_doesnt_exist(this_name);
-                *scope.get_mut(this_name).unwrap() = core::mem::take(&mut self.this);
+                *scope.get_mut(this_name).unwrap() = core::mem::take(&mut self.self_var);
 
                 let start = self.bfas_stack_start.pop().unwrap();
                 let end = self.bfas_stack_end.pop().unwrap();

zenlang/src/vm/opcodes/vm_iafs.rs

@@ -19,7 +19,7 @@ impl VM {
             self.error = format!("iafs failed: no more values on stack for array");
             return;
         }
-        self.this = array.clone();
+        self.self_var = array.clone();
 
         match array {
             Value::Object(obj) => match &*obj.borrow() {

zenlang/src/vm/vm.rs

@@ -21,7 +21,7 @@ pub struct VM {
     pub platform: Option<Box<dyn Platform>>,
     pub global_scope: Scope,
     pub halted: bool,
-    pub this: Value,
+    pub self_var: Value,
     pub(crate) bfas_stack_start: Vec<i64>,
     pub(crate) bfas_stack_end: Vec<i64>,
 }
@@ -39,7 +39,7 @@ impl VM {
             platform: None,
             global_scope: Scope::new(),
             halted: false,
-            this: Value::Null(),
+            self_var: Value::Null(),
             bfas_stack_start: Vec::new(),
             bfas_stack_end: Vec::new(),
         };

zenlang/tests/vm_this.rs

@@ -62,16 +62,16 @@ fn expect_to_return_obj(code: String, object: Object) {
 }
 
 #[test]
-fn vm_test_this_1() {
+fn vm_test_self_1() {
     expect_to_return(
         r#"
 fn f2 {
-    let this.hi = this.hi + 3;
+    let self.hi = self.hi + 3;
 }
 
 fn f {
-    let this.hi = 1;
-    this.test2();
+    let self.hi = 1;
+    self.test2();
 }
 
 fn main {
@@ -88,20 +88,20 @@ fn main {
 }
 
 #[test]
-fn vm_test_this_2() {
+fn vm_test_self_2() {
     expect_to_return(
         r#"
 fn f2 {
-    let this.hi = 3;
+    let self.hi = 3;
 }
 
 fn f {
-    let this.hi = 1;
+    let self.hi = 1;
     let obj = {
         "test" = f2
     };
     obj.test();
-    let this.hi = obj.hi - 1;
+    let self.hi = obj.hi - 1;
 }
 
 fn main {