prometheus-lang 0.2.2__py3-none-any.whl

prom/__init__.py

@@ -0,0 +1,3 @@
+"""Prometheus bootstrap toolchain."""
+
+__version__ = "0.2.2"

prom/ast.py

@@ -0,0 +1,249 @@
+"""Abstract syntax tree for Prometheus.
+
+The AST is deliberately small: Prometheus is an expression language with a
+thin declaration layer. Every node carries a Span for diagnostics.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from .errors import Span
+
+# ---------------------------------------------------------------------------
+# Type annotations (surface syntax for types)
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class TAnn:
+    span: Span = field(default_factory=Span.unknown)
+
+
+@dataclass
+class TAName(TAnn):
+    name: str = ""
+    args: list["TAnn"] = field(default_factory=list)
+
+
+@dataclass
+class TAFun(TAnn):
+    params: list[TAnn] = field(default_factory=list)
+    ret: TAnn | None = None
+
+
+@dataclass
+class TARecord(TAnn):
+    fields: list[tuple[str, TAnn]] = field(default_factory=list)
+
+
+# ---------------------------------------------------------------------------
+# Expressions
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class Expr:
+    span: Span = field(default_factory=Span.unknown)
+
+
+@dataclass
+class Lit(Expr):
+    value: object = None
+    type_name: str = ""  # Int | Float | Bool | Unit
+
+
+@dataclass
+class Str(Expr):
+    # parts: list of ("text", str) or ("expr", Expr)
+    parts: list[tuple[str, object]] = field(default_factory=list)
+
+
+@dataclass
+class Var(Expr):
+    name: str = ""
+
+
+@dataclass
+class ListLit(Expr):
+    items: list[Expr] = field(default_factory=list)
+
+
+@dataclass
+class RecordLit(Expr):
+    fields: list[tuple[str, Expr]] = field(default_factory=list)
+
+
+@dataclass
+class Field(Expr):
+    obj: Expr | None = None
+    name: str = ""
+
+
+@dataclass
+class Call(Expr):
+    fn: Expr | None = None
+    args: list[Expr] = field(default_factory=list)
+
+
+@dataclass
+class Lambda(Expr):
+    params: list[str] = field(default_factory=list)
+    body: Expr | None = None
+
+
+@dataclass
+class BinOp(Expr):
+    op: str = ""
+    left: Expr | None = None
+    right: Expr | None = None
+
+
+@dataclass
+class UnOp(Expr):
+    op: str = ""
+    operand: Expr | None = None
+
+
+@dataclass
+class If(Expr):
+    cond: Expr | None = None
+    then: Expr | None = None
+    els: Expr | None = None
+
+
+@dataclass
+class MatchArm:
+    pattern: "Pattern"
+    body: Expr
+    span: Span
+
+
+@dataclass
+class Match(Expr):
+    subject: Expr | None = None
+    arms: list[MatchArm] = field(default_factory=list)
+
+
+@dataclass
+class Bind:
+    name: str
+    ann: TAnn | None
+    expr: Expr
+    span: Span
+
+
+@dataclass
+class ParBlock:
+    """Bindings whose right-hand sides may evaluate in parallel.
+
+    Semantics are defined to be identical to sequential evaluation; the
+    expressions must be pure (the runtime enforces this dynamically in the
+    bootstrap, the native compiler will enforce it statically).
+    """
+
+    binds: list[Bind]
+    span: Span
+
+
+@dataclass
+class Block(Expr):
+    # items: Bind | ParBlock | Expr ; the final item must be an Expr and is
+    # the block's value.
+    items: list[object] = field(default_factory=list)
+
+
+# ---------------------------------------------------------------------------
+# Patterns
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class Pattern:
+    span: Span = field(default_factory=Span.unknown)
+
+
+@dataclass
+class PWild(Pattern):
+    pass
+
+
+@dataclass
+class PVar(Pattern):
+    name: str = ""
+
+
+@dataclass
+class PLit(Pattern):
+    value: object = None
+    type_name: str = ""
+
+
+@dataclass
+class PCtor(Pattern):
+    name: str = ""
+    args: list[Pattern] = field(default_factory=list)
+
+
+@dataclass
+class PList(Pattern):
+    items: list[Pattern] = field(default_factory=list)
+    rest: str | None = None  # name bound to the tail, or None
+
+
+# ---------------------------------------------------------------------------
+# Declarations
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class Decl:
+    span: Span = field(default_factory=Span.unknown)
+
+
+@dataclass
+class DType(Decl):
+    name: str = ""
+    params: list[str] = field(default_factory=list)
+    ctors: list[tuple[str, list[TAnn]]] = field(default_factory=list)
+
+
+@dataclass
+class DFunc(Decl):
+    name: str = ""
+    params: list[tuple[str, TAnn | None]] = field(default_factory=list)
+    ret_ann: TAnn | None = None
+    body: Expr | None = None
+    intent: str | None = None
+
+
+@dataclass
+class DVal(Decl):
+    name: str = ""
+    ann: TAnn | None = None
+    expr: Expr | None = None
+    intent: str | None = None
+
+
+@dataclass
+class DUse(Decl):
+    """use path.to.module — binds the module under its last path segment."""
+
+    parts: list[str] = field(default_factory=list)
+
+    @property
+    def alias(self) -> str:
+        return self.parts[-1]
+
+
+@dataclass
+class DCheck(Decl):
+    label: str | None = None
+    expr: Expr | None = None
+
+
+@dataclass
+class Program:
+    decls: list[Decl]
+    source: str
+    filename: str

prom/builtins.py

@@ -0,0 +1,437 @@
+"""Built-in functions: the primitive layer beneath the Prometheus prelude.
+
+Kept deliberately small — everything that *can* be written in Prometheus
+lives in stdlib/prelude.prom instead. Effectful builtins take a capability
+as their first argument; without the capability value they are uncallable,
+which is the whole security model in one sentence.
+"""
+
+from __future__ import annotations
+
+import math
+import os
+import random
+import time
+
+from .errors import RuntimeError_, Span
+from .eval import (
+    Builtin, Capability, Data, MapValue, list_iter, make_list, show_value,
+)
+from .types import (
+    BOOL, FLOAT, INT, TEXT, UNIT, Scheme, TCon, TFun, TRecord, TVar, tlist,
+)
+
+
+def _ok(v):
+    return Data("Ok", (v,))
+
+
+def _err(msg: str):
+    return Data("Err", (msg,))
+
+
+def _some(v):
+    return Data("Some", (v,))
+
+
+NONE = Data("None")
+
+SCALARS = (int, float, bool, str)
+
+
+def _require_scalar_key(k, span):
+    if not isinstance(k, SCALARS):
+        raise RuntimeError_(
+            f"map keys must be scalars (Int, Float, Bool, Text) in v0.2, got {show_value(k)}",
+            span,
+        )
+
+
+def _pure(name, arity, fn):
+    return Builtin(name, arity, lambda rt, args, span: fn(args, span), effectful=False)
+
+
+def _effect(name, arity, fn):
+    return Builtin(name, arity, fn, effectful=True)
+
+
+def _check_cap(args, kind: str, name: str, span: Span):
+    cap = args[0]
+    if not isinstance(cap, Capability) or cap.kind != kind:
+        raise RuntimeError_(f"{name} requires the {kind} capability", span)
+
+
+# -- pure primitives ---------------------------------------------------------
+
+
+def _show(args, span):
+    return show_value(args[0])
+
+
+def _length(args, span):
+    return sum(1 for _ in list_iter(args[0]))
+
+
+def _text_length(args, span):
+    return len(args[0])
+
+
+def _range(args, span):
+    lo, hi = args
+    return make_list(range(lo, hi))
+
+
+def _split(args, span):
+    text, sep = args
+    if sep == "":
+        raise RuntimeError_("split separator must not be empty", span)
+    return make_list(text.split(sep))
+
+
+def _join(args, span):
+    parts, sep = args
+    return sep.join(list_iter(parts))
+
+
+def _to_float(args, span):
+    return float(args[0])
+
+
+def _floor(args, span):
+    return math.floor(args[0])
+
+
+def _sqrt(args, span):
+    if args[0] < 0.0:
+        raise RuntimeError_("sqrt of a negative number", span)
+    return math.sqrt(args[0])
+
+
+def _contains(args, span):
+    return args[1] in args[0]
+
+
+def _starts_with(args, span):
+    return args[0].startswith(args[1])
+
+
+def _ends_with(args, span):
+    return args[0].endswith(args[1])
+
+
+def _replace(args, span):
+    text, old, new = args
+    if old == "":
+        raise RuntimeError_("replace: the text to replace must not be empty", span)
+    return text.replace(old, new)
+
+
+def _trim(args, span):
+    return args[0].strip()
+
+
+def _upper(args, span):
+    return args[0].upper()
+
+
+def _lower(args, span):
+    return args[0].lower()
+
+
+def _slice_text(args, span):
+    text, start, end = args
+    n = len(text)
+    start = max(0, min(start, n))
+    end = max(start, min(end, n))
+    return text[start:end]
+
+
+def _parse_int(args, span):
+    t = args[0].strip()
+    sign_ok = t and (t[0] in "+-" and t[1:].isdigit() or t.isdigit())
+    return _some(int(t)) if sign_ok else NONE
+
+
+def _parse_float(args, span):
+    try:
+        return _some(float(args[0].strip()))
+    except ValueError:
+        return NONE
+
+
+def _sort(args, span):
+    items = list(list_iter(args[0]))
+    kinds = {("text" if isinstance(x, str) else "num" if isinstance(x, (int, float))
+              and not isinstance(x, bool) else "other") for x in items}
+    if kinds - {"text"} and kinds - {"num"}:
+        raise RuntimeError_(
+            "sort works on lists of numbers or lists of Text (v0.2)", span
+        )
+    return make_list(sorted(items))
+
+
+def _abs(args, span):
+    return abs(args[0])
+
+
+def _min(args, span):
+    return min(args[0], args[1])
+
+
+def _max(args, span):
+    return max(args[0], args[1])
+
+
+# -- maps ---------------------------------------------------------------------
+
+
+def _put(args, span):
+    m, k, v = args
+    _require_scalar_key(k, span)
+    entries = dict(m.entries)
+    entries[k] = v
+    return MapValue(entries)
+
+
+def _get(args, span):
+    m, k = args
+    _require_scalar_key(k, span)
+    return _some(m.entries[k]) if k in m.entries else NONE
+
+
+def _remove(args, span):
+    m, k = args
+    _require_scalar_key(k, span)
+    if k not in m.entries:
+        return m
+    entries = dict(m.entries)
+    del entries[k]
+    return MapValue(entries)
+
+
+def _has(args, span):
+    m, k = args
+    _require_scalar_key(k, span)
+    return k in m.entries
+
+
+def _keys(args, span):
+    return make_list(sorted(args[0].entries.keys(), key=repr))
+
+
+def _size(args, span):
+    return len(args[0].entries)
+
+
+# -- effectful primitives (capability-gated) ---------------------------------
+
+
+def _print(rt, args, span):
+    _check_cap(args, "Io", "print", span)
+    rt.stdout.write(show_value(args[1]) + "\n")
+    from .eval import UNIT as U
+
+    return U
+
+
+def _read_line(rt, args, span):
+    _check_cap(args, "Io", "read_line", span)
+    line = rt.stdin.readline()
+    return line[:-1] if line.endswith("\n") else line
+
+
+def _read_file(rt, args, span):
+    _check_cap(args, "Fs", "read_file", span)
+    try:
+        with open(args[1], "r", encoding="utf-8") as f:
+            return _ok(f.read())
+    except OSError as err:
+        return _err(f"cannot read {args[1]}: {err.strerror or err}")
+
+
+def _write_file(rt, args, span):
+    _check_cap(args, "Fs", "write_file", span)
+    from .eval import UNIT as U
+
+    try:
+        with open(args[1], "w", encoding="utf-8") as f:
+            f.write(args[2])
+        return _ok(U)
+    except OSError as err:
+        return _err(f"cannot write {args[1]}: {err.strerror or err}")
+
+
+def _list_dir(rt, args, span):
+    _check_cap(args, "Fs", "list_dir", span)
+    try:
+        return _ok(make_list(sorted(os.listdir(args[1]))))
+    except OSError as err:
+        return _err(f"cannot list {args[1]}: {err.strerror or err}")
+
+
+def _exists(rt, args, span):
+    _check_cap(args, "Fs", "exists", span)
+    return os.path.exists(args[1])
+
+
+def _get_env(rt, args, span):
+    _check_cap(args, "Env", "get_env", span)
+    v = os.environ.get(args[1])
+    return NONE if v is None else _some(v)
+
+
+def _http_get(rt, args, span):
+    _check_cap(args, "Net", "http_get", span)
+    import urllib.error
+    import urllib.request
+
+    url = args[1]
+    if not url.startswith(("http://", "https://")):
+        return _err(f"http_get: unsupported URL scheme in {url}")
+    try:
+        with urllib.request.urlopen(url, timeout=30) as resp:
+            return _ok(resp.read().decode("utf-8", errors="replace"))
+    except (urllib.error.URLError, OSError, ValueError) as err:
+        return _err(f"http_get {url}: {err}")
+
+
+def _rand_int(rt, args, span):
+    _check_cap(args, "Rand", "rand_int", span)
+    lo, hi = args[1], args[2]
+    if lo > hi:
+        raise RuntimeError_(f"rand_int: empty range {lo}..{hi}", span)
+    return random.randint(lo, hi)
+
+
+def _rand_float(rt, args, span):
+    _check_cap(args, "Rand", "rand_float", span)
+    return random.random()
+
+
+def _now_ms(rt, args, span):
+    _check_cap(args, "Clock", "now_ms", span)
+    return int(time.time() * 1000)
+
+
+IO = TCon("Io")
+FS = TCon("Fs")
+CLOCK = TCon("Clock")
+ENV = TCon("Env")
+NET = TCon("Net")
+RAND = TCon("Rand")
+
+
+def _result(ok, err):
+    return TCon("Result", [ok, err])
+
+
+def _option(a):
+    return TCon("Option", [a])
+
+
+def _map_t(k, v):
+    return TCon("Map", [k, v])
+
+
+def make_builtins() -> tuple[dict[str, object], dict[str, Scheme]]:
+    """Returns (value environment, type environment) for the primitives."""
+    a = TVar()
+    b = TVar()
+    values: dict[str, object] = {
+        "show": _pure("show", 1, _show),
+        "length": _pure("length", 1, _length),
+        "text_length": _pure("text_length", 1, _text_length),
+        "range": _pure("range", 2, _range),
+        "split": _pure("split", 2, _split),
+        "join": _pure("join", 2, _join),
+        "to_float": _pure("to_float", 1, _to_float),
+        "floor": _pure("floor", 1, _floor),
+        "sqrt": _pure("sqrt", 1, _sqrt),
+        "text_contains": _pure("text_contains", 2, _contains),
+        "starts_with": _pure("starts_with", 2, _starts_with),
+        "ends_with": _pure("ends_with", 2, _ends_with),
+        "replace": _pure("replace", 3, _replace),
+        "trim": _pure("trim", 1, _trim),
+        "upper": _pure("upper", 1, _upper),
+        "lower": _pure("lower", 1, _lower),
+        "slice": _pure("slice", 3, _slice_text),
+        "parse_int": _pure("parse_int", 1, _parse_int),
+        "parse_float": _pure("parse_float", 1, _parse_float),
+        "sort": _pure("sort", 1, _sort),
+        "abs": _pure("abs", 1, _abs),
+        "min": _pure("min", 2, _min),
+        "max": _pure("max", 2, _max),
+        "empty_map": MapValue({}),
+        "put": _pure("put", 3, _put),
+        "get": _pure("get", 2, _get),
+        "remove": _pure("remove", 2, _remove),
+        "has": _pure("has", 2, _has),
+        "keys": _pure("keys", 1, _keys),
+        "size": _pure("size", 1, _size),
+        "print": _effect("print", 2, _print),
+        "read_line": _effect("read_line", 1, _read_line),
+        "read_file": _effect("read_file", 2, _read_file),
+        "write_file": _effect("write_file", 3, _write_file),
+        "list_dir": _effect("list_dir", 2, _list_dir),
+        "exists": _effect("exists", 2, _exists),
+        "get_env": _effect("get_env", 2, _get_env),
+        "http_get": _effect("http_get", 2, _http_get),
+        "rand_int": _effect("rand_int", 3, _rand_int),
+        "rand_float": _effect("rand_float", 1, _rand_float),
+        "now_ms": _effect("now_ms", 1, _now_ms),
+    }
+    n1 = TVar(numeric=True)
+    n2 = TVar(numeric=True)
+    n3 = TVar(numeric=True)
+    s1 = TVar()
+    mk, mv = TVar(), TVar()
+    mk2, mv2 = TVar(), TVar()
+    mk3, mv3 = TVar(), TVar()
+    mk4, mv4 = TVar(), TVar()
+    mk5, mv5 = TVar(), TVar()
+    mk6, mv6 = TVar(), TVar()
+    mk7, mv7 = TVar(), TVar()
+    types: dict[str, Scheme] = {
+        "show": Scheme([a], TFun([a], TEXT)),
+        "length": Scheme([b], TFun([tlist(b)], INT)),
+        "text_length": Scheme([], TFun([TEXT], INT)),
+        "range": Scheme([], TFun([INT, INT], tlist(INT))),
+        "split": Scheme([], TFun([TEXT, TEXT], tlist(TEXT))),
+        "join": Scheme([], TFun([tlist(TEXT), TEXT], TEXT)),
+        "to_float": Scheme([], TFun([INT], FLOAT)),
+        "floor": Scheme([], TFun([FLOAT], INT)),
+        "sqrt": Scheme([], TFun([FLOAT], FLOAT)),
+        "text_contains": Scheme([], TFun([TEXT, TEXT], BOOL)),
+        "starts_with": Scheme([], TFun([TEXT, TEXT], BOOL)),
+        "ends_with": Scheme([], TFun([TEXT, TEXT], BOOL)),
+        "replace": Scheme([], TFun([TEXT, TEXT, TEXT], TEXT)),
+        "trim": Scheme([], TFun([TEXT], TEXT)),
+        "upper": Scheme([], TFun([TEXT], TEXT)),
+        "lower": Scheme([], TFun([TEXT], TEXT)),
+        "slice": Scheme([], TFun([TEXT, INT, INT], TEXT)),
+        "parse_int": Scheme([], TFun([TEXT], _option(INT))),
+        "parse_float": Scheme([], TFun([TEXT], _option(FLOAT))),
+        "sort": Scheme([s1], TFun([tlist(s1)], tlist(s1))),
+        "abs": Scheme([n1], TFun([n1], n1)),
+        "min": Scheme([n2], TFun([n2, n2], n2)),
+        "max": Scheme([n3], TFun([n3, n3], n3)),
+        "empty_map": Scheme([mk, mv], _map_t(mk, mv)),
+        "put": Scheme([mk2, mv2], TFun([_map_t(mk2, mv2), mk2, mv2], _map_t(mk2, mv2))),
+        "get": Scheme([mk3, mv3], TFun([_map_t(mk3, mv3), mk3], _option(mv3))),
+        "remove": Scheme([mk4, mv4], TFun([_map_t(mk4, mv4), mk4], _map_t(mk4, mv4))),
+        "has": Scheme([mk5, mv5], TFun([_map_t(mk5, mv5), mk5], BOOL)),
+        "keys": Scheme([mk6, mv6], TFun([_map_t(mk6, mv6)], tlist(mk6))),
+        "size": Scheme([mk7, mv7], TFun([_map_t(mk7, mv7)], INT)),
+        "print": Scheme([], TFun([IO, TEXT], UNIT)),
+        "read_line": Scheme([], TFun([IO], TEXT)),
+        "read_file": Scheme([], TFun([FS, TEXT], _result(TEXT, TEXT))),
+        "write_file": Scheme([], TFun([FS, TEXT, TEXT], _result(UNIT, TEXT))),
+        "list_dir": Scheme([], TFun([FS, TEXT], _result(tlist(TEXT), TEXT))),
+        "exists": Scheme([], TFun([FS, TEXT], BOOL)),
+        "get_env": Scheme([], TFun([ENV, TEXT], _option(TEXT))),
+        "http_get": Scheme([], TFun([NET, TEXT], _result(TEXT, TEXT))),
+        "rand_int": Scheme([], TFun([RAND, INT, INT], INT)),
+        "rand_float": Scheme([], TFun([RAND], FLOAT)),
+        "now_ms": Scheme([], TFun([CLOCK], INT)),
+    }
+    return values, types