affinirum 1.1.4 → 1.2.0

package/README.md

@@ -27,7 +27,7 @@ The value of a block is determined by the value of the last expression.
 - Scientific notation is supported for floating point numbers, like *0.1281e+2*.
 - ISO Timestamps prefixed with **@**, like *@2025-05-11T19:09:21.320Z*.
 - Hexadecimal buffer values are enclosed in backtick (**\`**) quotes, like *\`10ab0901\`*.
-- String literals are enclosed in single (**'**), or double (**"**) quotes, like *'string value'*.
+- String literals are enclosed in single (**'**), or double (**"**) quotes, like *'string value1'*, or *"string value2"*.
 
 Array is an ordered sequence of values of any type.
 It is defined by comma-separated values enclosed in brackets (**[]**),
@@ -41,12 +41,12 @@ Easy way to check if array contains an index is to use presence operator (**?**)
 
 Object is a container of named values of any type.
 It is defined by comma-separated key-value pair enclosed in brackets (**[]**) where key is separated from value by colon (**:**),
- like *["NumericProperty":100, "StringProperty":"abc"]*, *["a":0,"b":"str":"c":valueVar]*.
+ like *["key1":100, "key2":"abc"]*, *["a":0,"b":"str":"c":valueVar]*.
 <br>An empty object is represented as **[\:]**.
 
 Object properties can be accessed using the access operator (**.**) with a string literal, token,
  or with brackets containing a string key,
- like *theObject."StringProperty"*, *theObject.stringProp*, *theObject["StringProperty"]*.
+ like *theObject."key"*, *theObject.key*, or *theObject["key"]*.
 
 Easy way to check if object contains a key is to use presence operator (**?**), like *theObject?myKey*.
 
@@ -64,12 +64,12 @@ Whitespace characters are ignored.
 - **void** for value **null**
 - **boolean** for values **true** and **false**
 - **timestamp** for date-time values, millisecons since Unix epoch
-- **float** IEEE 754 double-precision binary floating-point format: binary64
+- **float** for 64-bit floating point values in binary64, IEEE 754 binary floating-point format
 - **integer** for 64-bit integer values
 - **buffer** for ordered sequences of bytes
 - **string** for ordered sequences of characters, text strings
-- **array** for ordered sequences of valuese
-- **object** for sets of named values
+- **array** for ordered sequences of values
+- **object** for collections of named values
 - **function** for built-in, injected or script-defined subroutines
 
 Type modifier **?** can be used to make any type optional (nullable).
@@ -299,12 +299,12 @@ const objExpr = new Affinirum( '[`prop1`:a,`prop2`:`abc`].prop1+10' );
 const oValue = objExpr.evaluate( { a: 50 } ); // 60
 ...
 const iteratorExpr = new Affinirum(
-	'Float.Sum(arr1.Derive(float(a:float)->a*2).Filter(boolean(a:float)->a>3))'
+	'Float.Sum(arr1.Derive(float(a:float){a*2}).Filter(boolean(a:float){a>3}))'
 );
 const iValue = iteratorExpr.evaluate( { arr1: [ 1, 2, 3 ] } ); // 10
 ...
 const complexExpr = new Affinirum(
-	'var a=myvar1/10, const b=myvar2-100, a/b + b*a + 600'
+	'var a=myvar1/10, val b=myvar2-100, a/b + b*a + 600'
 );
 const value = complexExpr.evaluate( { myvar1: 40, myvar2: 104 } ); // 4761
 ...

package/dst/Affinirum.d.ts

@@ -59,9 +59,11 @@ export declare class Affinirum {
     protected _coalescence(state: ParserState, scope: StaticScope): Node;
     protected _disjunction(state: ParserState, scope: StaticScope): Node;
     protected _conjunction(state: ParserState, scope: StaticScope): Node;
+    protected _negation(state: ParserState, scope: StaticScope): Node;
     protected _comparison(state: ParserState, scope: StaticScope): Node;
     protected _aggregate(state: ParserState, scope: StaticScope): Node;
     protected _product(state: ParserState, scope: StaticScope): Node;
+    protected _signum(state: ParserState, scope: StaticScope): Node;
     protected _factor(state: ParserState, scope: StaticScope): Node;
     protected _accessor(state: ParserState, scope: StaticScope): Node;
     protected _term(state: ParserState, scope: StaticScope): Node;

package/dst/Affinirum.js

@@ -105,7 +105,7 @@ export class Affinirum {
     _block(state, scope) {
         const frame = state.starts();
         const nodes = [this._unit(state, scope)];
-        while (state.isSemicolonSeparator) {
+        while (state.isSemicolon) {
             nodes.push(this._unit(state.next(), scope));
         }
         return new BlockNode(frame.ends(state), nodes);
@@ -128,29 +128,33 @@ export class Affinirum {
         return node;
     }
     _conjunction(state, scope) {
-        let node = this._comparison(state, scope);
+        let node = this._negation(state, scope);
         while (state.operator === funcAnd) {
-            node = this._call(state.starts(), state.operator, [node, this._comparison(state.next(), scope)]);
+            node = this._call(state.starts(), state.operator, [node, this._negation(state.next(), scope)]);
         }
         return node;
     }
-    _comparison(state, scope) {
+    _negation(state, scope) {
         const frame = state.starts();
-        let not = false;
+        let negate = false;
         while (state.operator === funcNot) {
-            not = !not;
-            frame.starts(state);
+            negate = !negate;
+            frame.ends(state);
             state.next();
         }
+        let node = this._comparison(state, scope);
+        if (negate) {
+            node = this._call(frame, funcNot, [node]);
+        }
+        return node;
+    }
+    _comparison(state, scope) {
         let node = this._aggregate(state, scope);
         while (state.operator === funcGreaterThan || state.operator === funcLessThan
             || state.operator === funcGreaterOrEqual || state.operator === funcLessOrEqual
             || state.operator === funcEqual || state.operator === funcNotEqual) {
             node = this._call(state.starts(), state.operator, [node, this._aggregate(state.next(), scope)]);
         }
-        if (not) {
-            node = this._call(frame.ends(state), funcNot, [node]);
-        }
         return node;
     }
     _aggregate(state, scope) {
@@ -161,35 +165,41 @@ export class Affinirum {
         return node;
     }
     _product(state, scope) {
-        let node = this._factor(state, scope);
+        let node = this._signum(state, scope);
         while (state.operator === funcMultiply || state.operator === funcDivide || state.operator === funcRemainder) {
-            node = this._call(state.starts(), state.operator, [node, this._factor(state.next(), scope)]);
+            node = this._call(state.starts(), state.operator, [node, this._signum(state.next(), scope)]);
         }
         return node;
     }
-    _factor(state, scope) {
+    _signum(state, scope) {
         const frame = state.starts();
-        let neg = false;
-        while (state.operator === funcSubtract) {
-            neg = !neg;
-            frame.starts(state);
+        let negate = false;
+        while (state.operator === funcAdd || state.operator === funcSubtract) {
+            if (state.operator === funcSubtract) {
+                negate = !negate;
+            }
+            frame.ends(state);
             state.next();
         }
+        let node = this._factor(state, scope);
+        if (negate) {
+            node = this._call(frame.ends(state), funcNegate, [node]);
+        }
+        return node;
+    }
+    _factor(state, scope) {
         let node = this._accessor(state, scope);
         while (state.operator === funcPower) {
             node = this._call(state.starts(), state.operator, [node, this._accessor(state.next(), scope)]);
         }
-        if (neg) {
-            node = this._call(frame.ends(state), funcNegate, [node]);
-        }
         return node;
     }
     _accessor(state, scope) {
         let node = this._term(state, scope);
-        while (state.isDotMark || state.isQuestionMark || state.isParenthesesOpen || state.isBracketsOpen) {
+        while (state.isDot || state.isQuestion || state.isParenthesesOpen || state.isBracketsOpen) {
             const frame = state.starts();
-            if (state.isDotMark || state.isQuestionMark) {
-                const operator = state.isDotMark ? funcAt : funcHas;
+            if (state.isDot || state.isQuestion) {
+                const operator = state.isDot ? funcAt : funcHas;
                 if (state.next().isLiteral && (typeof state.literal.value === "string" || typeof state.literal.value === "bigint")) {
                     node = this._call(frame.ends(state), operator, [node, new ConstantNode(state, new Constant(state.literal.value))]);
                     state.next();
@@ -202,7 +212,7 @@ export class Affinirum {
                             const subnodes = [node];
                             while (!state.next().isParenthesesClose) {
                                 subnodes.push(this._unit(state, scope));
-                                if (!state.isCommaSeparator) {
+                                if (!state.isComma) {
                                     break;
                                 }
                             }
@@ -226,7 +236,7 @@ export class Affinirum {
                 const subnodes = [];
                 while (!state.next().isParenthesesClose) {
                     subnodes.push(this._unit(state, scope));
-                    if (!state.isCommaSeparator) {
+                    if (!state.isComma) {
                         break;
                     }
                 }
@@ -251,7 +261,7 @@ export class Affinirum {
             const frame = state.starts();
             const constants = this._constants.get(state.token);
             if (constants != null) {
-                if (!state.next().isDotMark) {
+                if (!state.next().isDot) {
                     state.throwError("missing constant accessor operator");
                 }
                 if (!state.next().isToken) {
@@ -281,8 +291,8 @@ export class Affinirum {
                 this._vframes.set(state.token, state.starts());
             }
             if (state.next().isAssignment) {
-                if (variable.constant) {
-                    state.throwError("illegal constant assignment");
+                if (!variable.assignable) {
+                    state.throwError("illegal re-assignment");
                 }
                 if (state.assignment.operator) {
                     const operator = state.assignment.operator;
@@ -316,20 +326,20 @@ export class Affinirum {
             const subnodes = [];
             let index = 0, colon = false;
             while (!state.next().isBracketsClose) {
-                if (state.isColonSeparator) {
+                if (state.isColon) {
                     colon = true;
                     state.next();
                     break;
                 }
                 const node = this._unit(state, scope);
-                if (state.isColonSeparator) {
+                if (state.isColon) {
                     colon = true;
                     subnodes.push([node, this._unit(state.next(), scope)]);
                 }
                 else {
                     subnodes.push([index++, node]);
                 }
-                if (!state.isCommaSeparator) {
+                if (!state.isComma) {
                     break;
                 }
             }
@@ -343,31 +353,31 @@ export class Affinirum {
         else if (state.isBracketsClose) {
             state.throwError("unexpected closing brackets");
         }
-        else if (state.isVariableDefinition || state.isConstantDefinition) {
-            const constant = state.isConstantDefinition;
+        else if (state.isVariable || state.isValue) {
+            const assignable = state.isVariable;
             if (!state.next().isToken) {
-                state.throwError(`missing ${constant ? "constant" : "variable"} name`);
+                state.throwError(`missing variable name`);
             }
             const token = state.token;
             if (scope.has(token)) {
-                state.throwError(`illegal redefinition of ${constant ? "constant" : "variable"} ${token}`);
+                state.throwError(`illegal redefinition of variable ${token}`);
             }
             const frame = state.starts();
             let type;
-            if (state.next().isColonSeparator) {
+            if (state.next().isColon) {
                 type = this._type(state.next(), scope);
             }
-            const variable = new Variable(type, constant);
+            const variable = new Variable(type, assignable);
             scope.local(token, variable);
             if (state.isAssignment) {
                 if (state.assignment.operator) {
-                    state.throwError(`illegal assignment operator to ${constant ? "constant" : "variable"} ${token}`);
+                    state.throwError(`illegal assignment operator with variable ${token}`);
                 }
                 return new VariableNode(frame, variable, this._unit(state.next(), scope));
             }
             return new VariableNode(frame, variable);
         }
-        else if (state.isTildaMark) {
+        else if (state.isTilda) {
             return this._function(state, scope);
         }
         else if (state.isWhile) {
@@ -399,16 +409,21 @@ export class Affinirum {
                 state.throwError("variable redefinition");
             }
             let argType = Type.Unknown;
-            if (state.next().isColonSeparator) {
+            if (state.next().isColon) {
                 argType = this._type(state.next(), scope);
             }
             variables.set(token, new Variable(argType));
-            if (argType.isArray && state.isVariadicFunction) {
-                variadic = true;
-                state.next();
-                break;
+            if (state.isEllipsis) {
+                if (argType.isArray) {
+                    variadic = true;
+                    state.next();
+                    break;
+                }
+                else {
+                    state.throwError("variadic function argument must be an array type");
+                }
             }
-            if (!state.isCommaSeparator) {
+            if (!state.isComma) {
                 break;
             }
         }
@@ -416,10 +431,6 @@ export class Affinirum {
         frame.ends(state);
         const args = Array.from(variables.values());
         state.next().openBraces().next();
-        if (args.length === 0 && state.isBracesClose) {
-            state.next();
-            return new ConstantNode(frame, Constant.EmptyFunction);
-        }
         const subnode = this._block(state, scope.subscope(variables));
         state.closeBraces().next();
         const value = (...values) => {
@@ -462,7 +473,7 @@ export class Affinirum {
     _type(state, scope) {
         if (state.isType) {
             let type = state.type;
-            if (state.next().isQuestionMark) {
+            if (state.next().isQuestion) {
                 type = type.toOptional();
                 state.next();
             }
@@ -472,36 +483,29 @@ export class Affinirum {
             return type;
         }
         else if (state.isBracketsOpen) { // array or object type
-            const itemPropTypes = [];
+            const itemKeyTypes = [];
             let index = 0, colon = false;
             while (!state.next().isBracketsClose) {
-                if (state.isColonSeparator) { // default object type
-                    colon = true;
-                    state.next();
-                    break;
-                }
-                if (state.isType) {
-                    itemPropTypes.push([index++, this._type(state, scope)]);
-                }
-                else if (state.isToken) {
-                    const token = state.token;
+                if (state.isLiteral && typeof state.literal.value === "string") {
+                    const key = state.literal.value;
                     state.next().separateByColon().next();
-                    itemPropTypes.push([token, this._type(state, scope)]);
+                    itemKeyTypes.push([key, this._type(state, scope)]);
+                    colon = true;
                 }
                 else {
-                    state.throwError("missing type or property name");
+                    itemKeyTypes.push([index++, this._type(state, scope)]);
                 }
-                if (!state.isCommaSeparator) {
+                if (!state.isComma) {
                     break;
                 }
             }
             state.closeBrackets().next();
             return colon
-                ? Type.objectType(Object.fromEntries(itemPropTypes.map(([prop, type]) => [prop, type])))
-                : Type.arrayType(itemPropTypes.map(([, v]) => v));
+                ? Type.objectType(Object.fromEntries(itemKeyTypes.map(([key, type]) => [key, type])))
+                : Type.arrayType(itemKeyTypes.map(([, v]) => v));
         }
-        else if (state.isTildaMark) { // function type
-            let retType = undefined;
+        else if (state.isTilda) { // function type
+            let retType = Type.Unknown;
             if (!state.next().isParenthesesOpen) {
                 retType = this._type(state, scope);
                 state.openParentheses();
@@ -511,7 +515,7 @@ export class Affinirum {
             while (!state.next().isParenthesesClose) {
                 const argType = this._type(state, scope);
                 argTypes.push(argType);
-                if (state.isVariadicFunction) {
+                if (state.isEllipsis) {
                     if (argType.isArray) {
                         variadic = true;
                         state.next();
@@ -521,7 +525,7 @@ export class Affinirum {
                         state.throwError("variadic function argument must be an array type");
                     }
                 }
-                if (!state.isCommaSeparator) {
+                if (!state.isComma) {
                     break;
                 }
             }

package/dst/Constant.d.ts

@@ -10,7 +10,4 @@ export declare class Constant {
     set type(type: Type);
     get deterministic(): boolean;
     static Null: Constant;
-    static EmptyArray: Constant;
-    static EmptyObject: Constant;
-    static EmptyFunction: Constant;
 }

package/dst/Constant.js

@@ -21,7 +21,4 @@ export class Constant {
         return this._deterministic;
     }
     static Null = new Constant(undefined);
-    static EmptyArray = new Constant([]);
-    static EmptyObject = new Constant({});
-    static EmptyFunction = new Constant(() => undefined, Type.functionType(undefined, [], false));
 }

package/dst/Keywords.js

@@ -1,15 +1,15 @@
 export const Keywords = [
     "true", "false",
     "null", "void",
-    "boolean", "bool",
-    "timestamp", "time",
-    "float", "flo",
-    "integer", "int",
-    "buffer", "buf",
-    "string", "str",
-    "array", "arr",
-    "object", "obj",
-    "function", "func",
+    "boolean",
+    "timestamp",
+    "float",
+    "integer",
+    "buffer",
+    "string",
+    "array",
+    "object",
+    "function",
     "variable", "var",
     "constant", "const",
     "while",

package/dst/ParserState.d.ts

@@ -29,15 +29,15 @@ export declare class ParserState extends ParserFrame {
     get isBracketsClose(): boolean;
     get isBracesOpen(): boolean;
     get isBracesClose(): boolean;
-    get isSemicolonSeparator(): boolean;
-    get isColonSeparator(): boolean;
-    get isCommaSeparator(): boolean;
-    get isDotMark(): boolean;
-    get isQuestionMark(): boolean;
-    get isTildaMark(): boolean;
-    get isVariadicFunction(): boolean;
-    get isVariableDefinition(): boolean;
-    get isConstantDefinition(): boolean;
+    get isSemicolon(): boolean;
+    get isColon(): boolean;
+    get isComma(): boolean;
+    get isDot(): boolean;
+    get isQuestion(): boolean;
+    get isTilda(): boolean;
+    get isEllipsis(): boolean;
+    get isVariable(): boolean;
+    get isValue(): boolean;
     get isWhile(): boolean;
     get isIf(): boolean;
     get isElse(): boolean;