@rsconcept/domain 1.0.0

package/src/rslang/semantic/typification-api.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from 'vitest';
+
+import type { TypePath } from './typification';
+import { AnyTypificationT, basic, bool, IntegerT, tuple } from './typification';
+import { applyPath } from './typification-api';
+
+describe('applyPath', () => {
+  function typePath(path: number[]): TypePath {
+    return path as TypePath;
+  }
+
+  it('returns the same typification for empty path', () => {
+    const type = basic('X1');
+    expect(applyPath(type, typePath([]))).toBe(type);
+  });
+
+  it('returns null for path on non-nested types', () => {
+    const types = [AnyTypificationT, basic('X1'), IntegerT];
+    for (const typ of types) {
+      expect(applyPath(typ, typePath([0]))).toBeNull();
+    }
+  });
+
+  it('follows collection base as expected', () => {
+    const base = basic('X1');
+    const collection = bool(base);
+    expect(applyPath(collection, typePath([0]))).toBe(base);
+    expect(applyPath(collection, typePath([0, 0]))).toBeNull();
+  });
+
+  it('navigates within tuple by path index', () => {
+    const f1 = basic('X1');
+    const f2 = basic('X2');
+    const tup = tuple([f1, f2]);
+    expect(applyPath(tup, typePath([0]))).toBeNull();
+    expect(applyPath(tup, typePath([1]))).toBe(f1);
+    expect(applyPath(tup, typePath([2]))).toBe(f2);
+    expect(applyPath(tup, typePath([3]))).toBeNull();
+    expect(applyPath(tup, typePath([1, 0]))).toBeNull();
+
+    const nested = tuple([tup, f2]);
+    expect(applyPath(nested, typePath([1, 2]))).toBe(f2);
+    expect(applyPath(nested, typePath([1, 3]))).toBeNull();
+    expect(applyPath(nested, typePath([2, 1]))).toBeNull();
+  });
+});

package/src/rslang/semantic/typification-api.ts

@@ -0,0 +1,321 @@
+/**
+ * Module: Typification API for RSLang.
+ */
+
+import {
+  bool,
+  component,
+  type EchelonBase,
+  type EchelonCollection,
+  type EchelonTuple,
+  type ExpressionType,
+  IntegerT,
+  isRadical,
+  isTypification,
+  tuple,
+  TypeClass,
+  TypeID,
+  type TypePath,
+  type Typification
+} from './typification';
+
+/** Record map from typeID to typeClass. */
+const TypeIDToClass: Record<TypeID, TypeClass> = {
+  [TypeID.anyTypification]: TypeClass.typification,
+  [TypeID.integer]: TypeClass.typification,
+  [TypeID.basic]: TypeClass.typification,
+  [TypeID.tuple]: TypeClass.typification,
+  [TypeID.collection]: TypeClass.typification,
+  [TypeID.logic]: TypeClass.logic,
+  [TypeID.function]: TypeClass.function,
+  [TypeID.predicate]: TypeClass.predicate
+};
+
+/** Returns the TypeClass associated with the given TypeID. */
+export function getTypeClass(typeID: TypeID): TypeClass {
+  return TypeIDToClass[typeID];
+}
+
+/** Returns true if the given typification is generic. */
+export function hasGenerics(type: Typification): boolean {
+  switch (type.typeID) {
+    case TypeID.anyTypification:
+      return true;
+    case TypeID.integer:
+      return false;
+    case TypeID.basic:
+      return isRadical(type.baseID);
+    case TypeID.collection:
+      return hasGenerics(type.base);
+    case TypeID.tuple:
+      for (const factor of type.factors) {
+        if (hasGenerics(factor)) {
+          return true;
+        }
+      }
+      return false;
+  }
+}
+
+/** Checks if two typifications are equal. */
+export function checkEquality(type1: Typification, type2: Typification): boolean {
+  if (type1 === type2) {
+    return true;
+  }
+  if (type1.typeID !== type2.typeID) {
+    return false;
+  }
+  switch (type1.typeID) {
+    case TypeID.integer:
+    case TypeID.anyTypification:
+      return true;
+    case TypeID.basic:
+      return type1.baseID === (type2 as EchelonBase).baseID;
+    case TypeID.collection:
+      return checkEquality(type1.base, (type2 as EchelonCollection).base);
+    case TypeID.tuple: {
+      if (type1.factors.length !== (type2 as EchelonTuple).factors.length) {
+        return false;
+      }
+      for (let index = 0; index < type1.factors.length; ++index) {
+        if (!checkEquality(type1.factors[index], (type2 as EchelonTuple).factors[index])) {
+          return false;
+        }
+      }
+      return true;
+    }
+  }
+}
+
+/** Merge two types to get result of binary operation. */
+export function mergeTypifications(type1: Typification, type2: Typification): Typification | null {
+  if (type1 === type2) {
+    return type1;
+  }
+  if (type1.typeID === TypeID.anyTypification) {
+    return isTypification(type2) ? type2 : null;
+  }
+  if (type2.typeID === TypeID.anyTypification) {
+    return isTypification(type1) ? type1 : null;
+  }
+
+  switch (type1.typeID) {
+    case TypeID.integer:
+    case TypeID.basic:
+      return commonType(type1, type2);
+    case TypeID.collection:
+      if (type2.typeID !== TypeID.collection) {
+        return null;
+      }
+      const base = mergeTypifications(type1.base, type2.base);
+      return base ? bool(base) : null;
+    case TypeID.tuple:
+      if (type2.typeID !== TypeID.tuple) {
+        return null;
+      }
+      if (type1.factors.length !== type2.factors.length) {
+        return null;
+      }
+      const components: Typification[] = [];
+      for (let index = 0; index < type1.factors.length; ++index) {
+        const component = mergeTypifications(type1.factors[index], type2.factors[index]);
+        if (component === null) {
+          return null;
+        }
+        components.push(component);
+      }
+      return tuple(components);
+  }
+}
+
+/** Check compatibility of typifications. */
+export function checkCompatibility(type1: ExpressionType, type2: ExpressionType): boolean {
+  if (type1 === type2) {
+    return true;
+  }
+  if (type1.typeID === TypeID.anyTypification) {
+    return isTypification(type2);
+  }
+  if (type2.typeID === TypeID.anyTypification) {
+    return isTypification(type1);
+  }
+  if (isTypification(type1) !== isTypification(type2)) {
+    return false;
+  }
+  if (
+    type1.typeID === TypeID.integer ||
+    type1.typeID === TypeID.basic ||
+    type2.typeID === TypeID.integer ||
+    type2.typeID === TypeID.basic
+  ) {
+    return commonType(type1 as Typification, type2 as Typification) !== null;
+  }
+
+  if (type1.typeID !== type2.typeID) {
+    return false;
+  }
+  switch (type1.typeID) {
+    case TypeID.collection:
+      return checkCompatibility(type1.base, (type2 as EchelonCollection).base);
+    case TypeID.tuple:
+      if (type1.factors.length !== (type2 as EchelonTuple).factors.length) {
+        return false;
+      }
+      for (let index = 0; index < type1.factors.length; ++index) {
+        if (!checkCompatibility(type1.factors[index], (type2 as EchelonTuple).factors[index])) {
+          return false;
+        }
+      }
+      return true;
+    case TypeID.logic:
+    case TypeID.predicate:
+    case TypeID.function:
+      return false;
+  }
+}
+
+/** Compare typification with substitutions. */
+export function compareTemplated(
+  substitutes: Map<string, Typification>,
+  arg: Typification,
+  value: Typification
+): boolean {
+  if (arg === value) {
+    return true;
+  }
+  if (arg.typeID === TypeID.basic && isRadical(arg.baseID)) {
+    if (!substitutes.has(arg.baseID)) {
+      substitutes.set(arg.baseID, value);
+      return true;
+    } else {
+      const mergeType = mergeTypifications(substitutes.get(arg.baseID)!, value);
+      if (mergeType === null) {
+        return false;
+      }
+      substitutes.set(arg.baseID, mergeType);
+      return true;
+    }
+  }
+  if (value.typeID === TypeID.anyTypification) {
+    return true;
+  }
+  if (
+    arg.typeID === TypeID.integer ||
+    arg.typeID === TypeID.basic ||
+    value.typeID === TypeID.integer ||
+    value.typeID === TypeID.basic
+  ) {
+    return commonType(arg, value) !== null;
+  }
+  if (arg.typeID !== value.typeID) {
+    return false;
+  }
+  switch (arg.typeID) {
+    case TypeID.collection:
+      return compareTemplated(substitutes, arg.base, (value as EchelonCollection).base);
+    case TypeID.tuple: {
+      if (arg.factors.length !== (value as EchelonTuple).factors.length) {
+        return false;
+      }
+      for (let index = 0; index < arg.factors.length; ++index) {
+        if (!compareTemplated(substitutes, arg.factors[index], (value as EchelonTuple).factors[index])) {
+          return false;
+        }
+      }
+      return true;
+    }
+  }
+}
+
+/** Apply substitutions to typification. */
+export function substituteBase(target: Typification, substitutes: Map<string, Typification>): void {
+  switch (target.typeID) {
+    case TypeID.basic: {
+      if (substitutes.has(target.baseID)) {
+        Object.assign(target, substitutes.get(target.baseID)!);
+      }
+      return;
+    }
+    case TypeID.collection: {
+      substituteBase(target.base, substitutes);
+      return;
+    }
+    case TypeID.tuple: {
+      for (const factor of target.factors) {
+        substituteBase(factor, substitutes);
+      }
+      return;
+    }
+  }
+}
+
+/** Extract bases from typification. */
+export function extractBases(target: ExpressionType): Set<string> {
+  return new Set(extractBasesImpl(target));
+}
+
+/** Apply type path to typification. */
+export function applyPath(target: Typification, path: TypePath, index = 0): Typification | null {
+  let current: Typification | null = target;
+  let i = index;
+  while (i < path.length && current) {
+    switch (current.typeID) {
+      case TypeID.anyTypification:
+      case TypeID.integer:
+      case TypeID.basic:
+        return null;
+      case TypeID.collection:
+        current = current.base;
+        i++;
+        break;
+      case TypeID.tuple:
+        current = component(current, path[i]);
+        if (current === null) {
+          return null;
+        }
+        i++;
+        break;
+    }
+  }
+  return current;
+}
+
+// ===== Internals =====
+function commonType(type1: Typification, type2: Typification): Typification | null {
+  if (type1 === type2) {
+    return type1;
+  }
+  const int1 = 'isIntegerCompatible' in type1 && type1.isIntegerCompatible;
+  const int2 = 'isIntegerCompatible' in type2 && type2.isIntegerCompatible;
+  if (!int1 || !int2) {
+    if (type1.typeID === TypeID.basic && type2.typeID === TypeID.basic) {
+      return type1.baseID === type2.baseID ? type1 : null;
+    }
+    return null;
+  }
+  if (type1.typeID === TypeID.integer) {
+    return type2;
+  } else if (type2.typeID === TypeID.integer) {
+    return type1;
+  } else {
+    return IntegerT;
+  }
+}
+
+function extractBasesImpl(target: ExpressionType): string[] {
+  switch (target.typeID) {
+    case TypeID.basic:
+      return [target.baseID];
+    case TypeID.collection:
+      return extractBasesImpl(target.base);
+    case TypeID.tuple:
+      return target.factors.reduce((result, factor) => result.concat(extractBasesImpl(factor)), [] as string[]);
+    case TypeID.function:
+      const result = extractBasesImpl(target.result);
+      return target.args.reduce((result, arg) => result.concat(extractBasesImpl(arg.type)), result);
+    case TypeID.predicate:
+      return target.args.reduce((result, arg) => result.concat(extractBasesImpl(arg.type)), [] as string[]);
+    default:
+      return [];
+  }
+}

package/src/rslang/semantic/typification-parser.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+
+import { labelType } from '../labels';
+
+import { TypeID } from './typification';
+import { applyAsciiTypeSubstitutions, parseTypeText } from './typification-parser';
+
+describe('parseTypeText', () => {
+  it('parses simple typifications', () => {
+    expect(labelType(parseTypeText('X1').type)).toBe('X1');
+    expect(labelType(parseTypeText('ℬ(X1×X2)').type)).toBe('ℬ(X1×X2)');
+    expect(labelType(parseTypeText('Z').type)).toBe('Z');
+    expect(labelType(parseTypeText('ℬℬ(X1)').type)).toBe('ℬℬ(X1)');
+    expect(labelType(parseTypeText('ℬ(ℬ(X1))').type)).toBe('ℬℬ(X1)');
+    expect(labelType(parseTypeText('X1×ℬ(X2)').type)).toBe('X1×ℬ(X2)');
+  });
+
+  it('parses function typification with unicode and ascii arrows', () => {
+    const unicode = parseTypeText('[X1, ℬ(X2)] → X3');
+    const ascii = parseTypeText('[X1, ℬ(X2)] -> X3');
+
+    expect(unicode.error).toBeNull();
+    expect(unicode.type?.typeID).toBe(TypeID.function);
+    expect(labelType(unicode.type)).toBe('[X1, ℬ(X2)] → X3');
+
+    expect(ascii.error).toBeNull();
+    expect(ascii.type?.typeID).toBe(TypeID.function);
+    expect(labelType(ascii.type)).toBe('[X1, ℬ(X2)] → X3');
+  });
+
+  it('parses predicate typification when result is logic', () => {
+    const parsed = parseTypeText('[X1] → Logic');
+    expect(parsed.error).toBeNull();
+    expect(parsed.type?.typeID).toBe(TypeID.predicate);
+    expect(labelType(parsed.type)).toBe('[X1] → Logic');
+  });
+
+  it('rejects invalid typification strings', () => {
+    expect(parseTypeText('[X1, ] → X2').type).toBeNull();
+    expect(parseTypeText('ℬ(X1').type).toBeNull();
+    expect(parseTypeText('ℬX1').type).toBeNull();
+    expect(parseTypeText('ℬX1×X2').type).toBeNull();
+    expect(parseTypeText('').error).toBeNull();
+  });
+
+  it('applies live input substitutions', () => {
+    expect(applyAsciiTypeSubstitutions('X1*X2 -> X3')).toBe('X1×X2 → X3');
+    expect(applyAsciiTypeSubstitutions('B(X1)')).toBe('ℬ(X1)');
+  });
+});

package/src/rslang/semantic/typification-parser.ts

@@ -0,0 +1,220 @@
+import {
+  bool,
+  type ExpressionType,
+  IntegerT,
+  isTypification,
+  LogicT,
+  tuple,
+  TypeID,
+  type Typification
+} from './typification';
+
+export interface TypificationParseResult {
+  type: ExpressionType | null;
+  error: string | null;
+}
+
+export function parseTypeText(input: string): TypificationParseResult {
+  const normalized = input.trim().replaceAll('->', '→');
+  if (normalized.length === 0) {
+    return { type: null, error: null };
+  }
+  const parser = new TypificationParser(normalized);
+  return parser.parse();
+}
+
+/** ASCII substitutions while editing typification text */
+export function applyAsciiTypeSubstitutions(raw: string): string {
+  return raw.replaceAll('->', '→').replaceAll('*', '×').replaceAll('B', 'ℬ');
+}
+
+class TypificationParser {
+  private index = 0;
+  private input: string;
+
+  constructor(input: string) {
+    this.index = 0;
+    this.input = input;
+  }
+
+  parse(): TypificationParseResult {
+    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 };
+    }
+  }
+
+  private parseExpressionType(): ExpressionType {
+    this.skipSpaces();
+    if (this.peek() === '[') {
+      return this.parseCallableType();
+    } else {
+      return this.parseTypification();
+    }
+  }
+
+  private parseCallableType(): ExpressionType {
+    this.expect('[');
+    const args: Typification[] = [];
+    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('→');
+    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: result as Typification,
+      args: args.map((arg, index) => ({ alias: `a${index + 1}`, type: arg }))
+    };
+  }
+
+  private parseCallableResult(): ExpressionType {
+    this.skipSpaces();
+    const lookahead = this.readToken();
+    this.index -= lookahead.length;
+    if (lookahead === 'Logic') {
+      this.index += lookahead.length;
+      return LogicT;
+    }
+    return this.parseTypification();
+  }
+
+  private parseTypification(): Typification {
+    this.skipSpaces();
+    if (this.match('ℬ')) {
+      this.skipSpaces();
+      if (this.peek() === '(') {
+        this.next();
+        const base = this.parseTypification();
+        this.expect(')');
+        return bool(base);
+      }
+      this.skipSpaces();
+      if (this.input.startsWith('ℬ', this.index)) {
+        const base = this.parseTypification();
+        return bool(base);
+      }
+      throw new Error('Expected "(" after "ℬ"');
+    }
+    const first = this.parseTypificationAtom();
+    const factors: Typification[] = [first];
+    while (true) {
+      this.skipSpaces();
+      if (!this.match('×')) {
+        break;
+      }
+      factors.push(this.parseTypificationAtom());
+    }
+    if (factors.length === 1) {
+      return first;
+    }
+    return tuple(factors);
+  }
+
+  private parseTypificationAtom(): Typification {
+    this.skipSpaces();
+    if (this.input.startsWith('ℬ', 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 };
+  }
+
+  private readToken(): string {
+    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);
+  }
+
+  private skipSpaces(): void {
+    while (!this.eof() && /\s/.test(this.peek()!)) {
+      this.index += 1;
+    }
+  }
+
+  private expect(symbol: string): void {
+    this.skipSpaces();
+    if (!this.match(symbol)) {
+      throw new Error(`Expected "${symbol}"`);
+    }
+  }
+
+  private match(symbol: string): boolean {
+    if (this.input.startsWith(symbol, this.index)) {
+      this.index += symbol.length;
+      return true;
+    }
+    return false;
+  }
+
+  private peek(): string | undefined {
+    return this.input[this.index];
+  }
+
+  private next(): string | undefined {
+    const value = this.input[this.index];
+    this.index += 1;
+    return value;
+  }
+
+  private eof(): boolean {
+    return this.index >= this.input.length;
+  }
+}