@rsconcept/domain 1.0.0

package/dist/rslang/semantic/typification-parser.js

@@ -0,0 +1,226 @@
+// 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 };
+}
+function tuple(factors) {
+  if (factors.length < 2) {
+    throw new Error("Tuple with less than two factors is not allowed");
+  }
+  return { typeID: TypeID.tuple, factors };
+}
+function isTypification(type) {
+  return type?.typeID === TypeID.basic || type?.typeID === TypeID.anyTypification || type?.typeID === TypeID.integer || type?.typeID === TypeID.collection || type?.typeID === TypeID.tuple;
+}
+
+// src/rslang/semantic/typification-parser.ts
+function parseTypeText(input) {
+  const normalized = input.trim().replaceAll("->", "\u2192");
+  if (normalized.length === 0) {
+    return { type: null, error: null };
+  }
+  const parser = new TypificationParser(normalized);
+  return parser.parse();
+}
+function applyAsciiTypeSubstitutions(raw) {
+  return raw.replaceAll("->", "\u2192").replaceAll("*", "\xD7").replaceAll("B", "\u212C");
+}
+var TypificationParser = class {
+  index = 0;
+  input;
+  constructor(input) {
+    this.index = 0;
+    this.input = input;
+  }
+  parse() {
+    try {
+      const result = this.parseExpressionType();
+      this.skipSpaces();
+      if (!this.eof()) {
+        throw new Error("Unexpected trailing symbols");
+      }
+      return { type: result, error: null };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return { type: null, error: message };
+    }
+  }
+  parseExpressionType() {
+    this.skipSpaces();
+    if (this.peek() === "[") {
+      return this.parseCallableType();
+    } else {
+      return this.parseTypification();
+    }
+  }
+  parseCallableType() {
+    this.expect("[");
+    const args = [];
+    this.skipSpaces();
+    if (this.peek() !== "]") {
+      while (true) {
+        args.push(this.parseTypification());
+        this.skipSpaces();
+        if (this.peek() === ",") {
+          this.next();
+          this.skipSpaces();
+          if (this.peek() === "]") {
+            throw new Error("Empty argument in callable typification");
+          }
+          continue;
+        }
+        break;
+      }
+    }
+    this.expect("]");
+    this.skipSpaces();
+    this.expect("\u2192");
+    const result = this.parseCallableResult();
+    if (result.typeID === TypeID.logic) {
+      return {
+        typeID: TypeID.predicate,
+        result: LogicT,
+        args: args.map((arg, index) => ({ alias: `a${index + 1}`, type: arg }))
+      };
+    }
+    if (!isTypification(result)) {
+      throw new Error("Invalid callable result type");
+    }
+    return {
+      typeID: TypeID.function,
+      result,
+      args: args.map((arg, index) => ({ alias: `a${index + 1}`, type: arg }))
+    };
+  }
+  parseCallableResult() {
+    this.skipSpaces();
+    const lookahead = this.readToken();
+    this.index -= lookahead.length;
+    if (lookahead === "Logic") {
+      this.index += lookahead.length;
+      return LogicT;
+    }
+    return this.parseTypification();
+  }
+  parseTypification() {
+    this.skipSpaces();
+    if (this.match("\u212C")) {
+      this.skipSpaces();
+      if (this.peek() === "(") {
+        this.next();
+        const base = this.parseTypification();
+        this.expect(")");
+        return bool(base);
+      }
+      this.skipSpaces();
+      if (this.input.startsWith("\u212C", this.index)) {
+        const base = this.parseTypification();
+        return bool(base);
+      }
+      throw new Error('Expected "(" after "\u212C"');
+    }
+    const first = this.parseTypificationAtom();
+    const factors = [first];
+    while (true) {
+      this.skipSpaces();
+      if (!this.match("\xD7")) {
+        break;
+      }
+      factors.push(this.parseTypificationAtom());
+    }
+    if (factors.length === 1) {
+      return first;
+    }
+    return tuple(factors);
+  }
+  parseTypificationAtom() {
+    this.skipSpaces();
+    if (this.input.startsWith("\u212C", this.index)) {
+      return this.parseTypification();
+    }
+    if (this.peek() === "(") {
+      this.next();
+      const wrapped = this.parseTypification();
+      this.expect(")");
+      return wrapped;
+    }
+    const token = this.readToken();
+    if (token === "Z") {
+      return IntegerT;
+    }
+    if (token === "R0") {
+      return { typeID: TypeID.anyTypification };
+    }
+    if (!/^[A-Z]\d+$/.test(token)) {
+      throw new Error(`Unknown typification token "${token}"`);
+    }
+    return { typeID: TypeID.basic, baseID: token };
+  }
+  readToken() {
+    this.skipSpaces();
+    const start = this.index;
+    while (!this.eof()) {
+      const char = this.peek();
+      if (!char || /[\s,()[\]→×]/.test(char)) {
+        break;
+      }
+      this.next();
+    }
+    if (start === this.index) {
+      throw new Error("Expected typification token");
+    }
+    return this.input.slice(start, this.index);
+  }
+  skipSpaces() {
+    while (!this.eof() && /\s/.test(this.peek())) {
+      this.index += 1;
+    }
+  }
+  expect(symbol) {
+    this.skipSpaces();
+    if (!this.match(symbol)) {
+      throw new Error(`Expected "${symbol}"`);
+    }
+  }
+  match(symbol) {
+    if (this.input.startsWith(symbol, this.index)) {
+      this.index += symbol.length;
+      return true;
+    }
+    return false;
+  }
+  peek() {
+    return this.input[this.index];
+  }
+  next() {
+    const value = this.input[this.index];
+    this.index += 1;
+    return value;
+  }
+  eof() {
+    return this.index >= this.input.length;
+  }
+};
+export {
+  applyAsciiTypeSubstitutions,
+  parseTypeText
+};
+//# sourceMappingURL=typification-parser.js.map

package/dist/rslang/semantic/typification-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/rslang/semantic/typification.ts","../../../src/rslang/semantic/typification-parser.ts"],"sourcesContent":["/*\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 {\n  bool,\n  type ExpressionType,\n  IntegerT,\n  isTypification,\n  LogicT,\n  tuple,\n  TypeID,\n  type Typification\n} from './typification';\n\nexport interface TypificationParseResult {\n  type: ExpressionType | null;\n  error: string | null;\n}\n\nexport function parseTypeText(input: string): TypificationParseResult {\n  const normalized = input.trim().replaceAll('->', '→');\n  if (normalized.length === 0) {\n    return { type: null, error: null };\n  }\n  const parser = new TypificationParser(normalized);\n  return parser.parse();\n}\n\n/** ASCII substitutions while editing typification text */\nexport function applyAsciiTypeSubstitutions(raw: string): string {\n  return raw.replaceAll('->', '→').replaceAll('*', '×').replaceAll('B', 'ℬ');\n}\n\nclass TypificationParser {\n  private index = 0;\n  private input: string;\n\n  constructor(input: string) {\n    this.index = 0;\n    this.input = input;\n  }\n\n  parse(): TypificationParseResult {\n    try {\n      const result = this.parseExpressionType();\n      this.skipSpaces();\n      if (!this.eof()) {\n        throw new Error('Unexpected trailing symbols');\n      }\n      return { type: result, error: null };\n    } catch (error) {\n      const message = error instanceof Error ? error.message : String(error);\n      return { type: null, error: message };\n    }\n  }\n\n  private parseExpressionType(): ExpressionType {\n    this.skipSpaces();\n    if (this.peek() === '[') {\n      return this.parseCallableType();\n    } else {\n      return this.parseTypification();\n    }\n  }\n\n  private parseCallableType(): ExpressionType {\n    this.expect('[');\n    const args: Typification[] = [];\n    this.skipSpaces();\n    if (this.peek() !== ']') {\n      while (true) {\n        args.push(this.parseTypification());\n        this.skipSpaces();\n        if (this.peek() === ',') {\n          this.next();\n          this.skipSpaces();\n          if (this.peek() === ']') {\n            throw new Error('Empty argument in callable typification');\n          }\n          continue;\n        }\n        break;\n      }\n    }\n    this.expect(']');\n    this.skipSpaces();\n    this.expect('→');\n    const result = this.parseCallableResult();\n    if (result.typeID === TypeID.logic) {\n      return {\n        typeID: TypeID.predicate,\n        result: LogicT,\n        args: args.map((arg, index) => ({ alias: `a${index + 1}`, type: arg }))\n      };\n    }\n    if (!isTypification(result)) {\n      throw new Error('Invalid callable result type');\n    }\n    return {\n      typeID: TypeID.function,\n      result: result as Typification,\n      args: args.map((arg, index) => ({ alias: `a${index + 1}`, type: arg }))\n    };\n  }\n\n  private parseCallableResult(): ExpressionType {\n    this.skipSpaces();\n    const lookahead = this.readToken();\n    this.index -= lookahead.length;\n    if (lookahead === 'Logic') {\n      this.index += lookahead.length;\n      return LogicT;\n    }\n    return this.parseTypification();\n  }\n\n  private parseTypification(): Typification {\n    this.skipSpaces();\n    if (this.match('ℬ')) {\n      this.skipSpaces();\n      if (this.peek() === '(') {\n        this.next();\n        const base = this.parseTypification();\n        this.expect(')');\n        return bool(base);\n      }\n      this.skipSpaces();\n      if (this.input.startsWith('ℬ', this.index)) {\n        const base = this.parseTypification();\n        return bool(base);\n      }\n      throw new Error('Expected \"(\" after \"ℬ\"');\n    }\n    const first = this.parseTypificationAtom();\n    const factors: Typification[] = [first];\n    while (true) {\n      this.skipSpaces();\n      if (!this.match('×')) {\n        break;\n      }\n      factors.push(this.parseTypificationAtom());\n    }\n    if (factors.length === 1) {\n      return first;\n    }\n    return tuple(factors);\n  }\n\n  private parseTypificationAtom(): Typification {\n    this.skipSpaces();\n    if (this.input.startsWith('ℬ', this.index)) {\n      return this.parseTypification();\n    }\n    if (this.peek() === '(') {\n      this.next();\n      const wrapped = this.parseTypification();\n      this.expect(')');\n      return wrapped;\n    }\n    const token = this.readToken();\n    if (token === 'Z') {\n      return IntegerT;\n    }\n    if (token === 'R0') {\n      return { typeID: TypeID.anyTypification };\n    }\n    if (!/^[A-Z]\\d+$/.test(token)) {\n      throw new Error(`Unknown typification token \"${token}\"`);\n    }\n    return { typeID: TypeID.basic, baseID: token };\n  }\n\n  private readToken(): string {\n    this.skipSpaces();\n    const start = this.index;\n    while (!this.eof()) {\n      const char = this.peek();\n      if (!char || /[\\s,()[\\]→×]/.test(char)) {\n        break;\n      }\n      this.next();\n    }\n    if (start === this.index) {\n      throw new Error('Expected typification token');\n    }\n    return this.input.slice(start, this.index);\n  }\n\n  private skipSpaces(): void {\n    while (!this.eof() && /\\s/.test(this.peek()!)) {\n      this.index += 1;\n    }\n  }\n\n  private expect(symbol: string): void {\n    this.skipSpaces();\n    if (!this.match(symbol)) {\n      throw new Error(`Expected \"${symbol}\"`);\n    }\n  }\n\n  private match(symbol: string): boolean {\n    if (this.input.startsWith(symbol, this.index)) {\n      this.index += symbol.length;\n      return true;\n    }\n    return false;\n  }\n\n  private peek(): string | undefined {\n    return this.input[this.index];\n  }\n\n  private next(): string | undefined {\n    const value = this.input[this.index];\n    this.index += 1;\n    return value;\n  }\n\n  private eof(): boolean {\n    return this.index >= this.input.length;\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/rslang/semantic/typification.d.ts

@@ -0,0 +1,119 @@
+import { Branded } from '../../shared/branded.js';
+
+/** Typification structure enumeration. */
+declare const TypeID: {
+    readonly anyTypification: 1;
+    readonly integer: 2;
+    readonly basic: 3;
+    readonly tuple: 4;
+    readonly collection: 5;
+    readonly logic: 6;
+    readonly function: 7;
+    readonly predicate: 8;
+};
+type TypeID = (typeof TypeID)[keyof typeof TypeID];
+/** Represents type class. */
+declare const TypeClass: {
+    readonly logic: 1;
+    readonly typification: 2;
+    readonly function: 3;
+    readonly predicate: 4;
+};
+type TypeClass = (typeof TypeClass)[keyof typeof TypeClass];
+/** Logic type object. */
+declare const LogicT: {
+    readonly typeID: 6;
+};
+/** Integer type object. */
+declare const IntegerT: {
+    readonly typeID: 2;
+    readonly isOrdered: true;
+    readonly isArithmetic: true;
+    readonly isIntegerCompatible: true;
+};
+/** Type transformation path. */
+type TypePath = Branded<number[], 'TypePath'>;
+/** Creates type path. */
+declare function makeTypePath(path: number[]): TypePath;
+/** AnyTyped type object. */
+declare const AnyTypificationT: {
+    readonly typeID: 1;
+};
+/** Empty set typification. */
+declare const EmptySetT: EchelonCollection;
+/** Parametrized typification. */
+type Parametrized = EchelonFunctional | EchelonPredicate;
+/** General expression types. */
+type ExpressionType = EchelonLogic | EchelonBase | EchelonTuple | EchelonCollection | EchelonFunctional | EchelonPredicate | EchelonAnyTyped | EchelonInteger;
+/** Setexpr type. */
+type Typification = EchelonBase | EchelonAnyTyped | EchelonInteger | EchelonCollection | EchelonTuple;
+/** Typification context. */
+type TypeContext = Map<string, ExpressionType>;
+/** Functional argument. */
+interface Argument {
+    readonly alias: string;
+    readonly type: Typification;
+}
+/** Type: Logic. */
+interface EchelonLogic {
+    readonly typeID: typeof TypeID.logic;
+}
+/** Type: AnyTyped. */
+interface EchelonAnyTyped {
+    readonly typeID: typeof TypeID.anyTypification;
+}
+/** Type: Integer. */
+interface EchelonInteger {
+    readonly typeID: typeof TypeID.integer;
+    readonly isOrdered: true;
+    readonly isArithmetic: true;
+    readonly isIntegerCompatible: true;
+}
+/** Type: Element of basic set. */
+interface EchelonBase {
+    readonly typeID: typeof TypeID.basic;
+    readonly baseID: string;
+    readonly isOrdered?: boolean;
+    readonly isArithmetic?: boolean;
+    readonly isIntegerCompatible?: boolean;
+}
+/** Type: Tuple. */
+interface EchelonTuple {
+    readonly typeID: typeof TypeID.tuple;
+    readonly factors: readonly Typification[];
+}
+/** Type: Collection. */
+interface EchelonCollection {
+    readonly typeID: typeof TypeID.collection;
+    readonly base: Typification;
+}
+/** Type: Functional. */
+interface EchelonFunctional {
+    readonly typeID: typeof TypeID.function;
+    readonly result: Typification;
+    readonly args: readonly Argument[];
+}
+/** Type: Predicate. */
+interface EchelonPredicate {
+    readonly typeID: typeof TypeID.predicate;
+    readonly result: EchelonLogic;
+    readonly args: readonly Argument[];
+}
+/** Create basic element typification. */
+declare function basic(alias: string): EchelonBase;
+/** Create constant element typification. */
+declare function constant(alias: string): EchelonBase;
+/** Create boolean typification. */
+declare function bool(base: Typification): EchelonCollection;
+/** Create tuple typification. */
+declare function tuple(factors: Typification[]): EchelonTuple;
+/** Remove boolean from typification. */
+declare function debool(target: EchelonCollection): Typification;
+/** Extract component from tuple. */
+declare function component(target: EchelonTuple, index: number): Typification | null;
+/** Checks if given type is typification. */
+declare function isTypification(type: ExpressionType | null): boolean;
+/** Checks if given type is radical. */
+declare function isRadical(alias: string): boolean;
+
+export { AnyTypificationT, type Argument, type EchelonAnyTyped, type EchelonBase, type EchelonCollection, type EchelonFunctional, type EchelonInteger, type EchelonLogic, type EchelonPredicate, type EchelonTuple, EmptySetT, type ExpressionType, IntegerT, LogicT, type Parametrized, TypeClass, type TypeContext, TypeID, type TypePath, type Typification, basic, bool, component, constant, debool, isRadical, isTypification, makeTypePath, tuple };

package/dist/rslang/semantic/typification.js

@@ -0,0 +1,74 @@
+// src/rslang/semantic/typification.ts
+var TypeID = {
+  anyTypification: 1,
+  integer: 2,
+  basic: 3,
+  tuple: 4,
+  collection: 5,
+  logic: 6,
+  function: 7,
+  predicate: 8
+};
+var TypeClass = {
+  logic: 1,
+  typification: 2,
+  function: 3,
+  predicate: 4
+};
+var LogicT = { typeID: TypeID.logic };
+var IntegerT = {
+  typeID: TypeID.integer,
+  isOrdered: true,
+  isArithmetic: true,
+  isIntegerCompatible: true
+};
+function makeTypePath(path) {
+  return path;
+}
+var AnyTypificationT = { typeID: TypeID.anyTypification };
+var EmptySetT = bool(AnyTypificationT);
+function basic(alias) {
+  return { typeID: TypeID.basic, baseID: alias };
+}
+function constant(alias) {
+  return { typeID: TypeID.basic, baseID: alias, isOrdered: true, isArithmetic: true, isIntegerCompatible: true };
+}
+function bool(base) {
+  return { typeID: TypeID.collection, base };
+}
+function tuple(factors) {
+  if (factors.length < 2) {
+    throw new Error("Tuple with less than two factors is not allowed");
+  }
+  return { typeID: TypeID.tuple, factors };
+}
+function debool(target) {
+  return target.base;
+}
+function component(target, index) {
+  return target.factors[index - 1] ?? null;
+}
+function isTypification(type) {
+  return type?.typeID === TypeID.basic || type?.typeID === TypeID.anyTypification || type?.typeID === TypeID.integer || type?.typeID === TypeID.collection || type?.typeID === TypeID.tuple;
+}
+function isRadical(alias) {
+  return alias.length > 0 && alias.startsWith("R") && alias[1] !== "0";
+}
+export {
+  AnyTypificationT,
+  EmptySetT,
+  IntegerT,
+  LogicT,
+  TypeClass,
+  TypeID,
+  basic,
+  bool,
+  component,
+  constant,
+  debool,
+  isRadical,
+  isTypification,
+  makeTypePath,
+  tuple
+};
+//# sourceMappingURL=typification.js.map

package/dist/rslang/semantic/typification.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/rslang/semantic/typification.ts"],"sourcesContent":["/*\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"],"mappings":";AAOO,IAAM,SAAS;AAAA,EACpB,iBAAiB;AAAA,EACjB,SAAS;AAAA,EACT,OAAO;AAAA,EACP,OAAO;AAAA,EACP,YAAY;AAAA,EACZ,OAAO;AAAA,EACP,UAAU;AAAA,EACV,WAAW;AACb;AAIO,IAAM,YAAY;AAAA,EACvB,OAAO;AAAA,EACP,cAAc;AAAA,EACd,UAAU;AAAA,EACV,WAAW;AACb;AAIO,IAAM,SAAS,EAAE,QAAQ,OAAO,MAAM;AAGtC,IAAM,WAAW;AAAA,EACtB,QAAQ,OAAO;AAAA,EACf,WAAW;AAAA,EACX,cAAc;AAAA,EACd,qBAAqB;AACvB;AAMO,SAAS,aAAa,MAA0B;AACrD,SAAO;AACT;AAGO,IAAM,mBAAmB,EAAE,QAAQ,OAAO,gBAAgB;AAG1D,IAAM,YAAY,KAAK,gBAAgB;AAkFvC,SAAS,MAAM,OAA4B;AAChD,SAAO,EAAE,QAAQ,OAAO,OAAO,QAAQ,MAAM;AAC/C;AAGO,SAAS,SAAS,OAA4B;AACnD,SAAO,EAAE,QAAQ,OAAO,OAAO,QAAQ,OAAO,WAAW,MAAM,cAAc,MAAM,qBAAqB,KAAK;AAC/G;AAGO,SAAS,KAAK,MAAuC;AAC1D,SAAO,EAAE,QAAQ,OAAO,YAAY,KAAK;AAC3C;AAGO,SAAS,MAAM,SAAuC;AAC3D,MAAI,QAAQ,SAAS,GAAG;AACtB,UAAM,IAAI,MAAM,iDAAiD;AAAA,EACnE;AACA,SAAO,EAAE,QAAQ,OAAO,OAAO,QAAQ;AACzC;AAGO,SAAS,OAAO,QAAyC;AAC9D,SAAO,OAAO;AAChB;AAGO,SAAS,UAAU,QAAsB,OAAoC;AAClF,SAAO,OAAO,QAAQ,QAAQ,CAAC,KAAK;AACtC;AAGO,SAAS,eAAe,MAAsC;AACnE,SACE,MAAM,WAAW,OAAO,SACxB,MAAM,WAAW,OAAO,mBACxB,MAAM,WAAW,OAAO,WACxB,MAAM,WAAW,OAAO,cACxB,MAAM,WAAW,OAAO;AAE5B;AAGO,SAAS,UAAU,OAAwB;AAChD,SAAO,MAAM,SAAS,KAAK,MAAM,WAAW,GAAG,KAAK,MAAM,CAAC,MAAM;AACnE;","names":[]}

package/dist/rslang/semantic/value-auditor.d.ts

@@ -0,0 +1,43 @@
+import { AstNode } from '../../parsing/ast.js';
+import { ErrorReporter } from '../error.js';
+import { ValueClassContext, ValueClass } from './value-class.js';
+import '@lezer/common';
+
+/**
+ * Module: Value auditor for AST value class checking.
+ *
+ * Determines whether an expression yields a concrete value (computable)
+ * or a property (e.g., depends on a quantified variable).
+ */
+
+/** Value auditor for AST value class checking. */
+declare class ValueAuditor {
+    private context;
+    private annotateErrors;
+    private reporter?;
+    constructor(context: ValueClassContext);
+    /**
+     * Runs value audit on the AST. Returns the value class on success, null on failure.
+     */
+    run(ast: AstNode, reporter?: ErrorReporter, annotateErrors?: boolean): ValueClass | null;
+    private dispatchVisit;
+    private onError;
+    private visitChild;
+    private visitAllAndReturn;
+    private assertChildIsValue;
+    private assertAllValues;
+    private visitFunctionDefinition;
+    private visitFunctionCall;
+    private visitGlobal;
+    private visitQuantifier;
+    private visitSetexprPredicate;
+    private visitDeclarative;
+    private visitImperative;
+    private visitIterateOrAssign;
+    private visitDecart;
+    private visitBoolean;
+    private visitFilter;
+    private visitSetexprBinary;
+}
+
+export { ValueAuditor };