Add pre-assignment type declaration, LAMBDA

Author: python-processing-unit

SPECIFICATION.html

@@ -194,6 +194,8 @@
 
 Functions are defined using the `FUNC` keyword with explicit parameter and return types. The canonical positional-only form is `FUNC name(T1: arg1, T2: arg2, ..., TN: argN):R{ block }`, where each `Tk` and `R` is `INT`, `FLT`, `STR`, `TNS`, or `FUNC`. Parameters may also declare a call-time default value using `Tk: arg = expr`. A parameter without a default is positional; a parameter with a default is keyword-capable. Positional parameters must appear before any parameters with defaults. Defining a function binds `name` to a callable body with the specified typed formal parameters. Function names must not conflict with the names of built-in operators or functions.
 
+In addition to named functions, the language provides an anonymous function literal form `LAMBDA` which constructs a `FUNC` value without binding it to a function name in the global function table. The syntax is `LAMBDA(T1: arg1, T2: arg2, ..., TN: argN):R{ block }`. Parameter typing, default-value rules, call semantics, and return-type rules are the same as for `FUNC`. Evaluating a `LAMBDA` expression captures (closes over) the current lexical environment, producing a first-class `FUNC` value that can be assigned to variables, stored in tensors, passed as an argument, or returned.
+
 A user-defined function is called with the same syntax as a built-in: `callee(expr1, expr2, ..., exprN)`. The callee may be any expression that evaluates to `FUNC`, including identifiers, tensor elements, or intermediate expressions. Calls may supply zero or more positional arguments (left-to-right) followed by zero or more keyword arguments of the form `param=expr`. Keyword arguments can only appear after all positional arguments. At the call site, every positional argument is bound to the next positional parameter; keyword arguments must match the name of a parameter that declared a default value. Duplicate keyword names, supplying too many positional arguments, or providing a keyword for an unknown parameter are runtime errors. If a keyword-capable parameter is omitted from the call, its default expression is evaluated at call time in the function's lexical environment after earlier parameters have been bound. The evaluated default must match the parameter's declared type. Built-in functions do not accept keyword arguments except that `READFILE` and `WRITEFILE` allow a single optional `coding=` keyword; attempting to pass any other keyword raises a runtime error. Arguments are evaluated left-to-right. The function body executes in a new environment (activation record) that closes over the defining environment. If a `RETURN(v)` statement is executed, the function terminates immediately and yields `v`; the returned value must match the declared return type. If control reaches the end of the body without `RETURN`, the function returns a default value of the declared return type (0 for `INT`, 0.0 for `FLT`, "" for `STR`). Functions whose return type is
 `TNS` or `FUNC` must execute an explicit `RETURN` of the declared type; reaching the end of the body without returning is a runtime error for `TNS`- or `FUNC`-returning functions.
 
@@ -204,7 +206,7 @@
 
 ## 6. Variables and Memory Model
 
-A variable is created only when it is first assigned with an explicit type annotation of the form `TYPE : name = expression`, where TYPE is `INT`, `FLT`, `STR`, `TNS`, or `FUNC`. For example: `INT : counter = 0` or `FUNC : handler = DISPATCH`. Subsequent assignments to the same name must match the declared type and may omit the type annotation (`counter = ADD(counter,1)`). Assigning to an undeclared name without a type annotation is a runtime error. A variable exists until `DEL(name)` is executed. Referencing a variable that has never been declared, or that has been deleted, is a runtime error.
+A symbol's type may be declared without assigning a value using the form `TYPE : name` (for example `INT: x`). Such a declaration records the name's type but does not create a runtime binding: reading `name` before it has been assigned still yields an undefined-identifier error. A variable is created when it is first assigned with an explicit type annotation `TYPE : name = expression`, or when a value is assigned to a previously-declared name. Subsequent assignments to the same name must match the declared type and may omit the type annotation (for example `x = 1` after `INT: x`). Assigning to an undeclared name without either an inline type annotation or a prior declaration is a runtime error. A variable exists until `DEL(name)` is executed. Referencing a variable that has never been assigned (even if it was previously declared) or that has been deleted is a runtime error.
 
 The language assumes at least a global typed environment mapping identifiers to (type, value) pairs. Function calls create new environments for parameters and local variables, as described in Section 6.2; the precise details of name resolution depend on the chosen scoping rules.
 

asm-lang.exe

@@ -18,6 +18,7 @@
 from extensions import ASMExtensionError, HookRegistry, RuntimeServices, StepContext, TypeContext, TypeRegistry, TypeSpec, build_default_services
 from parser import (
     Assignment,
+    Declaration,
     Block,
     BreakStatement,
     CallArgument,
@@ -27,6 +28,7 @@
     ForStatement,
     ParForStatement,
     FuncDef,
+    LambdaExpression,
     AsyncStatement,
     GotoStatement,
     GotopointStatement,
@@ -152,6 +154,8 @@ def __init__(self, target: Value) -> None:
 class Environment:
     parent: Optional["Environment"] = None
     values: Dict[str, Value] = field(default_factory=dict)
+    # declared but unassigned symbol types
+    declared: Dict[str, str] = field(default_factory=dict)
     frozen: set = field(default_factory=set)
     permafrozen: set = field(default_factory=set)
 
@@ -213,16 +217,56 @@ def set(self, name: str, value: Value, declared_type: Optional[str] = None) -> N
             found_env.values[name] = value
             return
 
+        # No existing value binding found. Look for a prior type declaration
+        # in this environment chain.
+        decl_env: Optional[Environment] = None
+        decl_type: Optional[str] = None
+        env2: Optional[Environment] = self
+        while env2 is not None:
+            if name in env2.declared:
+                decl_env = env2
+                decl_type = env2.declared[name]
+                break
+            env2 = env2.parent
+
         if declared_type is None:
-            raise ASMRuntimeError(
-                f"Identifier '{name}' must be declared with a type before assignment",
-                rewrite_rule="ASSIGN",
-            )
+            # Assignment without inline declaration: require a prior declaration
+            if decl_env is None:
+                raise ASMRuntimeError(
+                    f"Identifier '{name}' must be declared with a type before assignment",
+                    rewrite_rule="ASSIGN",
+                )
+            if decl_type != value.type:
+                raise ASMRuntimeError(
+                    f"Assigned value type {value.type} does not match declaration {decl_type}",
+                    rewrite_rule="ASSIGN",
+                )
+            decl_env.values[name] = value
+            return
+
+        # Assignment with inline declaration: if there is an existing declaration
+        # ensure it matches; otherwise record declaration in current env.
+        if decl_env is not None:
+            if decl_type != declared_type:
+                raise ASMRuntimeError(
+                    f"Type mismatch for '{name}': previously declared as {decl_type}",
+                    rewrite_rule="ASSIGN",
+                )
+            if declared_type != value.type:
+                raise ASMRuntimeError(
+                    f"Assigned value type {value.type} does not match declaration {declared_type}",
+                    rewrite_rule="ASSIGN",
+                )
+            decl_env.values[name] = value
+            return
+
+        # No prior declaration: record it in this environment and create the value
         if declared_type != value.type:
             raise ASMRuntimeError(
                 f"Assigned value type {value.type} does not match declaration {declared_type}",
                 rewrite_rule="ASSIGN",
             )
+        self.declared[name] = declared_type
         self.values[name] = value
 
     def get(self, name: str) -> Value:
@@ -3486,6 +3530,9 @@ def _func_to_str(ctx: TypeContext, v: Value) -> str:
         self._functions_version: int = 0
         self._call_resolution_cache: Dict[Tuple[str, str, int], Optional[str]] = {}
 
+        # Monotonic counter for anonymous lambda names (for logs/tracebacks only).
+        self._lambda_counter: int = 0
+
     def _mark_functions_changed(self) -> None:
         self._functions_version += 1
         self._call_resolution_cache.clear()
@@ -3715,6 +3762,28 @@ def _execute_block(self, statements: List[Statement], env: Environment) -> None:
     def _execute_statement(self, statement: Statement, env: Environment) -> None:
         self._log_step(rule=statement.__class__.__name__, location=statement.location)
         statement_type = type(statement)
+        if statement_type is Declaration:
+            # Record a type declaration without creating a value. Do not
+            # introduce a binding; reads will still raise until the name is
+            # assigned. If a value already exists in the same environment,
+            # ensure the types match.
+            if statement.name in self.functions:
+                raise ASMRuntimeError(
+                    f"Identifier '{statement.name}' already bound as function",
+                    location=statement.location,
+                    rewrite_rule="ASSIGN",
+                )
+            env_found = env._find_env(statement.name)
+            if env_found is not None:
+                existing = env_found.values.get(statement.name)
+                if existing is not None and existing.type != statement.declared_type:
+                    raise ASMRuntimeError(
+                        f"Type mismatch for '{statement.name}': previously declared as {existing.type}",
+                        location=statement.location,
+                        rewrite_rule="ASSIGN",
+                    )
+            env.declared[statement.name] = statement.declared_type
+            return
         if statement_type is Assignment:
             if statement.target in self.functions:
                 raise ASMRuntimeError(
@@ -4496,6 +4565,27 @@ def _evaluate_expression(self, expression: Expression, env: Environment) -> Valu
                 location=expression.location,
                 rewrite_rule="IDENT",
             )
+        if expression_type is LambdaExpression:
+            # Create an anonymous function value that closes over the current environment.
+            self._lambda_counter += 1
+            name = f"<lambda_{self._lambda_counter}>"
+            fn = Function(
+                name=name,
+                params=expression.params,
+                return_type=expression.return_type,
+                body=expression.body,
+                closure=env,
+            )
+            self._log_step(
+                rule="LAMBDA",
+                location=expression.location,
+                extra={
+                    "name": name,
+                    "params": [p.name for p in expression.params],
+                    "return_type": expression.return_type,
+                },
+            )
+            return Value(TYPE_FUNC, fn)
         if expression_type is CallExpression:
             callee_expr = expression.callee
             callee_ident = callee_expr.name if type(callee_expr) is Identifier else None

interpreter.py

@@ -27,6 +27,7 @@ class Token:
     "FOR",
     "PARFOR",
     "FUNC",
+    "LAMBDA",
     "ASYNC",
     "RETURN",
     "POP",

lexer.py

@@ -37,9 +37,16 @@ class Block(Node):
 @dataclass(slots=True)
 class Assignment(Statement):
     target: str
-    expression: "Expression"
     declared_type: Optional[str]
 
+    expression: "Expression"
+
+
+@dataclass(slots=True)
+class Declaration(Statement):
+    name: str
+    declared_type: str
+
 
 @dataclass(slots=True)
 class ExpressionStatement(Statement):
@@ -134,6 +141,13 @@ class Expression(Node):
     pass
 
 
+@dataclass(slots=True)
+class LambdaExpression(Expression):
+    params: List["Param"]
+    return_type: str
+    body: Block
+
+
 @dataclass(slots=True)
 class TensorLiteral(Expression):
     items: List["Expression"]
@@ -285,10 +299,17 @@ def _parse_assignment(self, declared_type: Optional[str]) -> Assignment:
         location: SourceLocation = self._location_from_token(ident)
         return Assignment(location=location, target=ident.value, expression=expr, declared_type=declared_type)
 
-    def _parse_typed_assignment(self) -> Assignment:
+    def _parse_typed_assignment(self) -> Statement:
         type_token = self._consume_type_token()
         self._consume("COLON")
-        return self._parse_assignment(type_token.value)
+        # Allow a bare type declaration (e.g. `INT: x`) which records the
+        # symbol's declared type but does not perform an assignment. If an
+        # equals follows, parse as a normal typed assignment.
+        if self._peek().type == "IDENT" and self._peek_next().type == "EQUALS":
+            return self._parse_assignment(type_token.value)
+        ident = self._consume("IDENT")
+        location: SourceLocation = self._location_from_token(type_token)
+        return Declaration(location=location, name=ident.value, declared_type=type_token.value)
 
     def _parse_index_assignment(self) -> TensorSetStatement:
         target = self._parse_index_expression()
@@ -324,6 +345,33 @@ def _parse_func(self) -> FuncDef:
         location: SourceLocation = self._location_from_token(keyword)
         return FuncDef(location=location, name=name_token.value, params=params, return_type=return_type.value, body=block)
 
+    def _parse_lambda(self) -> LambdaExpression:
+        keyword = self._consume("LAMBDA")
+        self._consume("LPAREN")
+        params: List[Param] = []
+        seen_default = False
+        if self._peek().type != "RPAREN":
+            while True:
+                type_token = self._consume_type_token()
+                self._consume("COLON")
+                name_tok = self._consume("IDENT")
+                default_expr: Optional[Expression] = None
+                if self._match("EQUALS"):
+                    seen_default = True
+                    default_expr = self._parse_expression()
+                elif seen_default:
+                    raise ASMParseError(
+                        f"Positional parameter cannot follow parameter with default at line {name_tok.line}")
+                params.append(Param(type=type_token.value, name=name_tok.value, default=default_expr))
+                if not self._match("COMMA"):
+                    break
+        self._consume("RPAREN")
+        self._consume("COLON")
+        return_type = self._consume_type_token()
+        block: Block = self._parse_block()
+        location: SourceLocation = self._location_from_token(keyword)
+        return LambdaExpression(location=location, params=params, return_type=return_type.value, body=block)
+
     def _parse_if(self) -> IfStatement:
         keyword = self._consume("IF")
         condition: Expression = self._parse_parenthesized_expression()
@@ -452,6 +500,8 @@ def _parse_primary(self) -> Expression:
             return self._parse_tensor_literal()
         if token.type == "LANGLE":
             return self._parse_map_literal()
+        if token.type == "LAMBDA":
+            return self._parse_lambda()
         if token.type == "IDENT":
             ident: Token = self._consume("IDENT")
             location: SourceLocation = self._location_from_token(ident)