openalgo-script 0.1.0-alpha.0 → 0.1.0-alpha.1

package/src/core/index.ts

@@ -144,3 +144,4 @@ export {
 export { lex } from './lex/index.js';
 
 export { parse, parseTokens } from './parse/index.js';
+export { COMPILED_FORMAT_VERSION, VERSION } from './version/index.js';

package/src/core/parse/functions.ts

@@ -1,109 +1,109 @@
-import type { Block, Expression, FunctionDeclaration, Name, Parameter } from '../ast/index.js';
-import { makeNode } from '../ast/index.js';
-import { spanning } from '../span/index.js';
-import type { Token } from '../tokens/index.js';
-import { parseTypeAnnotation } from './annotations.js';
-import { parseBlock } from './blocks.js';
-import type { Cursor } from './cursor.js';
-import { parseBracketedList, parseExpression } from './expressions.js';
-import { takeName } from './names.js';
-import { finishStatement } from './statements.js';
-
-/**
- * `fn name(parameters) => body`, language.md 11.1.
- *
- * The body is an expression when it is written after the `=>` on one line, and
- * a block when the `=>` ends the line. Both forms exist because the one line
- * form needs the implicit return and an early exit needs the explicit one.
- *
- * The `=>` is two tokens. Section 3.12 does not list it among the punctuation,
- * so it arrives as an `=` and a `>` that touch, and touching is what tells it
- * from a comparison: the lexer suppresses its continuation rule for that exact
- * pair, and the same adjacency test is what matches it here.
- */
-export function parseFunctionDeclaration(cursor: Cursor): FunctionDeclaration {
-  const keyword = cursor.advance();
-  const name = takeName(cursor);
-
-  const open = cursor.take('(');
-  if (open === undefined) cursor.unexpected(cursor.token);
-  const parameters =
-    open === undefined ? [] : parseBracketedList(cursor, open, parseParameter).items;
-
-  const arrow = takeArrow(cursor);
-  if (arrow === undefined) {
-    return declaration(keyword, name, parameters, headerWithNoArrow(cursor, keyword));
-  }
-
-  if (!cursor.atStatementEnd()) {
-    const body = parseExpression(cursor);
-    finishStatement(cursor);
-    return declaration(keyword, name, parameters, body);
-  }
-
-  finishStatement(cursor);
-  return declaration(keyword, name, parameters, parseBlock(cursor, 'fn', keyword.span));
-}
-
-/**
- * A parameter, which is an ordinary identifier and not a label.
- *
- * `fn f(color = red)` is OS1019, and `plot(v, "V", color = aqua)` is not: the
- * body of a function refers to its parameters, and nothing ever refers to a
- * label (language.md 3.4). `takeName` is the whole of that difference.
- */
-function parseParameter(cursor: Cursor): Parameter {
-  const name = takeName(cursor);
-
-  const annotation = cursor.take(':') !== undefined ? parseTypeAnnotation(cursor) : undefined;
-  const defaultValue = cursor.take('=') !== undefined ? parseExpression(cursor) : undefined;
-
-  const end = defaultValue?.span ?? annotation?.span ?? name.span;
-  return makeNode('parameter', spanning(name.span, end), { name, annotation, defaultValue });
-}
-
-/** The `=>` of 11.1: an `=` and a `>` written against each other. */
-function takeArrow(cursor: Cursor): Token | undefined {
-  const equals = cursor.token;
-  const greater = cursor.peek();
-  if (equals.kind !== '=' || greater.kind !== '>') return undefined;
-  if (equals.span.offset + equals.span.length !== greater.span.offset) return undefined;
-
-  cursor.advance();
-  return cursor.advance();
-}
-
-/**
- * A header with no `=>`, which the catalogue has no code of its own for.
- *
- * What is reported is what is true. A token sitting where the arrow belongs is
- * OS1018, whose fix names the operator that was meant to join the two halves. A
- * header that simply ends is OS1010, because that is what it now is: a header
- * with no body, since without the arrow the lexer opened no block under it.
- */
-function headerWithNoArrow(cursor: Cursor, keyword: Token): Block | Expression {
-  if (!cursor.atStatementEnd()) {
-    cursor.unexpected(cursor.token);
-    const body = parseExpression(cursor);
-    finishStatement(cursor);
-    return body;
-  }
-
-  cursor.report('OS1010', keyword.span, { header: 'fn' });
-  finishStatement(cursor);
-  if (cursor.at('indent')) return parseBlock(cursor, 'fn', keyword.span);
-  return makeNode('block', cursor.holeSpan(), { statements: [] });
-}
-
-function declaration(
-  keyword: Token,
-  name: Name,
-  parameters: readonly Parameter[],
-  body: Block | Expression,
-): FunctionDeclaration {
-  return makeNode('functionDeclaration', spanning(keyword.span, body.span), {
-    name,
-    parameters,
-    body,
-  });
-}
+import type { Block, Expression, FunctionDeclaration, Name, Parameter } from '../ast/index.js';
+import { makeNode } from '../ast/index.js';
+import { spanning } from '../span/index.js';
+import type { Token } from '../tokens/index.js';
+import { parseTypeAnnotation } from './annotations.js';
+import { parseBlock } from './blocks.js';
+import type { Cursor } from './cursor.js';
+import { parseBracketedList, parseExpression } from './expressions.js';
+import { takeName } from './names.js';
+import { finishStatement } from './statements.js';
+
+/**
+ * `fn name(parameters) => body`, language.md 11.1.
+ *
+ * The body is an expression when it is written after the `=>` on one line, and
+ * a block when the `=>` ends the line. Both forms exist because the one line
+ * form needs the implicit return and an early exit needs the explicit one.
+ *
+ * The `=>` is two tokens. Section 3.12 does not list it among the punctuation,
+ * so it arrives as an `=` and a `>` that touch, and touching is what tells it
+ * from a comparison: the lexer suppresses its continuation rule for that exact
+ * pair, and the same adjacency test is what matches it here.
+ */
+export function parseFunctionDeclaration(cursor: Cursor): FunctionDeclaration {
+  const keyword = cursor.advance();
+  const name = takeName(cursor);
+
+  const open = cursor.take('(');
+  if (open === undefined) cursor.unexpected(cursor.token);
+  const parameters =
+    open === undefined ? [] : parseBracketedList(cursor, open, parseParameter).items;
+
+  const arrow = takeArrow(cursor);
+  if (arrow === undefined) {
+    return declaration(keyword, name, parameters, headerWithNoArrow(cursor, keyword));
+  }
+
+  if (!cursor.atStatementEnd()) {
+    const body = parseExpression(cursor);
+    finishStatement(cursor);
+    return declaration(keyword, name, parameters, body);
+  }
+
+  finishStatement(cursor);
+  return declaration(keyword, name, parameters, parseBlock(cursor, 'fn', keyword.span));
+}
+
+/**
+ * A parameter, which is an ordinary identifier and not a label.
+ *
+ * `fn f(color = red)` is OS1019, and `plot(v, "V", color = aqua)` is not: the
+ * body of a function refers to its parameters, and nothing ever refers to a
+ * label (language.md 3.4). `takeName` is the whole of that difference.
+ */
+function parseParameter(cursor: Cursor): Parameter {
+  const name = takeName(cursor);
+
+  const annotation = cursor.take(':') !== undefined ? parseTypeAnnotation(cursor) : undefined;
+  const defaultValue = cursor.take('=') !== undefined ? parseExpression(cursor) : undefined;
+
+  const end = defaultValue?.span ?? annotation?.span ?? name.span;
+  return makeNode('parameter', spanning(name.span, end), { name, annotation, defaultValue });
+}
+
+/** The `=>` of 11.1: an `=` and a `>` written against each other. */
+function takeArrow(cursor: Cursor): Token | undefined {
+  const equals = cursor.token;
+  const greater = cursor.peek();
+  if (equals.kind !== '=' || greater.kind !== '>') return undefined;
+  if (equals.span.offset + equals.span.length !== greater.span.offset) return undefined;
+
+  cursor.advance();
+  return cursor.advance();
+}
+
+/**
+ * A header with no `=>`, which the catalogue has no code of its own for.
+ *
+ * What is reported is what is true. A token sitting where the arrow belongs is
+ * OS1018, whose fix names the operator that was meant to join the two halves. A
+ * header that simply ends is OS1010, because that is what it now is: a header
+ * with no body, since without the arrow the lexer opened no block under it.
+ */
+function headerWithNoArrow(cursor: Cursor, keyword: Token): Block | Expression {
+  if (!cursor.atStatementEnd()) {
+    cursor.unexpected(cursor.token);
+    const body = parseExpression(cursor);
+    finishStatement(cursor);
+    return body;
+  }
+
+  cursor.report('OS1010', keyword.span, { header: 'fn' });
+  finishStatement(cursor);
+  if (cursor.at('indent')) return parseBlock(cursor, 'fn', keyword.span);
+  return makeNode('block', cursor.holeSpan(), { statements: [] });
+}
+
+function declaration(
+  keyword: Token,
+  name: Name,
+  parameters: readonly Parameter[],
+  body: Block | Expression,
+): FunctionDeclaration {
+  return makeNode('functionDeclaration', spanning(keyword.span, body.span), {
+    name,
+    parameters,
+    body,
+  });
+}

package/src/core/parse/switches.ts

@@ -1,105 +1,105 @@
-import type { Expression, SwitchCase, SwitchDefault, SwitchStatement } from '../ast/index.js';
-import { makeNode } from '../ast/index.js';
-import type { Span } from '../span/index.js';
-import { spanning } from '../span/index.js';
-import { parseBlock } from './blocks.js';
-import type { Cursor } from './cursor.js';
-import { parseCondition } from './expressions.js';
-import { finishStatement } from './statements.js';
-
-/**
- * `switch`, in both forms of language.md 10.6.
- *
- * With a subject each case value is compared against it, and without one each
- * case value is a condition. The difference is the absent subject and needs no
- * flag beside it.
- *
- * The arms are the whole of a switch body. A `default` that is not last would
- * leave the arms after it unreachable, so the arm that follows one is OS1017,
- * and the arm is kept in the tree all the same: a reader who moves the default
- * should not then be told about the arms one at a time.
- */
-export function parseSwitchStatement(cursor: Cursor): SwitchStatement {
-  const keyword = cursor.advance();
-  const subject = cursor.atStatementEnd() ? undefined : parseCondition(cursor);
-  finishStatement(cursor);
-
-  const cases: SwitchCase[] = [];
-  let defaultCase: SwitchDefault | undefined;
-  let end: Span = keyword.span;
-
-  if (!cursor.at('indent')) {
-    if (!cursor.reportedHere) cursor.report('OS1010', keyword.span, { header: 'switch' });
-    return makeNode('switchStatement', spanning(keyword.span, end), {
-      subject,
-      cases,
-      defaultCase,
-    });
-  }
-
-  if (!cursor.openBlock(cursor.token.span)) {
-    cursor.skipBlockBody();
-    return makeNode('switchStatement', spanning(keyword.span, end), {
-      subject,
-      cases,
-      defaultCase,
-    });
-  }
-  cursor.advance();
-
-  while (!cursor.at('dedent') && !cursor.at('endOfFile')) {
-    const before = cursor.position;
-    const word = cursor.token;
-
-    if (cursor.at('case')) {
-      if (defaultCase !== undefined) cursor.report('OS1017', word.span, { word: word.text });
-      const arm = parseCase(cursor);
-      cases.push(arm);
-      end = arm.span;
-    } else if (cursor.at('default')) {
-      const arm = parseDefault(cursor);
-      if (defaultCase === undefined) defaultCase = arm;
-      else cursor.report('OS1017', word.span, { word: word.text });
-      end = arm.span;
-    } else {
-      // A line in a switch body that is not an arm. The catalogue has no code
-      // for it, and OS1017 carries the rule it breaks: the arms are the whole
-      // of the body, so this line belongs inside one of them or above the
-      // switch.
-      cursor.report('OS1017', word.span, { word: 'case' });
-      cursor.skipStatement();
-    }
-
-    if (cursor.position === before) cursor.skipStatement();
-  }
-
-  cursor.closeBlock();
-  cursor.take('dedent');
-
-  return makeNode('switchStatement', spanning(keyword.span, end), { subject, cases, defaultCase });
-}
-
-/** One arm. Several values separated by commas are one arm, not several. */
-function parseCase(cursor: Cursor): SwitchCase {
-  cursor.beginStatement();
-  const keyword = cursor.advance();
-
-  const values: Expression[] = [parseCondition(cursor)];
-  while (cursor.take(',') !== undefined) {
-    const before = cursor.position;
-    values.push(parseCondition(cursor));
-    if (cursor.position === before) break;
-  }
-
-  finishStatement(cursor);
-  const body = parseBlock(cursor, 'case', keyword.span);
-  return makeNode('switchCase', spanning(keyword.span, body.span), { values, body });
-}
-
-function parseDefault(cursor: Cursor): SwitchDefault {
-  cursor.beginStatement();
-  const keyword = cursor.advance();
-  finishStatement(cursor);
-  const body = parseBlock(cursor, 'default', keyword.span);
-  return makeNode('switchDefault', spanning(keyword.span, body.span), { body });
-}
+import type { Expression, SwitchCase, SwitchDefault, SwitchStatement } from '../ast/index.js';
+import { makeNode } from '../ast/index.js';
+import type { Span } from '../span/index.js';
+import { spanning } from '../span/index.js';
+import { parseBlock } from './blocks.js';
+import type { Cursor } from './cursor.js';
+import { parseCondition } from './expressions.js';
+import { finishStatement } from './statements.js';
+
+/**
+ * `switch`, in both forms of language.md 10.6.
+ *
+ * With a subject each case value is compared against it, and without one each
+ * case value is a condition. The difference is the absent subject and needs no
+ * flag beside it.
+ *
+ * The arms are the whole of a switch body. A `default` that is not last would
+ * leave the arms after it unreachable, so the arm that follows one is OS1017,
+ * and the arm is kept in the tree all the same: a reader who moves the default
+ * should not then be told about the arms one at a time.
+ */
+export function parseSwitchStatement(cursor: Cursor): SwitchStatement {
+  const keyword = cursor.advance();
+  const subject = cursor.atStatementEnd() ? undefined : parseCondition(cursor);
+  finishStatement(cursor);
+
+  const cases: SwitchCase[] = [];
+  let defaultCase: SwitchDefault | undefined;
+  let end: Span = keyword.span;
+
+  if (!cursor.at('indent')) {
+    if (!cursor.reportedHere) cursor.report('OS1010', keyword.span, { header: 'switch' });
+    return makeNode('switchStatement', spanning(keyword.span, end), {
+      subject,
+      cases,
+      defaultCase,
+    });
+  }
+
+  if (!cursor.openBlock(cursor.token.span)) {
+    cursor.skipBlockBody();
+    return makeNode('switchStatement', spanning(keyword.span, end), {
+      subject,
+      cases,
+      defaultCase,
+    });
+  }
+  cursor.advance();
+
+  while (!cursor.at('dedent') && !cursor.at('endOfFile')) {
+    const before = cursor.position;
+    const word = cursor.token;
+
+    if (cursor.at('case')) {
+      if (defaultCase !== undefined) cursor.report('OS1017', word.span, { word: word.text });
+      const arm = parseCase(cursor);
+      cases.push(arm);
+      end = arm.span;
+    } else if (cursor.at('default')) {
+      const arm = parseDefault(cursor);
+      if (defaultCase === undefined) defaultCase = arm;
+      else cursor.report('OS1017', word.span, { word: word.text });
+      end = arm.span;
+    } else {
+      // A line in a switch body that is not an arm. The catalogue has no code
+      // for it, and OS1017 carries the rule it breaks: the arms are the whole
+      // of the body, so this line belongs inside one of them or above the
+      // switch.
+      cursor.report('OS1017', word.span, { word: 'case' });
+      cursor.skipStatement();
+    }
+
+    if (cursor.position === before) cursor.skipStatement();
+  }
+
+  cursor.closeBlock();
+  cursor.take('dedent');
+
+  return makeNode('switchStatement', spanning(keyword.span, end), { subject, cases, defaultCase });
+}
+
+/** One arm. Several values separated by commas are one arm, not several. */
+function parseCase(cursor: Cursor): SwitchCase {
+  cursor.beginStatement();
+  const keyword = cursor.advance();
+
+  const values: Expression[] = [parseCondition(cursor)];
+  while (cursor.take(',') !== undefined) {
+    const before = cursor.position;
+    values.push(parseCondition(cursor));
+    if (cursor.position === before) break;
+  }
+
+  finishStatement(cursor);
+  const body = parseBlock(cursor, 'case', keyword.span);
+  return makeNode('switchCase', spanning(keyword.span, body.span), { values, body });
+}
+
+function parseDefault(cursor: Cursor): SwitchDefault {
+  cursor.beginStatement();
+  const keyword = cursor.advance();
+  finishStatement(cursor);
+  const body = parseBlock(cursor, 'default', keyword.span);
+  return makeNode('switchDefault', spanning(keyword.span, body.span), { body });
+}

package/src/core/version/index.ts

@@ -0,0 +1 @@
+export { COMPILED_FORMAT_VERSION, VERSION } from './version.generated.js';

package/src/core/version/version.generated.ts

@@ -0,0 +1,15 @@
+// Generated by scripts/generate-version.mjs. Do not edit.
+//
+// VERSION comes from package.json and COMPILED_FORMAT_VERSION from
+// spec/compiled-program.md, so neither can drift from the thing it names.
+
+/** This build's package version. The release refuses to publish unless the tag, the manifest and this agree. */
+export const VERSION = "0.1.0-alpha.1";
+
+/**
+ * The compiled program format this compiler emits.
+ *
+ * Deliberately not the package version. An engine written by somebody else
+ * targets this number, and it moves only when the format does.
+ */
+export const COMPILED_FORMAT_VERSION = "1.0";