koskript 1.4.2__tar.gz → 1.5.0__tar.gz

{koskript-1.4.2 → koskript-1.5.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: koskript
-Version: 1.4.2
-Summary: A programming language fully embbeded on python.
+Version: 1.5.0
+Summary: A programming language fully embedded in Python.
 Author: alesis.buzz
 License: Mozilla Public License Version 2.0
         ==================================
@@ -378,7 +378,7 @@ License: Mozilla Public License Version 2.0
           defined by the Mozilla Public License, v. 2.0.
         
 Project-URL: Homepage, https://github.com/alesis-buzz/koskript
-Keywords: scripting,programming-language,embedded,interpreter,parser,lark
+Keywords: scripting,programming-language,embedded,interpreter,parser
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
@@ -387,12 +387,10 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
 Classifier: Topic :: Software Development :: Interpreters
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: lark>=1.3.1
 Dynamic: license-file
 
 ![Koskript](https://raw.githubusercontent.com/alesisce/koskript/refs/heads/main/banner.png)
@@ -466,13 +464,13 @@ There is an experimental dependency-free parser behind
 
 | Document | What it covers |
 |---|---|
-| [Getting started](docs/getting-started.md) | Installation, first script, a complete example |
-| [Language reference](docs/language.md) | Types, variables, operators, control flow, errors, functions, wrappers, namespaces, closures, modules, loops, strings, bytes |
-| [Classes](docs/classes.md) | Inheritance, visibility, static members, constructors, `super` |
-| [Standard library](docs/standard-library.md) | Core builtins and the `map`, `array`, `string`, `bytes`, `math` and `json` namespaces |
-| [Python interop](docs/python-interop.md) | Exposing Python values, callables and classes to scripts |
-| [Embedding guide](docs/embedding.md) | `KoskriptRuntime`, `run()`, error handling and stdlib activation |
-| [Roadmap](docs/roadmap.md) | What is done, what is planned, known limitations |
+| [Getting started](docs/docs/getting-started.md) | Installation, first script, a complete example |
+| [Language reference](docs/docs/language.md) | Types, variables, operators, control flow, errors, functions, wrappers, namespaces, closures, modules, loops, strings, bytes |
+| [Classes](docs/docs/classes.md) | Inheritance, visibility, static members, constructors, `super` |
+| [Standard library](docs/docs/standard-library.md) | Core builtins and the `map`, `array`, `string`, `bytes`, `math` and `json` namespaces |
+| [Python interop](docs/docs/python-interop.md) | Exposing Python values, callables and classes to scripts |
+| [Embedding guide](docs/docs/embedding.md) | `KoskriptRuntime`, `run()`, error handling and stdlib activation |
+| [Roadmap](docs/docs/roadmap.md) | What is done, what is planned, known limitations |
 
 ---
 

{koskript-1.4.2 → koskript-1.5.0}/README.md

@@ -69,13 +69,13 @@ There is an experimental dependency-free parser behind
 
 | Document | What it covers |
 |---|---|
-| [Getting started](docs/getting-started.md) | Installation, first script, a complete example |
-| [Language reference](docs/language.md) | Types, variables, operators, control flow, errors, functions, wrappers, namespaces, closures, modules, loops, strings, bytes |
-| [Classes](docs/classes.md) | Inheritance, visibility, static members, constructors, `super` |
-| [Standard library](docs/standard-library.md) | Core builtins and the `map`, `array`, `string`, `bytes`, `math` and `json` namespaces |
-| [Python interop](docs/python-interop.md) | Exposing Python values, callables and classes to scripts |
-| [Embedding guide](docs/embedding.md) | `KoskriptRuntime`, `run()`, error handling and stdlib activation |
-| [Roadmap](docs/roadmap.md) | What is done, what is planned, known limitations |
+| [Getting started](docs/docs/getting-started.md) | Installation, first script, a complete example |
+| [Language reference](docs/docs/language.md) | Types, variables, operators, control flow, errors, functions, wrappers, namespaces, closures, modules, loops, strings, bytes |
+| [Classes](docs/docs/classes.md) | Inheritance, visibility, static members, constructors, `super` |
+| [Standard library](docs/docs/standard-library.md) | Core builtins and the `map`, `array`, `string`, `bytes`, `math` and `json` namespaces |
+| [Python interop](docs/docs/python-interop.md) | Exposing Python values, callables and classes to scripts |
+| [Embedding guide](docs/docs/embedding.md) | `KoskriptRuntime`, `run()`, error handling and stdlib activation |
+| [Roadmap](docs/docs/roadmap.md) | What is done, what is planned, known limitations |
 
 ---
 

{koskript-1.4.2 → koskript-1.5.0}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "koskript"
-version = "1.4.2"
-description = "A programming language fully embbeded on python."
+version = "1.5.0"
+description = "A programming language fully embedded in Python."
 readme = "README.md"
 requires-python = ">=3.10"
 license = { file = "LICENSE" }
@@ -19,8 +19,7 @@ keywords = [
     "programming-language",
     "embedded",
     "interpreter",
-    "parser",
-    "lark"
+    "parser"
 ]
 
 classifiers = [
@@ -32,19 +31,15 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
-    "License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)",
+
     "Topic :: Software Development :: Interpreters",
 ]
 
 
-dependencies = [
-    # only the default parser needs it; `native_parser_experiment=True`
-    # runs without it
-    "lark>=1.3.1"
-]
+dependencies = []
 
 [project.urls]
 Homepage = "https://github.com/alesis-buzz/koskript"
 
 [tool.setuptools.package-data]
-koskript = ["*.lark", "*.json", "*.txt"]
+koskript = ["*.json", "*.txt"]

{koskript-1.4.2 → koskript-1.5.0}/src/koskript/__init__.py

@@ -8,74 +8,15 @@ from .lang.errors import Errors
 from .stdlib import build_globals
 import os
 
-_grammar_path = os.path.join(pathlib.Path(__file__).resolve().parent,
-                             "grammar.lark")
-
 
 def _wrap(value):
     return value if isinstance(value, KoskriptObject) else KoskriptObject(value=value)
 
 
-def _require_lark():
-    """Import Lark, with a message that points at the experimental parser."""
-    try:
-        from lark import Lark
-    except ImportError:
-        raise Errors.RuntimeError(
-            "the default parser needs the 'lark' package: install it, or pass "
-            "native_parser_experiment=True to use the native parser") from None
-    return Lark
-
-
-class _Grammar(object):
-    """The Lark grammar, with the LALR tables built on first use.
-
-    Building them takes about 200 ms, so it is deferred until a script is
-    actually parsed: runtimes created with ``native_parser_experiment=True``
-    never pay for them.
-    """
-
-    __slots__ = ("path", "parser")
-
-    def __init__(self, path):
-        self.path = path
-        self.parser = None
-
-    def parse(self, code: str):
-        """Parse ``code`` into a Lark tree."""
-        if self.parser is None:
-            with open(self.path, "r") as grammar_file:
-                self.parser = _require_lark()(
-                    grammar_file.read(), parser="lalr", maybe_placeholders=False)
-        return self.parser.parse(code)
-
-
-grammar = _Grammar(_grammar_path)
-
 # How many compiled sources a runtime keeps. Running the same script again is
 # then free of parsing and compiling; the oldest entry is dropped past this.
 _CHUNK_CACHE = 32
 
-
-def _format_syntax_error(code: str, error) -> str:
-    from lark.exceptions import UnexpectedInput
-
-    if not isinstance(error, UnexpectedInput) or error.line is None:
-        return str(error)
-
-    lines = [f"Syntax error at line {error.line}, column {error.column}:", error.get_context(code).rstrip()]
-
-    token = getattr(error, "token", None)
-    if token is not None and token.type != "$END":
-        lines.append(f"Unexpected token '{token}'.")
-
-    expected = getattr(error, "expected", None)
-    if expected:
-        lines.append("Expected one of: " + ", ".join(sorted(expected)))
-
-    return "\n".join(lines)
-
-
 class KoskriptRuntime(object):
     """Embeddable Koskript runtime.
 
@@ -86,14 +27,11 @@ class KoskriptRuntime(object):
     Any Python value or callable exposed to scripts is wrapped automatically,
     so you can pass plain functions without building ``KoskriptObject`` by hand.
 
-    Scripts are parsed with Lark, the default and stable front end, which
-    needs the ``lark`` package. ``native_parser_experiment=True`` switches to
-    the experimental pure Python scanner and parser instead: it needs no
-    dependency, starts faster and parses about 6x quicker, and it is what
-    will become the default once it has been validated in production.
+    Scripts are parsed with the native pure Python scanner and parser,
+    which needs no external dependency.
 
     >>> rt = KoskriptRuntime({"print": print})
-    >>> rt.execute("local x = 10\\nx + 26")
+    >>> rt.execute("let x = 10\\nx + 26")
     36
     """
 
@@ -105,39 +43,21 @@ class KoskriptRuntime(object):
         self.globals = {}
         self.native_parser_experiment = bool(native_parser_experiment)
         self.__interpreter__ = KoskriptInterpreter()
-        self._ast = None
         self.__interpreter__.module_loader = self._load_module
         self._modules = {}
         self._loading = []
         self._import_paths = []
         self._chunks = {}
 
-        if not self.native_parser_experiment:
-            # fail here instead of on the first script
-            _require_lark()
-
         if stdlib:
             self.register_many(build_globals(self.__interpreter__.call_value))
 
         if globals_map:
             self.register_many(globals_map)
 
-    @property
-    def __ast__(self):
-        """The Lark AST transformer, created the first time it is needed.
-
-        It lives in :mod:`koskript.lang.astgen`, which imports Lark, so
-        runtimes using the native parser never load it.
-        """
-        transformer = self._ast
-        if transformer is None:
-            from .lang.astgen import KoskriptTransformer
-            transformer = self._ast = KoskriptTransformer()
-        return transformer
-
-    @__ast__.setter
-    def __ast__(self, transformer):
-        self._ast = transformer
+        # expose `loadcode` to scripts: compiles a source string into a
+        # callable that runs it in this runtime
+        self.register("loadcode", self._loadcode_host)
 
     def register(self, name: str, value):
         """Expose a Python value or callable to scripts.
@@ -210,6 +130,25 @@ class KoskriptRuntime(object):
         self._chunks[code] = chunk
         return chunk
 
+    def compile(self, code: str):
+        """Compile ``code`` once and return a callable that runs it.
+
+        The returned object can be called with no arguments; it executes the
+        already compiled chunk in this runtime.
+        """
+        chunk = self._chunk(code)
+
+        def run():
+            try:
+                return self.__interpreter__.run_chunk(chunk)
+            except ThrownSignal as signal:
+                raise self.__interpreter__._uncaught(signal) from None
+
+        return run
+
+    def _loadcode_host(self, code):
+        return self.compile(str(code))
+
     def execute_module(self, path: str):
         """Execute ``path`` as a Koskript module and return the module.
 
@@ -224,31 +163,9 @@ class KoskriptRuntime(object):
         except ThrownSignal as signal:
             raise self.__interpreter__._uncaught(signal) from None
 
-    def _transform(self, tree):
-        """Run the AST transformer, unwrapping clean syntax errors."""
-        from lark.exceptions import VisitError
-
-        transformer = self.__ast__
-        try:
-            return transformer.transform(tree)
-        except VisitError as e:
-            if isinstance(e.orig_exc, Errors.SyntaxError):
-                raise e.orig_exc from None
-            raise
-
     def _compile(self, code: str):
         """Parse ``code`` into the list of statements the compiler consumes."""
-        if self.native_parser_experiment:
-            return parse(code)
-
-        from lark.exceptions import LarkError
-
-        try:
-            tree = grammar.parse(code)
-        except LarkError as e:
-            raise Errors.SyntaxError(_format_syntax_error(code, e)) from e
-        ast = self._transform(tree)
-
+        ast = parse(code)
         if not isinstance(ast, list):
             ast = [ast]
         return ast

koskript-1.5.0/src/koskript/headers.py

@@ -0,0 +1,57 @@
+"""Helpers for reading Koskript header files (``.kosh``).
+
+A ``.kosh`` file is a normal Koskript source that only contains
+declarations: ``fun``, ``class``, ``const``, ``namespace`` and ``import``.
+Bodies are usually empty (``{}``), so the file can be parsed with the
+standard parser without being executed.
+"""
+
+from .lang.parser import parse
+from .lang import emtypes
+
+
+def _collect(statements, symbols):
+    for stmt in statements:
+        kind = type(stmt)
+        if kind is emtypes.FnDef:
+            symbols["functions"].append({
+                "name": stmt.name,
+                "params": list(stmt.params),
+            })
+        elif kind is emtypes.ClassDef:
+            methods = []
+            for method in stmt.methods:
+                methods.append({
+                    "name": method.name,
+                    "params": list(method.params),
+                    "modifiers": list(method.modifiers),
+                })
+            symbols["classes"].append({
+                "name": stmt.name,
+                "parent": stmt.parent_name,
+                "methods": methods,
+                "fields": [
+                    {"name": f.name, "modifiers": list(f.modifiers)}
+                    for f in stmt.fields
+                ],
+            })
+        elif kind is emtypes.ConstDecl:
+            symbols["constants"].append(stmt.name)
+        elif kind is emtypes.NamespaceDef:
+            nested = {"functions": [], "classes": [], "constants": [], "namespaces": []}
+            _collect(stmt.body, nested)
+            symbols["namespaces"].append({"name": stmt.name, "symbols": nested})
+
+
+def load_header(source_or_path):
+    """Parse a ``.kosh`` source or file path and return its symbol index."""
+    if "\n" not in source_or_path and source_or_path.endswith(".kosh"):
+        with open(source_or_path, "r", encoding="utf-8-sig") as handle:
+            code = handle.read()
+    else:
+        code = source_or_path
+
+    statements = parse(code, allow_bodyless=True)
+    symbols = {"functions": [], "classes": [], "constants": [], "namespaces": []}
+    _collect(statements, symbols)
+    return symbols

{koskript-1.4.2 → koskript-1.5.0}/src/koskript/lang/compiler.py

@@ -22,9 +22,9 @@ from .errors import Errors
 
 _IDENTIFIER_RE = re.compile(r"[A-Za-z_][A-Za-z0-9_]*\Z")
 _RESERVED_NAMES = frozenset((
-    "if", "elseif", "else", "while", "for", "foreach", "fn", "wrapper",
+    "if", "elseif", "else", "while", "for", "foreach", "fun", "wrapper",
     "return",
-    "local", "const", "true", "false", "null", "and", "or", "not", "in",
+    "let", "const", "true", "false", "null", "and", "or", "not", "in",
     "break", "continue", "class", "extends", "new", "static", "public",
     "private", "this", "super", "constructor", "import", "as",
     "error", "throw", "try", "catch", "finally", "namespace",
@@ -157,15 +157,36 @@ class _Emitter(object):
     def _arguments(self, args, env):
         return ", ".join(f"({self.expr(arg, env)})" for arg in args)
 
+    def _split_args(self, args, env):
+        positional = []
+        keywords = []
+        for arg in args:
+            if type(arg) is KwArg:
+                keywords.append((arg.name, self.expr(arg.value, env)))
+            else:
+                positional.append(self.expr(arg, env))
+        pos_code = ", ".join(f"({item})" for item in positional)
+        if keywords:
+            kw_code = "{" + ", ".join(
+                f"{name!r}: ({value})" for name, value in keywords) + "}"
+            return pos_code, kw_code
+        return pos_code, None
+
     def _call(self, node, env="env"):
-        args = self._arguments(node.args, env)
+        pos_code, kw_code = self._split_args(node.args, env)
         callee_node = node.name
         if type(callee_node) is MemberAccess and len(callee_node.attrs) == 1:
             base = self.expr(callee_node.name, env)
             attr = callee_node.attrs[0].name
-            return f"_i.call_member_values(({base}), {attr!r}, [{args}])"
+            if kw_code is None:
+                return (f"_i.call_member_values(({base}), {attr!r}, "
+                        f"[{pos_code}])")
+            return (f"_i.call_member_values(({base}), {attr!r}, "
+                    f"[{pos_code}], {kw_code})")
         callee = self.expr(callee_node, env)
-        return f"_i.call_value(({callee}), [{args}])"
+        if kw_code is None:
+            return f"_i.call_value(({callee}), [{pos_code}])"
+        return f"_i.call_value(({callee}), [{pos_code}], {kw_code})"
 
     def expr(self, node, env="env"):
         kind = type(node)
@@ -221,20 +242,30 @@ class _Emitter(object):
             return self._call(node, env)
         if kind is NewExpr:
             target = self.expr(node.target, env)
-            args = self._arguments(node.args, env)
-            return f"_i.new_value({node.label!r}, ({target}), [{args}])"
+            pos_code, kw_code = self._split_args(node.args, env)
+            if kw_code is None:
+                return f"_i.new_value({node.label!r}, ({target}), [{pos_code}])"
+            return f"_i.new_value({node.label!r}, ({target}), [{pos_code}], {kw_code})"
         if kind is MethodCall:
-            args = self._arguments(node.args, env)
-            return f"_i._method_call_values({node.name!r}, [{args}])"
+            pos_code, kw_code = self._split_args(node.args, env)
+            if kw_code is None:
+                return f"_i._method_call_values({node.name!r}, [{pos_code}])"
+            return f"_i._method_call_values({node.name!r}, [{pos_code}], {kw_code})"
         if kind is SuperCall:
-            args = self._arguments(node.args, env)
-            return f"_i._super_call_values({node.name!r}, [{args}])"
+            pos_code, kw_code = self._split_args(node.args, env)
+            if kw_code is None:
+                return f"_i._super_call_values({node.name!r}, [{pos_code}])"
+            return f"_i._super_call_values({node.name!r}, [{pos_code}], {kw_code})"
         if kind is StaticRef:
             return f"_i._static_ref_value({node.name!r})"
         if kind is BoundMethodCall:
+            pos_code, kw_code = self._split_args(node.args, env)
             target = self.expr(node.target, env)
-            args = self._arguments(node.args, env)
-            return f"_i._bound_method_call_values(({target}), {node.name!r}, [{args}])"
+            if kw_code is None:
+                return (f"_i._bound_method_call_values(({target}), {node.name!r}, "
+                        f"[{pos_code}])")
+            return (f"_i._bound_method_call_values(({target}), {node.name!r}, "
+                    f"[{pos_code}], {kw_code})")
         if kind is ThisRef:
             return "_i.current_instance()"
         fallback = self._closure(node)
@@ -487,6 +518,10 @@ class _Unit(object):
             self.indent += 1
             self.line("env.values[0] = values[0]")
             self.indent -= 1
+            self.line("else:")
+            self.indent += 1
+            self.line("env.values[0] = None")
+            self.indent -= 1
         elif arity == 2:
             count = self.new_temp()
             self.line(f"{count} = len(values)")
@@ -495,6 +530,10 @@ class _Unit(object):
                 self.indent += 1
                 self.line(f"env.values[{index}] = values[{index}]")
                 self.indent -= 1
+                self.line("else:")
+                self.indent += 1
+                self.line(f"env.values[{index}] = None")
+                self.indent -= 1
         elif arity == 3:
             count = self.new_temp()
             self.line(f"{count} = len(values)")
@@ -503,6 +542,10 @@ class _Unit(object):
                 self.indent += 1
                 self.line(f"env.values[{index}] = values[{index}]")
                 self.indent -= 1
+                self.line("else:")
+                self.indent += 1
+                self.line(f"env.values[{index}] = None")
+                self.indent -= 1
         else:
             count = self.new_temp()
             key = self.new_temp()
@@ -512,6 +555,10 @@ class _Unit(object):
             self.indent += 1
             self.line(f"env.values[{key}] = values[{key}]")
             self.indent -= 1
+            self.line(f"for {key} in range({count}, {arity}):")
+            self.indent += 1
+            self.line(f"env.values[{key}] = None")
+            self.indent -= 1
 
     def _finish(self, name, header):
         source = header + "\n" + "\n".join(self.lines) + "\n"
@@ -725,15 +772,26 @@ class _Unit(object):
 
         loop_scope = ScopeInfo(scope)
         var_index = loop_scope.declare(node.var, readonly=True)
-        loop_env = self.new_env(loop_scope, env)
         item = self.new_temp()
         body_scope = ScopeInfo(loop_scope)
         self.compiler._predeclare(node.body, body_scope)
-        self.line(f"for {item} in {iterable}:")
-        self.indent += 1
-        self.line(f"{loop_env}.values[{var_index}] = {item}")
-        self._emit_loop_body(node.body, body_scope, loop_scope, loop_env)
-        self.indent -= 1
+        captures = _captures_scope(node.body)
+        if captures:
+            self.line(f"for {item} in {iterable}:")
+            self.indent += 1
+            # fresh scope per iteration so closures capture this iteration's value
+            loop_env = self.new_env(loop_scope, env)
+            self.line(f"{loop_env}.values[{var_index}] = {item}")
+            self._emit_loop_body(node.body, body_scope, loop_scope, loop_env)
+            self.indent -= 1
+        else:
+            # reuse a single scope: no closure captures this iteration's value
+            loop_env = self.new_env(loop_scope, env)
+            self.line(f"for {item} in {iterable}:")
+            self.indent += 1
+            self.line(f"{loop_env}.values[{var_index}] = {item}")
+            self._emit_loop_body(node.body, body_scope, loop_scope, loop_env)
+            self.indent -= 1
 
     def _emit_foreach(self, node, scope, env):
         mapping = self.new_temp()
@@ -746,17 +804,27 @@ class _Unit(object):
         loop_scope = ScopeInfo(scope)
         key_index = loop_scope.declare(node.key, readonly=True)
         value_index = loop_scope.declare(node.var, readonly=True)
-        loop_env = self.new_env(loop_scope, env)
         key = self.new_temp()
         value = self.new_temp()
         body_scope = ScopeInfo(loop_scope)
         self.compiler._predeclare(node.body, body_scope)
-        self.line(f"for {key}, {value} in {mapping}.items():")
-        self.indent += 1
-        self.line(f"{loop_env}.values[{key_index}] = {key}")
-        self.line(f"{loop_env}.values[{value_index}] = {value}")
-        self._emit_loop_body(node.body, body_scope, loop_scope, loop_env)
-        self.indent -= 1
+        captures = _captures_scope(node.body)
+        if captures:
+            self.line(f"for {key}, {value} in {mapping}.items():")
+            self.indent += 1
+            loop_env = self.new_env(loop_scope, env)
+            self.line(f"{loop_env}.values[{key_index}] = {key}")
+            self.line(f"{loop_env}.values[{value_index}] = {value}")
+            self._emit_loop_body(node.body, body_scope, loop_scope, loop_env)
+            self.indent -= 1
+        else:
+            loop_env = self.new_env(loop_scope, env)
+            self.line(f"for {key}, {value} in {mapping}.items():")
+            self.indent += 1
+            self.line(f"{loop_env}.values[{key_index}] = {key}")
+            self.line(f"{loop_env}.values[{value_index}] = {value}")
+            self._emit_loop_body(node.body, body_scope, loop_scope, loop_env)
+            self.indent -= 1
 
     def _emit_loop_body(self, statements, body_scope, parent_scope, parent_env):
         # The try only exists to catch `break` / `continue`; a body without

{koskript-1.4.2 → koskript-1.5.0}/src/koskript/lang/emtypes.py

@@ -53,6 +53,7 @@ ReturnStmt = namedtuple("ReturnStmt", ["value"])
 FnDef  = namedtuple("FnDef",  ["name", "params", "body", "decorators", "implicit_return"],
                     defaults=((), False))
 FnCall = namedtuple("FnCall", ["name", "args"])
+KwArg = namedtuple("KwArg", ["name", "value"])
 LambdaFnDef = namedtuple("LambdaFnDef", ["params", "body"])
 ImportStmt = namedtuple("ImportStmt", ["path", "name"])
 ErrorDef = namedtuple("ErrorDef", ["name", "params", "body"])