astreum 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

astreum/__init__.py

@@ -1 +1,2 @@
 from .machine import AstreumMachine
+from .node import Node

astreum/lispeum/expression.py

@@ -0,0 +1,95 @@
+from typing import List, Union
+
+class Expr:
+    class ListExpr:
+        def __init__(self, elements: List['Expr']):
+            self.elements = elements
+
+        def __eq__(self, other):
+            if not isinstance(other, Expr.ListExpr):
+                return NotImplemented
+            return self.elements == other.elements
+
+        def __ne__(self, other):
+            return not self.__eq__(other)
+
+        @property
+        def value(self):
+            inner = " ".join(str(e) for e in self.elements)
+            return f"({inner})"
+
+
+        def __repr__(self):
+            if not self.elements:
+                return "()"
+            
+            inner = " ".join(str(e) for e in self.elements)
+            return f"({inner})"
+        
+        def __iter__(self):
+            return iter(self.elements)
+        
+        def __getitem__(self, index: Union[int, slice]):
+            return self.elements[index]
+
+        def __len__(self):
+            return len(self.elements)
+
+    class Symbol:
+        def __init__(self, value: str):
+            self.value = value
+
+        def __repr__(self):
+            return self.value
+
+    class Integer:
+        def __init__(self, value: int):
+            self.value = value
+
+        def __repr__(self):
+            return str(self.value)
+
+    class String:
+        def __init__(self, value: str):
+            self.value = value
+
+        def __repr__(self):
+            return f'"{self.value}"'
+        
+    class Boolean:
+        def __init__(self, value: bool):
+            self.value = value
+
+        def __repr__(self):
+            return "true" if self.value else "false"
+
+    class Function:
+        def __init__(self, params: List[str], body: 'Expr'):
+            self.params = params
+            self.body = body
+
+        def __repr__(self):
+            params_str = " ".join(self.params)
+            body_str = str(self.body)
+            return f"(fn ({params_str}) {body_str})"
+        
+    class Error:
+        """
+        Represents an error with a freeform category and message.
+        - `category`: A string identifying the type of error (e.g., 'SyntaxError').
+        - `message`: A human-readable description of the error.
+        - `details`: Optional, additional information about the error.
+        """
+        def __init__(self, category: str, message: str, details: str = None):
+            if not category:
+                raise ValueError("Error category must be provided.")
+            if not message:
+                raise ValueError("Error message must be provided.")
+            self.category = category
+            self.message = message
+            self.details = details
+
+        def __repr__(self):
+            if self.details:
+                return f'({self.category} "{self.message}" {self.details})'
+            return f'({self.category} "{self.message}")'

astreum/{machine → lispeum}/parser.py

@@ -1,6 +1,6 @@
 from typing import List, Tuple
 from astreum.machine.error import ParseError
-from astreum.machine.expression import Expr
+from astreum.lispeum.expression import Expr
 
 
 def parse(tokens: List[str]) -> Tuple[Expr, List[str]]:

astreum/lispeum/special/definition.py

@@ -0,0 +1,27 @@
+from astreum.lispeum.expression import Expr
+from astreum.machine.environment import Environment
+
+
+def handle_definition(machine, args: Expr.ListExpr, env: Environment) -> Expr:
+        if len(args) != 2:
+            return Expr.Error(
+                category="SyntaxError",
+                message="def expects exactly two arguments: a symbol and an expression"
+            )
+        
+        if not isinstance(args[0], Expr.Symbol):
+            return Expr.Error(
+                category="TypeError",
+                message="First argument to def must be a symbol"
+            )
+    
+        var_name = args[0].value
+
+        result = machine.evaluate_expression(args[1], env)
+
+        if isinstance(result, Expr.Error):
+            return result
+
+        env.set(var_name, result)
+    
+        return result

astreum/lispeum/special/list/all.py

@@ -0,0 +1,32 @@
+from astreum.lispeum.expression import Expr
+from astreum.machine.environment import Environment
+
+def handle_list_all(machine, list: Expr.ListExpr, predicate: Expr.Function, env: Environment) -> Expr:
+    if not isinstance(list, Expr.ListExpr):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("First argument must be a list")
+        ])
+    
+    if not isinstance(predicate, Expr.Function):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("Second argument must be a function")
+        ])
+    
+    for elem in list.elements:
+        new_env = Environment(parent=env)
+        new_env.set(predicate.params[0], elem)
+        
+        result, _ = machine.evaluate_expression(predicate, new_env)
+
+        if result == Expr.Boolean(False):
+            return Expr.ListExpr([
+                Expr.Boolean(False),
+                Expr.ListExpr([])
+            ])
+    
+    return Expr.ListExpr([
+        Expr.Boolean(True),
+        Expr.ListExpr([])
+    ])

astreum/lispeum/special/list/any.py

@@ -0,0 +1,32 @@
+from astreum.lispeum.expression import Expr
+from astreum.machine.environment import Environment
+
+def handle_list_any(machine, list: Expr.ListExpr, predicate: Expr.Function, env: Environment) -> Expr:
+    if not isinstance(list, Expr.ListExpr):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("First argument must be a list")
+        ])
+    
+    if not isinstance(predicate, Expr.Function):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("Second argument must be a function")
+        ])
+    
+    for elem in list.elements:
+        new_env = Environment(parent=env)
+        new_env.set(predicate.params[0], elem)
+        
+        result, _ = machine.evaluate_expression(predicate, new_env)
+
+        if result == Expr.Boolean(True):
+            return Expr.ListExpr([
+                Expr.Boolean(True),
+                Expr.ListExpr([])
+            ])
+    
+    return Expr.ListExpr([
+        Expr.Boolean(False),
+        Expr.ListExpr([])
+    ])

astreum/lispeum/special/list/fold.py

@@ -0,0 +1,29 @@
+from astreum.lispeum.expression import Expr
+from astreum.machine.environment import Environment
+
+
+def handle_list_fold(machine, list: Expr.ListExpr, initial: Expr, func: Expr.Function, env: Environment) -> Expr:
+    if not isinstance(list, Expr.ListExpr):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("First argument must be a list")
+        ])
+    
+    if not isinstance(func, Expr.Function):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("Third argument must be a function")
+        ])
+    
+    result = initial
+    for elem in list.elements:
+        new_env = Environment(parent=env)
+        new_env.set(func.params[0], result)
+        new_env.set(func.params[1], elem)
+        
+        result = machine.evaluate_expression(func, new_env)
+    
+    return Expr.ListExpr([
+        result,
+        Expr.ListExpr([])
+    ])

astreum/lispeum/special/list/get.py

@@ -0,0 +1,20 @@
+
+
+from astreum.lispeum.expression import Expr
+from astreum.machine.environment import Environment
+
+
+def handle_list_get(machine, list: Expr.ListExpr, index: Expr.Integer, env: Environment) -> Expr:
+    if not isinstance(list, Expr.ListExpr):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("First argument must be a list")
+        ])
+    
+    if index.value < 0 or index.value >= len(list.elements):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("Index out of bounds")
+        ])
+    
+    return machine.evaluate_expression(list.elements[index])

astreum/lispeum/special/list/insert.py

@@ -0,0 +1,23 @@
+from astreum.lispeum.expression import Expr
+
+
+def handle_list_insert(list: Expr.ListExpr, index: Expr.Integer, value: Expr) -> Expr:
+    if not isinstance(list, Expr.ListExpr):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("First argument must be a list")
+        ])
+    
+    if index.value < 0 or index.value > len(list.elements):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("Index out of bounds")
+        ])
+    
+    new_elements = list.elements[:index.value] + [value] + list.elements[index.value:]
+    
+    return Expr.ListExpr([
+        Expr.ListExpr(new_elements),
+        Expr.ListExpr([])
+    ])
+    

astreum/lispeum/special/list/map.py

@@ -0,0 +1,30 @@
+from astreum.lispeum.expression import Expr
+from astreum.machine.environment import Environment
+
+
+def handle_list_map(machine, list: Expr.ListExpr, func: Expr.Function, env: Environment) -> Expr:
+    if not isinstance(list, Expr.ListExpr):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("First argument must be a list")
+        ])
+    
+    if not isinstance(func, Expr.Function):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("Second argument must be a function")
+        ])
+    
+    mapped_elements = []
+    for elem in list.elements:
+        new_env = Environment(parent=env)
+        new_env.set(func.params[0], elem)
+        
+        mapped_elem = machine.evaluate_expression(func.body, new_env)
+        
+        mapped_elements.append(mapped_elem)
+    
+    return Expr.ListExpr([
+        Expr.ListExpr(mapped_elements),
+        Expr.ListExpr([])
+    ])

astreum/lispeum/special/list/position.py

@@ -0,0 +1,33 @@
+from astreum.lispeum.expression import Expr
+from astreum.machine.environment import Environment
+
+
+def handle_list_position(machine, list: Expr.ListExpr, predicate: Expr.Function, env: Environment) -> Expr:
+    if not isinstance(list, Expr.ListExpr):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("First argument must be a list")
+        ])
+    
+    if not isinstance(predicate, Expr.Function):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("Second argument must be a function")
+        ])
+    
+    for idx, elem in enumerate(list.elements):
+        new_env = Environment(parent=env)
+        new_env.set(predicate.params[0], elem)
+        
+        result, _ = machine.evaluate_expression(predicate, new_env)
+
+        if result == Expr.Boolean(True):
+            return Expr.ListExpr([
+                Expr.Integer(idx),
+                Expr.ListExpr([])
+            ])
+    
+    return Expr.ListExpr([
+        Expr.ListExpr([]),
+        Expr.ListExpr([])
+    ])

astreum/lispeum/special/list/remove.py

@@ -0,0 +1,22 @@
+from astreum.lispeum.expression import Expr
+
+
+def handle_list_remove(list: Expr.ListExpr, index: Expr.Integer) -> Expr:
+    if not isinstance(list, Expr.ListExpr):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("First argument must be a list")
+        ])
+    
+    if index.value < 0 or index.value >= len(list.elements):
+        return Expr.ListExpr([
+            Expr.ListExpr([]),
+            Expr.String("Index out of bounds")
+        ])
+    
+    new_elements = list.elements[:index.value] + list.elements[index.value + 1:]
+    
+    return Expr.ListExpr([
+        Expr.ListExpr(new_elements),
+        Expr.ListExpr([])
+    ])

astreum/machine/__init__.py

@@ -1,19 +1,27 @@
 import threading
-from typing import Callable, Dict, List, Optional, Tuple
+from typing import Dict, Optional
 import uuid
 
+from astreum.lispeum.special.definition import handle_definition
+from astreum.lispeum.special.list.all import handle_list_all
+from astreum.lispeum.special.list.any import handle_list_any
+from astreum.lispeum.special.list.fold import handle_list_fold
+from astreum.lispeum.special.list.get import handle_list_get
+from astreum.lispeum.special.list.insert import handle_list_insert
+from astreum.lispeum.special.list.map import handle_list_map
+from astreum.lispeum.special.list.position import handle_list_position
+from astreum.lispeum.special.list.remove import handle_list_remove
 from astreum.machine.environment import Environment
-from astreum.machine.expression import Expr
-from astreum.machine.tokenizer import tokenize
-from astreum.machine.parser import parse
+from astreum.lispeum.expression import Expr
+from astreum.lispeum.tokenizer import tokenize
+from astreum.lispeum.parser import parse
 
 class AstreumMachine:
-    def __init__(self):
-        self.global_env = Environment()
-        
+    def __init__(self, node: 'Node' = None):
+        self.global_env = Environment(node=node)
         self.sessions: Dict[str, Environment] = {}
-        
         self.lock = threading.Lock()
+         
     
     def create_session(self) -> str:
         session_id = str(uuid.uuid4())
@@ -33,36 +41,42 @@ class AstreumMachine:
         with self.lock:
             return self.sessions.get(session_id, None)
     
-    def evaluate_code(self, code: str, session_id: str) -> Tuple[Optional[Expr], Optional[str]]:
+    def evaluate_code(self, code: str, session_id: str) -> Expr:
         session_env = self.get_session_env(session_id)
         if session_env is None:
-            return None, f"Session ID {session_id} not found."
+            raise ValueError(f"Session ID {session_id} not found.")
         
         try:
             tkns = tokenize(input=code)
             expr, _ = parse(tokens=tkns)
             result = self.evaluate_expression(expr, session_env)
-            return result, None
+            return result
+        
         except Exception as e:
-            return None, str(e)
+            raise ValueError(e)
     
     def evaluate_expression(self, expr: Expr, env: Environment) -> Expr:
-        if isinstance(expr, Expr.Integer):
-            return expr
-        
-        elif isinstance(expr, Expr.String):
+        if isinstance(expr, Expr.Boolean) or isinstance(expr, Expr.Integer) or isinstance(expr, Expr.String) or isinstance(expr, Expr.Error):
             return expr
         
         elif isinstance(expr, Expr.Symbol):
             value = env.get(expr.value)
-            if value is not None:
+            
+            if value:
                 return value
             else:
-                raise ValueError("Variable not found in environments.")
+                return Expr.Error(
+                    category="NameError",
+                    message=f"Variable '{expr.value}' not found in environments."
+                )
         
         elif isinstance(expr, Expr.ListExpr):
-            if not expr.elements:
-                raise ValueError("Empty list cannot be evaluated.")
+            
+            if len(expr.elements) == 0:
+                return expr 
+            
+            if len(expr.elements) == 1:
+                return self.evaluate_expression(expr=expr.elements[0], env=env)
             
             first = expr.elements[0]
 
@@ -72,50 +86,169 @@ class AstreumMachine:
 
                 if first_symbol_value and not isinstance(first_symbol_value, Expr.Function):
                     evaluated_elements = [self.evaluate_expression(e, env) for e in expr.elements]
-                    return Expr.ListExpr(evaluated_elements) 
+                    return Expr.ListExpr(evaluated_elements)
+                
+                elif first.value == "def":
+                    return handle_definition(
+                        machine=self,
+                        args=expr.elements[1:],
+                        env=env
+                    )
+
+                # List
+                elif first.value == "list.new":
+                    return Expr.ListExpr([self.evaluate_expression(arg, env) for arg in expr.elements[1:]])
+
+                elif first.value == "list.get":
+                    args = expr.elements[1:]
+                    if len(args) != 2:
+                        return Expr.Error(
+                            category="SyntaxError",
+                            message="list.get expects exactly two arguments: a list and an index"
+                        )
+                    list_obj = self.evaluate_expression(args[0], env)
+                    index = self.evaluate_expression(args[1], env)
+                    return handle_list_get(self, list_obj, index, env)
+
+                elif first.value == "list.insert":
                     args = expr.elements[1:]
+                    if len(args) != 3:
+                        return Expr.ListExpr([
+                            Expr.ListExpr([]),
+                            Expr.String("list.insert expects exactly three arguments: a list, an index, and a value")
+                        ])
                     
-                    if len(fn_params) != len(args):
-                        raise ValueError(f"Expected {len(fn_params)} arguments, got {len(args)}.")
+                    return handle_list_insert(
+                        list=self.evaluate_expression(args[0], env),
+                        index=self.evaluate_expression(args[1], env),
+                        value=self.evaluate_expression(args[2], env),
+                    )
+
+                elif first.value == "list.remove":
+                    args = expr.elements[1:]
+                    if len(args) != 2:
+                        return Expr.ListExpr([
+                            Expr.ListExpr([]),
+                            Expr.String("list.remove expects exactly two arguments: a list and an index")
+                        ])
                     
-                    # Create a new environment for the function execution, inheriting from the function's defining environment
-                    new_env = Environment(parent=env)
+                    return handle_list_remove(
+                        list=self.evaluate_expression(args[0], env),
+                        index=self.evaluate_expression(args[1], env),
+                    )
+
+                elif first.value == "list.length":
+                    args = expr.elements[1:]
+                    if len(args) != 1:
+                        return Expr.ListExpr([
+                            Expr.ListExpr([]),
+                            Expr.String("list.length expects exactly one argument: a list")
+                        ])
                     
-                    # Evaluate and bind each argument
-                    for param, arg in zip(fn_params, args):
-                        evaluated_arg = self.evaluate_expression(arg, env)
-                        new_env.set(param, evaluated_arg)
+                    list_obj = self.evaluate_expression(args[0], env)
+                    if not isinstance(list_obj, Expr.ListExpr):
+                        return Expr.ListExpr([
+                            Expr.ListExpr([]),
+                            Expr.String("Argument must be a list")
+                        ])
                     
-                    # Evaluate the function body within the new environment
-                    return self.evaluate_expression(fn_body, new_env)
-                
-                elif first.value in ["def", "+"]:
-                    args = expr.elements[1:]
+                    return Expr.ListExpr([
+                        Expr.Integer(len(list_obj.elements)),
+                        Expr.ListExpr([]) 
+                    ])
+
+                elif first.value == "list.fold":
+                    if len(args) != 3:
+                        return Expr.ListExpr([
+                            Expr.ListExpr([]),
+                            Expr.String("list.fold expects exactly three arguments: a list, an initial value, and a function")
+                        ])
+                    
+                    return handle_list_fold(
+                        machine=self,
+                        list=self.evaluate_expression(args[0], env),
+                        initial=self.evaluate_expression(args[1], env),
+                        func=self.evaluate_expression(args[2], env),
+                        env=env,
+                    )
+
+                elif first.value == "list.map":
+                    if len(args) != 2:
+                        return Expr.ListExpr([
+                            Expr.ListExpr([]),
+                            Expr.String("list.map expects exactly two arguments: a list and a function")
+                        ])
+                    
+                    return handle_list_map(
+                        machine=self,
+                        list=self.evaluate_expression(args[0], env),
+                        func=self.evaluate_expression(args[1], env),
+                        env=env,
+                    )
+
+                elif first.value == "list.position":
+                    if len(args) != 2:
+                        return Expr.ListExpr([
+                            Expr.ListExpr([]),
+                            Expr.String("list.position expects exactly two arguments: a list and a function")
+                        ])
+                    
+                    return handle_list_position(
+                        machine=self,
+                        list=self.evaluate_expression(args[0], env),
+                        predicate=self.evaluate_expression(args[1], env),
+                        env=env,
+                    )
 
-                    match first.value:
-                        case "def":
-                            if len(args) != 2:
-                                raise ValueError("def expects exactly two arguments: a symbol and an expression")
-                            if not isinstance(args[0], Expr.Symbol):
-                                raise ValueError("First argument to def must be a symbol")
-                            
-                            var_name = args[0].value
-                            var_value = self.evaluate_expression(args[1], env)
-                            env.set(var_name, var_value)
-                            return args[0]
-                        
-                        case "+":
-                            evaluated_args = [self.evaluate_expression(arg, env) for arg in args]
-                            if not all(isinstance(arg, Expr.Integer) for arg in evaluated_args):
-                                raise ValueError("All arguments to + must be integers")
-                            
-                            result = sum(arg.value for arg in evaluated_args)
-                            return Expr.Integer(result)
+                elif first.value == "list.any":
+                    if len(args) != 2:
+                        return Expr.ListExpr([
+                            Expr.ListExpr([]),
+                            Expr.String("list.any expects exactly two arguments: a list and a function")
+                        ])
+                    
+                    return handle_list_any(
+                        machine=self,
+                        list=self.evaluate_expression(args[0], env),
+                        predicate=self.evaluate_expression(args[1], env),
+                        env=env,
+                    )
+
+                elif first.value == "list.all":
+                    if len(args) != 2:
+                        return Expr.ListExpr([
+                            Expr.ListExpr([]),
+                            Expr.String("list.all expects exactly two arguments: a list and a function")
+                        ])
+                    
+                    return handle_list_all(
+                        machine=self,
+                        list=self.evaluate_expression(args[0], env),
+                        predicate=self.evaluate_expression(args[1], env),
+                        env=env,
+                    )
+
+                # Number
+                elif first.value == "+":
+                    evaluated_args = [self.evaluate_expression(arg, env) for arg in expr.elements[1:]]
+
+                    # Check for non-integer arguments
+                    if not all(isinstance(arg, Expr.Integer) for arg in evaluated_args):
+                        return Expr.Error(
+                            category="TypeError",
+                            message="All arguments to + must be integers"
+                        )
+                    
+                    # Sum up the integer values
+                    result = sum(arg.value for arg in evaluated_args)
+                    return Expr.Integer(result)
 
             else:
                 evaluated_elements = [self.evaluate_expression(e, env) for e in expr.elements]
                 return Expr.ListExpr(evaluated_elements)
+            
         elif isinstance(expr, Expr.Function):
             return expr
+        
         else:
             raise ValueError(f"Unknown expression type: {type(expr)}")