@rsconcept/domain 1.0.0

package/src/rslang/labels.ts

@@ -0,0 +1,191 @@
+import { type AstNodeBase } from '../parsing';
+
+import { TokenID } from './parser/token';
+import { type ExpressionType, TypeID } from './semantic/typification';
+
+const INTEGER_TYPE_NAME = 'Z';
+const ANY_TYPE_NAME = 'R0';
+const LOGIC_TYPE_NAME = 'Logic';
+
+const labelTokenRecord: Partial<Record<TokenID, string>> = {
+  [TokenID.DECART]: '×',
+  [TokenID.PUNCTUATION_PL]: '( )',
+  [TokenID.PUNCTUATION_SL]: '[ ]',
+  [TokenID.QUANTOR_UNIVERSAL]: '∀',
+  [TokenID.QUANTOR_EXISTS]: '∃',
+  [TokenID.LOGIC_NOT]: '¬',
+  [TokenID.LOGIC_AND]: '&',
+  [TokenID.LOGIC_OR]: '∨',
+  [TokenID.LOGIC_IMPLICATION]: '⇒',
+  [TokenID.LOGIC_EQUIVALENT]: '⇔',
+  [TokenID.LIT_EMPTYSET]: '∅',
+  [TokenID.LIT_WHOLE_NUMBERS]: 'Z',
+  [TokenID.MULTIPLY]: '*',
+  [TokenID.EQUAL]: '=',
+  [TokenID.NOTEQUAL]: '≠',
+  [TokenID.GREATER_OR_EQ]: '≥',
+  [TokenID.LESSER_OR_EQ]: '≤',
+  [TokenID.SET_IN]: '∈',
+  [TokenID.SET_NOT_IN]: '∉',
+  [TokenID.SUBSET_OR_EQ]: '⊆',
+  [TokenID.SUBSET]: '⊂',
+  [TokenID.NOT_SUBSET]: '⊄',
+  [TokenID.SET_INTERSECTION]: '∩',
+  [TokenID.SET_UNION]: '∪',
+  [TokenID.SET_MINUS]: '\\',
+  [TokenID.SET_SYMMETRIC_MINUS]: '∆',
+  [TokenID.BOOLEAN]: 'ℬ()',
+  [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]: ':∈'
+};
+
+/** Retrieves label for {@link TokenID}. */
+export function labelToken(id: TokenID): string {
+  const text = labelTokenRecord[id];
+  return text ?? 'UNKNOWN TOKEN: ' + String(id);
+}
+
+/** Generates label for {@link AstNodeBase}. */
+export function labelRSLangNode(node: AstNodeBase): string {
+  // prettier-ignore
+  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 as string;
+
+    case TokenID.LIT_INTEGER: return String(node.data.value);
+
+    case TokenID.BIGPR: return 'Pr' + (node.data.value as string[]).toString();
+    case TokenID.SMALLPR: return 'pr' + (node.data.value as string[]).toString();
+    case TokenID.FILTER: return 'Fi' + (node.data.value as string[]).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 'ℬ';
+    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 as string;
+  }
+  return 'UNKNOWN NODE: ' + String(node.typeID);
+}
+
+/** Converts expression type to string. */
+export function labelType(type: ExpressionType | null): string {
+  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('×');
+    case TypeID.collection:
+      return type.base.typeID === TypeID.collection ? `ℬ${labelType(type.base)}` : `ℬ(${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}] → ${labelType(type.result)}`;
+  }
+}
+
+/** Converts expression type to normalized string. */
+export function normalizeType(type: ExpressionType | null): string {
+  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('×');
+    case TypeID.collection:
+      return type.base.typeID === TypeID.collection ? `ℬ${normalizeType(type.base)}` : `ℬ(${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}] → ${normalizeType(type.result)}`;
+  }
+}

package/src/rslang/parser/expression-generator.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, it } from 'vitest';
+
+import { RSLangAnalyzer } from '../index';
+
+import { generateExpressionFromAst } from './expression-generator';
+
+const analyzer = new RSLangAnalyzer();
+
+function parseAst(expression: string) {
+  const ast = analyzer.checkFast(expression).ast;
+  if (!ast) {
+    throw new Error(`Failed to parse expression: ${expression}`);
+  }
+  return ast;
+}
+
+const testNormalized = [
+  // Predicates
+  ['1 = 2', '1=2'],
+  ['1 < X1', '1<X1'],
+  ['1 > 2', '1>2'],
+  ['1 < 2', '1<2'],
+  ['X1 ≠ a', 'X1≠a1'],
+  ['P1[a,b]', 'P1[a1, a2]'],
+  // Logic operators
+  ['¬1=2', '¬(1=2)'],
+  ['1=1 & 2=2 & 3=3', '1=1 & 2=2 & 3=3'],
+  ['1=1 & (2=2 & 3=3)', '1=1 & 2=2 & 3=3'],
+  ['(1=1 & 2=2) & 3=3', '1=1 & 2=2 & 3=3'],
+  ['1=1 ∨ 2=2 ∨ 3=3', '1=1 ∨ 2=2 ∨ 3=3'],
+  ['1=1 ⇒ 2=2 ⇒ 3=3', '1=1 ⇒ 2=2 ⇒ 3=3'],
+  ['(1=1 ⇒ 2=2) ⇒ 3=3', '1=1 ⇒ 2=2 ⇒ 3=3'],
+  ['1=1 ⇒ (2=2 ⇒ 3=3)', '1=1 ⇒ (2=2 ⇒ 3=3)'],
+  ['1=1 ⇔ 2=2 ⇔ 3=3', '1=1 ⇔ 2=2 ⇔ 3=3'],
+  ['(1=1 ∨ 2=2) & 3=3', '(1=1 ∨ 2=2) & 3=3'],
+  // Quantifiers
+  ['∀a∈X1 1=1', '∀a1∈X1 1=1'],
+  ['∃a∈X1 1=1', '∃a1∈X1 1=1'],
+  ['∀a∈X1 ∃b∈X1 1=1 & 2=2', '∀a1∈X1 ∃a2∈X1 1=1 & 2=2'],
+  ['∀a∈X1 1=1 & 2=2', '∀a1∈X1 1=1 & 2=2'],
+  ['∀a∈X1 (1=1 & 2=2)', '∀a1∈X1 (1=1 & 2=2)'],
+  ['∀a∈X1 (a=a & a=a)', '∀a1∈X1 (a1=a1 & a1=a1)'],
+  ['∀a,b∈X1 1=2', '∀a1, a2∈X1 1=2'],
+  ['∀(a,b),(c,d)∈S1 1=2', '∀(a1, a2), (a3, a4)∈S1 1=2'],
+  // Setexpr operators
+  ['1+2+3', '(1+2)+3'],
+  ['((a ∪ b) ∩ (c \\ d)) ∆ (e × f)', '((a1∪a2)∩(a3\\a4))∆(a5×a6)'],
+  // Function calls / text functions
+  ['card(X1)', 'card(X1)'],
+  ['card(1)', 'card(1)'],
+  ['card(a)', 'card(a1)'],
+  ['Pr2(a)', 'Pr2(a1)'],
+  ['bool(a)', 'bool(a1)'],
+  ['debool(a)', 'debool(a1)'],
+  ['red(a)', 'red(a1)'],
+  ['Fi1,2[b](a)', 'Fi1,2[a1](a2)'],
+  ['F1[a]', 'F1[a1]'],
+  ['F1[a,b]', 'F1[a1, a2]'],
+  ['F1[{(a,b)}]', 'F1[{(a1, a2)}]'],
+  // Tuple & Set constructors
+  ['(a,b,c)', '(a1, a2, a3)'],
+  ['{a,b,c}', '{a1, a2, a3}'],
+  ['{a}', '{a1}'],
+  ['{(a,b)}', '{(a1, a2)}'],
+  ['{(a,b),(b,c)}', '{(a1, a2), (a2, a3)}'],
+  ['{{a, b}, {c, d}}', '{{a1, a2}, {a3, a4}}'],
+  ['ℬ(a)', 'ℬ(a1)'],
+  ['ℬℬ(a)', 'ℬℬ(a1)'],
+  ['a×b×c', 'a1×a2×a3'],
+  ['a×(b×c)', 'a1×(a2×a3)'],
+  // Term constructors
+  ['D{a∈X1 | 1=2}', 'D{a1∈X1 | 1=2}'],
+  ['{a∈X1 | 1=2}', 'D{a1∈X1 | 1=2}'],
+  ['D{(a,b)∈X1 | 1=2}', 'D{(a1, a2)∈X1 | 1=2}'],
+  ['R{a:=S1 | card(a)<10 | a \\ a}', 'R{a1:=S1 | card(a1)<10 | a1\\a1}'],
+  ['R{a:=S1 | a \\ a}', 'R{a1:=S1 | a1\\a1}'],
+  ['R{(a,b):=S1 | (a \\ a, b)}', 'R{(a1, a2):=S1 | (a1\\a1, a2)}'],
+  ['I{(a, b) | a:∈X1; b:=a}', 'I{(a1, a2) | a1:∈X1; a2:=a1}'],
+  ['I{(a, b) | (a,b):∈Z×Z}', 'I{(a1, a2) | (a1, a2):∈Z×Z}'],
+  ['I{(a, b) | a:∈X1; b:=a; (a,b) ∈ S1}', 'I{(a1, a2) | a1:∈X1; a2:=a1; (a1, a2)∈S1}'],
+  // Functions
+  ['[σ∈ℬ((R1×R1)×R1)] ∀((α1,α2),γ)∈σ ((α2,α1),γ)∈σ', '[a1∈ℬ((R1×R1)×R1)] ∀((a2, a3), a4)∈a1 ((a3, a2), a4)∈a1']
+];
+
+describe('Testing AST expression generator', () => {
+  testNormalized.forEach(([input, normalized]) => {
+    it(`Normalize "${input}"`, () => {
+      expect(generateExpressionFromAst(parseAst(input), { normalize: true })).toBe(normalized);
+    });
+  });
+
+  it('normalizes local names consistently across declarations and usage', () => {
+    const expression = '[a∈X1, b∈X1] a=b';
+    expect(generateExpressionFromAst(parseAst(expression), { normalize: true })).toBe('[a1∈X1, a2∈X1] a1=a2');
+  });
+
+  it('normalizes radical names when requested', () => {
+    expect(generateExpressionFromAst(parseAst('R7=R3'), { normalize: true })).toBe('R1=R2');
+  });
+});