@cortex-js/compute-engine 0.27.0 → 0.28.0

package/dist/math-json.min.esm.js

@@ -1,4 +1,275 @@
-/** Compute Engine 0.27.0 */
+/** Compute Engine 0.28.0 */
+
+// src/common/json5.ts
+var JSON5 = class {
+  static parse(input) {
+    const parser = new JSON5Parser(input);
+    const value = parser.parseValue();
+    parser.skipWhitespace();
+    if (!parser.isAtEnd()) {
+      throw parser.error(
+        `Unexpected token '${parser.currentChar()}' after parsing complete value`
+      );
+    }
+    return value;
+  }
+};
+var JSON5Parser = class {
+  constructor(input) {
+    this.index = 0;
+    this.text = input;
+  }
+  parseValue() {
+    this.skipWhitespace();
+    if (this.isAtEnd()) {
+      throw this.error("Unexpected end of input");
+    }
+    const ch = this.currentChar();
+    if (ch === "{") return this.parseObject();
+    if (ch === "[") return this.parseArray();
+    if (ch === '"' || ch === "'") return this.parseString();
+    if (ch === "-" || ch === "+" || ch >= "0" && ch <= "9" || ch === ".")
+      return this.parseNumber();
+    return this.parseIdentifier();
+  }
+  parseObject() {
+    const obj = {};
+    this.expectChar("{");
+    this.skipWhitespace();
+    if (this.currentChar() === "}") {
+      this.index++;
+      return obj;
+    }
+    while (true) {
+      this.skipWhitespace();
+      let key;
+      const ch = this.currentChar();
+      if (ch === '"' || ch === "'") {
+        key = this.parseString();
+      } else {
+        key = this.parseIdentifier();
+      }
+      this.skipWhitespace();
+      this.expectChar(":");
+      this.skipWhitespace();
+      const value = this.parseValue();
+      obj[key] = value;
+      this.skipWhitespace();
+      if (this.currentChar() === ",") {
+        this.index++;
+        this.skipWhitespace();
+        if (this.currentChar() === "}") {
+          this.index++;
+          break;
+        }
+      } else if (this.currentChar() === "}") {
+        this.index++;
+        break;
+      } else {
+        throw this.error(
+          `Expected ',' or '}' in object but found '${this.currentChar()}'`
+        );
+      }
+    }
+    return obj;
+  }
+  parseArray() {
+    const arr = [];
+    this.expectChar("[");
+    this.skipWhitespace();
+    if (this.currentChar() === "]") {
+      this.index++;
+      return arr;
+    }
+    while (true) {
+      this.skipWhitespace();
+      arr.push(this.parseValue());
+      this.skipWhitespace();
+      if (this.currentChar() === ",") {
+        this.index++;
+        this.skipWhitespace();
+        if (this.currentChar() === "]") {
+          this.index++;
+          break;
+        }
+      } else if (this.currentChar() === "]") {
+        this.index++;
+        break;
+      } else {
+        throw this.error(
+          `Expected ',' or ']' in array but found '${this.currentChar()}'`
+        );
+      }
+    }
+    return arr;
+  }
+  parseString() {
+    const quote = this.currentChar();
+    if (quote !== '"' && quote !== "'") {
+      throw this.error(`String should start with a quote, got '${quote}'`);
+    }
+    this.index++;
+    let result = "";
+    while (!this.isAtEnd()) {
+      const ch = this.currentChar();
+      if (ch === quote) {
+        this.index++;
+        return result;
+      }
+      if (ch === "\\") {
+        this.index++;
+        if (this.isAtEnd()) {
+          throw this.error("Unterminated escape sequence in string");
+        }
+        const esc = this.currentChar();
+        switch (esc) {
+          case "b":
+            result += "\b";
+            break;
+          case "f":
+            result += "\f";
+            break;
+          case "n":
+            result += "\n";
+            break;
+          case "r":
+            result += "\r";
+            break;
+          case "t":
+            result += "	";
+            break;
+          case "v":
+            result += "\v";
+            break;
+          case "\\":
+            result += "\\";
+            break;
+          case "'":
+            result += "'";
+            break;
+          case '"':
+            result += '"';
+            break;
+          case "0":
+            result += "\0";
+            break;
+          case "u": {
+            this.index++;
+            const hex = this.text.substr(this.index, 4);
+            if (!/^[0-9a-fA-F]{4}$/.test(hex)) {
+              throw this.error(`Invalid Unicode escape sequence: \\u${hex}`);
+            }
+            result += String.fromCharCode(parseInt(hex, 16));
+            this.index += 3;
+            break;
+          }
+          default:
+            result += esc;
+        }
+        this.index++;
+      } else {
+        result += ch;
+        this.index++;
+      }
+    }
+    throw this.error("Unterminated string literal");
+  }
+  parseNumber() {
+    const start = this.index;
+    if (this.text.startsWith("-Infinity", this.index)) {
+      this.index += "-Infinity".length;
+      return -Infinity;
+    }
+    if (this.text.startsWith("+Infinity", this.index)) {
+      this.index += "+Infinity".length;
+      return Infinity;
+    }
+    if (this.text.startsWith("Infinity", this.index)) {
+      this.index += "Infinity".length;
+      return Infinity;
+    }
+    while (!this.isAtEnd() && /[0-9+\-_.eE]/.test(this.currentChar())) {
+      this.index++;
+    }
+    const token = this.text.slice(start, this.index);
+    const normalized = token.replace(/_/g, "");
+    const num = Number(normalized);
+    if (isNaN(num)) {
+      throw this.error(`Invalid number: ${token}`);
+    }
+    return num;
+  }
+  parseIdentifier() {
+    const start = this.index;
+    const firstChar = this.currentChar();
+    if (!/[a-zA-Z$_]/.test(firstChar)) {
+      throw this.error(`Unexpected token '${firstChar}'`);
+    }
+    this.index++;
+    while (!this.isAtEnd()) {
+      const ch = this.currentChar();
+      if (!/[a-zA-Z0-9$_]/.test(ch)) break;
+      this.index++;
+    }
+    const token = this.text.slice(start, this.index);
+    if (token === "true") return true;
+    if (token === "false") return false;
+    if (token === "null") return null;
+    if (token === "Infinity") return Infinity;
+    if (token === "NaN") return NaN;
+    return token;
+  }
+  skipWhitespace() {
+    while (!this.isAtEnd()) {
+      const ch = this.currentChar();
+      if (/\s/.test(ch)) {
+        this.index++;
+        continue;
+      }
+      if (ch === "/") {
+        const next = this.peekChar(1);
+        if (next === "/") {
+          this.index += 2;
+          while (!this.isAtEnd() && this.currentChar() !== "\n") {
+            this.index++;
+          }
+          continue;
+        } else if (next === "*") {
+          this.index += 2;
+          while (!this.isAtEnd() && !(this.currentChar() === "*" && this.peekChar(1) === "/")) {
+            this.index++;
+          }
+          if (this.isAtEnd()) {
+            throw this.error("Unterminated multi-line comment");
+          }
+          this.index += 2;
+          continue;
+        }
+      }
+      break;
+    }
+  }
+  expectChar(expected) {
+    if (this.currentChar() !== expected) {
+      throw this.error(
+        `Expected '${expected}' but found '${this.currentChar()}'`
+      );
+    }
+    this.index++;
+  }
+  currentChar() {
+    return this.text[this.index];
+  }
+  peekChar(offset) {
+    return this.text[this.index + offset];
+  }
+  isAtEnd() {
+    return this.index >= this.text.length;
+  }
+  error(message) {
+    return new Error(`${message} at position ${this.index}`);
+  }
+};
 
 // src/math-json/utils.ts
 function isSymbolObject(expr) {
@@ -62,12 +333,21 @@ function keyValuePair(expr) {
   }
   return null;
 }
-function dictionary(expr) {
+function dictionaryFromExpression(expr) {
   if (expr === null) return null;
+  if (typeof expr === "object" && !("sym" in expr) && !("num" in expr) && !("str" in expr) && !("fn" in expr)) {
+    return expr;
+  }
+  if (typeof expr === "string" && expr[0] === "{" && expr[expr.length - 1] === "}") {
+    try {
+      return JSON5.parse(expr);
+    } catch {
+      return null;
+    }
+  }
   const kv = keyValuePair(expr);
   if (kv) return { [kv[0]]: kv[1] };
-  const h = operator(expr);
-  if (h === "Dictionary") {
+  if (operator(expr) === "Dictionary") {
     const result = {};
     const ops = operands(expr);
     for (let i = 1; i < nops(expr); i++) {
@@ -93,16 +373,16 @@ function mapArgs(expr, fn) {
 }
 
 // src/math-json.ts
-var version = "0.27.0";
+var version = "0.28.0";
 export {
-  dictionary as getDictionary,
-  stringValue as getStringValue,
+  dictionaryFromExpression,
   isFunctionObject,
   isStringObject,
   isSymbolObject,
   mapArgs,
   operand,
   operator,
+  stringValue,
   symbol,
   version
 };

package/dist/math-json.min.js

@@ -1,4 +1,6 @@
-/** MathJSON 0.27.0 */
+/** MathJSON 0.28.0 */
     (function(global,factory){typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'],factory):(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.MathJson = {}));})(this, (function (exports) { 'use strict';
-var MathJson=(()=>{var f=Object.defineProperty;var M=Object.getOwnPropertyDescriptor;var S=Object.getOwnPropertyNames;var N=Object.prototype.hasOwnProperty;var A=(n,t)=>{for(var e in t)f(n,e,{get:t[e],enumerable:!0})},p=(n,t,e,r)=>{if(t&&typeof t=="object"||typeof t=="function")for(let i of S(t))!N.call(n,i)&&i!==e&&f(n,i,{get:()=>t[i],enumerable:!(r=M(t,i))||r.enumerable});return n};var J=n=>p(f({},"__esModule",{value:!0}),n);var O={};A(O,{getDictionary:()=>g,getStringValue:()=>c,isFunctionObject:()=>u,isStringObject:()=>y,isSymbolObject:()=>a,mapArgs:()=>h,operand:()=>E,operator:()=>o,symbol:()=>b,version:()=>I});function a(n){return n!==null&&typeof n=="object"&&"sym"in n}function y(n){return n!==null&&typeof n=="object"&&"str"in n}function u(n){return n!==null&&typeof n=="object"&&"fn"in n}function c(n){return n==null?null:typeof n=="object"&&"str"in n?n.str:typeof n!="string"||n.length<2||n.at(0)!=="'"||n.at(-1)!=="'"?null:n.substring(1,n.length-1)}function o(n){return Array.isArray(n)?n[0]:n==null?"":u(n)?n.fn[0]:""}function m(n){return Array.isArray(n)?n.slice(1):n!==void 0&&u(n)?n.fn.slice(1):[]}function E(n,t){return Array.isArray(n)?n[t]??null:n===null||!u(n)?null:n.fn[t]??null}function j(n){return n==null?0:Array.isArray(n)?Math.max(0,n.length-1):u(n)?Math.max(0,n.fn.length-1):0}function b(n){if(typeof n=="string")return/^[+-]?[0-9\.]/.test(n)||n.length>=2&&n[0]==="'"&&n[n.length-1]==="'"?null:n;if(n==null)return null;let t=a(n)?n.sym:n;return typeof t!="string"?null:t}function d(n){let t=o(n);if(t==="KeyValuePair"||t==="Tuple"||t==="Pair"){let[e,r]=m(n),i=c(e);return i?[i,r??"Nothing"]:null}return null}function g(n){if(n===null)return null;let t=d(n);if(t)return{[t[0]]:t[1]};if(o(n)==="Dictionary"){let r={},i=m(n);for(let l=1;l<j(n);l++){let s=d(i[l]);s&&(r[s[0]]=s[1])}return r}return null}function h(n,t){let e=null;if(Array.isArray(n)&&(e=n),u(n)&&(e=n.fn),e===null)return[];let r=1,i=[];for(;r<e.length;)i.push(t(e[r])),r+=1;return i}var I="0.27.0";return J(O);})();
+var MathJson=(()=>{var a=Object.defineProperty;var k=Object.getOwnPropertyDescriptor;var C=Object.getOwnPropertyNames;var x=Object.prototype.hasOwnProperty;var A=(n,t)=>{for(var i in t)a(n,i,{get:t[i],enumerable:!0})},w=(n,t,i,e)=>{if(t&&typeof t=="object"||typeof t=="function")for(let r of C(t))!x.call(n,r)&&r!==i&&a(n,r,{get:()=>t[r],enumerable:!(e=k(t,r))||e.enumerable});return n};var I=n=>w(a({},"__esModule",{value:!0}),n);var S={};A(S,{dictionaryFromExpression:()=>g,isFunctionObject:()=>u,isStringObject:()=>y,isSymbolObject:()=>f,mapArgs:()=>E,operand:()=>b,operator:()=>l,stringValue:()=>c,symbol:()=>m,version:()=>v});var o=class{static parse(t){let i=new h(t),e=i.parseValue();if(i.skipWhitespace(),!i.isAtEnd())throw i.error(`Unexpected token '${i.currentChar()}' after parsing complete value`);return e}},h=class{constructor(t){this.index=0;this.text=t}parseValue(){if(this.skipWhitespace(),this.isAtEnd())throw this.error("Unexpected end of input");let t=this.currentChar();return t==="{"?this.parseObject():t==="["?this.parseArray():t==='"'||t==="'"?this.parseString():t==="-"||t==="+"||t>="0"&&t<="9"||t==="."?this.parseNumber():this.parseIdentifier()}parseObject(){let t={};if(this.expectChar("{"),this.skipWhitespace(),this.currentChar()==="}")return this.index++,t;for(;;){this.skipWhitespace();let i,e=this.currentChar();e==='"'||e==="'"?i=this.parseString():i=this.parseIdentifier(),this.skipWhitespace(),this.expectChar(":"),this.skipWhitespace();let r=this.parseValue();if(t[i]=r,this.skipWhitespace(),this.currentChar()===","){if(this.index++,this.skipWhitespace(),this.currentChar()==="}"){this.index++;break}}else if(this.currentChar()==="}"){this.index++;break}else throw this.error(`Expected ',' or '}' in object but found '${this.currentChar()}'`)}return t}parseArray(){let t=[];if(this.expectChar("["),this.skipWhitespace(),this.currentChar()==="]")return this.index++,t;for(;;)if(this.skipWhitespace(),t.push(this.parseValue()),this.skipWhitespace(),this.currentChar()===","){if(this.index++,this.skipWhitespace(),this.currentChar()==="]"){this.index++;break}}else if(this.currentChar()==="]"){this.index++;break}else throw this.error(`Expected ',' or ']' in array but found '${this.currentChar()}'`);return t}parseString(){let t=this.currentChar();if(t!=='"'&&t!=="'")throw this.error(`String should start with a quote, got '${t}'`);this.index++;let i="";for(;!this.isAtEnd();){let e=this.currentChar();if(e===t)return this.index++,i;if(e==="\\"){if(this.index++,this.isAtEnd())throw this.error("Unterminated escape sequence in string");let r=this.currentChar();switch(r){case"b":i+="\b";break;case"f":i+="\f";break;case"n":i+=`
+`;break;case"r":i+="\r";break;case"t":i+="	";break;case"v":i+="\v";break;case"\\":i+="\\";break;case"'":i+="'";break;case'"':i+='"';break;case"0":i+="\0";break;case"u":{this.index++;let s=this.text.substr(this.index,4);if(!/^[0-9a-fA-F]{4}$/.test(s))throw this.error(`Invalid Unicode escape sequence: \\u${s}`);i+=String.fromCharCode(parseInt(s,16)),this.index+=3;break}default:i+=r}this.index++}else i+=e,this.index++}throw this.error("Unterminated string literal")}parseNumber(){let t=this.index;if(this.text.startsWith("-Infinity",this.index))return this.index+=9,-1/0;if(this.text.startsWith("+Infinity",this.index))return this.index+=9,1/0;if(this.text.startsWith("Infinity",this.index))return this.index+=8,1/0;for(;!this.isAtEnd()&&/[0-9+\-_.eE]/.test(this.currentChar());)this.index++;let i=this.text.slice(t,this.index),e=i.replace(/_/g,""),r=Number(e);if(isNaN(r))throw this.error(`Invalid number: ${i}`);return r}parseIdentifier(){let t=this.index,i=this.currentChar();if(!/[a-zA-Z$_]/.test(i))throw this.error(`Unexpected token '${i}'`);for(this.index++;!this.isAtEnd();){let r=this.currentChar();if(!/[a-zA-Z0-9$_]/.test(r))break;this.index++}let e=this.text.slice(t,this.index);return e==="true"?!0:e==="false"?!1:e==="null"?null:e==="Infinity"?1/0:e==="NaN"?NaN:e}skipWhitespace(){for(;!this.isAtEnd();){let t=this.currentChar();if(/\s/.test(t)){this.index++;continue}if(t==="/"){let i=this.peekChar(1);if(i==="/"){for(this.index+=2;!this.isAtEnd()&&this.currentChar()!==`
+`;)this.index++;continue}else if(i==="*"){for(this.index+=2;!this.isAtEnd()&&!(this.currentChar()==="*"&&this.peekChar(1)==="/");)this.index++;if(this.isAtEnd())throw this.error("Unterminated multi-line comment");this.index+=2;continue}}break}}expectChar(t){if(this.currentChar()!==t)throw this.error(`Expected '${t}' but found '${this.currentChar()}'`);this.index++}currentChar(){return this.text[this.index]}peekChar(t){return this.text[this.index+t]}isAtEnd(){return this.index>=this.text.length}error(t){return new Error(`${t} at position ${this.index}`)}};function f(n){return n!==null&&typeof n=="object"&&"sym"in n}function y(n){return n!==null&&typeof n=="object"&&"str"in n}function u(n){return n!==null&&typeof n=="object"&&"fn"in n}function c(n){return n==null?null:typeof n=="object"&&"str"in n?n.str:typeof n!="string"||n.length<2||n.at(0)!=="'"||n.at(-1)!=="'"?null:n.substring(1,n.length-1)}function l(n){return Array.isArray(n)?n[0]:n==null?"":u(n)?n.fn[0]:""}function p(n){return Array.isArray(n)?n.slice(1):n!==void 0&&u(n)?n.fn.slice(1):[]}function b(n,t){return Array.isArray(n)?n[t]??null:n===null||!u(n)?null:n.fn[t]??null}function N(n){return n==null?0:Array.isArray(n)?Math.max(0,n.length-1):u(n)?Math.max(0,n.fn.length-1):0}function m(n){if(typeof n=="string")return/^[+-]?[0-9\.]/.test(n)||n.length>=2&&n[0]==="'"&&n[n.length-1]==="'"?null:n;if(n==null)return null;let t=f(n)?n.sym:n;return typeof t!="string"?null:t}function d(n){let t=l(n);if(t==="KeyValuePair"||t==="Tuple"||t==="Pair"){let[i,e]=p(n),r=c(i);return r?[r,e??"Nothing"]:null}return null}function g(n){if(n===null)return null;if(typeof n=="object"&&!("sym"in n)&&!("num"in n)&&!("str"in n)&&!("fn"in n))return n;if(typeof n=="string"&&n[0]==="{"&&n[n.length-1]==="}")try{return o.parse(n)}catch{return null}let t=d(n);if(t)return{[t[0]]:t[1]};if(l(n)==="Dictionary"){let i={},e=p(n);for(let r=1;r<N(n);r++){let s=d(e[r]);s&&(i[s[0]]=s[1])}return i}return null}function E(n,t){let i=null;if(Array.isArray(n)&&(i=n),u(n)&&(i=n.fn),i===null)return[];let e=1,r=[];for(;e<i.length;)r.push(t(i[e])),e+=1;return r}var v="0.28.0";return I(S);})();
 Object.assign(exports, MathJson); Object.defineProperty(exports, '__esModule', { value: true });}));

package/dist/types/common/ansi-codes.d.ts

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
 export declare const DEFAULT_COLOR = "\u001B[39m";
 export declare const DEFAULT_BG = "\u001B[49m";
 export declare const WHITE_BG = "\u001B[47m";

package/dist/types/common/buffer.d.ts

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
     s: string;
     pos: number;
     constructor(s: string, pos?: number);

package/dist/types/common/fuzzy-string-match.d.ts

@@ -0,0 +1,2 @@
+/* 0.28.0 */
+export declare function fuzzyStringMatch(invalidWord: string, validWords: string[]): string | null;

package/dist/types/common/grapheme-splitter.d.ts

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
 /**
  * Return a string or an array of graphemes.
  *

package/dist/types/common/interruptible.d.ts

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
     cause: unknown;
     value: T;
     constructor({ message, value, cause, }?: {
@@ -16,5 +16,5 @@
  * @returns The final value produced by the generator.
  * @throws CancellationError if the operation is canceled or times out.
  */
-export declare function runAsync<T>(gen: Generator<T>, timeLimitMs: number, signal: AbortSignal): Promise<T>;
+export declare function runAsync<T>(gen: Generator<T>, timeLimitMs: number, signal?: AbortSignal): Promise<T>;
 export declare function run<T>(gen: Generator<T>, timeLimitMs: number): T;

package/dist/types/common/json5.d.ts

@@ -0,0 +1,3 @@
+/* 0.28.0 */
+    static parse(input: string): any;
+}

package/dist/types/common/one-of.d.ts

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
     infer Head,
     ...infer Rem
 ] ? MergeTypes<Rem, Res & Head> : Res;

package/dist/types/common/signals.d.ts

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
 /** @category Error Handling */
 export type RuntimeSignalCode = 'timeout' | 'out-of-memory' | 'recursion-depth-exceeded' | 'iteration-limit-exceeded';
 /** @category Error Handling */

package/dist/types/common/styled-text.d.ts

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
     fg?: string;
     bg?: string;
     weight?: 'bold' | 'normal' | 'thin';

package/dist/types/common/syntax-highlighter.d.ts

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
 import { StyledBlock, StyledSpan } from './styled-text';
 export type CodeTag = 
 /** Plain text in default foreground/background color */

package/dist/types/common/terminal.d.ts

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
 declare abstract class Terminal {
     width: number | undefined;
     indent: number;

package/dist/types/common/type/boxed-type.d.ts

@@ -0,0 +1,13 @@
+/* 0.28.0 */
+export declare class BoxedType {
+    static unknown: BoxedType;
+    type: Type;
+    constructor(type: Type | TypeString);
+    matches(other: Type | TypeString | BoxedType): boolean;
+    is(other: Type | TypeString): boolean;
+    get isUnknown(): boolean;
+    toString(): string;
+    toJSON(): string;
+    [Symbol.toPrimitive](hint: string): string | null;
+    valueOf(): string;
+}

package/dist/types/common/type/parse.d.ts

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
 export declare function parseType(s: undefined): undefined;
 export declare function parseType(s: string | Type): Type;
 export declare function parseType(s: string | Type | undefined): Type | undefined;

package/dist/types/common/type/primitive.d.ts

@@ -1,4 +1,5 @@
-/* 0.27.0 */
+/* 0.28.0 */
+/** All the types representing numeric values */
 export declare const NUMERIC_TYPES: PrimitiveType[];
 export declare const COLLECTION_TYPES: PrimitiveType[];
 export declare const SCALAR_TYPES: PrimitiveType[];

package/dist/types/common/type/serialize.d.ts

@@ -1,2 +1,2 @@
-/* 0.27.0 */
+/* 0.28.0 */
 export declare function typeToString(type: Type, precedence?: number): string;

package/dist/types/common/type/subtype.d.ts

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
 /** Return true if lhs is a subtype of rhs */
 export declare function isPrimitiveSubtype(lhs: PrimitiveType, rhs: PrimitiveType): boolean;
 /** Return true if lhs is a subtype of rhs */

package/dist/types/common/type/types.d.ts

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
  * A primitive type is a simple type that represents a concrete value.
  *
  * - `any`: the top type
@@ -30,24 +30,26 @@
  *          `tuple<number, boolean>`, `tuple<x: number, y: boolean>`.
  *       - `map`: a set key-value pairs, e.g. `map<x: number, y: boolean>`.
  *
- * - `number`: any numeric value:
- *    - `finite_number`: <finite_complex> or <finite_imaginary> or
- *       <finite_real> or <finite_rational> or <finite_integer>
- *    - `non_finite_number`: `NaN`, `PositiveInfinity`, `NegativeInfinity` or
- *      `ComplexInfinity`
- *    - `complex` and `finite_complex`: a complex number, with non-zero real
- *       and imaginary parts.
- *    - `imaginary` and `finite_imaginary`: a complex number with a real part
- *       of 0 (pure imaginary).
- *    - `real` and `finite_real`: a complex number with an imaginary part of 0.
- *    - `rational` and `finite_rational`: a pure rational number
- *       (not an integer)
- *    - `integer` and `finite_integer`: a whole number
  *
  *
  */
 export type PrimitiveType = NumericType | 'collection' | 'list' | 'set' | 'map' | 'tuple' | 'value' | 'scalar' | 'function' | 'symbol' | 'boolean' | 'string' | 'expression' | 'unknown' | 'error' | 'nothing' | 'never' | 'any';
-export type NumericType = 'number' | 'finite_number' | 'complex' | 'finite_complex' | 'imaginary' | 'finite_imaginary' | 'real' | 'finite_real' | 'rational' | 'finite_rational' | 'integer' | 'finite_integer' | 'non_finite_number';
+/**
+ * - `number`: any numeric value = `complex` + `real` plus `NaN`
+ * - `complex`: a number with non-zero real and imaginary parts = `finite_complex` plus `ComplexInfinity`
+ * - `finite_complex`: a finite complex number = `imaginary` + `finite_real`
+ * - `imaginary`: a complex number with a real part of 0 (pure imaginary)
+ * - `finite_number`: a finite numeric value = `finite_complex`
+ * - `finite_real`: a finite real number = `finite_rational` + `finite_integer`
+ * - `finite_rational`: a pure rational number
+ * - `finite_integer`: a whole number
+ * - `real`: a complex number with an imaginary part of 0 = `finite_real` + `non_finite_number`
+ * - `non_finite_number`: `PositiveInfinity`, `NegativeInfinity`
+ * - `integer`: a whole number = `finite_integer` + `non_finite_number`
+ * - `rational`: a pure rational number (not an integer) = `finite_rational` + `non_finite_number`
+ *
+ */
+export type NumericType = 'number' | 'finite_number' | 'complex' | 'finite_complex' | 'imaginary' | 'real' | 'finite_real' | 'rational' | 'finite_rational' | 'integer' | 'finite_integer' | 'non_finite_number';
 export type NamedElement = {
     name?: string;
     type: Type;
@@ -71,7 +73,7 @@ export type ValueType = {
     kind: 'value';
     value: any;
 };
-/** Map is not a collection. It is a set of key/value pairs.
+/** Map is a non-indexable collection of key/value pairs.
  * An element of a map whose type is a subtype of `nothing` is optional.
  * For example, in `{x: number, y: boolean | nothing}` the element `y` is optional.
  */
@@ -90,8 +92,8 @@ export type CollectionType = {
 /**
  * The elements of a list are ordered.
  *
- * All elements of a list have the same type (but it can be a broad type,
- * up to `any`).
+ * All elements of a list have the same type, but it can be a broad type,
+ * up to `any`.
  *
  * The same element can be present in the list more than once.
  *
@@ -130,7 +132,7 @@ export type Type = PrimitiveType | AlgebraicType | NegationType | CollectionType
  * Types are described using the following BNF grammar:
 
 ```bnf
-<type> ::= <union_type>
+<type> ::= <union_type> | "(" <type> ")"
 
 <union_type> ::= <intersection_type> (" | " <intersection_type>)*
 
@@ -138,12 +140,8 @@ export type Type = PrimitiveType | AlgebraicType | NegationType | CollectionType
 
 <primary_type> ::=  <primitive>
                 | <tuple_type>
-                | <function_type>
+                | <signature>
                 | <list_type>
-                | <wrapped_primary_type>
-
-<wrapped_primary_type> ::= "(" <primary_type> ")"
-
 
 <primitive> ::= "any" | "unknown" | <value-type> | <symbolic-type> | <numeric-type>
 
@@ -153,9 +151,9 @@ export type Type = PrimitiveType | AlgebraicType | NegationType | CollectionType
 
 <symbolic-type> ::= "expression" | "function" | "symbol"
 
-<tuple_type> ::= "(" (<name> <type> "," <named_tuple_elements>*) ")"
-            | "(" (<type> "," <unnamed_tuple_elements>*) ")" |
-            | "tuple(" <tuple_elements> ")"
+<tuple_type> ::= "tuple<" (<name> <type> "," <named_tuple_elements>*) ">"
+            | "tuple<" (<type> "," <unnamed_tuple_elements>*) ">" |
+            | "tuple<" <tuple_elements> ">"
 
 <tuple_elements> ::= <unnamed_tuple_elements> | <named_tuple_elements>
 
@@ -163,15 +161,11 @@ export type Type = PrimitiveType | AlgebraicType | NegationType | CollectionType
 
 <named_tuple_elements> ::= <name> <type> ("," <name> <type>)*
 
-<function_type> ::=  <arguments> " -> " <type>
+<signature> ::=  <arguments> " -> " <type>
 
 <arguments> ::= "()"
             | <argument>
             | "(" <argument-list> ")"
-            | <deferred_evaluation>
-
-<deferred_evaluation> ::= "???" <argument>
-                       | "???" "(" <argument-list> ")"
 
 <argument> ::= <type>
             | <name> <type>
@@ -191,7 +185,7 @@ export type Type = PrimitiveType | AlgebraicType | NegationType | CollectionType
             | <rest_argument>
 
 
-<list_type> ::= "[" <type> <dimensions>? "]"
+<list_type> ::= "list<" <type> <dimensions>? ">"
 
 <dimensions> ::= "^" <fixed_size>
             | "^(" <multi_dimensional_size> ")"
@@ -200,9 +194,7 @@ export type Type = PrimitiveType | AlgebraicType | NegationType | CollectionType
 
 <multi_dimensional_size> ::= <positive-integer_literal> "x" <positive-integer_literal> ("x" <positive-integer_literal>)*
 
-<map> ::= "{}"
-            |"{" <map_elements> "}"
-            | "map(" <map_elements> ")"
+<map> ::= "map" | "map<" <map_elements> ">"
 
 <map_elements> ::= <name> <type> ("," <name> <type>)*
 
@@ -218,31 +210,29 @@ export type Type = PrimitiveType | AlgebraicType | NegationType | CollectionType
 ```
 
 
-Examples of types:
+Examples of types strings:
    "number"    -- a simple type primitive
-
-
    "(number, boolean)" -- a tuple type
    "(x: number, y:boolean)" -- a named tuple/record type. Either all arguments are named, or none are
 
-   "[any]" -- an arbitrary collection type, with no length or element type restrictions
-   "[integer]" -- a collection type where all the elements are integers
-   "[(number, boolean)]" -- a collection of tuples
-   "[(value:number, seen:boolean)]" -- a collection of named tuples
+   "collection<any>" -- an arbitrary collection type, with no length or element type restrictions
+   "collection<integer>" -- a collection type where all the elements are integers
+   "collection<(number, boolean)>" -- a collection of tuples
+   "collection<(value:number, seen:boolean)>" -- a collection of named tuples
    "[boolean]^32" -- a collection type with a fixed size of 32 elements
    "[integer]^(2x3)" -- an integer matrix of 2 columns and 3 rows
    "[integer]^(2x3x4)" -- a tensor of dimensions 2x3x4
 
-   "number -> number" -- a function type with a single argument
-   "(x: number, number) -> number" -- a function type with a named argument
-   "(number, y:number?) -> number" -- a function type with an optional named argument (can have several optional arguments, at the end)
-   "(number, ...number) -> number" -- a function type with a rest argument (can have only one, and no optional arguments if there is a rest argument).
-   "() -> number" -- a function type with an empty argument list
+   "number -> number" -- a signature with a single argument
+   "(x: number, number) -> number" -- a signature with a named argument
+   "(number, y:number?) -> number" -- a signature with an optional named argument (can have several optional arguments, at the end)
+   "(number, ...number) -> number" -- a signature with a rest argument (can have only one, and no optional arguments if there is a rest argument).
+   "() -> number" -- a signature with an empty argument list
 
    "number | boolean" -- a union type
    "(x: number) & (y: number)" -- an intersection type
    "number | ((x: number) & (y: number))" -- a union type with an intersection type
-   "(number -> number) | number" -- a union type with a function type
+   "(number -> number) | number" -- a union type with a signature and a primitive type
 */
 export type TypeString = string;
 export type TypeCompatibility = 'covariant' | 'contravariant' | 'bivariant' | 'invariant';