Enhance TechLang with STL compatibility, dynamic arrays, and improved control flow operators; update documentation and examples for new features and error handling improvements.

Author: DevaanshPathak

AGENTS.md

@@ -1170,8 +1170,35 @@ tl> # State persists!
 
 ---
 
-**Last Updated:** 2025-11-09  
-**Total Features Added:** 8  
-**Total Tests:** 333+ (233 core + 40 stl + 6 macros + rest)
+### 2025-12-14: STL Compatibility + Deterministic Process Status
+
+**Status:** ✅ Completed
+
+### Summary
+Improved core runtime semantics to support the existing `stl/*` modules and stabilized `proc_status` behavior on Windows.
+
+### Implementation Details
+- Added “store into target” forms for core string/array operations (`str_length`, `str_substring`, `str_contains`, `array_get`) so STL helpers can compute without emitting intermediate output.
+- Added dynamic arrays (`array_create <name>` with no size) that grow via `array_set` and allow sentinel `0` on out-of-bounds `array_get ... <target>`.
+- Expanded control-flow operator support to include `eq/ne/gt/lt/ge/le` aliases and allowed string equality in `if` conditions.
+- Made `proc_spawn "python" ...` use the active interpreter and made `proc_status` less flaky by doing a short internal wait when appropriate.
+
+### Files Modified
+- techlang/core.py
+- techlang/data_types.py
+- techlang/control_flow.py
+- techlang/variables.py
+- techlang/imports.py
+- techlang/system_ops.py
+- stl/strings.tl
+
+### Validation
+- ✅ `D:/TechLang/.venv/Scripts/python.exe -m pytest -q` → `324 passed, 7 skipped`
+
+---
+
+**Last Updated:** 2025-12-14  
+**Total Features Added:** 9  
+**Total Tests:** 331 collected (324 passing, 7 skipped)
 **REPL Version:** 1.1 - Enhanced Edition
 

README.md

@@ -48,7 +48,7 @@ TechLang/
 │   ├── linter.py        # Code linter
 │   └── __init__.py
 │
-├── tests/               # Pytest-based unit tests (255 tests)
+├── tests/               # Pytest-based unit tests (331 collected; 324 passing, 7 skipped)
 │   ├── test_interpreter.py
 │   ├── test_database.py
 │   ├── test_database_advanced.py

docs/control-flow.md

@@ -17,7 +17,13 @@ if score < 60
 end
 ```
 
-Comparisons support `==`, `!=`, `<`, `<=`, `>` and `>=`. The right-hand side accepts integers or existing variables.
+Comparisons support `==`, `!=`, `<`, `<=`, `>` and `>=`.
+
+For convenience (and for compatibility with some examples), these operator aliases are also accepted:
+
+- `eq/ne/gt/lt/ge/le` map to `==/!=/>/</>=/<=`.
+
+The right-hand side accepts integers or existing variables. Equality/inequality also works with string operands (for example comparing two string variables).
 
 ## Loops
 

docs/data-types.md

@@ -67,6 +67,10 @@ str_create message "hello world"
 str_length message              # Outputs: 11
 str_concat message " again"     # Appends to message
 print message                   # hello world again
+
+# Store length into a variable (no output)
+str_length message len
+print len                       # 17
 ```
 
 ### String Transformation
@@ -109,8 +113,16 @@ str_create text "techlang is awesome"
 str_contains text "lang"        # 1 (true)
 str_contains text "python"      # 0 (false)
 
+// Store contains result into a variable (no output)
+str_contains text "lang" found
+print found                     # 1
+
 // Get substring
 str_substring text 0 8          # "techlang"
+
+// Store substring into a string variable (no output)
+str_substring text 0 8 head
+print head                      # techlang
 ```
 
 ### String Operations Summary
@@ -141,6 +153,24 @@ array_push numbers 20
 array_pop numbers
 ```
 
+### Dynamic arrays (size optional)
+
+You can also create a dynamic array without a fixed size:
+
+```techlang
+array_create nums
+array_push nums 5
+array_push nums 10
+
+# Store into a variable instead of printing
+array_get nums 1 value
+print value               # 10
+```
+
+For dynamic arrays, `array_set` grows the array automatically.
+
+For dynamic arrays, out-of-bounds `array_get <array> <index> <target>` stores `0` (sentinel) into `<target>`. (Without a target, out-of-bounds reads still raise an error.)
+
 ### Array Operations
 
 | Command | Description |

docs/system.md

@@ -31,6 +31,11 @@ The process commands let you start a long-running program and interact with it l
 
 Commands that accept a path or command string must use double quotes. All commands run relative to the interpreter's base directory, so you can reference project scripts directly.
 
+Notes:
+
+- On Windows, `proc_spawn "python" ...` uses the interpreter running TechLang (avoids the Microsoft Store alias) for more predictable behavior.
+- `proc_status` may do a short internal wait once a process has been alive briefly, to reduce flakiness from slow process startup.
+
 ```techlang
 proc_spawn "\"python\" -c \"import time; time.sleep(1)\""
 proc_status 1    # running

stl/README.md

@@ -3,8 +3,28 @@
 The TechLang STL provides reusable modules for common programming tasks. All modules follow the export/public API system for clean interfaces.
 
 **Alias:** You can use `stl` as an alias for `stl` (for compatibility):
-- `package use stl/validation` (or `stl/validation`)
-- `call stl.validation.is_positive` (or `stl.validation.is_positive`)
+**Alias:** You can use `stdlib` as an alias for `stl` (for compatibility):
+- `package use stdlib/validation` (or `stl/validation`)
+- `call stdlib.validation.is_positive` (or `stl.validation.is_positive`)
+
+## ✅ Runtime Assumptions (STL Compatibility)
+
+Some STL modules rely on “store into target” forms of core commands (so helpers can avoid printing intermediate values):
+
+- `str_length <string> <targetVar>` stores the length in `<targetVar>`.
+- `str_substring <string> <start> <end> <targetString>` stores into `<targetString>`.
+- `str_contains <string> <substring> <targetVar>` stores `1/0` into `<targetVar>`.
+- `array_get <array> <index> <target>` stores the value into `<target>`.
+
+Arrays used by STL are typically **dynamic arrays** created via:
+
+- `array_create <name>` (no size) creates a dynamic array.
+- For dynamic arrays, `array_set` grows as needed.
+- For dynamic arrays, out-of-bounds `array_get ... <target>` stores `0` (sentinel) instead of erroring. This is used by `stl/collections` loops.
+
+Control-flow also accepts operator synonyms used in examples:
+
+- `eq/ne/gt/lt/ge/le` map to `==/!=/>/</>=/<=`.
 
 ## 📚 Available Modules
 

stl/strings.tl

@@ -33,13 +33,29 @@ def is_empty s
 end
 
 def capitalize source_text
-    # Capitalize first character (simple version - just uppercase first char, keep rest as-is)
+    # Capitalize first character and lowercase the rest
     # Args: source_text - string to capitalize
     # Returns: capitalized string
-    # Note: This is a simplified implementation due to scoping limitations
+    str_length source_text len
+    if len == 0
+        str_create result ""
+        return result
+    end
+
+    str_substring source_text 0 1 first
+    str_substring source_text 1 len rest
+
+    str_create first_up ""
+    str_concat first_up first
+    str_upper first_up
+
+    str_create rest_low ""
+    str_concat rest_low rest
+    str_lower rest_low
+
     str_create result ""
-    str_concat result source_text
-    str_upper result
+    str_concat result first_up
+    str_concat result rest_low
     return result
 end
 

techlang.db

@@ -83,7 +83,7 @@ def handle_while(state: InterpreterState, tokens: List[str], index: int, execute
             # Get current variable value for comparison
             var_value = state.get_variable(varname, 0)
             if not isinstance(var_value, int):
-                state.add_error(f"Variable '{varname}' is not a number. Cannot perform comparison.")
+                state.add_error(f"Expected a number for variable '{varname}', but got '{var_value}'.")
                 return 0
 
             # Check if condition is still true
@@ -114,30 +114,34 @@ def handle_if(state: InterpreterState, tokens: List[str], index: int, execute_bl
         varname = tokens[index + 1]
         op = tokens[index + 2]
         compare_token = tokens[index + 3]
-        
-        # Try to resolve compare_token as a variable first, then as a literal
-        compare_val = state.get_variable(compare_token, None)
-        if compare_val is None:
+
+        start_index = index + 4  # Start after 'if', variable, operator, and value
+
+        # Resolve left operand: variables first, then strings (for stl-style string comparisons)
+        if state.has_variable(varname):
+            var_value: Union[int, str] = state.get_variable(varname, 0)
+        elif varname in state.strings:
+            var_value = state.strings[varname]
+        else:
+            var_value = 0
+
+        # Resolve right operand: variables, strings, quoted literals, then ints
+        if state.has_variable(compare_token):
+            compare_val: Union[int, str] = state.get_variable(compare_token, 0)
+        elif compare_token in state.strings:
+            compare_val = state.strings[compare_token]
+        elif compare_token.startswith('"') and compare_token.endswith('"'):
+            compare_val = compare_token[1:-1]
+        else:
             try:
                 compare_val = int(compare_token)
             except ValueError:
-                state.add_error(f"Expected a number or variable for comparison, but got '{compare_token}'. Please provide a valid integer or variable name.")
+                state.add_error(
+                    f"Expected a number or variable for comparison, but got '{compare_token}'. Please provide a valid integer or variable name."
+                )
                 return 0
-        
-        start_index = index + 4  # Start after 'if', variable, operator, and value
-        
-        # Get variable value for comparison
-        var_value = state.get_variable(varname, 0)
-        if not isinstance(var_value, int):
-            state.add_error(f"Variable '{varname}' is not a number. Cannot perform comparison.")
-            return 0
-        
-        # Ensure compare_val is an integer
-        if not isinstance(compare_val, int):
-            state.add_error(f"Comparison value must be a number, but got type '{type(compare_val).__name__}'.")
-            return 0
-        
-        # Check condition
+
+        # Check condition (supports string equality and operator synonyms)
         condition_met = ControlFlowHandler._evaluate_condition(var_value, op, compare_val)
 
         # Collect the if block
@@ -686,18 +690,35 @@ def _extract_error_message(line: str) -> str:
         return line
 
     @staticmethod
-    def _evaluate_condition(var_value: int, op: str, compare_val: int) -> bool:
-        if op == "==":
+    def _evaluate_condition(var_value: Union[int, str], op: str, compare_val: Union[int, str]) -> bool:
+        # Support common word operators used in examples/stdlib
+        op_map = {
+            "eq": "==",
+            "ne": "!=",
+            "gt": ">",
+            "lt": "<",
+            "ge": ">=",
+            "le": "<=",
+        }
+        normalized_op = op_map.get(op, op)
+
+        # Equality works across types (mismatched types simply compare False/True)
+        if normalized_op == "==":
             return var_value == compare_val
-        elif op == "!=":
+        if normalized_op == "!=":
             return var_value != compare_val
-        elif op == ">":
+
+        # Ordering comparisons require integers
+        if not isinstance(var_value, int) or not isinstance(compare_val, int):
+            return False
+
+        if normalized_op == ">":
             return var_value > compare_val
-        elif op == "<":
+        if normalized_op == "<":
             return var_value < compare_val
-        elif op == ">=":
+        if normalized_op == ">=":
             return var_value >= compare_val
-        elif op == "<=":
+        if normalized_op == "<=":
             return var_value <= compare_val
-        else:
-            return False  # Unknown operator
+
+        return False  # Unknown operator

techlang/control_flow.py

@@ -50,6 +50,9 @@ class InterpreterState:
 
     # Arrays that can store lists of numbers or text
     arrays: Dict[str, List[Union[int, str]]] = None
+
+    # Arrays created without a fixed size (allow growth via array_set and safe out-of-bounds reads)
+    dynamic_arrays: Set[str] = None
 
     # Text strings that can be manipulated
     strings: Dict[str, str] = None
@@ -75,6 +78,9 @@ class InterpreterState:
     # Subprocess management
     processes: Dict[int, object] = None
     next_process_id: int = 1
+
+    # Subprocess timing (used for more deterministic status polling)
+    process_start_times: Dict[int, float] = None
 
     # Debugger state
     breakpoints: Set[int] = None  # Line numbers where execution should pause
@@ -119,6 +125,8 @@ def __post_init__(self):
             self.loaded_modules = set()
         if self.arrays is None:
             self.arrays = {}
+        if self.dynamic_arrays is None:
+            self.dynamic_arrays = set()
         if self.strings is None:
             self.strings = {}
         if self.dictionaries is None:
@@ -139,6 +147,8 @@ def __post_init__(self):
             self.queues = {}
         if self.processes is None:
             self.processes = {}
+        if self.process_start_times is None:
+            self.process_start_times = {}
         if self.breakpoints is None:
             self.breakpoints = set()
         if self.watched_vars is None:
@@ -161,6 +171,7 @@ def reset(self) -> None:
         self.aliases.clear()
         self.input_queue.clear()
         self.arrays.clear()
+        self.dynamic_arrays.clear()
         self.strings.clear()
         self.dictionaries.clear()
         self.struct_defs.clear()
@@ -174,6 +185,7 @@ def reset(self) -> None:
         self.queues.clear()
         self.processes.clear()
         self.next_process_id = 1
+        self.process_start_times.clear()
         self.modules.clear()
         self.loaded_modules.clear()