@rsconcept/domain 1.0.0

package/dist/rslang/labels.d.ts

@@ -0,0 +1,16 @@
+import { AstNodeBase } from '../parsing/ast.js';
+import { TokenID } from './parser/token.js';
+import { ExpressionType } from './semantic/typification.js';
+import '@lezer/common';
+import '../shared/branded.js';
+
+/** Retrieves label for {@link TokenID}. */
+declare function labelToken(id: TokenID): string;
+/** Generates label for {@link AstNodeBase}. */
+declare function labelRSLangNode(node: AstNodeBase): string;
+/** Converts expression type to string. */
+declare function labelType(type: ExpressionType | null): string;
+/** Converts expression type to normalized string. */
+declare function normalizeType(type: ExpressionType | null): string;
+
+export { labelRSLangNode, labelToken, labelType, normalizeType };

package/dist/rslang/labels.js

@@ -0,0 +1,315 @@
+// src/parsing/ast.ts
+var TOKEN_ERROR = 0;
+
+// src/rslang/parser/token.ts
+var TokenID = {
+  // Global, local IDs and literals
+  ERROR: TOKEN_ERROR,
+  ID_LOCAL: 258,
+  ID_GLOBAL: 259,
+  ID_FUNCTION: 260,
+  ID_PREDICATE: 261,
+  ID_RADICAL: 262,
+  LIT_INTEGER: 263,
+  LIT_WHOLE_NUMBERS: 264,
+  LIT_EMPTYSET: 265,
+  // Arithmetic
+  PLUS: 266,
+  MINUS: 267,
+  MULTIPLY: 268,
+  // Integer predicate symbols
+  GREATER: 269,
+  LESSER: 270,
+  GREATER_OR_EQ: 271,
+  LESSER_OR_EQ: 272,
+  // Equality comparison
+  EQUAL: 273,
+  NOTEQUAL: 274,
+  // Logic predicate symbols
+  QUANTOR_UNIVERSAL: 275,
+  QUANTOR_EXISTS: 276,
+  LOGIC_NOT: 277,
+  LOGIC_EQUIVALENT: 278,
+  LOGIC_IMPLICATION: 279,
+  LOGIC_OR: 280,
+  LOGIC_AND: 281,
+  // Set theory predicate symbols
+  SET_IN: 282,
+  SET_NOT_IN: 283,
+  SUBSET: 284,
+  SUBSET_OR_EQ: 285,
+  NOT_SUBSET: 286,
+  // Set theory operators
+  DECART: 287,
+  SET_UNION: 288,
+  SET_INTERSECTION: 289,
+  SET_MINUS: 290,
+  SET_SYMMETRIC_MINUS: 291,
+  BOOLEAN: 292,
+  // Structure operations
+  BIGPR: 293,
+  SMALLPR: 294,
+  FILTER: 295,
+  CARD: 296,
+  BOOL: 297,
+  DEBOOL: 298,
+  REDUCE: 299,
+  // Term constructions prefixes
+  DECLARATIVE: 300,
+  RECURSIVE: 301,
+  IMPERATIVE: 302,
+  ITERATE: 303,
+  ASSIGN: 304,
+  // Punctuation
+  PUNCTUATION_DEFINE: 305,
+  PUNCTUATION_STRUCT: 306,
+  PUNCTUATION_PL: 307,
+  PUNCTUATION_PR: 308,
+  PUNCTUATION_CL: 309,
+  PUNCTUATION_CR: 310,
+  PUNCTUATION_SL: 311,
+  PUNCTUATION_SR: 312,
+  PUNCTUATION_BAR: 313,
+  PUNCTUATION_COMMA: 314,
+  PUNCTUATION_SEMICOLON: 315,
+  // ======= Non-terminal tokens =========
+  NT_ENUM_DECL: 316,
+  NT_TUPLE: 317,
+  NT_ENUMERATION: 318,
+  NT_TUPLE_DECL: 319,
+  NT_ARG_DECL: 320,
+  NT_FUNC_DEFINITION: 321,
+  NT_ARGUMENTS: 322,
+  NT_FUNC_CALL: 323,
+  NT_DECLARATIVE_EXPR: 324,
+  NT_IMPERATIVE_EXPR: 325,
+  NT_RECURSIVE_FULL: 326,
+  NT_RECURSIVE_SHORT: 327,
+  // ======= Helper tokens ========
+  INTERRUPT: 328,
+  END: 329
+};
+
+// src/rslang/semantic/typification.ts
+var TypeID = {
+  anyTypification: 1,
+  integer: 2,
+  basic: 3,
+  tuple: 4,
+  collection: 5,
+  logic: 6,
+  function: 7,
+  predicate: 8
+};
+var LogicT = { typeID: TypeID.logic };
+var IntegerT = {
+  typeID: TypeID.integer,
+  isOrdered: true,
+  isArithmetic: true,
+  isIntegerCompatible: true
+};
+var AnyTypificationT = { typeID: TypeID.anyTypification };
+var EmptySetT = bool(AnyTypificationT);
+function bool(base) {
+  return { typeID: TypeID.collection, base };
+}
+
+// src/rslang/labels.ts
+var INTEGER_TYPE_NAME = "Z";
+var ANY_TYPE_NAME = "R0";
+var LOGIC_TYPE_NAME = "Logic";
+var labelTokenRecord = {
+  [TokenID.DECART]: "\xD7",
+  [TokenID.PUNCTUATION_PL]: "( )",
+  [TokenID.PUNCTUATION_SL]: "[ ]",
+  [TokenID.QUANTOR_UNIVERSAL]: "\u2200",
+  [TokenID.QUANTOR_EXISTS]: "\u2203",
+  [TokenID.LOGIC_NOT]: "\xAC",
+  [TokenID.LOGIC_AND]: "&",
+  [TokenID.LOGIC_OR]: "\u2228",
+  [TokenID.LOGIC_IMPLICATION]: "\u21D2",
+  [TokenID.LOGIC_EQUIVALENT]: "\u21D4",
+  [TokenID.LIT_EMPTYSET]: "\u2205",
+  [TokenID.LIT_WHOLE_NUMBERS]: "Z",
+  [TokenID.MULTIPLY]: "*",
+  [TokenID.EQUAL]: "=",
+  [TokenID.NOTEQUAL]: "\u2260",
+  [TokenID.GREATER_OR_EQ]: "\u2265",
+  [TokenID.LESSER_OR_EQ]: "\u2264",
+  [TokenID.SET_IN]: "\u2208",
+  [TokenID.SET_NOT_IN]: "\u2209",
+  [TokenID.SUBSET_OR_EQ]: "\u2286",
+  [TokenID.SUBSET]: "\u2282",
+  [TokenID.NOT_SUBSET]: "\u2284",
+  [TokenID.SET_INTERSECTION]: "\u2229",
+  [TokenID.SET_UNION]: "\u222A",
+  [TokenID.SET_MINUS]: "\\",
+  [TokenID.SET_SYMMETRIC_MINUS]: "\u2206",
+  [TokenID.BOOLEAN]: "\u212C()",
+  [TokenID.NT_DECLARATIVE_EXPR]: "D{}",
+  [TokenID.NT_IMPERATIVE_EXPR]: "I{}",
+  [TokenID.NT_RECURSIVE_FULL]: "R{}",
+  [TokenID.BIGPR]: "Pr1()",
+  [TokenID.SMALLPR]: "pr1()",
+  [TokenID.FILTER]: "Fi1[]()",
+  [TokenID.REDUCE]: "red()",
+  [TokenID.CARD]: "card()",
+  [TokenID.BOOL]: "bool()",
+  [TokenID.DEBOOL]: "debool()",
+  [TokenID.ASSIGN]: ":=",
+  [TokenID.ITERATE]: ":\u2208"
+};
+function labelToken(id) {
+  const text = labelTokenRecord[id];
+  return text ?? "UNKNOWN TOKEN: " + String(id);
+}
+function labelRSLangNode(node) {
+  switch (node.typeID) {
+    case TokenID.ERROR:
+      return "[ERROR]";
+    case TokenID.ID_LOCAL:
+    case TokenID.ID_GLOBAL:
+    case TokenID.ID_FUNCTION:
+    case TokenID.ID_PREDICATE:
+    case TokenID.ID_RADICAL:
+      return node.data.value;
+    case TokenID.LIT_INTEGER:
+      return String(node.data.value);
+    case TokenID.BIGPR:
+      return "Pr" + node.data.value.toString();
+    case TokenID.SMALLPR:
+      return "pr" + node.data.value.toString();
+    case TokenID.FILTER:
+      return "Fi" + node.data.value.toString();
+    case TokenID.NT_DECLARATIVE_EXPR:
+      return "DECLARATIVE";
+    case TokenID.NT_IMPERATIVE_EXPR:
+      return "IMPERATIVE";
+    case TokenID.NT_RECURSIVE_FULL:
+      return "RECURSIVE";
+    case TokenID.NT_RECURSIVE_SHORT:
+      return "RECURSIVE";
+    case TokenID.BOOLEAN:
+      return "\u212C";
+    case TokenID.REDUCE:
+      return "red";
+    case TokenID.CARD:
+      return "card";
+    case TokenID.BOOL:
+      return "bool";
+    case TokenID.DEBOOL:
+      return "debool";
+    case TokenID.PLUS:
+      return "+";
+    case TokenID.MINUS:
+      return "-";
+    case TokenID.MULTIPLY:
+      return "*";
+    case TokenID.GREATER:
+      return ">";
+    case TokenID.LESSER:
+      return "<";
+    case TokenID.NT_TUPLE:
+      return "TUPLE";
+    case TokenID.NT_ENUMERATION:
+      return "ENUM";
+    case TokenID.NT_ENUM_DECL:
+      return "ENUM_DECLARE";
+    case TokenID.NT_TUPLE_DECL:
+      return "TUPLE_DECLARE";
+    case TokenID.PUNCTUATION_DEFINE:
+      return "DEFINITION";
+    case TokenID.PUNCTUATION_STRUCT:
+      return "STRUCTURE_DEFINE";
+    case TokenID.NT_ARG_DECL:
+      return "ARG";
+    case TokenID.NT_FUNC_CALL:
+      return "CALL";
+    case TokenID.NT_ARGUMENTS:
+      return "ARGS";
+    case TokenID.NT_FUNC_DEFINITION:
+      return "FUNCTION_DEFINE";
+    case TokenID.DECART:
+    case TokenID.QUANTOR_UNIVERSAL:
+    case TokenID.QUANTOR_EXISTS:
+    case TokenID.LOGIC_NOT:
+    case TokenID.LOGIC_AND:
+    case TokenID.LOGIC_OR:
+    case TokenID.LOGIC_IMPLICATION:
+    case TokenID.LOGIC_EQUIVALENT:
+    case TokenID.LIT_EMPTYSET:
+    case TokenID.LIT_WHOLE_NUMBERS:
+    case TokenID.EQUAL:
+    case TokenID.NOTEQUAL:
+    case TokenID.GREATER_OR_EQ:
+    case TokenID.LESSER_OR_EQ:
+    case TokenID.SET_IN:
+    case TokenID.SET_NOT_IN:
+    case TokenID.SUBSET_OR_EQ:
+    case TokenID.SUBSET:
+    case TokenID.NOT_SUBSET:
+    case TokenID.SET_INTERSECTION:
+    case TokenID.SET_UNION:
+    case TokenID.SET_MINUS:
+    case TokenID.SET_SYMMETRIC_MINUS:
+    case TokenID.ASSIGN:
+    case TokenID.ITERATE:
+      return labelToken(node.typeID);
+  }
+  if (node.data.value) {
+    return node.data.value;
+  }
+  return "UNKNOWN NODE: " + String(node.typeID);
+}
+function labelType(type) {
+  if (!type) {
+    return "N/A";
+  }
+  switch (type.typeID) {
+    case TypeID.anyTypification:
+      return ANY_TYPE_NAME;
+    case TypeID.integer:
+      return INTEGER_TYPE_NAME;
+    case TypeID.basic:
+      return type.baseID;
+    case TypeID.tuple:
+      return type.factors.map((factor) => factor.typeID === TypeID.tuple ? `(${labelType(factor)})` : labelType(factor)).join("\xD7");
+    case TypeID.collection:
+      return type.base.typeID === TypeID.collection ? `\u212C${labelType(type.base)}` : `\u212C(${labelType(type.base)})`;
+    case TypeID.logic:
+      return LOGIC_TYPE_NAME;
+    case TypeID.predicate:
+    case TypeID.function:
+      const argsText = type.args.map((arg) => labelType(arg.type)).join(", ");
+      return `[${argsText}] \u2192 ${labelType(type.result)}`;
+  }
+}
+function normalizeType(type) {
+  if (!type) {
+    return "N/A";
+  }
+  switch (type.typeID) {
+    case TypeID.anyTypification:
+      return ANY_TYPE_NAME;
+    case TypeID.integer:
+    case TypeID.basic:
+      return "X1";
+    case TypeID.tuple:
+      return type.factors.map((factor) => factor.typeID === TypeID.tuple ? `(${normalizeType(factor)})` : normalizeType(factor)).join("\xD7");
+    case TypeID.collection:
+      return type.base.typeID === TypeID.collection ? `\u212C${normalizeType(type.base)}` : `\u212C(${normalizeType(type.base)})`;
+    case TypeID.logic:
+      return LOGIC_TYPE_NAME;
+    case TypeID.predicate:
+    case TypeID.function:
+      const argsText = type.args.map((arg) => normalizeType(arg.type)).join(", ");
+      return `[${argsText}] \u2192 ${normalizeType(type.result)}`;
+  }
+}
+export {
+  labelRSLangNode,
+  labelToken,
+  labelType,
+  normalizeType
+};
+//# sourceMappingURL=labels.js.map

package/dist/rslang/labels.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/parsing/ast.ts","../../src/rslang/parser/token.ts","../../src/rslang/semantic/typification.ts","../../src/rslang/labels.ts"],"sourcesContent":["import { type TreeCursor } from './lezer-tree';\n\nexport const TOKEN_ERROR = 0;\n\n/** Represents AST node data. */\ninterface AstNodeData extends Record<string, unknown> {\n  dataType: string;\n  value: unknown;\n}\n\n/** Represents AST structured node base. */\nexport interface AstNodeBase {\n  typeID: number;\n  data: AstNodeData;\n  annotation?: Record<string, unknown>;\n}\n\n/** Represents AST structured node. */\nexport interface AstNode extends Record<string, unknown>, AstNodeBase {\n  uid: number;\n  from: number;\n  to: number;\n  hasError: boolean;\n  parenthesis?: boolean;\n  parent: AstNode | null;\n  children: AstNode[];\n}\n\n/** Represents AST node. */\nexport interface FlatAstNode extends Record<string, unknown>, AstNodeBase {\n  uid: number;\n  parent: number | null;\n  from: number;\n  to: number;\n}\n\n/** Represents Syntax tree flat representation. */\nexport type FlatAST = FlatAstNode[];\n\n/** Builds AST tree from a given tree cursor, generating unique uids for each node. */\nexport function buildTree(cursor: TreeCursor): AstNode {\n  let nextUid = 1;\n  function genUid() {\n    return nextUid++;\n  }\n  return buildTreeInternal(cursor, null, genUid);\n}\n\n/** Flattens AST tree to a array form. */\nexport function flattenAst(node: AstNode, parent: number | null = null, out: FlatAST = []): FlatAST {\n  out.push({\n    uid: node.uid,\n    parent: parent,\n    typeID: node.typeID,\n    from: node.from,\n    to: node.to,\n    data: node.data,\n    annotation: node.annotation\n  });\n  for (const child of node.children) {\n    flattenAst(child, node.uid, out);\n  }\n  return out;\n}\n\n/** Visits AST tree in depth-first order. */\nexport function visitAstDFS(node: AstNode, callback: (node: AstNode) => void) {\n  for (const child of node.children) {\n    visitAstDFS(child, callback);\n  }\n  callback(node);\n}\n\n/** Finds and returns the AstNode with the given ui. */\nexport function findByUid(root: AstNode, uid: number): AstNode | null {\n  let found: AstNode | null = null;\n  visitAstDFS(root, node => {\n    if (node.uid === uid && !found) {\n      found = node;\n    }\n  });\n  return found;\n}\n\n/** Prints AST tree. */\nexport function printAst(node: AstNode, printNode: (node: AstNode) => string): string {\n  let children: string = '';\n  for (const child of node.children) {\n    children += `${printAst(child, printNode)}`;\n  }\n  return `[${printNode(node)}${children}]`;\n}\n\n/** Extracts node text. */\nexport function getNodeText(node: AstNode): string {\n  if (node.data.dataType === 'string' && typeof node.data.value === 'string') {\n    return node.data.value;\n  }\n  return `NO DATA NODE: ${node.typeID}`;\n}\n\n/** Extracts node indices. */\nexport function getNodeIndices(node: AstNode): number[] {\n  if (node.data.dataType === 'string[]' && Array.isArray(node.data.value)) {\n    return (node.data.value as string[]).map(s => parseInt(s, 10)).filter(n => !isNaN(n));\n  }\n  return [];\n}\n\n// ======== Internals ========\nfunction buildTreeInternal(cursor: TreeCursor, parent: AstNode | null = null, genUid: () => number): AstNode {\n  const node = cursor.node;\n\n  const result: AstNode = {\n    uid: genUid(),\n    typeID: node.type.isError ? 0 : node.type.id,\n    from: node.from,\n    to: node.to,\n    hasError: node.type.isError,\n    data: node.type.isError ? { dataType: 'null', value: null } : { dataType: 'string', value: node.type.name },\n    parent,\n    children: []\n  };\n\n  if (cursor.firstChild()) {\n    do {\n      const child = buildTreeInternal(cursor, result, genUid);\n      if (child.hasError) {\n        result.hasError = true;\n      }\n      result.children.push(child);\n    } while (cursor.nextSibling());\n    cursor.parent();\n  }\n  return result;\n}\n","import { TOKEN_ERROR } from '../../parsing';\n\n/** Represents RSLang token types. */\nexport const TokenID = {\n  // Global, local IDs and literals\n  ERROR: TOKEN_ERROR,\n\n  ID_LOCAL: 258,\n  ID_GLOBAL: 259,\n  ID_FUNCTION: 260,\n  ID_PREDICATE: 261,\n  ID_RADICAL: 262,\n  LIT_INTEGER: 263,\n  LIT_WHOLE_NUMBERS: 264,\n  LIT_EMPTYSET: 265,\n\n  // Arithmetic\n  PLUS: 266,\n  MINUS: 267,\n  MULTIPLY: 268,\n\n  // Integer predicate symbols\n  GREATER: 269,\n  LESSER: 270,\n  GREATER_OR_EQ: 271,\n  LESSER_OR_EQ: 272,\n\n  // Equality comparison\n  EQUAL: 273,\n  NOTEQUAL: 274,\n\n  // Logic predicate symbols\n  QUANTOR_UNIVERSAL: 275,\n  QUANTOR_EXISTS: 276,\n  LOGIC_NOT: 277,\n  LOGIC_EQUIVALENT: 278,\n  LOGIC_IMPLICATION: 279,\n  LOGIC_OR: 280,\n  LOGIC_AND: 281,\n\n  // Set theory predicate symbols\n  SET_IN: 282,\n  SET_NOT_IN: 283,\n  SUBSET: 284,\n  SUBSET_OR_EQ: 285,\n  NOT_SUBSET: 286,\n\n  // Set theory operators\n  DECART: 287,\n  SET_UNION: 288,\n  SET_INTERSECTION: 289,\n  SET_MINUS: 290,\n  SET_SYMMETRIC_MINUS: 291,\n  BOOLEAN: 292,\n\n  // Structure operations\n  BIGPR: 293,\n  SMALLPR: 294,\n  FILTER: 295,\n  CARD: 296,\n  BOOL: 297,\n  DEBOOL: 298,\n  REDUCE: 299,\n\n  // Term constructions prefixes\n  DECLARATIVE: 300,\n  RECURSIVE: 301,\n  IMPERATIVE: 302,\n\n  ITERATE: 303,\n  ASSIGN: 304,\n\n  // Punctuation\n  PUNCTUATION_DEFINE: 305,\n  PUNCTUATION_STRUCT: 306,\n  PUNCTUATION_PL: 307,\n  PUNCTUATION_PR: 308,\n  PUNCTUATION_CL: 309,\n  PUNCTUATION_CR: 310,\n  PUNCTUATION_SL: 311,\n  PUNCTUATION_SR: 312,\n  PUNCTUATION_BAR: 313,\n  PUNCTUATION_COMMA: 314,\n  PUNCTUATION_SEMICOLON: 315,\n\n  // ======= Non-terminal tokens =========\n  NT_ENUM_DECL: 316,\n  NT_TUPLE: 317,\n  NT_ENUMERATION: 318,\n  NT_TUPLE_DECL: 319,\n  NT_ARG_DECL: 320,\n\n  NT_FUNC_DEFINITION: 321,\n  NT_ARGUMENTS: 322,\n  NT_FUNC_CALL: 323,\n\n  NT_DECLARATIVE_EXPR: 324,\n  NT_IMPERATIVE_EXPR: 325,\n  NT_RECURSIVE_FULL: 326,\n  NT_RECURSIVE_SHORT: 327,\n\n  // ======= Helper tokens ========\n  INTERRUPT: 328,\n  END: 329\n} as const;\nexport type TokenID = (typeof TokenID)[keyof typeof TokenID];\n","/*\n * Module: Typification for RSLang.\n */\n\nimport { type Branded } from '../../shared';\n\n/** Typification structure enumeration. */\nexport const TypeID = {\n  anyTypification: 1,\n  integer: 2,\n  basic: 3,\n  tuple: 4,\n  collection: 5,\n  logic: 6,\n  function: 7,\n  predicate: 8\n} as const;\nexport type TypeID = (typeof TypeID)[keyof typeof TypeID];\n\n/** Represents type class. */\nexport const TypeClass = {\n  logic: 1,\n  typification: 2,\n  function: 3,\n  predicate: 4\n} as const;\nexport type TypeClass = (typeof TypeClass)[keyof typeof TypeClass];\n\n/** Logic type object. */\nexport const LogicT = { typeID: TypeID.logic } as const;\n\n/** Integer type object. */\nexport const IntegerT = {\n  typeID: TypeID.integer,\n  isOrdered: true,\n  isArithmetic: true,\n  isIntegerCompatible: true\n} as const;\n\n/** Type transformation path. */\nexport type TypePath = Branded<number[], 'TypePath'>;\n\n/** Creates type path. */\nexport function makeTypePath(path: number[]): TypePath {\n  return path as TypePath;\n}\n\n/** AnyTyped type object. */\nexport const AnyTypificationT = { typeID: TypeID.anyTypification } as const;\n\n/** Empty set typification. */\nexport const EmptySetT = bool(AnyTypificationT);\n\n/** Parametrized typification. */\nexport type Parametrized = EchelonFunctional | EchelonPredicate;\n\n/** General expression types. */\nexport type ExpressionType =\n  | EchelonLogic\n  | EchelonBase\n  | EchelonTuple\n  | EchelonCollection\n  | EchelonFunctional\n  | EchelonPredicate\n  | EchelonAnyTyped\n  | EchelonInteger;\n\n/** Setexpr type. */\nexport type Typification = EchelonBase | EchelonAnyTyped | EchelonInteger | EchelonCollection | EchelonTuple;\n\n/** Typification context. */\nexport type TypeContext = Map<string, ExpressionType>;\n\n/** Functional argument. */\nexport interface Argument {\n  readonly alias: string;\n  readonly type: Typification;\n}\n\n/** Type: Logic. */\nexport interface EchelonLogic {\n  readonly typeID: typeof TypeID.logic;\n}\n\n/** Type: AnyTyped. */\nexport interface EchelonAnyTyped {\n  readonly typeID: typeof TypeID.anyTypification;\n}\n\n/** Type: Integer. */\nexport interface EchelonInteger {\n  readonly typeID: typeof TypeID.integer;\n  readonly isOrdered: true;\n  readonly isArithmetic: true;\n  readonly isIntegerCompatible: true;\n}\n\n/** Type: Element of basic set. */\nexport interface EchelonBase {\n  readonly typeID: typeof TypeID.basic;\n  readonly baseID: string;\n  readonly isOrdered?: boolean;\n  readonly isArithmetic?: boolean;\n  readonly isIntegerCompatible?: boolean;\n}\n\n/** Type: Tuple. */\nexport interface EchelonTuple {\n  readonly typeID: typeof TypeID.tuple;\n  readonly factors: readonly Typification[];\n}\n\n/** Type: Collection. */\nexport interface EchelonCollection {\n  readonly typeID: typeof TypeID.collection;\n  readonly base: Typification;\n}\n\n/** Type: Functional. */\nexport interface EchelonFunctional {\n  readonly typeID: typeof TypeID.function;\n  readonly result: Typification;\n  readonly args: readonly Argument[];\n}\n\n/** Type: Predicate. */\nexport interface EchelonPredicate {\n  readonly typeID: typeof TypeID.predicate;\n  readonly result: EchelonLogic;\n  readonly args: readonly Argument[];\n}\n\n/** Create basic element typification. */\nexport function basic(alias: string): EchelonBase {\n  return { typeID: TypeID.basic, baseID: alias };\n}\n\n/** Create constant element typification. */\nexport function constant(alias: string): EchelonBase {\n  return { typeID: TypeID.basic, baseID: alias, isOrdered: true, isArithmetic: true, isIntegerCompatible: true };\n}\n\n/** Create boolean typification. */\nexport function bool(base: Typification): EchelonCollection {\n  return { typeID: TypeID.collection, base };\n}\n\n/** Create tuple typification. */\nexport function tuple(factors: Typification[]): EchelonTuple {\n  if (factors.length < 2) {\n    throw new Error('Tuple with less than two factors is not allowed');\n  }\n  return { typeID: TypeID.tuple, factors };\n}\n\n/** Remove boolean from typification. */\nexport function debool(target: EchelonCollection): Typification {\n  return target.base;\n}\n\n/** Extract component from tuple. */\nexport function component(target: EchelonTuple, index: number): Typification | null {\n  return target.factors[index - 1] ?? null;\n}\n\n/** Checks if given type is typification. */\nexport function isTypification(type: ExpressionType | null): boolean {\n  return (\n    type?.typeID === TypeID.basic ||\n    type?.typeID === TypeID.anyTypification ||\n    type?.typeID === TypeID.integer ||\n    type?.typeID === TypeID.collection ||\n    type?.typeID === TypeID.tuple\n  );\n}\n\n/** Checks if given type is radical. */\nexport function isRadical(alias: string): boolean {\n  return alias.length > 0 && alias.startsWith('R') && alias[1] !== '0';\n}\n","import { type AstNodeBase } from '../parsing';\n\nimport { TokenID } from './parser/token';\nimport { type ExpressionType, TypeID } from './semantic/typification';\n\nconst INTEGER_TYPE_NAME = 'Z';\nconst ANY_TYPE_NAME = 'R0';\nconst LOGIC_TYPE_NAME = 'Logic';\n\nconst labelTokenRecord: Partial<Record<TokenID, string>> = {\n  [TokenID.DECART]: '×',\n  [TokenID.PUNCTUATION_PL]: '( )',\n  [TokenID.PUNCTUATION_SL]: '[ ]',\n  [TokenID.QUANTOR_UNIVERSAL]: '∀',\n  [TokenID.QUANTOR_EXISTS]: '∃',\n  [TokenID.LOGIC_NOT]: '¬',\n  [TokenID.LOGIC_AND]: '&',\n  [TokenID.LOGIC_OR]: '∨',\n  [TokenID.LOGIC_IMPLICATION]: '⇒',\n  [TokenID.LOGIC_EQUIVALENT]: '⇔',\n  [TokenID.LIT_EMPTYSET]: '∅',\n  [TokenID.LIT_WHOLE_NUMBERS]: 'Z',\n  [TokenID.MULTIPLY]: '*',\n  [TokenID.EQUAL]: '=',\n  [TokenID.NOTEQUAL]: '≠',\n  [TokenID.GREATER_OR_EQ]: '≥',\n  [TokenID.LESSER_OR_EQ]: '≤',\n  [TokenID.SET_IN]: '∈',\n  [TokenID.SET_NOT_IN]: '∉',\n  [TokenID.SUBSET_OR_EQ]: '⊆',\n  [TokenID.SUBSET]: '⊂',\n  [TokenID.NOT_SUBSET]: '⊄',\n  [TokenID.SET_INTERSECTION]: '∩',\n  [TokenID.SET_UNION]: '∪',\n  [TokenID.SET_MINUS]: '\\\\',\n  [TokenID.SET_SYMMETRIC_MINUS]: '∆',\n  [TokenID.BOOLEAN]: 'ℬ()',\n  [TokenID.NT_DECLARATIVE_EXPR]: 'D{}',\n  [TokenID.NT_IMPERATIVE_EXPR]: 'I{}',\n  [TokenID.NT_RECURSIVE_FULL]: 'R{}',\n  [TokenID.BIGPR]: 'Pr1()',\n  [TokenID.SMALLPR]: 'pr1()',\n  [TokenID.FILTER]: 'Fi1[]()',\n  [TokenID.REDUCE]: 'red()',\n  [TokenID.CARD]: 'card()',\n  [TokenID.BOOL]: 'bool()',\n  [TokenID.DEBOOL]: 'debool()',\n  [TokenID.ASSIGN]: ':=',\n  [TokenID.ITERATE]: ':∈'\n};\n\n/** Retrieves label for {@link TokenID}. */\nexport function labelToken(id: TokenID): string {\n  const text = labelTokenRecord[id];\n  return text ?? 'UNKNOWN TOKEN: ' + String(id);\n}\n\n/** Generates label for {@link AstNodeBase}. */\nexport function labelRSLangNode(node: AstNodeBase): string {\n  // prettier-ignore\n  switch (node.typeID) {\n    case TokenID.ERROR: return '[ERROR]';\n    case TokenID.ID_LOCAL:\n    case TokenID.ID_GLOBAL:\n    case TokenID.ID_FUNCTION:\n    case TokenID.ID_PREDICATE:\n    case TokenID.ID_RADICAL:\n      return node.data.value as string;\n\n    case TokenID.LIT_INTEGER: return String(node.data.value);\n\n    case TokenID.BIGPR: return 'Pr' + (node.data.value as string[]).toString();\n    case TokenID.SMALLPR: return 'pr' + (node.data.value as string[]).toString();\n    case TokenID.FILTER: return 'Fi' + (node.data.value as string[]).toString();\n\n    case TokenID.NT_DECLARATIVE_EXPR: return 'DECLARATIVE';\n    case TokenID.NT_IMPERATIVE_EXPR: return 'IMPERATIVE';\n    case TokenID.NT_RECURSIVE_FULL: return 'RECURSIVE';\n    case TokenID.NT_RECURSIVE_SHORT: return 'RECURSIVE';\n\n    case TokenID.BOOLEAN: return 'ℬ';\n    case TokenID.REDUCE: return 'red';\n    case TokenID.CARD: return 'card';\n    case TokenID.BOOL: return 'bool';\n    case TokenID.DEBOOL: return 'debool';\n\n    case TokenID.PLUS: return '+';\n    case TokenID.MINUS: return '-';\n    case TokenID.MULTIPLY: return '*';\n    case TokenID.GREATER: return '>';\n    case TokenID.LESSER: return '<';\n\n    case TokenID.NT_TUPLE: return 'TUPLE';\n    case TokenID.NT_ENUMERATION: return 'ENUM';\n\n    case TokenID.NT_ENUM_DECL: return 'ENUM_DECLARE';\n    case TokenID.NT_TUPLE_DECL: return 'TUPLE_DECLARE';\n    case TokenID.PUNCTUATION_DEFINE: return 'DEFINITION';\n    case TokenID.PUNCTUATION_STRUCT: return 'STRUCTURE_DEFINE';\n\n    case TokenID.NT_ARG_DECL: return 'ARG';\n    case TokenID.NT_FUNC_CALL: return 'CALL';\n    case TokenID.NT_ARGUMENTS: return 'ARGS';\n\n    case TokenID.NT_FUNC_DEFINITION: return 'FUNCTION_DEFINE';\n\n    case TokenID.DECART:\n    case TokenID.QUANTOR_UNIVERSAL:\n    case TokenID.QUANTOR_EXISTS:\n    case TokenID.LOGIC_NOT:\n    case TokenID.LOGIC_AND:\n    case TokenID.LOGIC_OR:\n    case TokenID.LOGIC_IMPLICATION:\n    case TokenID.LOGIC_EQUIVALENT:\n    case TokenID.LIT_EMPTYSET:\n    case TokenID.LIT_WHOLE_NUMBERS:\n    case TokenID.EQUAL:\n    case TokenID.NOTEQUAL:\n    case TokenID.GREATER_OR_EQ:\n    case TokenID.LESSER_OR_EQ:\n    case TokenID.SET_IN:\n    case TokenID.SET_NOT_IN:\n    case TokenID.SUBSET_OR_EQ:\n    case TokenID.SUBSET:\n    case TokenID.NOT_SUBSET:\n    case TokenID.SET_INTERSECTION:\n    case TokenID.SET_UNION:\n    case TokenID.SET_MINUS:\n    case TokenID.SET_SYMMETRIC_MINUS:\n    case TokenID.ASSIGN:\n    case TokenID.ITERATE:\n      return labelToken(node.typeID);\n  }\n  if (node.data.value) {\n    return node.data.value as string;\n  }\n  return 'UNKNOWN NODE: ' + String(node.typeID);\n}\n\n/** Converts expression type to string. */\nexport function labelType(type: ExpressionType | null): string {\n  if (!type) {\n    return 'N/A';\n  }\n  switch (type.typeID) {\n    case TypeID.anyTypification:\n      return ANY_TYPE_NAME;\n    case TypeID.integer:\n      return INTEGER_TYPE_NAME;\n    case TypeID.basic:\n      return type.baseID;\n    case TypeID.tuple:\n      return type.factors\n        .map(factor => (factor.typeID === TypeID.tuple ? `(${labelType(factor)})` : labelType(factor)))\n        .join('×');\n    case TypeID.collection:\n      return type.base.typeID === TypeID.collection ? `ℬ${labelType(type.base)}` : `ℬ(${labelType(type.base)})`;\n    case TypeID.logic:\n      return LOGIC_TYPE_NAME;\n    case TypeID.predicate:\n    case TypeID.function:\n      const argsText = type.args.map(arg => labelType(arg.type)).join(', ');\n      return `[${argsText}] → ${labelType(type.result)}`;\n  }\n}\n\n/** Converts expression type to normalized string. */\nexport function normalizeType(type: ExpressionType | null): string {\n  if (!type) {\n    return 'N/A';\n  }\n  switch (type.typeID) {\n    case TypeID.anyTypification:\n      return ANY_TYPE_NAME;\n    case TypeID.integer:\n    case TypeID.basic:\n      return 'X1';\n    case TypeID.tuple:\n      return type.factors\n        .map(factor => (factor.typeID === TypeID.tuple ? `(${normalizeType(factor)})` : normalizeType(factor)))\n        .join('×');\n    case TypeID.collection:\n      return type.base.typeID === TypeID.collection ? `ℬ${normalizeType(type.base)}` : `ℬ(${normalizeType(type.base)})`;\n    case TypeID.logic:\n      return LOGIC_TYPE_NAME;\n    case TypeID.predicate:\n    case TypeID.function:\n      const argsText = type.args.map(arg => normalizeType(arg.type)).join(', ');\n      return `[${argsText}] → ${normalizeType(type.result)}`;\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/rslang/parser/expression-generator.d.ts

@@ -0,0 +1,10 @@
+import { AstNode } from '../../parsing/ast.js';
+import '@lezer/common';
+
+interface ExpressionGeneratorOptions {
+    normalize?: boolean;
+}
+/** Generates Math-syntax RS expression from AST, with optional identifier normalization. */
+declare function generateExpressionFromAst(ast: AstNode, options?: ExpressionGeneratorOptions): string;
+
+export { generateExpressionFromAst };