@mojir/lits 2.0.8 → 2.0.10

package/dist/lits.iife.js

@@ -3164,7 +3164,7 @@ var Lits = (function (exports) {
         },
     };
 
-    var version = "2.0.8";
+    var version = "2.0.10";
 
     var uuidTemplate = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
     var xyRegexp = /[xy]/g;
@@ -4379,6 +4379,7 @@ var Lits = (function (exports) {
             };
             return node;
         },
+        validateParameterCount: function () { return undefined; },
         evaluate: function (node, contextStack, _a) {
             var e_1, _b;
             var evaluateAstNode = _a.evaluateAstNode;
@@ -4406,42 +4407,30 @@ var Lits = (function (exports) {
         },
     };
 
-    var commentSpecialExpression = {
-        parse: function (tokenStream, parseState, firstToken, _a) {
-            var parseToken = _a.parseToken;
-            var node = {
-                t: exports.AstNodeType.SpecialExpression,
-                n: 'comment',
-                p: [],
-                token: undefined,
-            };
-            var tkn = asToken(tokenStream.tokens[parseState.position]);
-            while (!isRParenToken(tkn)) {
-                node.p.push(parseToken(tokenStream, parseState));
-                tkn = asToken(tokenStream.tokens[parseState.position]);
-            }
-            parseState.position += 1;
-            node.token = getTokenDebugData(firstToken) && firstToken;
-            return node;
-        },
-        evaluate: function () { return null; },
-        findUnresolvedIdentifiers: function () { return new Set(); },
-    };
-
-    var condSpecialExpression = {
-        parse: function (tokenStream, parseState, firstToken, _a) {
+    function getCommonParser(name) {
+        return function (tokenStream, parseState, firstToken, _a) {
             var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
             var params = parseTokensUntilClosingBracket(tokenStream, parseState);
             assertRParenToken(tokenStream.tokens[parseState.position++]);
-            var node = {
+            return {
                 t: exports.AstNodeType.SpecialExpression,
-                n: 'cond',
+                n: name,
                 p: params,
                 token: getTokenDebugData(firstToken) && firstToken,
             };
-            assertEvenNumberOfParams(node);
-            return node;
-        },
+        };
+    }
+
+    var commentSpecialExpression = {
+        parse: getCommonParser('comment'),
+        validateParameterCount: function () { return undefined; },
+        evaluate: function () { return null; },
+        findUnresolvedIdentifiers: function () { return new Set(); },
+    };
+
+    var condSpecialExpression = {
+        parse: getCommonParser('cond'),
+        validateParameterCount: function (node) { return assertEvenNumberOfParams(node); },
         evaluate: function (node, contextStack, _a) {
             var e_1, _b;
             var evaluateAstNode = _a.evaluateAstNode;
@@ -4470,19 +4459,8 @@ var Lits = (function (exports) {
     };
 
     var declaredSpecialExpression = {
-        parse: function (tokenStream, parseState, firstToken, _a) {
-            var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-            var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-            assertRParenToken(tokenStream.tokens[parseState.position++]);
-            var node = {
-                t: exports.AstNodeType.SpecialExpression,
-                n: 'declared?',
-                p: params,
-                token: getTokenDebugData(firstToken) && firstToken,
-            };
-            assertNumberOfParams(1, node);
-            return node;
-        },
+        parse: getCommonParser('declared?'),
+        validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
         evaluate: function (node, contextStack) {
             var lookUpResult = contextStack.lookUp(node.p[0]);
             return lookUpResult !== null;
@@ -4528,9 +4506,9 @@ var Lits = (function (exports) {
                 token: getTokenDebugData(firstToken) && firstToken,
             };
             assertSymbolNode(node.p[0], (_b = getTokenDebugData(node.token)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
-            assertNumberOfParams(2, node);
             return node;
         },
+        validateParameterCount: function (node) { return assertNumberOfParams(2, node); },
         evaluate: function (node, contextStack, _a) {
             var _b;
             var evaluateAstNode = _a.evaluateAstNode, builtin = _a.builtin;
@@ -4566,9 +4544,9 @@ var Lits = (function (exports) {
                 p: params,
                 token: getTokenDebugData(firstToken) && firstToken,
             };
-            assertNumberOfParams(2, node);
             return node;
         },
+        validateParameterCount: function (node) { return assertNumberOfParams(2, node); },
         evaluate: function (node, contextStack, _a) {
             var _b, _c;
             var evaluateAstNode = _a.evaluateAstNode, builtin = _a.builtin;
@@ -4596,23 +4574,8 @@ var Lits = (function (exports) {
     };
 
     var doSpecialExpression = {
-        parse: function (tokenStream, parseState, firstToken, _a) {
-            var parseToken = _a.parseToken;
-            var node = {
-                t: exports.AstNodeType.SpecialExpression,
-                n: 'do',
-                p: [],
-                token: undefined,
-            };
-            var tkn = asToken(tokenStream.tokens[parseState.position]);
-            while (!isRParenToken(tkn)) {
-                node.p.push(parseToken(tokenStream, parseState));
-                tkn = asToken(tokenStream.tokens[parseState.position]);
-            }
-            parseState.position += 1;
-            node.token = getTokenDebugData(firstToken) && firstToken;
-            return node;
-        },
+        parse: getCommonParser('do'),
+        validateParameterCount: function () { return undefined; },
         evaluate: function (node, contextStack, _a) {
             var e_1, _b;
             var evaluateAstNode = _a.evaluateAstNode;
@@ -4689,6 +4652,7 @@ var Lits = (function (exports) {
             };
             return node;
         },
+        validateParameterCount: function () { return undefined; },
         evaluate: function (node, contextStack, _a) {
             var _b;
             var _c, _d;
@@ -4730,6 +4694,7 @@ var Lits = (function (exports) {
             };
             return node;
         },
+        validateParameterCount: function () { return undefined; },
         evaluate: function (node, contextStack, _a) {
             var _b;
             var _c, _d;
@@ -4773,6 +4738,7 @@ var Lits = (function (exports) {
             };
             return node;
         },
+        validateParameterCount: function () { return undefined; },
         evaluate: function (node, contextStack, _a) {
             var _b;
             var _c;
@@ -5004,19 +4970,8 @@ var Lits = (function (exports) {
     }
 
     var ifSpecialExpression = {
-        parse: function (tokenStream, parseState, firstToken, _a) {
-            var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-            var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-            assertRParenToken(tokenStream.tokens[parseState.position++]);
-            var node = {
-                t: exports.AstNodeType.SpecialExpression,
-                n: 'if',
-                p: params,
-                token: getTokenDebugData(firstToken) && firstToken,
-            };
-            assertNumberOfParams({ min: 2, max: 3 }, node);
-            return node;
-        },
+        parse: getCommonParser('if'),
+        validateParameterCount: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
         evaluate: function (node, contextStack, _a) {
             var _b;
             var evaluateAstNode = _a.evaluateAstNode;
@@ -5055,9 +5010,9 @@ var Lits = (function (exports) {
                 p: params,
                 token: getTokenDebugData(firstToken) && firstToken,
             };
-            assertNumberOfParams({ min: 1, max: 2 }, node);
             return node;
         },
+        validateParameterCount: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
         evaluate: function (node, contextStack, _a) {
             var _b;
             var evaluateAstNode = _a.evaluateAstNode;
@@ -5087,19 +5042,8 @@ var Lits = (function (exports) {
     };
 
     var ifNotSpecialExpression = {
-        parse: function (tokenStream, parseState, firstToken, _a) {
-            var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-            var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-            assertRParenToken(tokenStream.tokens[parseState.position++]);
-            var node = {
-                t: exports.AstNodeType.SpecialExpression,
-                n: 'if-not',
-                p: params,
-                token: getTokenDebugData(firstToken) && firstToken,
-            };
-            assertNumberOfParams({ min: 2, max: 3 }, node);
-            return node;
-        },
+        parse: getCommonParser('if-not'),
+        validateParameterCount: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
         evaluate: function (node, contextStack, _a) {
             var _b;
             var evaluateAstNode = _a.evaluateAstNode;
@@ -5136,6 +5080,7 @@ var Lits = (function (exports) {
             };
             return node;
         },
+        validateParameterCount: function () { return undefined; },
         evaluate: function (node, contextStack, _a) {
             var e_1, _b, e_2, _c;
             var evaluateAstNode = _a.evaluateAstNode;
@@ -5207,6 +5152,7 @@ var Lits = (function (exports) {
             };
             return node;
         },
+        validateParameterCount: function () { return undefined; },
         evaluate: function (node, contextStack, _a) {
             var _b;
             var evaluateAstNode = _a.evaluateAstNode;
@@ -5470,9 +5416,9 @@ var Lits = (function (exports) {
                 p: params,
                 token: getTokenDebugData(firstToken) && firstToken,
             };
-            assertNumberOfParams(1, node);
             return node;
         },
+        validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
         evaluate: function (node, contextStack, helpers) { return evaluateLoop(true, node, contextStack, helpers.evaluateAstNode); },
         findUnresolvedIdentifiers: function (node, contextStack, _a) {
             var findUnresolvedIdentifiers = _a.findUnresolvedIdentifiers, builtin = _a.builtin;
@@ -5492,9 +5438,9 @@ var Lits = (function (exports) {
                 p: params,
                 token: getTokenDebugData(firstToken) && firstToken,
             };
-            assertNumberOfParams(1, node);
             return node;
         },
+        validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
         evaluate: function (node, contextStack, helpers) {
             evaluateLoop(false, node, contextStack, helpers.evaluateAstNode);
             return null;
@@ -5506,18 +5452,8 @@ var Lits = (function (exports) {
     };
 
     var orSpecialExpression = {
-        parse: function (tokenStream, parseState, firstToken, _a) {
-            var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-            var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-            assertRParenToken(tokenStream.tokens[parseState.position++]);
-            var node = {
-                t: exports.AstNodeType.SpecialExpression,
-                n: 'or',
-                p: params,
-                token: getTokenDebugData(firstToken) && firstToken,
-            };
-            return node;
-        },
+        parse: getCommonParser('or'),
+        validateParameterCount: function () { return undefined; },
         evaluate: function (node, contextStack, _a) {
             var e_1, _b;
             var evaluateAstNode = _a.evaluateAstNode;
@@ -5546,19 +5482,8 @@ var Lits = (function (exports) {
     };
 
     var qqSpecialExpression = {
-        parse: function (tokenStream, parseState, firstToken, _a) {
-            var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-            var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-            assertRParenToken(tokenStream.tokens[parseState.position++]);
-            var node = {
-                t: exports.AstNodeType.SpecialExpression,
-                n: '??',
-                p: params,
-                token: getTokenDebugData(firstToken) && firstToken,
-            };
-            assertNumberOfParams({ min: 1, max: 2 }, node);
-            return node;
-        },
+        parse: getCommonParser('??'),
+        validateParameterCount: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
         evaluate: function (node, contextStack, _a) {
             var _b;
             var evaluateAstNode = _a.evaluateAstNode;
@@ -5590,6 +5515,7 @@ var Lits = (function (exports) {
             };
             return node;
         },
+        validateParameterCount: function () { return undefined; },
         evaluate: function (node, contextStack, _a) {
             var evaluateAstNode = _a.evaluateAstNode;
             var params = node.p.map(function (paramNode) { return evaluateAstNode(paramNode, contextStack); });
@@ -5602,19 +5528,8 @@ var Lits = (function (exports) {
     };
 
     var throwSpecialExpression = {
-        parse: function (tokenStream, parseState, firstToken, _a) {
-            var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-            var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-            assertRParenToken(tokenStream.tokens[parseState.position++]);
-            var node = {
-                t: exports.AstNodeType.SpecialExpression,
-                n: 'throw',
-                p: params,
-                token: getTokenDebugData(firstToken) && firstToken,
-            };
-            assertNumberOfParams(1, node);
-            return node;
-        },
+        parse: getCommonParser('throw'),
+        validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
         evaluate: function (node, contextStack, _a) {
             var _b, _c;
             var evaluateAstNode = _a.evaluateAstNode;
@@ -5630,19 +5545,8 @@ var Lits = (function (exports) {
     };
 
     var timeSpecialExpression = {
-        parse: function (tokenStream, parseState, firstToken, _a) {
-            var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-            var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-            assertRParenToken(tokenStream.tokens[parseState.position++]);
-            var node = {
-                t: exports.AstNodeType.SpecialExpression,
-                n: 'time!',
-                p: params,
-                token: getTokenDebugData(firstToken) && firstToken,
-            };
-            assertNumberOfParams(1, node);
-            return node;
-        },
+        parse: getCommonParser('time!'),
+        validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
         evaluate: function (node, contextStack, _a) {
             var evaluateAstNode = _a.evaluateAstNode;
             var param = node.p[0];
@@ -5683,9 +5587,9 @@ var Lits = (function (exports) {
                 e: error,
                 token: getTokenDebugData(firstToken) && firstToken,
             };
-            assertNumberOfParams(1, node);
             return node;
         },
+        validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
         evaluate: function (node, contextStack, _a) {
             var _b;
             var _c;
@@ -5715,19 +5619,8 @@ var Lits = (function (exports) {
     };
 
     var whenSpecialExpression = {
-        parse: function (tokenStream, parseState, firstToken, _a) {
-            var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-            var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-            assertRParenToken(tokenStream.tokens[parseState.position++]);
-            var node = {
-                t: exports.AstNodeType.SpecialExpression,
-                n: 'when',
-                p: params,
-                token: getTokenDebugData(firstToken) && firstToken,
-            };
-            assertNumberOfParams({ min: 1 }, node);
-            return node;
-        },
+        parse: getCommonParser('when'),
+        validateParameterCount: function (node) { return assertNumberOfParams({ min: 1 }, node); },
         evaluate: function (node, contextStack, _a) {
             var e_1, _b;
             var _c;
@@ -5777,6 +5670,7 @@ var Lits = (function (exports) {
             };
             return node;
         },
+        validateParameterCount: function () { return undefined; },
         evaluate: function (node, contextStack, _a) {
             var e_1, _b;
             var _c;
@@ -5838,6 +5732,7 @@ var Lits = (function (exports) {
             };
             return node;
         },
+        validateParameterCount: function () { return undefined; },
         evaluate: function (node, contextStack, _a) {
             var e_1, _b;
             var evaluateAstNode = _a.evaluateAstNode;
@@ -5876,19 +5771,8 @@ var Lits = (function (exports) {
     };
 
     var whenNotSpecialExpression = {
-        parse: function (tokenStream, parseState, firstToken, _a) {
-            var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-            var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-            assertRParenToken(tokenStream.tokens[parseState.position++]);
-            var node = {
-                t: exports.AstNodeType.SpecialExpression,
-                n: 'when-not',
-                p: params,
-                token: getTokenDebugData(firstToken) && firstToken,
-            };
-            assertNumberOfParams({ min: 1 }, node);
-            return node;
-        },
+        parse: getCommonParser('when-not'),
+        validateParameterCount: function (node) { return assertNumberOfParams({ min: 1 }, node); },
         evaluate: function (node, contextStack, _a) {
             var e_1, _b;
             var _c;
@@ -7116,6 +7000,7 @@ var Lits = (function (exports) {
     }
 
     var exponentiationPrecedence = 9;
+    var placeholderRegexp$1 = /^\$([1-9]\d?)?$/;
     function getPrecedence(operator) {
         var operatorSign = operator[1];
         switch (operatorSign) {
@@ -7348,7 +7233,7 @@ var Lits = (function (exports) {
             // Parentheses
             if (isLParenToken(token)) {
                 var positionBefore = this.parseState.position;
-                var lamdaFunction = this.parseLamdaFunction();
+                var lamdaFunction = this.parseLambdaFunction();
                 if (lamdaFunction) {
                     return lamdaFunction;
                 }
@@ -7369,6 +7254,9 @@ var Lits = (function (exports) {
                     var operand = this.parseOperand();
                     return fromUnaryAlgebraicToAstNode(token, operand);
                 }
+                else if (operatorName === '=>') {
+                    return this.parseShorthandLamdaFunction();
+                }
                 else {
                     throw new Error("Unknown unary operator: ".concat(operatorName));
                 }
@@ -7484,7 +7372,7 @@ var Lits = (function (exports) {
             };
         };
         AlgebraicParser.prototype.parseFunctionCall = function (symbol) {
-            var _a, _b;
+            var _a, _b, _c;
             var params = [];
             this.advance();
             while (!this.isAtEnd() && !isRParenToken(this.peek())) {
@@ -7516,13 +7404,17 @@ var Lits = (function (exports) {
                         case 'when':
                         case 'when-not':
                         case 'do':
-                        case 'throw':
-                            return {
+                        case 'time!':
+                        case 'throw': {
+                            var node_1 = {
                                 t: exports.AstNodeType.SpecialExpression,
                                 n: name_1,
                                 p: params,
                                 token: getTokenDebugData(symbol.token) && symbol.token,
                             };
+                            builtin.specialExpressions[node_1.n].validateParameterCount(node_1);
+                            return node_1;
+                        }
                         case 'def':
                         case 'defs':
                         case 'let':
@@ -7535,7 +7427,6 @@ var Lits = (function (exports) {
                         case 'try':
                         case 'recur':
                         case 'loop':
-                        case 'time!':
                         case 'doseq':
                         case 'for':
                             throw new Error("Special expression ".concat(name_1, " is not available in algebraic notation"));
@@ -7543,7 +7434,12 @@ var Lits = (function (exports) {
                             throw new Error("Unknown special expression: ".concat(name_1));
                     }
                 }
-                return createNamedNormalExpressionNode(symbol.v, params, symbol.token);
+                var node = createNamedNormalExpressionNode(symbol.v, params, symbol.token);
+                var builtinExpression = builtin.normalExpressions[node.n];
+                if (builtinExpression) {
+                    (_c = builtinExpression.validate) === null || _c === void 0 ? void 0 : _c.call(builtinExpression, __assign(__assign({}, node), { p: withoutCommentNodes(node.p) }));
+                }
+                return node;
             }
             else {
                 return {
@@ -7554,7 +7450,7 @@ var Lits = (function (exports) {
                 };
             }
         };
-        AlgebraicParser.prototype.parseLamdaFunction = function () {
+        AlgebraicParser.prototype.parseLambdaFunction = function () {
             var _a;
             var firstToken = this.peek();
             this.advance();
@@ -7613,6 +7509,62 @@ var Lits = (function (exports) {
                 token: getTokenDebugData(firstToken) && firstToken,
             };
         };
+        AlgebraicParser.prototype.parseShorthandLamdaFunction = function () {
+            var _a, _b, _c, _d;
+            var firstToken = this.peek();
+            this.advance();
+            var startPos = this.parseState.position;
+            var exprNode = this.parseExpression();
+            var endPos = this.parseState.position - 1;
+            var arity = 0;
+            var percent1 = 'NOT_SET'; // referring to argument bindings. % = NAKED, %1, %2, %3, etc = WITH_1
+            for (var pos = startPos; pos <= endPos; pos += 1) {
+                var tkn = this.tokenStream.tokens[pos];
+                if (isA_SymbolToken(tkn)) {
+                    var match = placeholderRegexp$1.exec(tkn[1]);
+                    if (match) {
+                        var number = (_a = match[1]) !== null && _a !== void 0 ? _a : '1';
+                        if (number === '1') {
+                            var mixedPercent1 = (!match[1] && percent1 === 'WITH_1') || (match[1] && percent1 === 'NAKED');
+                            if (mixedPercent1)
+                                throw new LitsError('Please make up your mind, either use $ or $1', (_b = getTokenDebugData(firstToken)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
+                            percent1 = match[1] ? 'WITH_1' : 'NAKED';
+                        }
+                        arity = Math.max(arity, Number(number));
+                        if (arity > 20)
+                            throw new LitsError('Can\'t specify more than 20 arguments', (_c = getTokenDebugData(firstToken)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo);
+                    }
+                }
+                if (isA_OperatorToken(tkn, '=>')) {
+                    throw new LitsError('Nested shortcut functions are not allowed', (_d = getTokenDebugData(firstToken)) === null || _d === void 0 ? void 0 : _d.sourceCodeInfo);
+                }
+            }
+            var mandatoryArguments = [];
+            for (var i = 1; i <= arity; i += 1) {
+                if (i === 1 && percent1 === 'NAKED')
+                    mandatoryArguments.push('$');
+                else
+                    mandatoryArguments.push("$".concat(i));
+            }
+            var args = {
+                b: [],
+                m: mandatoryArguments,
+            };
+            var node = {
+                t: exports.AstNodeType.SpecialExpression,
+                n: 'fn',
+                p: [],
+                o: [
+                    {
+                        as: args,
+                        b: [exprNode],
+                        a: args.m.length,
+                    },
+                ],
+                token: getTokenDebugData(firstToken) && firstToken,
+            };
+            return node;
+        };
         AlgebraicParser.prototype.isAtEnd = function () {
             return this.parseState.position >= this.tokenStream.tokens.length;
         };
@@ -7856,7 +7808,7 @@ var Lits = (function (exports) {
         var firstToken = asLParenToken(tokenStream.tokens[parseState.position++]);
         var nameToken = asP_SymbolToken(tokenStream.tokens[parseState.position++]);
         var expressionName = nameToken[1];
-        var parse = asNonUndefined(builtin.specialExpressions[expressionName], (_a = getTokenDebugData(nameToken)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo).parse;
+        var _b = asNonUndefined(builtin.specialExpressions[expressionName], (_a = getTokenDebugData(nameToken)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo), parse = _b.parse, validateParameterCount = _b.validateParameterCount;
         var node = parse(tokenStream, parseState, firstToken, {
             parseExpression: parseExpression,
             parseTokensUntilClosingBracket: parseTokensUntilClosingBracket,
@@ -7865,6 +7817,7 @@ var Lits = (function (exports) {
             parseBindings: parseBindings,
             parseArgument: parseArgument,
         });
+        validateParameterCount(node);
         return node;
     }
     function parsePolishToken(tokenStream, parseState) {