Iteration on namings

Author: vladbelousoff

README.md

@@ -235,88 +235,85 @@ functionality, I/O operations, and performance-critical code written in C.
 Native functions in C must follow this signature:
 
 ```c
-tea_value_t your_function_name(tea_context_t* context, const tea_function_args_t* args)
+tea_val_t your_function_name(tea_ctx_t* context, const tea_fn_args_t* args)
 ```
 
 The function receives a context and a list of arguments, and must return a `tea_value_t`. Arguments are accessed by calling `tea_function_args_pop()` in a loop. Here's an example:
 
 ```c
 // Native function to print values (similar to built-in print)
-static tea_value_t tea_print_values(tea_context_t* context, const tea_function_args_t* args) {
+static tea_val_t tea_print_values(tea_ctx_t* context, const tea_fn_args_t* args) {
     for (;;) {
-        tea_variable_t* arg = tea_function_args_pop(args);
+        tea_var_t* arg = tea_fn_args_pop(args);
         if (!arg) {
             break; // No more arguments
         }
         
-        const tea_value_t value = arg->value;
+        const tea_val_t value = arg->val;
         switch (value.type) {
-            case TEA_VALUE_I32:
+            case TEA_V_I32:
                 printf("%d ", value.i32);
                 break;
-            case TEA_VALUE_F32:
+            case TEA_V_F32:
                 printf("%f ", value.f32);
                 break;
-            case TEA_VALUE_STRING:
-                printf("%s ", value.string);
-                break;
-            case TEA_VALUE_INSTANCE:
-            case TEA_VALUE_INVALID:
+            case TEA_V_INST:
+            case TEA_V_UNDEF:
                 break;
         }
         
-        tea_free_variable(context, arg);
+        tea_free_var(context, arg);
     }
     printf("\n");
     
-    return tea_value_invalid();
+    return tea_val_undef();
 }
 
 // Native function to add two numbers
-static tea_value_t tea_add_numbers(tea_context_t* context, const tea_function_args_t* args) {
-    tea_variable_t* arg1 = tea_function_args_pop(args);
-    tea_variable_t* arg2 = tea_function_args_pop(args);
+static tea_val_t tea_add_numbers(tea_ctx_t* context, const tea_fn_args_t* args) {
+    tea_var_t* arg1 = tea_fn_args_pop(args);
+    tea_var_t* arg2 = tea_fn_args_pop(args);
     
     if (!arg1 || !arg2) {
         // Handle error case - not enough arguments
-        if (arg1) tea_free_variable(context, arg1);
-        if (arg2) tea_free_variable(context, arg2);
-        return tea_value_invalid();
+        if (arg1) tea_free_var(context, arg1);
+        if (arg2) tea_free_var(context, arg2);
+        return tea_val_undef();
     }
     
-    if (arg1->value.type == TEA_VALUE_I32 && arg2->value.type == TEA_VALUE_I32) {
-        tea_value_t result = {0};
-        result.type = TEA_VALUE_I32;
-        result.i32 = arg1->value.i32 + arg2->value.i32;
+    if (arg1->val.type == TEA_V_I32 && arg2->val.type == TEA_V_I32) {
+        tea_val_t result = {0};
+        result.type = TEA_V_I32;
+        result.i32 = arg1->val.i32 + arg2->val.i32;
         
-        tea_free_variable(context, arg1);
-        tea_free_variable(context, arg2);
+        tea_free_var(context, arg1);
+        tea_free_var(context, arg2);
         return result;
     }
     
-    tea_free_variable(context, arg1);
-    tea_free_variable(context, arg2);
-    return tea_value_invalid();
+    tea_free_var(context, arg1);
+    tea_free_var(context, arg2);
+    return tea_val_undef();
 }
 ```
 
 ### Binding Functions
 
-Register your native functions with the Tea context using `tea_bind_native_function`:
+Register your native functions with the Tea context using `tea_bind_native_fn`:
 
 ```c
 int main() {
-    tea_context_t context;
-    tea_interpret_init(&context, "example.tea");
+    tea_ctx_t context;
+    tea_interp_init(&context, "example.tea");
 
     // Bind native functions
-    tea_bind_native_function(&context, "print", tea_print);
-    tea_bind_native_function(&context, "add_numbers", tea_add_numbers);
-    tea_bind_native_function(&context, "print_values", tea_print_values);
+    tea_bind_native_fn(&context, "print", tea_print);
+    tea_bind_native_fn(&context, "add_numbers", tea_add_numbers);
+    tea_bind_native_fn(&context, "print_values", tea_print_values);
 
     // Execute Tea code...
 
-    tea_interpret_cleanup(&context);
+    tea_interp_cleanup(&context);
     return 0;
 }
 ```
@@ -339,23 +336,23 @@ print_values('Result:', sum, 'Done');
 
 ### Tea Value Types
 
-Native functions work with the `tea_value_t` type system:
+Native functions work with the `tea_val_t` type system:
 
-- `TEA_VALUE_I32` - 32-bit signed integers
-- `TEA_VALUE_F32` - 32-bit floating-point numbers
-- `TEA_VALUE_STRING` - Null-terminated strings
-- `TEA_VALUE_INSTANCE` - Complex objects (structs)
-- `TEA_VALUE_INVALID` - Uninitialized or error state
+- `i32` (TEA_V_I32) - 32-bit signed integers
+- `f32` (TEA_V_F32) - 32-bit floating-point numbers
+- `string` (TEA_V_INST) - Null-terminated strings wrapped as instances
+- `instance` (TEA_V_INST) - Complex objects (structs)
+- `undef` (TEA_V_UNDEF) - Uninitialized or error state
 
 ### Best Practices
 
-1. **Always validate arguments**: Use `tea_function_args_pop()` to safely access arguments and check for NULL
-2. **Handle errors gracefully**: Return `tea_value_invalid()` for error conditions
+1. **Always validate arguments**: Use `tea_fn_args_pop()` to safely access arguments and check for NULL
+2. **Handle errors gracefully**: Return `tea_val_undef()` for error conditions
 3. **Memory management**: 
-   - Always call `tea_free_variable(context, arg)` for each argument you pop
-   - Strings returned from native functions should be allocated with `rtl_malloc`
+   - Always call `tea_free_var(context, arg)` for each argument you pop
+   - Strings returned from native functions should be allocated with `tea_malloc`
 4. **Performance**: Use native functions for computationally intensive operations
-5. **Argument handling**: Process arguments in the order they were passed by calling `tea_function_args_pop()` sequentially
+5. **Argument handling**: Process arguments in the order they were passed by calling `tea_fn_args_pop()` sequentially
 
 ## Building
 

examples/002_basic_types.tea

@@ -22,6 +22,6 @@ let is_false = 2 > 10; // Results in false (0)
 let equality = 5 == 5; // Results in true (1)
 
 // Type annotations can be explicit when needed
-let explicit_int: i32 = 100;
-let explicit_float: f32 = 25.0;
+let explicit_i32: i32 = 100;
+let explicit_f32: f32 = 25.0;
 let explicit_string: string = 'Type annotated string';

examples/012_functions.tea

@@ -6,29 +6,29 @@ fn greet() {
 }
 
 // Function with parameters
-fn add_numbers(a: int, b: int) {
+fn add_numbers(a: i32, b: i32) {
     let sum = a + b;
     // sum is calculated but not returned
 }
 
 // Function with return type and return statement
-fn multiply(x: int, y: int) -> int {
+fn multiply(x: i32, y: i32) -> i32 {
     let result = x * y;
     return result;
 }
 
 // Function with single parameter
-fn square(n: int) -> int {
+fn square(n: i32) -> i32 {
     return n * n;
 }
 
 // Function that returns a constant
-fn get_magic_number() -> int {
+fn get_magic_number() -> i32 {
     return 42;
 }
 
 // Function with floating-point parameters and return
-fn calculate_area(width: float, height: float) -> float {
+fn calculate_area(width: f32, height: f32) -> f32 {
     return width * height;
 }
 
@@ -43,7 +43,7 @@ let complex_result = multiply(3, 4) + square(2);  // 12 + 4 = 16
 add_numbers(10, 20);                // Note: add_numbers doesn't return a value
 
 // Function with conditional logic
-fn absolute_value(x: int) -> int {
+fn absolute_value(x: i32) -> i32 {
     if x < 0 {
         return -x;
     } else {
@@ -52,7 +52,7 @@ fn absolute_value(x: int) -> int {
 }
 
 // Function with loop
-fn factorial(n: int) -> int {
+fn factorial(n: i32) -> i32 {
     let mut result = 1;
     let mut i = 1;
 
@@ -65,22 +65,22 @@ fn factorial(n: int) -> int {
 }
 
 // Function that calls other functions
-fn calculate_perimeter(width: float, height: float) -> float {
+fn calculate_perimeter(width: f32, height: f32) -> f32 {
     let double_width = multiply(2, width);   // Note: multiply expects int, this may cause issues
     let double_height = multiply(2, height); // Note: multiply expects int, this may cause issues
     return double_width + double_height;
 }
 
 // Functions with different parameter counts
-fn no_params() -> int {
+fn no_params() -> i32 {
     return 1;
 }
 
-fn one_param(x: int) -> int {
+fn one_param(x: i32) -> i32 {
     return x + 1;
 }
 
-fn three_params(a: int, b: int, c: int) -> int {
+fn three_params(a: i32, b: i32, c: i32) -> i32 {
     return a + b + c;
 }
 

examples/013_function_returns.tea

@@ -1,7 +1,7 @@
 // Advanced function features: return values, complex logic, and function composition
 
 // Function with multiple return points
-fn classify_number(n: int) -> int {
+fn classify_number(n: i32) -> i32 {
     if n < 0 {
         return -1;  // Negative
     }
@@ -12,7 +12,7 @@ fn classify_number(n: int) -> int {
 }
 
 // Function with complex calculation
-fn fibonacci(n: int) -> int {
+fn fibonacci(n: i32) -> i32 {
     if n <= 1 {
         return n;
     }
@@ -34,7 +34,7 @@ fn fibonacci(n: int) -> int {
 fn square(x: i32) -> i32 { return x * x; }
 
 // Function that uses other functions
-fn sum_of_squares(a: int, b: int) -> int {
+fn sum_of_squares(a: i32, b: i32) -> i32 {
     let sq_a = square(a);      // Assumes square function from previous example
     let sq_b = square(b);      // Assumes square function from previous example
     return sq_a + sq_b;
@@ -47,15 +47,15 @@ fn create_greeting(name: string) -> string {
 }
 
 // Function with optional type parameter
-fn safe_divide(a: int, b: int) -> int? {
+fn safe_divide(a: i32, b: i32) -> i32? {
     if b == 0 {
         return null;  // Cannot divide by zero
     }
     return a / b;
 }
 
 // Function that processes arrays/collections conceptually
-fn find_maximum(a: int, b: int, c: int) -> int {
+fn find_maximum(a: i32, b: i32, c: i32) -> i32 {
     let mut max_ab = 0;
 
     if a > b {
@@ -72,7 +72,7 @@ fn find_maximum(a: int, b: int, c: int) -> int {
 }
 
 // Function with accumulator pattern
-fn sum_range(start: int, end: int) -> int {
+fn sum_range(start: i32, end: i32) -> i32 {
     let mut sum = 0;
     let mut current = start;
 
@@ -85,7 +85,7 @@ fn sum_range(start: int, end: int) -> int {
 }
 
 // Nested function calls
-fn complex_calculation(x: int, y: int) -> int {
+fn complex_calculation(x: i32, y: i32) -> i32 {
     let step1 = multiply(x, 2);              // x * 2
     let step2 = square(y);                   // y^2
     let step3 = sum_of_squares(step1, step2); // (x*2)^2 + (y^2)^2
@@ -107,7 +107,7 @@ let combined = fibonacci(5) + sum_range(1, 5);  // 5 + 15 = 20
 let comparison = find_maximum(10, 20, 15) > square(4);  // 20 > 16 = 1
 
 // Functions with early returns
-fn check_conditions(a: int, b: int, c: int) -> int {
+fn check_conditions(a: i32, b: i32, c: i32) -> i32 {
     if a <= 0 {
         return 0;  // Early return for invalid input
     }

examples/014_mutable_functions.tea

@@ -12,7 +12,7 @@ fn mut increment_counter() {
 }
 
 // Mutable function with parameters that still modifies global state
-fn mut add_to_total(amount: int) {
+fn mut add_to_total(amount: i32) {
     global_total = global_total + amount;
 }
 
@@ -25,14 +25,14 @@ fn mut reset_and_increment() {
 }
 
 // Regular function (non-mutable) for comparison
-fn get_current_state() -> int {
+fn get_current_state() -> i32 {
     // This function can read global variables but cannot modify them
     let current_sum = global_counter + global_total;
     return current_sum;
 }
 
 // Mutable function with conditional modifications
-fn mut conditional_update(threshold: int) {
+fn mut conditional_update(threshold: i32) {
     if global_counter < threshold {
         global_counter = global_counter + 5;
     } else {
@@ -42,7 +42,7 @@ fn mut conditional_update(threshold: int) {
 }
 
 // Mutable function with loops
-fn mut batch_increment(times: int) {
+fn mut batch_increment(times: i32) {
     let mut i = 0;
     while i < times {
         global_counter = global_counter + 1;
@@ -66,13 +66,13 @@ reset_and_increment();                  // global_counter = 1, global_total = 10
 let mut status_flag = 0;
 let mut error_count = 0;
 
-fn mut update_status(new_status: int, errors: int) {
+fn mut update_status(new_status: i32, errors: i32) {
     status_flag = new_status;
     error_count = error_count + errors;
 }
 
 // Mutable function with return value (can both modify and return)
-fn mut increment_and_get() -> int {
+fn mut increment_and_get() -> i32 {
     global_counter = global_counter + 1;
     return global_counter;
 }