@mojir/lits 2.0.10 → 2.0.11

package/dist/cli/cli.js

@@ -92,7 +92,7 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-var version = "2.0.10";
+var version = "2.0.11";
 
 var AstNodeType;
 (function (AstNodeType) {
@@ -420,6 +420,12 @@ function isA_SymbolToken(token) {
 function isA_ReservedSymbolToken(token) {
     return (token === null || token === void 0 ? void 0 : token[0]) === 'A_ReservedSymbol';
 }
+function isA_CommentToken(token) {
+    return (token === null || token === void 0 ? void 0 : token[0]) === 'A_SingleLineComment';
+}
+function isA_MultiLineCommentToken(token) {
+    return (token === null || token === void 0 ? void 0 : token[0]) === 'A_MultiLineComment';
+}
 function isA_OperatorToken(token, operatorName) {
     if ((token === null || token === void 0 ? void 0 : token[0]) !== 'A_Operator') {
         return false;
@@ -4332,7 +4338,7 @@ var functionalNormalExpression = {
 var normalExpressions = __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, bitwiseNormalExpression), collectionNormalExpression), arrayNormalExpression), sequenceNormalExpression), mathNormalExpression), miscNormalExpression), assertNormalExpression), objectNormalExpression), predicatesNormalExpression), regexpNormalExpression), stringNormalExpression), functionalNormalExpression);
 
 var andSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
+    polishParse: function (tokenStream, parseState, firstToken, _a) {
         var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
         var params = parseTokensUntilClosingBracket(tokenStream, parseState);
         assertRParenToken(tokenStream.tokens[parseState.position++]);
@@ -4372,7 +4378,7 @@ var andSpecialExpression = {
     },
 };
 
-function getCommonParser(name) {
+function getCommonPolishSpecialExpressionParser(name) {
     return function (tokenStream, parseState, firstToken, _a) {
         var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
         var params = parseTokensUntilClosingBracket(tokenStream, parseState);
@@ -4387,14 +4393,14 @@ function getCommonParser(name) {
 }
 
 var commentSpecialExpression = {
-    parse: getCommonParser('comment'),
+    polishParse: getCommonPolishSpecialExpressionParser('comment'),
     validateParameterCount: function () { return undefined; },
     evaluate: function () { return null; },
     findUnresolvedIdentifiers: function () { return new Set(); },
 };
 
 var condSpecialExpression = {
-    parse: getCommonParser('cond'),
+    polishParse: getCommonPolishSpecialExpressionParser('cond'),
     validateParameterCount: function (node) { return assertEvenNumberOfParams(node); },
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
@@ -4424,7 +4430,7 @@ var condSpecialExpression = {
 };
 
 var declaredSpecialExpression = {
-    parse: getCommonParser('declared?'),
+    polishParse: getCommonPolishSpecialExpressionParser('declared?'),
     validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
     evaluate: function (node, contextStack) {
         var lookUpResult = contextStack.lookUp(node.p[0]);
@@ -4459,7 +4465,7 @@ function assertNameNotDefined(name, contextStack, builtin, sourceCodeInfo) {
 }
 
 var defSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
+    polishParse: function (tokenStream, parseState, firstToken, _a) {
         var _b;
         var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
         var params = parseTokensUntilClosingBracket(tokenStream, parseState);
@@ -4499,7 +4505,7 @@ var defSpecialExpression = {
 };
 
 var defsSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
+    polishParse: function (tokenStream, parseState, firstToken, _a) {
         var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
         var params = parseTokensUntilClosingBracket(tokenStream, parseState);
         assertRParenToken(tokenStream.tokens[parseState.position++]);
@@ -4539,7 +4545,7 @@ var defsSpecialExpression = {
 };
 
 var doSpecialExpression = {
-    parse: getCommonParser('do'),
+    polishParse: getCommonPolishSpecialExpressionParser('do'),
     validateParameterCount: function () { return undefined; },
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
@@ -4600,7 +4606,7 @@ function combinate(arrays) {
 }
 
 var defnSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, parsers) {
+    polishParse: function (tokenStream, parseState, firstToken, parsers) {
         var _a;
         var parseToken = parsers.parseToken;
         var functionName = parseToken(tokenStream, parseState);
@@ -4644,7 +4650,7 @@ var defnSpecialExpression = {
     },
 };
 var defnsSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, parsers) {
+    polishParse: function (tokenStream, parseState, firstToken, parsers) {
         var parseToken = parsers.parseToken;
         var functionName = parseToken(tokenStream, parseState);
         var functionOverloades = parseFunctionOverloades(tokenStream, parseState, parsers);
@@ -4691,7 +4697,7 @@ var defnsSpecialExpression = {
     },
 };
 var fnSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, parsers) {
+    polishParse: function (tokenStream, parseState, firstToken, parsers) {
         var functionOverloades = parseFunctionOverloades(tokenStream, parseState, parsers);
         assertRParenToken(tokenStream.tokens[parseState.position++]);
         var node = {
@@ -4935,7 +4941,7 @@ function parseFunctionArguments(tokenStream, parseState, parsers) {
 }
 
 var ifSpecialExpression = {
-    parse: getCommonParser('if'),
+    polishParse: getCommonPolishSpecialExpressionParser('if'),
     validateParameterCount: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     evaluate: function (node, contextStack, _a) {
         var _b;
@@ -4959,7 +4965,7 @@ var ifSpecialExpression = {
 };
 
 var ifLetSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
+    polishParse: function (tokenStream, parseState, firstToken, _a) {
         var _b, _c;
         var parseBindings = _a.parseBindings, parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
         var bindings = parseBindings(tokenStream, parseState);
@@ -5007,7 +5013,7 @@ var ifLetSpecialExpression = {
 };
 
 var ifNotSpecialExpression = {
-    parse: getCommonParser('if-not'),
+    polishParse: getCommonPolishSpecialExpressionParser('if-not'),
     validateParameterCount: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     evaluate: function (node, contextStack, _a) {
         var _b;
@@ -5031,7 +5037,7 @@ var ifNotSpecialExpression = {
 };
 
 var letSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
+    polishParse: function (tokenStream, parseState, firstToken, _a) {
         var parseBindings = _a.parseBindings, parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
         var bindings = parseBindings(tokenStream, parseState);
         var params = parseTokensUntilClosingBracket(tokenStream, parseState);
@@ -5103,7 +5109,7 @@ var letSpecialExpression = {
 };
 
 var loopSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
+    polishParse: function (tokenStream, parseState, firstToken, _a) {
         var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket, parseBindings = _a.parseBindings;
         var bindings = parseBindings(tokenStream, parseState);
         var params = parseTokensUntilClosingBracket(tokenStream, parseState);
@@ -5369,7 +5375,7 @@ function analyze$1(node, contextStack, findUnresolvedIdentifiers, builtin) {
     return result;
 }
 var forSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, parsers) {
+    polishParse: function (tokenStream, parseState, firstToken, parsers) {
         var parseTokensUntilClosingBracket = parsers.parseTokensUntilClosingBracket;
         var loopBindings = parseLoopBindings(tokenStream, parseState, parsers);
         var params = parseTokensUntilClosingBracket(tokenStream, parseState);
@@ -5391,7 +5397,7 @@ var forSpecialExpression = {
     },
 };
 var doseqSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, parsers) {
+    polishParse: function (tokenStream, parseState, firstToken, parsers) {
         var parseTokensUntilClosingBracket = parsers.parseTokensUntilClosingBracket;
         var loopBindings = parseLoopBindings(tokenStream, parseState, parsers);
         var params = parseTokensUntilClosingBracket(tokenStream, parseState);
@@ -5417,7 +5423,7 @@ var doseqSpecialExpression = {
 };
 
 var orSpecialExpression = {
-    parse: getCommonParser('or'),
+    polishParse: getCommonPolishSpecialExpressionParser('or'),
     validateParameterCount: function () { return undefined; },
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
@@ -5447,7 +5453,7 @@ var orSpecialExpression = {
 };
 
 var qqSpecialExpression = {
-    parse: getCommonParser('??'),
+    polishParse: getCommonPolishSpecialExpressionParser('??'),
     validateParameterCount: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
     evaluate: function (node, contextStack, _a) {
         var _b;
@@ -5468,7 +5474,7 @@ var qqSpecialExpression = {
 };
 
 var recurSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
+    polishParse: function (tokenStream, parseState, firstToken, _a) {
         var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
         var params = parseTokensUntilClosingBracket(tokenStream, parseState);
         assertRParenToken(tokenStream.tokens[parseState.position++]);
@@ -5493,7 +5499,7 @@ var recurSpecialExpression = {
 };
 
 var throwSpecialExpression = {
-    parse: getCommonParser('throw'),
+    polishParse: getCommonPolishSpecialExpressionParser('throw'),
     validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
     evaluate: function (node, contextStack, _a) {
         var _b, _c;
@@ -5510,7 +5516,7 @@ var throwSpecialExpression = {
 };
 
 var timeSpecialExpression = {
-    parse: getCommonParser('time!'),
+    polishParse: getCommonPolishSpecialExpressionParser('time!'),
     validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
     evaluate: function (node, contextStack, _a) {
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5529,7 +5535,7 @@ var timeSpecialExpression = {
 };
 
 var trySpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
+    polishParse: function (tokenStream, parseState, firstToken, _a) {
         var _b, _c, _d;
         var parseToken = _a.parseToken;
         var tryExpression = parseToken(tokenStream, parseState);
@@ -5584,7 +5590,7 @@ var trySpecialExpression = {
 };
 
 var whenSpecialExpression = {
-    parse: getCommonParser('when'),
+    polishParse: getCommonPolishSpecialExpressionParser('when'),
     validateParameterCount: function (node) { return assertNumberOfParams({ min: 1 }, node); },
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
@@ -5617,7 +5623,7 @@ var whenSpecialExpression = {
 };
 
 var whenFirstSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
+    polishParse: function (tokenStream, parseState, firstToken, _a) {
         var _b, _c;
         var parseBindings = _a.parseBindings, parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
         var bindings = parseBindings(tokenStream, parseState);
@@ -5679,7 +5685,7 @@ var whenFirstSpecialExpression = {
 };
 
 var whenLetSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
+    polishParse: function (tokenStream, parseState, firstToken, _a) {
         var _b, _c;
         var parseBindings = _a.parseBindings, parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
         var bindings = parseBindings(tokenStream, parseState);
@@ -5736,7 +5742,7 @@ var whenLetSpecialExpression = {
 };
 
 var whenNotSpecialExpression = {
-    parse: getCommonParser('when-not'),
+    polishParse: getCommonPolishSpecialExpressionParser('when-not'),
     validateParameterCount: function (node) { return assertNumberOfParams({ min: 1 }, node); },
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
@@ -7380,9 +7386,10 @@ var AlgebraicParser = /** @class */ (function () {
                         builtin.specialExpressions[node_1.n].validateParameterCount(node_1);
                         return node_1;
                     }
+                    case 'let':
+                        return this.parseLet(symbol, params);
                     case 'def':
                     case 'defs':
-                    case 'let':
                     case 'if-let':
                     case 'when-let':
                     case 'when-first':
@@ -7416,31 +7423,40 @@ var AlgebraicParser = /** @class */ (function () {
         }
     };
     AlgebraicParser.prototype.parseLambdaFunction = function () {
-        var _a;
+        var _a, _b;
         var firstToken = this.peek();
         this.advance();
-        var spread = false;
+        var rest = false;
+        var letBindingObject;
         var args = [];
         var restArg;
         while (!this.isAtEnd() && !isRParenToken(this.peek())) {
-            if (isA_OperatorToken(this.peek(), '...')) {
-                if (spread) {
-                    throw new LitsError('Multiple spread operators in lambda function', (_a = getTokenDebugData(this.peek())) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
-                }
-                this.advance();
-                spread = true;
+            if (letBindingObject) {
+                throw new LitsError('Expected right parentheses', (_a = getTokenDebugData(this.peek())) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
             }
-            var symbolToken = this.peek();
-            if (!isA_SymbolToken(symbolToken)) {
-                return null;
-            }
-            if (spread) {
-                restArg = symbolToken[1];
+            if (isLBraceToken(this.peek())) {
+                letBindingObject = this.parseObject();
             }
             else {
-                args.push(symbolToken[1]);
+                if (isA_OperatorToken(this.peek(), '...')) {
+                    if (rest) {
+                        throw new LitsError('Multiple spread operators in lambda function', (_b = getTokenDebugData(this.peek())) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
+                    }
+                    this.advance();
+                    rest = true;
+                }
+                var symbolToken = this.peek();
+                if (!isA_SymbolToken(symbolToken)) {
+                    return null;
+                }
+                if (rest) {
+                    restArg = symbolToken[1];
+                }
+                else {
+                    args.push(symbolToken[1]);
+                }
+                this.advance();
             }
-            this.advance();
             if (!isA_OperatorToken(this.peek(), ',') && !isRParenToken(this.peek())) {
                 return null;
             }
@@ -7456,6 +7472,7 @@ var AlgebraicParser = /** @class */ (function () {
             return null;
         }
         this.advance();
+        var letBindings = letBindingObject ? arrayToPairs(letBindingObject.p) : [];
         var body = this.parseExpression();
         var arity = restArg !== undefined ? { min: args.length } : args.length;
         return {
@@ -7466,7 +7483,17 @@ var AlgebraicParser = /** @class */ (function () {
                     as: {
                         m: args,
                         r: restArg,
-                        b: [],
+                        b: letBindings.map(function (pair) {
+                            var key = pair[0];
+                            var value = pair[1];
+                            return {
+                                t: AstNodeType.Binding,
+                                n: key.v,
+                                v: value,
+                                p: [],
+                                token: getTokenDebugData(key.token) && key.token,
+                            };
+                        }),
                     },
                     b: [body],
                     a: arity,
@@ -7530,6 +7557,35 @@ var AlgebraicParser = /** @class */ (function () {
         };
         return node;
     };
+    AlgebraicParser.prototype.parseLet = function (nameSymbol, params) {
+        var _a, _b;
+        if (params.length !== 2) {
+            throw new LitsError('let expects two arguments', (_a = getTokenDebugData(nameSymbol.token)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
+        }
+        var letObject = params[0];
+        if (letObject.t !== AstNodeType.NormalExpression || letObject.n !== 'object') {
+            throw new LitsError('let expects an object as first argument', (_b = getTokenDebugData(letObject.token)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
+        }
+        var letBindings = arrayToPairs(letObject.p);
+        var expression = params[1];
+        return {
+            t: AstNodeType.SpecialExpression,
+            n: 'let',
+            p: [expression],
+            token: getTokenDebugData(nameSymbol.token) && nameSymbol.token,
+            bs: letBindings.map(function (pair) {
+                var key = pair[0];
+                var value = pair[1];
+                return {
+                    t: AstNodeType.Binding,
+                    n: key.v,
+                    v: value,
+                    p: [],
+                    token: getTokenDebugData(key.token) && key.token,
+                };
+            }),
+        };
+    };
     AlgebraicParser.prototype.isAtEnd = function () {
         return this.parseState.position >= this.tokenStream.tokens.length;
     };
@@ -7773,7 +7829,7 @@ function parseSpecialExpression(tokenStream, parseState) {
     var firstToken = asLParenToken(tokenStream.tokens[parseState.position++]);
     var nameToken = asP_SymbolToken(tokenStream.tokens[parseState.position++]);
     var expressionName = nameToken[1];
-    var _b = asNonUndefined(builtin.specialExpressions[expressionName], (_a = getTokenDebugData(nameToken)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo), parse = _b.parse, validateParameterCount = _b.validateParameterCount;
+    var _b = asNonUndefined(builtin.specialExpressions[expressionName], (_a = getTokenDebugData(nameToken)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo), parse = _b.polishParse, validateParameterCount = _b.validateParameterCount;
     var node = parse(tokenStream, parseState, firstToken, {
         parseExpression: parseExpression,
         parseTokensUntilClosingBracket: parseTokensUntilClosingBracket,
@@ -7872,7 +7928,11 @@ function parse(tokenStream) {
 }
 function removeUnnecessaryTokens(tokenStream) {
     var tokens = tokenStream.tokens.filter(function (token) {
-        if (isP_CommentToken(token) || isA_WhitespaceToken(token) || isP_WhitespaceToken(token)) {
+        if (isP_CommentToken(token)
+            || isA_CommentToken(token)
+            || isA_MultiLineCommentToken(token)
+            || isA_WhitespaceToken(token)
+            || isP_WhitespaceToken(token)) {
             return false;
         }
         return true;
@@ -8188,7 +8248,6 @@ var algebraicReservedNamesRecord = {
     'null': { value: null },
     'def': { value: null, forbidden: true },
     'defs': { value: null, forbidden: true },
-    'let': { value: null, forbidden: true },
     'if-let': { value: null, forbidden: true },
     'when-let': { value: null, forbidden: true },
     'when-first': { value: null, forbidden: true },

package/dist/cli/src/builtin/index.d.ts

@@ -33,8 +33,8 @@ export type CommonSpecialExpressionName = keyof Pick<typeof specialExpressions,
 export type BuiltinSpecialExpressions = typeof specialExpressions;
 export type BuiltinSpecialExpression = typeof specialExpressions[SpecialExpressionName];
 export type BuiltinCommonSpecialExpression = typeof specialExpressions[CommonSpecialExpressionName];
-export type GenericCommonSpecialExpressionNode<T extends CommonSpecialExpressionName> = ReturnType<typeof specialExpressions[T]['parse']>;
-export type SpecialExpressionNode = ReturnType<typeof specialExpressions[SpecialExpressionName]['parse']>;
+export type GenericCommonSpecialExpressionNode<T extends CommonSpecialExpressionName> = ReturnType<typeof specialExpressions[T]['polishParse']>;
+export type SpecialExpressionNode = ReturnType<typeof specialExpressions[SpecialExpressionName]['polishParse']>;
 export declare const builtin: Builtin;
 export declare const normalExpressionKeys: string[];
 export declare const specialExpressionKeys: string[];

package/dist/cli/src/builtin/interface.d.ts

@@ -29,7 +29,7 @@ interface EvaluateHelpers {
     builtin: Builtin;
 }
 export interface BuiltinSpecialExpression<T, N extends SpecialExpressionNode> {
-    parse: (tokenStream: TokenStream, parseState: ParseState, firstToken: Token, parsers: ParserHelpers) => N;
+    polishParse: (tokenStream: TokenStream, parseState: ParseState, firstToken: Token, parsers: ParserHelpers) => N;
     evaluate: (node: N, contextStack: ContextStack, helpers: EvaluateHelpers) => T;
     validateParameterCount: ValidateSpecialExpressionNode;
     findUnresolvedIdentifiers: (node: N, contextStack: ContextStack, params: {

package/dist/cli/src/builtin/specialExpressions/commonParser.d.ts

@@ -1,4 +1,4 @@
 import type { CommonSpecialExpressionName, GenericCommonSpecialExpressionNode } from '..';
 import type { Any } from '../../interface';
 import type { BuiltinSpecialExpression } from '../interface';
-export declare function getCommonParser<T extends CommonSpecialExpressionName>(name: T): BuiltinSpecialExpression<Any, GenericCommonSpecialExpressionNode<T>>['parse'];
+export declare function getCommonPolishSpecialExpressionParser<T extends CommonSpecialExpressionName>(name: T): BuiltinSpecialExpression<Any, GenericCommonSpecialExpressionNode<T>>['polishParse'];

package/dist/cli/src/parser/AlgebraicParser.d.ts

@@ -13,6 +13,7 @@ export declare class AlgebraicParser {
     private parseFunctionCall;
     parseLambdaFunction(): AstNode | null;
     private parseShorthandLamdaFunction;
+    private parseLet;
     private isAtEnd;
     private peek;
 }