feat: add function type to midas syntax

feat(types): add type params to extend statement
refactor(types): extract TypeParams
2026-06-09 23:48:06 +02:00 · 2026-06-09 23:40:57 +02:00 · 2026-06-09 15:30:45 +02:00
13 changed files with 341 additions and 101 deletions
@@ -30,6 +30,7 @@ from __future__ import annotations

 T = TypeVar("T")

+{preamble}
 {sections}
 """

@@ -57,6 +58,11 @@ IMPORTS_REGEX = re.compile(
    re.MULTILINE | re.DOTALL,
 )

+PREAMBLE_REGEX = re.compile(
+    r"^###>\s*Preamble\s*?\n(?P<body>.*?)\n###<$",
+    re.MULTILINE | re.DOTALL,
+)
+

 def snake_case(text: str) -> str:
    return re.sub(r"[A-Z]", lambda c: "_" + c.group().lower(), text).lower().strip("_")
@@ -88,13 +94,14 @@ def make_banner(text: str) -> str:


 def make_section(full_name: str, base: str, param: str, body: str) -> str:
+    print(f"    Generating {full_name}")
    visitor_methods: list[str] = []
    classes: list[str] = []
    definitions: list[str] = body.strip("\n").split("\n\n\n")
    for cls in definitions:
        cls = cls.strip("\n")
        name: str = re.match("class (.*?):", cls).group(1)  # type: ignore
-        print(f"Processing {name}")
+        print(f"        Processing {name}")
        visitor_methods.append(make_visitor_method(name, param))
        classes.append(make_class(name, cls, base))

@@ -107,6 +114,7 @@ def make_section(full_name: str, base: str, param: str, body: str) -> str:


 def generate(definitions_path: Path, out_path: Path):
+    print(f"Processing generating {out_path} from {definitions_path}")
    root_dir: Path = Path(__file__).parent.parent
    rel_path: Path = definitions_path.relative_to(root_dir)
    src: str = definitions_path.read_text()
@@ -116,6 +124,10 @@ def generate(definitions_path: Path, out_path: Path):
    if m := IMPORTS_REGEX.search(src):
        imports = m.group("body").strip("\n")

+    preamble: str = ""
+    if m := PREAMBLE_REGEX.search(src):
+        preamble = m.group("body")
+
    for section_m in SECTION_REGEX.finditer(src):
        full_name: str = section_m.group("name")
        base: str = section_m.group("base")
@@ -129,6 +141,7 @@ def generate(definitions_path: Path, out_path: Path):
            gen_path=Path(__file__).relative_to(root_dir),
        ),
        imports=imports,
+        preamble=preamble,
        sections="\n\n\n".join(sections),
    )
    out_path.write_text(result)
@@ -12,18 +12,23 @@ from midas.lexer.token import Token
 ###<


+###> Preamble
+@dataclass(frozen=True, kw_only=True)
+class TypeParam:
+    location: Location
+    name: Token
+    bound: Optional[Type]
+
+
+###<
+
+
 ###> Stmt | Statements
 class TypeStmt:
    name: Token
-    params: list[Param]
+    params: list[TypeParam]
    type: Type

-    @dataclass(frozen=True, kw_only=True)
-    class Param:
-        location: Location
-        name: Token
-        bound: Optional[Type]
-

 class PropertyStmt:
    name: Token
@@ -31,6 +36,7 @@ class PropertyStmt:


 class ExtendStmt:
+    params: list[TypeParam]
    type: Type
    operations: list[OpStmt]

@@ -103,7 +109,7 @@ class NamedType:

 class GenericType:
    type: Type
-    params: list[Type]
+    args: list[Type]


 class ConstraintType:
@@ -115,4 +121,17 @@ class ComplexType:
    properties: list[PropertyStmt]


+class FunctionType:
+    pos_args: list[Argument]
+    kw_args: list[Argument]
+    returns: Type
+
+    @dataclass(frozen=True, kw_only=True)
+    class Argument:
+        location: Optional[Location] = None
+        name: Optional[Token]
+        type: Type
+        required: bool
+
+
 ###<
@@ -14,6 +14,13 @@ from midas.lexer.token import Token

 T = TypeVar("T")

+@dataclass(frozen=True, kw_only=True)
+class TypeParam:
+    location: Location
+    name: Token
+    bound: Optional[Type]
+
+
 ##############
 # Statements #
 ##############
@@ -46,15 +53,9 @@ class Stmt(ABC):
@dataclass(frozen=True)
 class TypeStmt(Stmt):
    name: Token
-    params: list[Param]
+    params: list[TypeParam]
    type: Type

-    @dataclass(frozen=True, kw_only=True)
-    class Param:
-        location: Location
-        name: Token
-        bound: Optional[Type]
-
    def accept(self, visitor: Stmt.Visitor[T]) -> T:
        return visitor.visit_type_stmt(self)

@@ -70,6 +71,7 @@ class PropertyStmt(Stmt):

@dataclass(frozen=True)
 class ExtendStmt(Stmt):
+    params: list[TypeParam]
    type: Type
    operations: list[OpStmt]

@@ -231,6 +233,9 @@ class Type(ABC):
        @abstractmethod
        def visit_complex_type(self, type: ComplexType) -> T: ...

+        @abstractmethod
+        def visit_function_type(self, type: FunctionType) -> T: ...
+

@dataclass(frozen=True)
 class NamedType(Type):
@@ -243,7 +248,7 @@ class NamedType(Type):
@dataclass(frozen=True)
 class GenericType(Type):
    type: Type
-    params: list[Type]
+    args: list[Type]

    def accept(self, visitor: Type.Visitor[T]) -> T:
        return visitor.visit_generic_type(self)
@@ -264,3 +269,20 @@ class ComplexType(Type):

    def accept(self, visitor: Type.Visitor[T]) -> T:
        return visitor.visit_complex_type(self)
+
+
+@dataclass(frozen=True)
+class FunctionType(Type):
+    pos_args: list[Argument]
+    kw_args: list[Argument]
+    returns: Type
+
+    @dataclass(frozen=True, kw_only=True)
+    class Argument:
+        location: Optional[Location] = None
+        name: Optional[Token]
+        type: Type
+        required: bool
+
+    def accept(self, visitor: Type.Visitor[T]) -> T:
+        return visitor.visit_function_type(self)
@@ -100,12 +100,12 @@ class MidasAstPrinter(
                    self._idx = i
                    if i == len(stmt.params) - 1:
                        self._mark_last()
-                    self._print_type_stmt_param(param)
+                    self._print_type_param(param)
            self._write_line("type", last=True)
            with self._child_level(single=True):
                stmt.type.accept(self)

-    def _print_type_stmt_param(self, param: m.TypeStmt.Param) -> None:
+    def _print_type_param(self, param: m.TypeParam) -> None:
        self._write_line("Param")
        with self._child_level():
            self._write_line(f'name: "{param.name.lexeme}"')
@@ -122,6 +122,13 @@ class MidasAstPrinter(
    def visit_extend_stmt(self, stmt: m.ExtendStmt) -> None:
        self._write_line("ExtendStmt")
        with self._child_level():
+            self._write_line("params")
+            with self._child_level():
+                for i, param in enumerate(stmt.params):
+                    self._idx = i
+                    if i == len(stmt.params) - 1:
+                        self._mark_last()
+                    self._print_type_param(param)
            self._write_line("type")
            with self._child_level(single=True):
                stmt.type.accept(self)
@@ -234,11 +241,11 @@ class MidasAstPrinter(
            self._write_line("type")
            with self._child_level():
                type.type.accept(self)
-            self._write_line("params", last=True)
+            self._write_line("args", last=True)
            with self._child_level():
-                for i, param in enumerate(type.params):
+                for i, param in enumerate(type.args):
                    self._idx = i
-                    if i == len(type.params) - 1:
+                    if i == len(type.args) - 1:
                        self._mark_last()
                    param.accept(self)

@@ -263,6 +270,41 @@ class MidasAstPrinter(
                        self._mark_last()
                    prop.accept(self)

+    def visit_function_type(self, type: m.FunctionType) -> None:
+        self._write_line("FunctionType")
+        with self._child_level():
+            self._write_line("pos_args")
+            with self._child_level():
+                for i, arg in enumerate(type.pos_args):
+                    self._idx = i
+                    if i == len(type.pos_args) - 1:
+                        self._mark_last()
+                    self._print_function_arg(arg)
+
+            self._write_line("kw_args")
+            with self._child_level():
+                for i, arg in enumerate(type.kw_args):
+                    self._idx = i
+                    if i == len(type.kw_args) - 1:
+                        self._mark_last()
+                    self._print_function_arg(arg)
+
+            self._write_line("returns", last=True)
+            with self._child_level(single=True):
+                type.returns.accept(self)
+
+    def _print_function_arg(self, arg: m.FunctionType.Argument) -> None:
+        self._write_line("Argument")
+        with self._child_level():
+            name: str = "None"
+            if arg.name is not None:
+                name = f'"{arg.name.lexeme}"'
+            self._write_line(f"name: {name}")
+            self._write_line("type")
+            with self._child_level(single=True):
+                arg.type.accept(self)
+            self._write_line(f"required: {arg.required}", last=True)
+

 class MidasPrinter(m.Expr.Visitor[str], m.Stmt.Visitor[str], m.Type.Visitor[str]):
    def __init__(self, indent: int = 4):
@@ -279,14 +321,12 @@ class MidasPrinter(m.Expr.Visitor[str], m.Stmt.Visitor[str], m.Type.Visitor[str]
    def visit_type_stmt(self, stmt: m.TypeStmt) -> str:
        template: str = ""
        if len(stmt.params) != 0:
-            params: list[str] = [
-                self._print_type_template_param(param) for param in stmt.params
-            ]
+            params: list[str] = [self._print_type_param(param) for param in stmt.params]
            template = f"[{', '.join(params)}]"
        res: str = f"type {stmt.name.lexeme}{template} = {stmt.type.accept(self)}"
        return self.indented(res)

-    def _print_type_template_param(self, param: m.TypeStmt.Param) -> str:
+    def _print_type_param(self, param: m.TypeParam) -> str:
        res: str = param.name.lexeme
        if param.bound is not None:
            res += "<:" + param.bound.accept(self)
@@ -358,9 +398,9 @@ class MidasPrinter(m.Expr.Visitor[str], m.Stmt.Visitor[str], m.Type.Visitor[str]

    def visit_generic_type(self, type: m.GenericType) -> str:
        res: str = type.type.accept(self)
-        if len(type.params) != 0:
-            params: list[str] = [param.accept(self) for param in type.params]
-            res += f"[{', '.join(params)}]"
+        if len(type.args) != 0:
+            args: list[str] = [param.accept(self) for param in type.args]
+            res += f"[{', '.join(args)}]"
        return res

    def visit_constraint_type(self, type: m.ConstraintType) -> str:
@@ -378,6 +418,29 @@ class MidasPrinter(m.Expr.Visitor[str], m.Stmt.Visitor[str], m.Type.Visitor[str]
        res += self.indented("}")
        return res

+    def visit_function_type(self, type: m.FunctionType) -> str:
+        pos_args: list[str] = [self._print_arg(arg) for arg in type.pos_args]
+        kw_args: list[str] = [self._print_arg(arg) for arg in type.pos_args]
+        args: list[str] = pos_args
+
+        if len(pos_args) != 0:
+            args.append("/")
+        if len(kw_args) != 0:
+            args.append("*")
+        args += kw_args
+
+        return f"({', '.join(args)}) -> {type.returns.accept(self)}"
+
+    def _print_arg(self, arg: m.FunctionType.Argument) -> str:
+        res: str = ""
+        if arg.name is not None:
+            res += arg.name.lexeme
+            res += ": "
+        res += arg.type.accept(self)
+        if not arg.required:
+            res += "?"
+        return res
+

 class PythonAstPrinter(
    AstPrinter,
@@ -14,6 +14,7 @@ from midas.ast.location import Location

 T = TypeVar("T")

+
 ####################
 # Type annotations #
 ####################
@@ -8,6 +8,7 @@ from midas.checker.reporter import FileReporter, Reporter
 from midas.checker.types import (
    AliasType,
    ComplexType,
+    Function,
    GenericType,
    Type,
    TypeVar,
@@ -64,15 +65,8 @@ class MidasTyper(m.Stmt.Visitor[None], m.Expr.Visitor[None], m.Type.Visitor[Type
            stmt.accept(self)

    def visit_type_stmt(self, stmt: m.TypeStmt) -> None:
-        params: list[TypeVar] = []
-        for param in stmt.params:
-            name: str = param.name.lexeme
-            bound: Optional[Type] = None
-            if param.bound is not None:
-                bound = param.bound.accept(self)
-            var = TypeVar(name=name, bound=bound)
-            self._local_variables[name] = var
-            params.append(var)
+        params: list[TypeVar] = self._resolve_type_params(stmt.params)
+
        name: str = stmt.name.lexeme
        type: Type = stmt.type.accept(self)
        if len(params) != 0:
@@ -85,6 +79,7 @@ class MidasTyper(m.Stmt.Visitor[None], m.Expr.Visitor[None], m.Type.Visitor[Type
    def visit_property_stmt(self, stmt: m.PropertyStmt) -> None: ...

    def visit_extend_stmt(self, stmt: m.ExtendStmt) -> None:
+        self._resolve_type_params(stmt.params)
        base: Type = stmt.type.accept(self)
        for op in stmt.operations:
            right: Type = op.operand.accept(self)
@@ -122,8 +117,8 @@ class MidasTyper(m.Stmt.Visitor[None], m.Expr.Visitor[None], m.Type.Visitor[Type

    def visit_generic_type(self, type: m.GenericType) -> Type:
        type_: Type = type.type.accept(self)
-        params: list[Type] = [param.accept(self) for param in type.params]
-        return self.types.apply_generic(type_, params)
+        args: list[Type] = [arg.accept(self) for arg in type.args]
+        return self.types.apply_generic(type_, args)

    def visit_constraint_type(self, type: m.ConstraintType) -> Type:
        type_: Type = type.type.accept(self)
@@ -137,3 +132,40 @@ class MidasTyper(m.Stmt.Visitor[None], m.Expr.Visitor[None], m.Type.Visitor[Type
                prop.name.lexeme: prop.type.accept(self) for prop in type.properties
            }
        )
+
+    def visit_function_type(self, type: m.FunctionType) -> Type:
+        return Function(
+            name="<anonymous>",
+            pos_args=[
+                Function.Argument(
+                    pos=i,
+                    name=arg.name.lexeme if arg.name is not None else str(i),
+                    type=arg.type.accept(self),
+                    required=arg.required,
+                )
+                for i, arg in enumerate(type.pos_args)
+            ],
+            args=[],
+            kw_args=[
+                Function.Argument(
+                    pos=i,
+                    name=arg.name.lexeme if arg.name is not None else str(i),
+                    type=arg.type.accept(self),
+                    required=arg.required,
+                )
+                for i, arg in enumerate(type.kw_args, start=len(type.pos_args))
+            ],
+            returns=type.returns.accept(self),
+        )
+
+    def _resolve_type_params(self, params: list[m.TypeParam]):
+        vars: list[TypeVar] = []
+        for param in params:
+            name: str = param.name.lexeme
+            bound: Optional[Type] = None
+            if param.bound is not None:
+                bound = param.bound.accept(self)
+            var = TypeVar(name=name, bound=bound)
+            self._local_variables[name] = var
+            vars.append(var)
+        return vars
@@ -250,34 +250,34 @@ class TypesRegistry:

        return True

-    def apply_generic(self, type: Type, params: list[Type]) -> Type:
+    def apply_generic(self, type: Type, args: list[Type]) -> Type:
        match type:
            case AliasType(name=name, type=base):
-                return AliasType(name=name, type=self.apply_generic(base, params))
+                return AliasType(name=name, type=self.apply_generic(base, args))

            case GenericType(name=name, params=type_vars, body=body):
-                n_params: int = len(params)
+                n_args: int = len(args)
                n_type_vars: int = len(type_vars)
-                if n_params < n_type_vars:
+                if n_args < n_type_vars:
                    raise ValueError(
-                        f"Missing type parameters, expected {n_type_vars} but only {n_params} provided"
+                        f"Missing type arguments, expected {n_type_vars} but only {n_args} provided"
                    )
-                if n_params > n_type_vars:
+                if n_args > n_type_vars:
                    raise ValueError(
-                        f"Too many type parameters, expected {n_type_vars} but {n_params} provided"
+                        f"Too many type arguments, expected {n_type_vars} but {n_args} provided"
                    )
                substitutions: dict[str, Type] = {}
-                for param, type_var in zip(params, type_vars):
+                for arg, type_var in zip(args, type_vars):
                    if type_var.bound is not None and not self.is_subtype(
-                        param, type_var.bound
+                        arg, type_var.bound
                    ):
                        raise ValueError(
-                            f"Type parameter {param} is not a subtype of {type_var.bound}"
+                            f"Type argument {arg} is not a subtype of {type_var.bound}"
                        )
-                    substitutions[type_var.name] = param
+                    substitutions[type_var.name] = arg
                return AppliedType(
                    name=name,
-                    args=params,
+                    args=args,
                    body=substitute_typevars(body, substitutions),
                )

@@ -288,8 +288,8 @@ class MidasHighlighter(
    def visit_generic_type(self, type: m.GenericType) -> None:
        self.wrap(type, "generic-type")
        type.type.accept(self)
-        for param in type.params:
-            param.accept(self)
+        for arg in type.args:
+            arg.accept(self)

    def visit_constraint_type(self, type: m.ConstraintType) -> None:
        self.wrap(type, "constraint-type")
@@ -301,6 +301,12 @@ class MidasHighlighter(
        for prop in type.properties:
            prop.accept(self)

+    def visit_function_type(self, type: m.FunctionType) -> None:
+        self.wrap(type, "function")
+        for arg in type.pos_args + type.kw_args:
+            arg.type.accept(self)
+        type.returns.accept(self)
+

 class DiagnosticsHighlighter(Highlighter):
    EXTRA_CSS_PATH: Optional[Path] = Path(__file__).parent / "hl_diagnostic.css"
@@ -50,12 +50,14 @@ class MidasLexer(Lexer):
            #     self.add_token(TokenType.PLUS)
            case "-":
                self.add_token(TokenType.MINUS)
-            # case "*":
-            #     self.add_token(TokenType.STAR)
+            case "*":
+                self.add_token(TokenType.STAR)
            case "/" if self.match("/"):
                self.scan_comment()
            case "/" if self.match("*"):
                self.scan_comment_multiline()
+            case "/":
+                self.add_token(TokenType.SLASH)
            case "\n":
                self.add_token(TokenType.NEWLINE)
            case " " | "\r" | "\t":
@@ -27,8 +27,8 @@ class TokenType(Enum):
    # Operators
    # PLUS = auto()
    MINUS = auto()
-    # STAR = auto()
-    # SLASH = auto()
+    STAR = auto()
+    SLASH = auto()
    GREATER = auto()
    GREATER_EQUAL = auto()
    LESS = auto()
@@ -7,6 +7,7 @@ from midas.ast.midas import (
    ConstraintType,
    Expr,
    ExtendStmt,
+    FunctionType,
    GenericType,
    GetExpr,
    GroupingExpr,
@@ -18,12 +19,13 @@ from midas.ast.midas import (
    PropertyStmt,
    Stmt,
    Type,
+    TypeParam,
    TypeStmt,
    UnaryExpr,
    VariableExpr,
    WildcardExpr,
 )
-from midas.lexer.token import Token, TokenType
+from midas.lexer.token import KEYWORDS, Token, TokenType
 from midas.parser.base import Parser
 from midas.parser.errors import ParsingError

@@ -107,10 +109,8 @@ class MidasParser(Parser):
            TypeStmt: the parsed type declaration statement
        """
        keyword: Token = self.previous()
-        name: Token = self.consume(TokenType.IDENTIFIER, "Expected type name")
-        params: list[TypeStmt.Param] = []
-        if self.check(TokenType.LEFT_BRACKET):
-            params = self.type_stmt_params()
+        name: Token = self.consume_identifier("Expected type name")
+        params: list[TypeParam] = self.type_params()

        self.consume(TokenType.EQUAL, "Expected '=' before type definition")

@@ -123,24 +123,27 @@ class MidasParser(Parser):
            type=type,
        )

-    def type_stmt_params(self) -> list[TypeStmt.Param]:
-        """Parse a generic template expression
+    def type_params(self) -> list[TypeParam]:
+        """Parse a list of type parameters

-        A template is written `[TypeExpr]`
+        Type parameters are a comma-separated list of type variables wrapped in brackets.
+        Each type variable is either a simple variable, or a bounded variable written `S <: T`

        Returns:
-            TemplateExpr: the parsed template expression
+            list[TypeParam]: the list of type parameters, if any, or an empty list
        """
-        self.consume(TokenType.LEFT_BRACKET, "Missing '[' before template expression")
-        params: list[TypeStmt.Param] = []
+        if not self.match(TokenType.LEFT_BRACKET):
+            return []
+
+        params: list[TypeParam] = []
        while not self.is_at_end() and not self.check(TokenType.RIGHT_BRACKET):
-            name: Token = self.consume(TokenType.IDENTIFIER, "Expected type variable")
+            name: Token = self.consume_identifier("Expected type variable")
            bound: Optional[Type] = None
            if self.match(TokenType.LESS):
                self.consume(TokenType.COLON, "Expected ':' after '<'")
                bound = self.type_expr()
            params.append(
-                TypeStmt.Param(
+                TypeParam(
                    location=name.location_to(self.previous()),
                    name=name,
                    bound=bound,
@@ -148,7 +151,7 @@ class MidasParser(Parser):
            )
            if not self.match(TokenType.COMMA):
                break
-        self.consume(TokenType.RIGHT_BRACKET, "Missing ']' after template expression")
+        self.consume(TokenType.RIGHT_BRACKET, "Missing ']' after type parameters")
        return params

    def type_expr(self) -> Type:
@@ -187,26 +190,26 @@ class MidasParser(Parser):
    def generic_type(self) -> Type:
        type: Type = self.named_type()
        if self.check(TokenType.LEFT_BRACKET):
-            params: list[Type] = self.type_params()
+            args: list[Type] = self.type_args()
            return GenericType(
                location=Location.span(type.location, self.previous().get_location()),
                type=type,
-                params=params,
+                args=args,
            )
        return type

-    def type_params(self) -> list[Type]:
-        params: list[Type] = []
-        self.consume(TokenType.LEFT_BRACKET, "Missing '[' before generic parameters")
+    def type_args(self) -> list[Type]:
+        args: list[Type] = []
+        self.consume(TokenType.LEFT_BRACKET, "Missing '[' before generic arguments")
        while not self.is_at_end() and not self.check(TokenType.RIGHT_BRACKET):
-            params.append(self.type_expr())
+            args.append(self.type_expr())
            if not self.match(TokenType.COMMA):
                break
-        self.consume(TokenType.RIGHT_BRACKET, "Missing ']' after generic parameters")
-        return params
+        self.consume(TokenType.RIGHT_BRACKET, "Missing ']' after generic arguments")
+        return args

    def named_type(self) -> Type:
-        name: Token = self.consume(TokenType.IDENTIFIER, "Expected type name")
+        name: Token = self.consume_identifier("Expected type name")
        return NamedType(
            location=name.get_location(),
            name=name,
@@ -322,9 +325,7 @@ class MidasParser(Parser):
        """
        expr: Expr = self.primary()
        while self.match(TokenType.DOT):
-            name: Token = self.consume(
-                TokenType.IDENTIFIER, "Expected property name after '.'"
-            )
+            name: Token = self.consume_identifier("Expected property name after '.'")
            location: Location = Location.span(expr.location, name.get_location())
            expr = GetExpr(location=location, expr=expr, name=name)
        return expr
@@ -348,7 +349,7 @@ class MidasParser(Parser):
        if self.match(TokenType.NUMBER):
            return LiteralExpr(location=token.get_location(), value=token.value)

-        if self.match(TokenType.IDENTIFIER):
+        if self.match_identifier():
            return VariableExpr(location=token.get_location(), name=token)

        if self.match(TokenType.UNDERSCORE):
@@ -361,6 +362,20 @@ class MidasParser(Parser):

        raise self.error(self.peek(), "Expected expression")

+    def consume_identifier(self, message: str = "Expected identifier") -> Token:
+        if not self.match_identifier():
+            raise self.error(self.peek(), message)
+        return self.previous()
+
+    def match_identifier(self) -> bool:
+        return self.match(TokenType.IDENTIFIER, *KEYWORDS.values())
+
+    def check_identifier(self) -> bool:
+        for tt in [TokenType.IDENTIFIER, *KEYWORDS.values()]:
+            if self.check(tt):
+                return True
+        return False
+
    def property_stmt(self) -> PropertyStmt:
        """Parse a property statement

@@ -369,7 +384,7 @@ class MidasParser(Parser):
        Returns:
            PropertyStmt: the parsed property statement
        """
-        name: Token = self.consume(TokenType.IDENTIFIER, "Expected property name")
+        name: Token = self.consume_identifier("Expected property name")
        self.consume(TokenType.COLON, "Expected ':' after property name")
        type: Type = self.type_expr()
        return PropertyStmt(
@@ -381,12 +396,14 @@ class MidasParser(Parser):
    def extend_declaration(self) -> ExtendStmt:
        """Parse an extension definition

-        An extension is written `extend Type { operations }`
+        An extension is written `extend Type { operations }` or `extend[S <: T, U] Type { operations }`

        Returns:
            ExtendStmt: the parsed extension statement
        """
        keyword: Token = self.previous()
+        params: list[TypeParam] = self.type_params()
+
        type: Type = self.type_expr()
        self.consume(TokenType.LEFT_BRACE, "Expected '{' to start extend body")
        operations: list[OpStmt] = []
@@ -394,7 +411,12 @@ class MidasParser(Parser):
            operations.append(self.op_declaration())
        self.consume(TokenType.RIGHT_BRACE, "Unclosed extend body")
        location: Location = keyword.location_to(self.previous())
-        return ExtendStmt(location=location, type=type, operations=operations)
+        return ExtendStmt(
+            location=location,
+            params=params,
+            type=type,
+            operations=operations,
+        )

    def op_declaration(self) -> OpStmt:
        """Parse an operation definition
@@ -430,9 +452,9 @@ class MidasParser(Parser):
            PredicateStmt: the parsed predicate declaration statement
        """
        keyword: Token = self.previous()
-        name: Token = self.consume(TokenType.IDENTIFIER, "Expected predicate name")
+        name: Token = self.consume_identifier("Expected predicate name")
        self.consume(TokenType.LEFT_PAREN, "Expected '(' before predicate subject")
-        subject: Token = self.consume(TokenType.IDENTIFIER, "Expected subject name")
+        subject: Token = self.consume_identifier("Expected subject name")
        self.consume(TokenType.COLON, "Expected ':' after subject name")
        type: Type = self.type_expr()
        self.consume(TokenType.RIGHT_PAREN, "Expected ')' after predicate subject")
@@ -445,3 +467,48 @@ class MidasParser(Parser):
            type=type,
            condition=condition,
        )
+
+    def function(self) -> FunctionType:
+        l_paren: Token = self.consume(
+            TokenType.LEFT_PAREN, "Expected '(' before function parameters"
+        )
+        pos_args: list[FunctionType.Argument] = []
+        kw_args: list[FunctionType.Argument] = []
+
+        positional: bool = True
+        while not self.is_at_end() and not self.check(TokenType.RIGHT_PAREN):
+            if positional and (
+                self.match(TokenType.STAR) or self.match(TokenType.SLASH)
+            ):
+                positional = False
+            else:
+                name: Optional[Token] = None
+                if self.check_identifier() and self.check_next(TokenType.COLON):
+                    name = self.advance()
+                    self.advance()
+                type: Type = self.type_expr()
+                required: bool = self.match(TokenType.QMARK)
+                arg = FunctionType.Argument(
+                    location=None,
+                    name=name,
+                    type=type,
+                    required=required,
+                )
+                if positional:
+                    pos_args.append(arg)
+                else:
+                    kw_args.append(arg)
+
+            if not self.match(TokenType.COMMA):
+                break
+        self.consume(TokenType.RIGHT_PAREN, "Expected ')' after function parameters")
+
+        self.consume(TokenType.ARROW, "Expected '->' before result type")
+        result: Type = self.type_expr()
+
+        return FunctionType(
+            location=l_paren.location_to(self.previous()),
+            pos_args=pos_args,
+            kw_args=kw_args,
+            returns=result,
+        )
@@ -2385,7 +2385,7 @@
              "_type": "NamedType",
              "name": "Difference"
            },
-            "params": [
+            "args": [
              {
                "_type": "NamedType",
                "name": "GeoLocation"
@@ -2416,7 +2416,7 @@
                "_type": "NamedType",
                "name": "Difference"
              },
-              "params": [
+              "args": [
                {
                  "_type": "NamedType",
                  "name": "Latitude"
@@ -2433,7 +2433,7 @@
                "_type": "NamedType",
                "name": "Difference"
              },
-              "params": [
+              "args": [
                {
                  "_type": "NamedType",
                  "name": "Longitude"
@@ -2464,7 +2464,7 @@
              "_type": "NamedType",
              "name": "Difference"
            },
-            "params": [
+            "args": [
              {
                "_type": "NamedType",
                "name": "Latitude"
@@ -2494,7 +2494,7 @@
              "_type": "NamedType",
              "name": "Difference"
            },
-            "params": [
+            "args": [
              {
                "_type": "NamedType",
                "name": "Longitude"
@@ -2638,7 +2638,7 @@
                "_type": "NamedType",
                "name": "Optional"
              },
-              "params": [
+              "args": [
                {
                  "_type": "ConstraintType",
                  "type": {
@@ -6,6 +6,7 @@ from midas.ast.midas import (
    ConstraintType,
    Expr,
    ExtendStmt,
+    FunctionType,
    GenericType,
    GetExpr,
    GroupingExpr,
@@ -17,6 +18,7 @@ from midas.ast.midas import (
    PropertyStmt,
    Stmt,
    Type,
+    TypeParam,
    TypeStmt,
    UnaryExpr,
    VariableExpr,
@@ -46,13 +48,11 @@ class MidasAstJsonSerializer(
        return {
            "_type": "TypeStmt",
            "name": stmt.name.lexeme,
-            "params": [
-                self._serialize_type_stmt_template_param(param) for param in stmt.params
-            ],
+            "params": [self._serialize_type_param(param) for param in stmt.params],
            "type": stmt.type.accept(self),
        }

-    def _serialize_type_stmt_template_param(self, param: TypeStmt.Param) -> dict:
+    def _serialize_type_param(self, param: TypeParam) -> dict:
        return {
            "name": param.name.lexeme,
            "bound": self._serialize_optional(param.bound),
@@ -150,7 +150,7 @@ class MidasAstJsonSerializer(
        return {
            "_type": "GenericType",
            "type": type.type.accept(self),
-            "params": self._serialize_list(type.params),
+            "args": self._serialize_list(type.args),
        }

    def visit_constraint_type(self, type: ConstraintType) -> dict:
@@ -165,3 +165,18 @@ class MidasAstJsonSerializer(
            "_type": "ComplexType",
            "properties": self._serialize_list(type.properties),
        }
+
+    def visit_function_type(self, type: FunctionType) -> dict:
+        return {
+            "_type": "FunctionType",
+            "pos_args": [self._serialize_func_arg(arg) for arg in type.pos_args],
+            "kw_args": [self._serialize_func_arg(arg) for arg in type.kw_args],
+            "returns": type.returns.accept(self),
+        }
+
+    def _serialize_func_arg(self, arg: FunctionType.Argument) -> dict:
+        return {
+            "name": arg.name,
+            "type": arg.type.accept(self),
+            "required": arg.required,
+        }
Author	SHA1	Message	Date
HEL	c6ead886ec	feat: add function type to midas syntax	2026-06-09 23:48:06 +02:00
HEL	9de03bf2b5	feat(types): add type params to extend statement	2026-06-09 23:40:57 +02:00
HEL	a26b9293be	refactor(types): extract TypeParams also rename generic type params to type args (when calling a generic)	2026-06-09 15:30:45 +02:00