@rsconcept/domain 1.0.0

package/src/rslang/eval/value-api.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, it } from 'vitest';
+
+import { TypeID } from '../index';
+import { basic, IntegerT, LogicT, tuple as makeTuple } from '../semantic/typification';
+
+import { TUPLE_ID, type Value, VALUE_FALSE, VALUE_TRUE } from './value';
+import { normalizeValue, validateValue } from './value-api';
+
+describe('validateValue', () => {
+  const basics = new Map([
+    ['X1', [1, 2, 3]],
+    ['X2', [7, 8, 42]]
+  ]);
+
+  it('validates integers', () => {
+    expect(validateValue(42, IntegerT, basics)).toBe(true);
+    expect(validateValue([], IntegerT, basics)).toBe(false);
+    expect(validateValue([1, 2, 3], IntegerT, basics)).toBe(false);
+    expect(validateValue([1, [], 3], IntegerT, basics)).toBe(false);
+  });
+
+  it('validates logic values', () => {
+    expect(validateValue(VALUE_TRUE, LogicT, basics)).toBe(true);
+    expect(validateValue(VALUE_FALSE, LogicT, basics)).toBe(true);
+    expect(validateValue(2, LogicT, basics)).toBe(false);
+    expect(validateValue([], LogicT, basics)).toBe(false);
+    expect(validateValue([1, [], 3], LogicT, basics)).toBe(false);
+  });
+
+  it('validates basic types', () => {
+    const basicType = basic('X1');
+    expect(validateValue(1, basicType, basics)).toBe(true);
+    expect(validateValue(2, basicType, basics)).toBe(true);
+    expect(validateValue(42, basicType, basics)).toBe(false);
+    expect(validateValue(7, basicType, basics)).toBe(false);
+    expect(validateValue([1], basicType, basics)).toBe(false);
+    const missingType = { typeID: TypeID.basic, baseID: 'NOT_PRESENT' };
+    expect(validateValue(1, missingType, basics)).toBe(false);
+  });
+
+  it('validates tuple values', () => {
+    const tupleType = makeTuple([IntegerT, basic('X1')]);
+    // valid tuple
+    expect(validateValue([TUPLE_ID, 7, 1], tupleType, basics)).toBe(true);
+    // Wrong length
+    expect(validateValue([TUPLE_ID, 11], tupleType, basics)).toBe(false);
+    // Wrong ID in first element
+    expect(validateValue([0, 11, 1], tupleType, basics)).toBe(false);
+    // First component invalid
+    expect(validateValue([TUPLE_ID, [], 1], tupleType, basics)).toBe(false);
+    // Second component invalid
+    expect(validateValue([TUPLE_ID, 11, 999], tupleType, basics)).toBe(false);
+  });
+
+  it('validates collections', () => {
+    const collectionType = {
+      typeID: TypeID.collection,
+      base: basic('X1')
+    };
+    // All valid elements
+    expect(validateValue([1, 2, 3], collectionType, basics)).toBe(true);
+    // Some invalid
+    expect(validateValue([1, 99], collectionType, basics)).toBe(false);
+    // Not an array
+    expect(validateValue(1, collectionType, basics)).toBe(false);
+    // Array of tuples (should not have TUPLE_ID at first position)
+    expect(validateValue([TUPLE_ID, 1, 2], collectionType, basics)).toBe(false);
+  });
+
+  it('returns false for unsupported types', () => {
+    expect(validateValue(1, { typeID: TypeID.anyTypification }, basics)).toBe(false);
+    expect(validateValue(1, { typeID: TypeID.predicate, result: LogicT, args: [] }, basics)).toBe(false);
+    expect(validateValue(1, { typeID: TypeID.function, result: basic('X1'), args: [] }, basics)).toBe(false);
+  });
+
+  it('normalizes data values correctly', () => {
+    const arr = [3, 1, 2, 2, 3, 4];
+    normalizeValue(arr);
+    expect(arr).toEqual([1, 2, 3, 4]);
+
+    const arr2: Value = [
+      [TUPLE_ID, 3, 1],
+      [TUPLE_ID, 1, 2],
+      [TUPLE_ID, 1, 2], // duplicate tuple
+      [TUPLE_ID, 2, 3]
+    ];
+    normalizeValue(arr2);
+    expect(arr2.length).toBe(3);
+    expect(arr2[0]).toEqual([TUPLE_ID, 1, 2]);
+    expect(arr2[1]).toEqual([TUPLE_ID, 2, 3]);
+    expect(arr2[2]).toEqual([TUPLE_ID, 3, 1]);
+
+    const num = 42;
+    normalizeValue(num);
+    expect(num).toBe(42);
+
+    const empty: Value[] = [];
+    normalizeValue(empty);
+    expect(empty).toEqual([]);
+
+    const val: Value = [TUPLE_ID, [3, 2, 1, 1], 1];
+    normalizeValue(val);
+    expect(val[1]).toEqual([1, 2, 3]);
+  });
+});

package/src/rslang/eval/value-api.ts

@@ -0,0 +1,444 @@
+import { generateStub } from '../../shared';
+import { type ExpressionType, TypeID, type TypePath, type Typification } from '../semantic/typification';
+
+import {
+  BOOL_INFINITY,
+  compare,
+  EmptySetV,
+  INVALID_ELEMENT,
+  makeValuePath,
+  set,
+  SET_INFINITY,
+  tuple,
+  TUPLE_ID,
+  type Value,
+  VALUE_FALSE,
+  VALUE_TRUE,
+  type ValueContext,
+  type ValuePath
+} from './value';
+
+/** Cartesian product of factor sets. */
+export function cartesianProduct(factors: Value[][]): Value[] | null {
+  const cardinality = factors.reduce((acc, f) => acc * f.length, 1);
+  if (cardinality > SET_INFINITY) {
+    return null;
+  }
+  if (cardinality === 0 || factors.length === 0) {
+    return EmptySetV;
+  }
+
+  let accumulator: Value[][] = [[]];
+  for (const factor of factors) {
+    const next: Value[][] = [];
+    for (const prefix of accumulator) {
+      for (const value of factor) {
+        next.push([...prefix, value]);
+      }
+    }
+    accumulator = next;
+  }
+  return accumulator.map(tuple);
+}
+
+/** Boolean power set ℬ(X). No cache - materialized. */
+export function boolean(base: Value[]): Value[] | null {
+  if (base.length > BOOL_INFINITY) {
+    return null;
+  }
+  return powerset(base);
+}
+
+/** Powerset of array. */
+function powerset(arr: readonly Value[]): Value[][] {
+  const result: Value[][] = [[]];
+  if (arr.length === 0) {
+    return result;
+  }
+
+  let current: Value[][] = [[]];
+  let maxIndex: number[] = [-1];
+  while (current.length > 0) {
+    const next: Value[][] = [];
+    const nextMaxIndex: number[] = [];
+    for (let i = 0; i < current.length; i++) {
+      for (let j = maxIndex[i] + 1; j < arr.length; j++) {
+        const subset = [...current[i], arr[j]];
+        result.push(subset);
+        if (j < arr.length - 1) {
+          next.push(subset);
+          nextMaxIndex.push(j);
+        }
+      }
+    }
+    current = next;
+    maxIndex = nextMaxIndex;
+  }
+  return result;
+}
+
+/** Check if set contains element. */
+export function contains(setData: Value[], element: Value): boolean {
+  let left = 0;
+  let right = setData.length - 1;
+  while (left <= right) {
+    const mid = Math.floor((left + right) / 2);
+    const cmp = compare(setData[mid], element);
+    if (cmp === 0) {
+      return true;
+    } else if (cmp < 0) {
+      left = mid + 1;
+    } else {
+      right = mid - 1;
+    }
+  }
+  return false;
+}
+
+/** Is A ⊆ B. */
+export function isSubsetOrEq(a: Value[], b: Value[]): boolean {
+  let i = 0,
+    j = 0;
+  while (i < a.length && j < b.length) {
+    const cmp = compare(a[i], b[j]);
+    if (cmp === 0) {
+      i++;
+      j++;
+    } else if (cmp > 0) {
+      j++;
+    } else {
+      return false;
+    }
+  }
+  return i === a.length;
+}
+
+/** Reduce: flatten double boolean to single boolean. */
+export function reduce(target: Value[][]): Value[] {
+  const result: Value[] = [];
+  for (const element of target) {
+    result.push(...element);
+  }
+  return set(result);
+}
+
+/** Union A ∪ B. */
+export function setUnion(set1: Value[], set2: Value[]): Value[] {
+  const result: Value[] = [];
+  let i = 0,
+    j = 0;
+  while (i < set1.length && j < set2.length) {
+    const cmp = compare(set1[i], set2[j]);
+    if (cmp < 0) {
+      result.push(set1[i]);
+      i++;
+    } else if (cmp > 0) {
+      result.push(set2[j]);
+      j++;
+    } else {
+      result.push(set1[i]);
+      i++;
+      j++;
+    }
+  }
+  while (i < set1.length) {
+    result.push(set1[i]);
+    i++;
+  }
+  while (j < set2.length) {
+    result.push(set2[j]);
+    j++;
+  }
+  return result;
+}
+
+/** Intersection A ∩ B. */
+export function setIntersection(set1: Value[], set2: Value[]): Value[] {
+  const result: Value[] = [];
+  for (let i = 0, j = 0; i < set1.length && j < set2.length; ) {
+    const cmp = compare(set1[i], set2[j]);
+    if (cmp < 0) {
+      i++;
+    } else if (cmp > 0) {
+      j++;
+    } else {
+      result.push(set1[i]);
+      i++;
+      j++;
+    }
+  }
+  return result;
+}
+
+/** Difference A \ B. */
+export function setDiff(set1: Value[], set2: Value[]): Value[] {
+  const result: Value[] = [];
+  let i = 0,
+    j = 0;
+  while (i < set1.length && j < set2.length) {
+    const cmp = compare(set1[i], set2[j]);
+    if (cmp < 0) {
+      result.push(set1[i]);
+      i++;
+    } else if (cmp > 0) {
+      j++;
+    } else {
+      i++;
+      j++;
+    }
+  }
+  while (i < set1.length) {
+    result.push(set1[i]);
+    i++;
+  }
+  return result;
+}
+
+/** Symmetric difference A ∆ B. */
+export function setSymDiff(set1: Value[], set2: Value[]): Value[] {
+  const result: Value[] = [];
+  let i = 0,
+    j = 0;
+  while (i < set1.length && j < set2.length) {
+    const cmp = compare(set1[i], set2[j]);
+    if (cmp < 0) {
+      result.push(set1[i]);
+      i++;
+    } else if (cmp > 0) {
+      result.push(set2[j]);
+      j++;
+    } else {
+      i++;
+      j++;
+    }
+  }
+  while (i < set1.length) {
+    result.push(set1[i]);
+    i++;
+  }
+  while (j < set2.length) {
+    result.push(set2[j]);
+    j++;
+  }
+  return result;
+}
+
+/** Projection of set by indices (BigPr). */
+export function projection(target: Value[][], indices: number[]): Value[] {
+  const projectedElements: Value[] = target.map(element => {
+    const newComponents = indices.map(idx => element[idx]);
+    return indices.length === 1 ? newComponents[0] : tuple(newComponents);
+  });
+  return set(projectedElements);
+}
+
+/** Condensed string representation. */
+export function printValue(data: Value | null): string {
+  if (!Array.isArray(data)) {
+    return String(data);
+  }
+  const len = data.length;
+  if (data.length === 0) {
+    return '{}';
+  }
+
+  const isTuple = data[0] === TUPLE_ID;
+  const start = isTuple ? 1 : 0;
+
+  let result = isTuple ? '(' : '{';
+  for (let i = start; i < len; i++) {
+    if (i > start) result += ', ';
+    result += printValue(data[i]);
+  }
+  result += isTuple ? ')' : '}';
+  return result;
+}
+
+/** Generates stub ID for value. */
+export function valueStub(value: Value | null): string {
+  if (value == null) {
+    return '';
+  }
+  const str = printValue(value);
+  return generateStub(str);
+}
+
+/** Checks if value is a set representation, not a tuple representation. */
+export function isSetValue(data: Value | null): data is Value[] {
+  return Array.isArray(data) && (data.length === 0 || data[0] !== TUPLE_ID);
+}
+
+/** Checks if value is a tuple representation. */
+export function isTupleValue(data: Value | null): data is Value[] {
+  return Array.isArray(data) && data.length > 1 && data[0] === TUPLE_ID;
+}
+
+/** Normalize unsorted array of values. */
+export function normalizeValue(data: Value): void {
+  if (!Array.isArray(data) || data.length === 0) {
+    return;
+  }
+
+  if (data[0] === TUPLE_ID) {
+    for (let i = 1; i < data.length; i++) {
+      normalizeValue(data[i]);
+    }
+    return;
+  }
+
+  for (const item of data) {
+    normalizeValue(item);
+  }
+
+  data.sort((a, b) => compare(a, b));
+  let i = 1;
+  while (i < data.length) {
+    if (compare(data[i - 1], data[i]) === 0) {
+      data.splice(i, 1);
+    } else {
+      i++;
+    }
+  }
+}
+
+/** Validates value for {@link ExpressionType} and value of basic sets. */
+export function validateValue(value: Value, type: ExpressionType, basics: ValueContext): boolean {
+  switch (type.typeID) {
+    case TypeID.integer:
+      return typeof value === 'number';
+    case TypeID.logic: {
+      if (typeof value !== 'number') {
+        return false;
+      }
+      return value === VALUE_TRUE || value === VALUE_FALSE;
+    }
+    case TypeID.basic: {
+      if (typeof value !== 'number') {
+        return false;
+      }
+      const domain = basics.get(type.baseID);
+      return !!domain && Array.isArray(domain) && domain.includes(value);
+    }
+
+    case TypeID.tuple: {
+      if (!Array.isArray(value) || value.length !== type.factors.length + 1 || value[0] !== TUPLE_ID) {
+        return false;
+      }
+      for (let i = 0; i < type.factors.length; i++) {
+        if (!validateValue(value[i + 1], type.factors[i], basics)) {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    case TypeID.collection: {
+      if (!isSetValue(value)) {
+        return false;
+      }
+      for (const item of value) {
+        if (!validateValue(item, type.base, basics)) {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    case TypeID.anyTypification:
+    case TypeID.predicate:
+    case TypeID.function:
+      return false;
+  }
+}
+
+/** Converts value path to type path. */
+export function convertPathToType(path: ValuePath, type: Typification): TypePath | null {
+  const result: number[] = [];
+  if (path.length === 0) {
+    return result as TypePath;
+  }
+
+  let curType = type;
+  let index = 0;
+  while (index < path.length) {
+    switch (curType.typeID) {
+      case TypeID.collection: {
+        result.push(0);
+        curType = curType.base;
+        index++;
+        break;
+      }
+      case TypeID.tuple: {
+        const tupleIdx = path[index];
+        if (typeof tupleIdx !== 'number' || tupleIdx < 1 || tupleIdx > curType.factors.length) {
+          return null;
+        }
+        result.push(tupleIdx);
+        curType = curType.factors[tupleIdx - 1];
+        index++;
+        break;
+      }
+      case TypeID.basic:
+      case TypeID.integer:
+      case TypeID.anyTypification:
+        return null;
+    }
+  }
+  return result as TypePath;
+}
+
+/** Extracts value from a target by path. */
+export function extractValue(target: Value, path: ValuePath): Value | null {
+  let current: Value = target;
+  let i = 0;
+  while (i < path.length) {
+    if (!Array.isArray(current) || current.length <= path[i]) {
+      return null;
+    }
+    current = current[path[i]];
+    i++;
+  }
+  return current;
+}
+
+/** Makes default value for a type. */
+export function makeDefaultValue(type: Typification): Value {
+  switch (type.typeID) {
+    case TypeID.anyTypification:
+    case TypeID.integer:
+    case TypeID.basic:
+      return INVALID_ELEMENT;
+    case TypeID.collection:
+      return [];
+    case TypeID.tuple:
+      return tuple(type.factors.map(item => makeDefaultValue(item)));
+  }
+}
+
+/** Perform immutable deep copy update. */
+export function setNestedValue(target: Value | null, path: ValuePath, newVal: Value): Value {
+  if (path.length === 0) {
+    return newVal;
+  }
+  const [head, ...rest] = path;
+  const arr = Array.isArray(target) ? [...target] : [];
+  arr[head] = setNestedValue(arr[head], makeValuePath(rest), newVal);
+  return arr;
+}
+
+/** Test if value contains invalid elements. */
+export function testInvalid(value: Value): boolean {
+  const stack = [value];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === INVALID_ELEMENT) {
+      return true;
+    }
+    if (Array.isArray(current)) {
+      for (const element of current) {
+        stack.push(element);
+      }
+    }
+  }
+  return false;
+}

package/src/rslang/eval/value.ts

@@ -0,0 +1,102 @@
+/**
+ * Module: Structured data for RSLang expression evaluation.
+ */
+
+import { type Branded } from '../../shared';
+
+import { printValue } from './value-api';
+
+/** Tuple ID for array distinction. */
+export const TUPLE_ID = -111;
+
+/** Invalid value for structured data. */
+export const INVALID_ELEMENT = -1;
+
+/** Boolean values: true. */
+export const VALUE_TRUE = 1;
+
+/** Boolean values: false. */
+export const VALUE_FALSE = 0;
+
+/** Cardinality threshold for "infinite" sets (e.g. Z). */
+export const SET_INFINITY = 10_000_000;
+
+/** Cardinality threshold for Boolean power set. */
+export const BOOL_INFINITY = 18;
+
+/** Expression evaluation result: structured data. */
+export type Value = number | Value[];
+
+/** Values context. */
+export type ValueContext = Map<string, Value>;
+
+/** Value extraction path. */
+export type ValuePath = Branded<number[], 'ValuePath'>;
+
+/** Creates value path. */
+export function makeValuePath(path: number[]): ValuePath {
+  return path as ValuePath;
+}
+
+/** Empty set ∅. */
+export const EmptySetV = [];
+
+/** Compare two structured data without recursive calls. */
+export function compare(v1: Value, v2: Value): number {
+  const stack1: Value[] = [v1];
+  const stack2: Value[] = [v2];
+
+  while (stack1.length > 0 && stack2.length > 0) {
+    const el1 = stack1.pop();
+    const el2 = stack2.pop();
+    if (el1 === el2) {
+      continue;
+    }
+
+    const type1 = typeof el1;
+    const type2 = typeof el2;
+    if (type1 === 'number' && type2 === 'number') {
+      const numDiff = (el1 as number) - (el2 as number);
+      if (numDiff !== 0) return numDiff;
+      continue;
+    }
+
+    const isArray1 = Array.isArray(el1);
+    const isArray2 = Array.isArray(el2);
+    if (!isArray1 || !isArray2) {
+      throw new Error(`Cannot compare different types ${printValue(el1!)} and ${printValue(el2!)}`);
+    }
+
+    const arr1 = el1;
+    const arr2 = el2;
+    const len1 = arr1.length;
+    const len2 = arr2.length;
+    if (len1 !== len2) {
+      return len1 - len2;
+    }
+
+    for (let i = len1 - 1; i >= 0; i--) {
+      stack1.push(arr1[i]);
+      stack2.push(arr2[i]);
+    }
+  }
+  return 0;
+}
+
+/** Tuple from components. */
+export function tuple(components: Value[]): Value {
+  return [TUPLE_ID, ...components];
+}
+
+/** Set from elements (unique). Value[] - materialized. */
+export function set(elements: Value[]): Value[] {
+  const sorted = [...elements].sort(compare);
+  for (let i = 1; i < sorted.length; ) {
+    if (compare(sorted[i - 1], sorted[i]) === 0) {
+      sorted.splice(i, 1);
+    } else {
+      i++;
+    }
+  }
+  return sorted;
+}

package/src/rslang/index.ts

@@ -0,0 +1,23 @@
+export { readErrorAnnotation, readTypeAnnotation } from './ast-annotations';
+export { RSErrorCode, type RSErrorDescription } from './error';
+export { type CalculatorEvaluateOptions, type CalculatorResult, RSCalculator } from './eval/calculator';
+export { makeValuePath, type Value, type ValuePath } from './eval/value';
+export { printValue } from './eval/value-api';
+export { parser as rslangParser } from './parser/parser';
+export { TokenID } from './parser/token';
+export { type AnalysisBase, type AnalysisFast, type AnalysisFull, RSLangAnalyzer } from './semantic/analyzer';
+export { type ArgumentsType } from './semantic/arguments-extractor';
+export {
+  AnyTypificationT,
+  EmptySetT,
+  type ExpressionType,
+  LogicT,
+  makeTypePath,
+  TypeClass,
+  TypeID,
+  type TypePath,
+  type Typification
+} from './semantic/typification';
+export { applyAsciiTypeSubstitutions, parseTypeText } from './semantic/typification-parser';
+export { ValueClass } from './semantic/value-class';
+export { TypificationGraph, type TypificationNodeData } from './typification-graph';