affinirum 1.0.1 → 1.0.2

package/dst/Type.d.ts

@@ -28,8 +28,8 @@ export declare class Type implements IType {
     get isFunction(): boolean;
     get isNumeric(): boolean;
     toOptional(): Type;
-    mergeFunctionAtomRetType(type: Type): Type;
-    mergeFunctionAtom(type: Type, argc: number): FunctionAtom | undefined;
+    functionAtomRetType(type: Type): Type;
+    functionAtoms(type: Type, argc: number): FunctionAtom[];
     reduce(mask: Type): Type | undefined;
     match(type: IType): boolean;
     weight(): number;

package/dst/Type.js

@@ -53,19 +53,15 @@ export class Type {
     toOptional() {
         return this._atoms.length ? Type.union(Type.Void, this) : this;
     }
-    mergeFunctionAtomRetType(type) {
-        const atoms = this._atoms.filter((i) => i instanceof FunctionAtom && (!i.retType || i.retType.match(type)));
-        return Type.union(...atoms.map((i) => i.retType ?? Type.Unknown));
+    functionAtomRetType(type) {
+        const atoms = this._atoms.filter((i) => i instanceof FunctionAtom && i.retType.match(type));
+        return Type.union(...atoms.map((i) => i.retType));
     }
-    mergeFunctionAtom(type, argc) {
-        if (this.isUnknown || type.isVoid) {
-            return Type._functionAtom(type, Array.from({ length: argc }).map(() => Type.Unknown), false);
-        }
-        const atoms = this._atoms.filter((i) => i instanceof FunctionAtom && i.minArity <= argc && i.maxArity >= argc && (!i.retType || i.retType.match(type)));
-        if (!atoms.length) {
-            return undefined;
+    functionAtoms(type, argc) {
+        if (this.isUnknown) {
+            return Type.Function._atoms;
         }
-        return Type._functionAtom(Type.union(...atoms.map((i) => i.retType ?? Type.Unknown)), Array.from({ length: argc }).map((_, ix) => Type.union(...atoms.map((i) => i.argType(ix)))), atoms.some((i) => i.isVariadic));
+        return this._atoms.filter((i) => i instanceof FunctionAtom && i.minArity <= argc && i.maxArity >= argc && (type.isVoid || i.retType.match(type)));
     }
     reduce(mask) {
         if (mask.isUnknown || mask.isVoid) {

package/dst/atom/FunctionAtom.d.ts

@@ -1,16 +1,17 @@
-import { IType } from '../Type.js';
+import { IType, Type } from '../Type.js';
 export declare class FunctionAtom implements IType {
     protected readonly _retType?: IType | undefined;
     protected readonly _argTypes: IType[];
     protected readonly _minArity: number;
     protected readonly _isVariadic: boolean;
     constructor(_retType?: IType | undefined, _argTypes?: IType[], _minArity?: number, _isVariadic?: boolean);
-    get retType(): IType | undefined;
+    get retType(): Type;
     get minArity(): number;
     get maxArity(): number;
     get isVariadic(): boolean;
+    get arity(): number;
     subtypes(): IType[];
-    argType(index: number): IType;
+    argType(index: number): Type;
     match(type: IType): boolean;
     weight(): number;
     toString(): string;

package/dst/atom/FunctionAtom.js

@@ -1,3 +1,4 @@
+import { Type } from '../Type.js';
 export class FunctionAtom {
     _retType;
     _argTypes;
@@ -10,7 +11,7 @@ export class FunctionAtom {
         this._isVariadic = _isVariadic;
     }
     get retType() {
-        return this._retType;
+        return this._retType ?? Type.Unknown;
     }
     get minArity() {
         return this._minArity;
@@ -21,11 +22,14 @@ export class FunctionAtom {
     get isVariadic() {
         return this._isVariadic;
     }
+    get arity() {
+        return this._argTypes.length;
+    }
     subtypes() {
         return this._retType ? [this._retType, ...this._argTypes] : [];
     }
     argType(index) {
-        return this._argTypes[index] ?? this._argTypes[this._argTypes.length - 1];
+        return (this._argTypes[index] ?? this._argTypes[this._argTypes.length - 1]);
     }
     match(type) {
         if (type instanceof FunctionAtom) {

package/dst/cjs/Type.js

@@ -56,19 +56,15 @@ class Type {
     toOptional() {
         return this._atoms.length ? Type.union(Type.Void, this) : this;
     }
-    mergeFunctionAtomRetType(type) {
-        const atoms = this._atoms.filter((i) => i instanceof FunctionAtom_js_1.FunctionAtom && (!i.retType || i.retType.match(type)));
-        return Type.union(...atoms.map((i) => i.retType ?? Type.Unknown));
+    functionAtomRetType(type) {
+        const atoms = this._atoms.filter((i) => i instanceof FunctionAtom_js_1.FunctionAtom && i.retType.match(type));
+        return Type.union(...atoms.map((i) => i.retType));
     }
-    mergeFunctionAtom(type, argc) {
-        if (this.isUnknown || type.isVoid) {
-            return Type._functionAtom(type, Array.from({ length: argc }).map(() => Type.Unknown), false);
-        }
-        const atoms = this._atoms.filter((i) => i instanceof FunctionAtom_js_1.FunctionAtom && i.minArity <= argc && i.maxArity >= argc && (!i.retType || i.retType.match(type)));
-        if (!atoms.length) {
-            return undefined;
+    functionAtoms(type, argc) {
+        if (this.isUnknown) {
+            return Type.Function._atoms;
         }
-        return Type._functionAtom(Type.union(...atoms.map((i) => i.retType ?? Type.Unknown)), Array.from({ length: argc }).map((_, ix) => Type.union(...atoms.map((i) => i.argType(ix)))), atoms.some((i) => i.isVariadic));
+        return this._atoms.filter((i) => i instanceof FunctionAtom_js_1.FunctionAtom && i.minArity <= argc && i.maxArity >= argc && (type.isVoid || i.retType.match(type)));
     }
     reduce(mask) {
         if (mask.isUnknown || mask.isVoid) {

package/dst/cjs/atom/FunctionAtom.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FunctionAtom = void 0;
+const Type_js_1 = require("../Type.js");
 class FunctionAtom {
     _retType;
     _argTypes;
@@ -13,7 +14,7 @@ class FunctionAtom {
         this._isVariadic = _isVariadic;
     }
     get retType() {
-        return this._retType;
+        return this._retType ?? Type_js_1.Type.Unknown;
     }
     get minArity() {
         return this._minArity;
@@ -24,11 +25,14 @@ class FunctionAtom {
     get isVariadic() {
         return this._isVariadic;
     }
+    get arity() {
+        return this._argTypes.length;
+    }
     subtypes() {
         return this._retType ? [this._retType, ...this._argTypes] : [];
     }
     argType(index) {
-        return this._argTypes[index] ?? this._argTypes[this._argTypes.length - 1];
+        return (this._argTypes[index] ?? this._argTypes[this._argTypes.length - 1]);
     }
     match(type) {
         if (type instanceof FunctionAtom) {

package/dst/cjs/node/CallNode.js

@@ -4,6 +4,7 @@ exports.CallNode = void 0;
 const Node_js_1 = require("../Node.js");
 const Constant_js_1 = require("../Constant.js");
 const ConstantNode_js_1 = require("./ConstantNode.js");
+const ArrayNode_js_1 = require("./ArrayNode.js");
 const Type_js_1 = require("../Type.js");
 class CallNode extends Node_js_1.Node {
     _fnode;
@@ -13,30 +14,45 @@ class CallNode extends Node_js_1.Node {
         super(frame);
         this._fnode = _fnode;
         this._subnodes = _subnodes;
-        this._type = this._fnode.type.mergeFunctionAtom(Type_js_1.Type.Unknown, _subnodes.length)?.retType ?? Type_js_1.Type.Unknown;
+        const functionAtoms = this._fnode.type.functionAtoms(Type_js_1.Type.Unknown, this._subnodes.length);
+        if (!functionAtoms.length) {
+            this.throwError(`function ${this._fnode.type} does not take ${this._subnodes.length} arguments)`);
+        }
+        this._type = Type_js_1.Type.union(...functionAtoms.map((i) => i.retType));
     }
     get type() {
         return this._type;
     }
     compile(type) {
         this._fnode = this._fnode.compile(this._fnode.type);
-        const mergedFunctionAtom = this._fnode.type.mergeFunctionAtom(type, this._subnodes.length);
-        if (!mergedFunctionAtom) {
-            this.throwError(`function ${this._fnode.type} does not return ${type} or take ${this._subnodes.length} arguments)`);
+        const functionAtoms = this._fnode.type.functionAtoms(type, this._subnodes.length);
+        if (!functionAtoms.length) {
+            this.throwError(`function ${this._fnode.type} does not take ${this._subnodes.length} arguments returning ${type})`);
+        }
+        this._type = Type_js_1.Type.union(...functionAtoms.map((i) => i.retType));
+        /*
+        if (this._subnodes.length < functionAtoms.minArity) {
+            this.throwError(`function requires at least ${functionAtoms.minArity} arguments not ${this._subnodes.length}`);
         }
-        this._type = mergedFunctionAtom.retType;
-        if (this._subnodes.length < mergedFunctionAtom.minArity) {
-            this.throwError(`function requires at least ${mergedFunctionAtom.minArity} arguments not ${this._subnodes.length}`);
+        if (this._subnodes.length > functionAtoms.maxArity) {
+            this.throwError(`function requires at most ${functionAtoms.maxArity} arguments not ${this._subnodes.length}`);
         }
-        if (this._subnodes.length > mergedFunctionAtom.maxArity) {
-            this.throwError(`function requires at most ${mergedFunctionAtom.maxArity} arguments not ${this._subnodes.length}`);
+        */
+        if (this._fnode.constant) {
+            let constant = true;
+            for (let i = 0; i < this._subnodes.length; ++i) {
+                const argType = Type_js_1.Type.union(...functionAtoms.map((a) => a.argType(i)));
+                this._subnodes[i] = this._subnodes[i].compile(argType);
+                constant &&= this._subnodes[i].constant;
+            }
+            return constant ? new ConstantNode_js_1.ConstantNode(this, new Constant_js_1.Constant(this.evaluate(), this.type)) : this;
         }
-        let constant = this._fnode.constant;
-        for (let i = 0; i < this._subnodes.length; ++i) {
-            this._subnodes[i] = this._subnodes[i].compile(mergedFunctionAtom.argType(i));
-            constant &&= this._subnodes[i].constant;
+        const arity = functionAtoms.filter((i) => i.isVariadic).map((i) => i.arity).reduce((acc, val) => Math.max(acc, val), 0);
+        if (arity > 0) {
+            const frame = this._subnodes[arity - 1].starts();
+            this._subnodes = this._subnodes.slice(0, arity - 1).concat(new ArrayNode_js_1.ArrayNode(frame.ends(this._subnodes[this._subnodes.length - 1]), this._subnodes.slice(arity - 1)));
         }
-        return constant ? new ConstantNode_js_1.ConstantNode(this, new Constant_js_1.Constant(this.evaluate(), this.type)) : this;
+        return this;
     }
     evaluate() {
         const func = this._fnode.evaluate();

package/dst/cjs/node/ConstantNode.js

@@ -15,7 +15,7 @@ class ConstantNode extends Node_js_1.Node {
     }
     compile(type) {
         this._constant.type = this.reduceType(type);
-        this._subnode = this._subnode?.compile(this._constant.type.mergeFunctionAtomRetType(type));
+        this._subnode = this._subnode?.compile(this._constant.type.functionAtomRetType(type));
         return this;
     }
     evaluate() {

package/dst/cjs/node/SwitchNode.js

@@ -24,14 +24,15 @@ class SwitchNode extends Node_js_1.Node {
     compile(type) {
         this._cnode = this._cnode.compile(Type_js_1.Type.Boolean);
         this._type = type;
-        let constant = this._cnode.constant;
-        for (let i = 0; i < this._subnodes.length; ++i) {
-            this._subnodes[i] = this._subnodes[i].compile(type);
-            constant &&= this._subnodes[i].constant;
+        if (this._cnode.constant) {
+            let constant = true;
+            for (let i = 0; i < this._subnodes.length; ++i) {
+                this._subnodes[i] = this._subnodes[i].compile(type);
+                constant &&= this._subnodes[i].constant;
+            }
+            return constant ? new ConstantNode_js_1.ConstantNode(this, new Constant_js_1.Constant(this.evaluate(), this.type)) : this;
         }
-        return constant
-            ? new ConstantNode_js_1.ConstantNode(this, new Constant_js_1.Constant(this.evaluate(), this.type))
-            : this;
+        return this;
     }
     evaluate() {
         return this._cnode.evaluate() ? this._subnodes[0].evaluate() : this._subnodes[1].evaluate();

package/dst/node/CallNode.js

@@ -1,6 +1,7 @@
 import { Node } from '../Node.js';
 import { Constant } from '../Constant.js';
 import { ConstantNode } from './ConstantNode.js';
+import { ArrayNode } from './ArrayNode.js';
 import { Type } from '../Type.js';
 export class CallNode extends Node {
     _fnode;
@@ -10,30 +11,45 @@ export class CallNode extends Node {
         super(frame);
         this._fnode = _fnode;
         this._subnodes = _subnodes;
-        this._type = this._fnode.type.mergeFunctionAtom(Type.Unknown, _subnodes.length)?.retType ?? Type.Unknown;
+        const functionAtoms = this._fnode.type.functionAtoms(Type.Unknown, this._subnodes.length);
+        if (!functionAtoms.length) {
+            this.throwError(`function ${this._fnode.type} does not take ${this._subnodes.length} arguments)`);
+        }
+        this._type = Type.union(...functionAtoms.map((i) => i.retType));
     }
     get type() {
         return this._type;
     }
     compile(type) {
         this._fnode = this._fnode.compile(this._fnode.type);
-        const mergedFunctionAtom = this._fnode.type.mergeFunctionAtom(type, this._subnodes.length);
-        if (!mergedFunctionAtom) {
-            this.throwError(`function ${this._fnode.type} does not return ${type} or take ${this._subnodes.length} arguments)`);
+        const functionAtoms = this._fnode.type.functionAtoms(type, this._subnodes.length);
+        if (!functionAtoms.length) {
+            this.throwError(`function ${this._fnode.type} does not take ${this._subnodes.length} arguments returning ${type})`);
+        }
+        this._type = Type.union(...functionAtoms.map((i) => i.retType));
+        /*
+        if (this._subnodes.length < functionAtoms.minArity) {
+            this.throwError(`function requires at least ${functionAtoms.minArity} arguments not ${this._subnodes.length}`);
         }
-        this._type = mergedFunctionAtom.retType;
-        if (this._subnodes.length < mergedFunctionAtom.minArity) {
-            this.throwError(`function requires at least ${mergedFunctionAtom.minArity} arguments not ${this._subnodes.length}`);
+        if (this._subnodes.length > functionAtoms.maxArity) {
+            this.throwError(`function requires at most ${functionAtoms.maxArity} arguments not ${this._subnodes.length}`);
         }
-        if (this._subnodes.length > mergedFunctionAtom.maxArity) {
-            this.throwError(`function requires at most ${mergedFunctionAtom.maxArity} arguments not ${this._subnodes.length}`);
+        */
+        if (this._fnode.constant) {
+            let constant = true;
+            for (let i = 0; i < this._subnodes.length; ++i) {
+                const argType = Type.union(...functionAtoms.map((a) => a.argType(i)));
+                this._subnodes[i] = this._subnodes[i].compile(argType);
+                constant &&= this._subnodes[i].constant;
+            }
+            return constant ? new ConstantNode(this, new Constant(this.evaluate(), this.type)) : this;
         }
-        let constant = this._fnode.constant;
-        for (let i = 0; i < this._subnodes.length; ++i) {
-            this._subnodes[i] = this._subnodes[i].compile(mergedFunctionAtom.argType(i));
-            constant &&= this._subnodes[i].constant;
+        const arity = functionAtoms.filter((i) => i.isVariadic).map((i) => i.arity).reduce((acc, val) => Math.max(acc, val), 0);
+        if (arity > 0) {
+            const frame = this._subnodes[arity - 1].starts();
+            this._subnodes = this._subnodes.slice(0, arity - 1).concat(new ArrayNode(frame.ends(this._subnodes[this._subnodes.length - 1]), this._subnodes.slice(arity - 1)));
         }
-        return constant ? new ConstantNode(this, new Constant(this.evaluate(), this.type)) : this;
+        return this;
     }
     evaluate() {
         const func = this._fnode.evaluate();

package/dst/node/ConstantNode.js

@@ -12,7 +12,7 @@ export class ConstantNode extends Node {
     }
     compile(type) {
         this._constant.type = this.reduceType(type);
-        this._subnode = this._subnode?.compile(this._constant.type.mergeFunctionAtomRetType(type));
+        this._subnode = this._subnode?.compile(this._constant.type.functionAtomRetType(type));
         return this;
     }
     evaluate() {

package/dst/node/SwitchNode.js

@@ -21,14 +21,15 @@ export class SwitchNode extends Node {
     compile(type) {
         this._cnode = this._cnode.compile(Type.Boolean);
         this._type = type;
-        let constant = this._cnode.constant;
-        for (let i = 0; i < this._subnodes.length; ++i) {
-            this._subnodes[i] = this._subnodes[i].compile(type);
-            constant &&= this._subnodes[i].constant;
+        if (this._cnode.constant) {
+            let constant = true;
+            for (let i = 0; i < this._subnodes.length; ++i) {
+                this._subnodes[i] = this._subnodes[i].compile(type);
+                constant &&= this._subnodes[i].constant;
+            }
+            return constant ? new ConstantNode(this, new Constant(this.evaluate(), this.type)) : this;
         }
-        return constant
-            ? new ConstantNode(this, new Constant(this.evaluate(), this.type))
-            : this;
+        return this;
     }
     evaluate() {
         return this._cnode.evaluate() ? this._subnodes[0].evaluate() : this._subnodes[1].evaluate();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "affinirum",
-	"version": "1.0.1",
+	"version": "1.0.2",
 	"description": "Affinirum Scripting Language",
 	"main": "dst/cjs/index.js",
 	"module": "dst/index.js",