@ascent-lang/dev 0.3.0 → 0.5.0

package/src/lexer/token.ts

@@ -9,6 +9,7 @@ export type TokenKind =
   | 'PLUS'       // '+'
   | 'MINUS'      // '-'
   | 'STAR'       // '*'
+  | 'STAR_STAR'  // '**' — raises the left operand to the right operand's power
   | 'SLASH'      // '/', always real division — yields a Float
   | 'KW_DIV'     // the keyword div — Int-only floor division
   | 'KW_MOD'     // the keyword mod — Int-only floored modulo

package/src/lib.ts

@@ -2,32 +2,36 @@
 // The `ascent` CLI (see index.ts) is the primary entry point. Embedders
 // wanting source-to-typed-AST in one call should use parse():
 //
-//   const { typedProgram, errorMarkers } = parse(src);
-//   const result = executeProgram(typedProgram!, new Environment());
+//   const { program, errorMarkers } = parse(src);
+//   const inputs = new ProgramInputs(program!.args).set('name', { type: 'String', value: 'Ada' });
+//   const result = executeProgram(program!, inputs);
 //
 // The individual stages are also re-exported for tools that need
 // intermediate results (e.g. tokens, or the untyped AST):
 //
 //   const { tokens, errorMarkers } = new Lexer(src).tokenize();
 //   const { program } = parseTokens(tokens);
-//   const { typedProgram } = typecheck(program!);
+//   const { program: typedProgram } = typecheck(program!);
 
 export { Lexer } from './lexer/index.js';
 export type { LexResult } from './lexer/index.js';
 
 export { parse, parseTokens } from './parser/index.js';
 export type { ParseResult } from './parser/index.js';
+export type { Program, ProgramArg } from './parser/ast.js';
 
 export { typecheck } from './parser/typechecker.js';
 export type { TypedResult } from './parser/typechecker.js';
+export type { TypedProgram } from './parser/typed-ast.js';
 
 export {
   Environment,
   evaluateExpr,
   executeStmt,
   executeProgram,
+  ProgramInputs,
 } from './interpreter.js';
-export type { RuntimeValue, AssignResult } from './interpreter.js';
+export type { RuntimeValue, AssignResult, PrimitiveValue } from './interpreter.js';
 
 export { formatExpr, formatStmt, formatValue, valueToString } from './parser/printer.js';
 export { formatTypedStmt } from './parser/typed-printer.js';

package/src/parser/ast.ts

@@ -16,7 +16,7 @@ export type Literal = (
 );
 
 export type UnaryOp = '-' | 'not';
-export type ArithmeticOp = '+' | '-' | '*' | '/' | 'div' | 'mod';
+export type ArithmeticOp = '+' | '-' | '*' | '/' | 'div' | 'mod' | '**';
 export type ComparisonOp = '==' | '!=' | '<' | '<=' | '>' | '>=';
 export type BooleanOp = 'and' | 'or';
 export type BinaryOp = ArithmeticOp | ComparisonOp | BooleanOp;
@@ -60,6 +60,6 @@ export type Statement = (
 );
 
 export type ArgType = 'Int' | 'Float' | 'Bool' | 'String';
-export type ArgDef = { name: string; type: ArgType };
+export type ProgramArg = { name: string; type: ArgType };
 
-export type Program = { args: ArgDef[]; stmts: Statement[] };
+export type Program = { args: ProgramArg[]; stmts: Statement[] };

package/src/parser/expr.ts

@@ -20,13 +20,23 @@ import { parseBlock, parseIf } from './stmt.js';
 // threshold passed down on each recursive call.
 //
 // This ladder is the single source of truth for what binds tighter
-// than what: postfix (`.method()`, `[index]`) binds tightest, then
-// unary '-', then '*'/'/'/'div'/'mod', then '+'/'-', then the
-// comparisons, then 'not', then 'and', then 'or', loosest —
+// than what: postfix (`.method()`, `[index]`) and '**' bind tightest
+// (tighter even than unary '-', per §5 of design.md — `-2 ** 2` is
+// `-(2 ** 2)`), then unary '-', then '*'/'/'/'div'/'mod', then '+'/'-',
+// then the comparisons, then 'not', then 'and', then 'or', loosest —
 // the word operators sit below the comparisons (§5 of design.md), so
 // `a == b and c == d` groups as `(a == b) and (c == d)`, never
 // `a == (b and c) == d`. Every table below is keyed off these numbers
 // instead of inlining its own.
+//
+// EXPONENT shares POSTFIX's tier rather than sitting strictly above it.
+// '**' is right-associative, so its right operand is parsed with
+// `minBp = infix.bp` (not `+ 1`, see the loop below) — if EXPONENT
+// outbid POSTFIX, that recursive parse would stop *before* absorbing a
+// trailing postfix chain (`2 ** a.b()` would parse `a` alone, leaving
+// `.b()` to wrongly attach to the whole `2 ** a` once control returned
+// to the caller). Equal tiers let the right-hand parse swallow both a
+// further '**' and any postfix chain in one pass.
 const BP = {
   OR: 1,
   AND: 2,
@@ -36,6 +46,7 @@ const BP = {
   MULTIPLICATIVE: 6,
   UNARY: 7,
   POSTFIX: 7,
+  EXPONENT: 7,
 } as const;
 
 // Every binary operator this parser knows about has one row in this
@@ -49,7 +60,7 @@ const BP = {
 // 'or' belongs to a tier below 'and' — the same "same precedence,
 // left-associative" shape as '+'/'-' — so `a or b or c` groups as
 // `(a or b) or c`.
-const INFIX_OPS: Partial<Record<TokenKind, { op: BinaryOp; bp: number; assoc: 'left' | 'none' }>> = {
+const INFIX_OPS: Partial<Record<TokenKind, { op: BinaryOp; bp: number; assoc: 'left' | 'right' | 'none' }>> = {
   KW_OR: { op: 'or', bp: BP.OR, assoc: 'left' },
   KW_AND: { op: 'and', bp: BP.AND, assoc: 'left' },
   EQ_EQ: { op: '==', bp: BP.COMPARISON, assoc: 'none' },
@@ -64,6 +75,8 @@ const INFIX_OPS: Partial<Record<TokenKind, { op: BinaryOp; bp: number; assoc: 'l
   SLASH: { op: '/', bp: BP.MULTIPLICATIVE, assoc: 'left' },
   KW_DIV: { op: 'div', bp: BP.MULTIPLICATIVE, assoc: 'left' },
   KW_MOD: { op: 'mod', bp: BP.MULTIPLICATIVE, assoc: 'left' },
+  // Right-associative — `2 ** 3 ** 2` groups as `2 ** (3 ** 2)` (§5).
+  STAR_STAR: { op: '**', bp: BP.EXPONENT, assoc: 'right' },
 };
 
 // Postfix table — dot-calls and indexing are "led" operators exactly
@@ -135,7 +148,11 @@ export function parseExpr(ts: TokenStream, minBp = 0): Expr | null {
     // operators reuse the same `bp + 1` call — it still keeps looser
     // operators out of the right operand, and the `chained` check
     // above is what stops them from reappearing at this level.
-    const right = parseExpr(ts, infix.bp + 1);
+    // Right-associative operators ('**') do the opposite: reusing the
+    // same `bp` (not `+ 1`) lets a second '**' at this level be
+    // absorbed into the right operand instead of returned to this loop,
+    // which is what makes `2 ** 3 ** 2` group as `2 ** (3 ** 2)`.
+    const right = parseExpr(ts, infix.assoc === 'right' ? infix.bp : infix.bp + 1);
     if (right === null) {
       return null;
     }

package/src/parser/index.ts

@@ -38,12 +38,12 @@ export const parseTokens = (tokens: Token[]): ParseResult => {
 export const parse = (src: string): TypedResult => {
   const lexResult = new Lexer(src).tokenize();
   if (lexResult.errorMarkers.length > 0) {
-    return { typedProgram: null, errorMarkers: lexResult.errorMarkers };
+    return { program: null, errorMarkers: lexResult.errorMarkers };
   }
 
   const parseResult = parseTokens(lexResult.tokens);
   if (parseResult.program === null || parseResult.errorMarkers.length > 0) {
-    return { typedProgram: null, errorMarkers: parseResult.errorMarkers };
+    return { program: null, errorMarkers: parseResult.errorMarkers };
   }
 
   return typecheck(parseResult.program);

package/src/parser/type-expr.ts

@@ -1,4 +1,4 @@
-import type { TypeExpr, ArgDef, ArgType } from './ast.js';
+import type { TypeExpr, ProgramArg, ArgType } from './ast.js';
 import type { TokenStream } from './token-stream.js';
 
 // 'Int', 'Float', 'Bool', 'String', or 'List<Type>' — used in type annotations.
@@ -30,7 +30,7 @@ export function parseTypeExpr(ts: TokenStream): TypeExpr | null {
 // annotation this only allows a bare type name (no 'List<…>'), so it
 // reads the TYPE_NAME token directly rather than going through
 // parseTypeExpr.
-function parseArgDef(ts: TokenStream): ArgDef | null {
+function parseArgDef(ts: TokenStream): ProgramArg | null {
   const nameTok = ts.peek();
   if (nameTok.kind !== 'SLOT') {
     ts.report('S0003', nameTok.span);
@@ -53,7 +53,7 @@ function parseArgDef(ts: TokenStream): ArgDef | null {
 // 'args (name: Type, …) ;' — the program's typed input declaration, if
 // present. Returns [] (not null) when there's no 'args' keyword at all;
 // null is reserved for an actual parse error.
-export function parseArgsSection(ts: TokenStream): ArgDef[] | null {
+export function parseArgsSection(ts: TokenStream): ProgramArg[] | null {
   if (ts.peek().kind !== 'KW_ARGS') return [];
   ts.advance(); // consume 'args'
 

package/src/parser/typechecker.ts

@@ -7,7 +7,7 @@ import {
 } from '../types/types.js';
 
 export interface TypedResult {
-  typedProgram: TypedProgram | null;
+  program: TypedProgram | null;
   errorMarkers: Marker[];
 }
 
@@ -22,7 +22,7 @@ interface Binding {
 }
 
 // A chain of scopes mirroring Environment in the interpreter.
-class TypeEnv {
+export class TypeEnv {
   private vars = new Map<string, Binding>();
   public constructor(private readonly parent: TypeEnv | null = null) { }
 
@@ -37,6 +37,13 @@ class TypeEnv {
   public child(): TypeEnv {
     return new TypeEnv(this);
   }
+
+  // The bindings declared directly in this scope (not inherited from a
+  // parent) — used to promote a successful trial scope's new names into
+  // a persistent parent, e.g. across REPL lines.
+  public ownEntries(): IterableIterator<[string, Binding]> {
+    return this.vars.entries();
+  }
 }
 
 // ---- Type formation:  ⊢ T type --------------------------------------
@@ -191,7 +198,7 @@ const inferExpr = (
 
       let type: AscentType;
       switch (expr.op) {
-        case '+': case '-': case '*': {
+        case '+': case '-': case '*': case '**': {
           if ((lt.kind !== 'Int' && lt.kind !== 'Float') || (rt.kind !== 'Int' && rt.kind !== 'Float')) {
             return operandError(markers, expr.op, expr.span, lt, rt);
           }
@@ -472,9 +479,14 @@ const inferStmt = (stmt: Statement, env: TypeEnv, markers: Marker[]): TypedState
   }
 };
 
-export const typecheck = (program: Program): TypedResult => {
+// parentEnv lets a caller (the REPL) carry name bindings across separate
+// typecheck() calls: each call type-checks into a child scope, and only
+// promotes its new bindings into parentEnv once the whole program
+// succeeds, so a line that fails typechecking never leaks a partial
+// declaration into later lines.
+export const typecheck = (program: Program, parentEnv?: TypeEnv): TypedResult => {
   const markers: Marker[] = [];
-  const env = new TypeEnv();
+  const env = parentEnv !== undefined ? parentEnv.child() : new TypeEnv();
 
   for (const arg of program.args) {
     env.set(arg.name, typeFromName(arg.type), 'arg');
@@ -488,7 +500,14 @@ export const typecheck = (program: Program): TypedResult => {
   }
 
   if (failed || markers.length > 0) {
-    return { typedProgram: null, errorMarkers: markers };
+    return { program: null, errorMarkers: markers };
+  }
+
+  if (parentEnv !== undefined) {
+    for (const [name, binding] of env.ownEntries()) {
+      parentEnv.set(name, binding.ty, binding.origin, binding.declSpan);
+    }
   }
-  return { typedProgram: { args: program.args, stmts: typedStmts }, errorMarkers: [] };
+
+  return { program: { args: program.args, stmts: typedStmts }, errorMarkers: [] };
 };

package/src/parser/typed-ast.ts

@@ -1,5 +1,5 @@
 import type { Span } from '../lexer/token.js';
-import type { UnaryOp, BinaryOp, ArgDef, TypeExpr } from './ast.js';
+import type { UnaryOp, BinaryOp, ProgramArg, TypeExpr } from './ast.js';
 import type { AscentType } from '../types/types.js';
 
 // Every typed expression carries `type`: the Type inferred by the type
@@ -58,6 +58,6 @@ export type TypedStatement = (
 );
 
 export type TypedProgram = {
-  args: ArgDef[];
+  args: ProgramArg[];
   stmts: TypedStatement[];
 };