@mojir/lits 2.1.32 → 2.1.34

package/dist/index.js

@@ -11698,165 +11698,13 @@ var doSpecialExpression = {
     },
 };
 
-var nonNumberReservedSymbolRecord = {
-    true: true,
-    false: false,
-    null: null,
-    else: null,
-    case: null,
-    each: null,
-    in: null,
-    when: null,
-    while: null,
-    catch: null,
-    function: null,
-    export: null,
-    as: null,
-    _: null,
-};
-var phi = (1 + Math.sqrt(5)) / 2;
-var numberReservedSymbolRecord = {
-    'E': Math.E,
-    '-E': -Math.E,
-    'ε': Math.E,
-    '-ε': -Math.E,
-    'PI': Math.PI,
-    '-PI': -Math.PI,
-    'π': Math.PI,
-    '-π': -Math.PI,
-    'PHI': phi,
-    '-PHI': -phi,
-    'φ': phi,
-    '-φ': -phi,
-    'POSITIVE_INFINITY': Number.POSITIVE_INFINITY,
-    '∞': Number.POSITIVE_INFINITY,
-    'NEGATIVE_INFINITY': Number.NEGATIVE_INFINITY,
-    '-∞': Number.NEGATIVE_INFINITY,
-    'MAX_SAFE_INTEGER': Number.MAX_SAFE_INTEGER,
-    'MIN_SAFE_INTEGER': Number.MIN_SAFE_INTEGER,
-    'MAX_VALUE': Number.MAX_VALUE,
-    'MIN_VALUE': Number.MIN_VALUE,
-    'NaN': Number.NaN,
-};
-var reservedSymbolRecord = __assign(__assign({}, nonNumberReservedSymbolRecord), numberReservedSymbolRecord);
-function isReservedSymbol(symbol) {
-    return symbol in reservedSymbolRecord;
-}
-function isNumberReservedSymbol(symbol) {
-    return symbol in numberReservedSymbolRecord;
-}
-
-var specialExpressionTypes = {
-    '??': 0,
-    '&&': 1,
-    '||': 2,
-    'array': 3,
-    'cond': 4,
-    '0_def': 5,
-    'defined?': 6,
-    '0_defn': 7,
-    'block': 8,
-    'doseq': 9,
-    '0_fn': 10,
-    'for': 11,
-    'function': 12,
-    'if': 13,
-    'let': 14,
-    'loop': 15,
-    'object': 16,
-    'recur': 17,
-    'switch': 18,
-    'throw': 19,
-    'try': 20,
-    'unless': 21,
-};
-
-function assertNameNotDefined(name, contextStack, builtin, sourceCodeInfo) {
-    if (typeof name !== 'string')
-        return;
-    // TODO only subset of special expressions are necessary to check (CommonSpecialExpressionType)
-    if (specialExpressionTypes[name])
-        throw new LitsError("Cannot define variable ".concat(name, ", it's a special expression."), sourceCodeInfo);
-    if (builtin.normalExpressions[name])
-        throw new LitsError("Cannot define variable ".concat(name, ", it's a builtin function."), sourceCodeInfo);
-    if (isReservedSymbol(name))
-        throw new LitsError("Cannot define variable ".concat(name, ", it's a reserved name."), sourceCodeInfo);
-    if (contextStack.globalContext[name])
-        throw new LitsError("Name already defined \"".concat(name, "\"."), sourceCodeInfo);
-}
-
-var functionSpecialExpression = {
-    arity: {},
-    evaluate: function (node, contextStack, _a) {
-        var _b, _c;
-        var builtin = _a.builtin, getUndefinedSymbols = _a.getUndefinedSymbols, evaluateNode = _a.evaluateNode;
-        var _d = __read(node[1], 4), functionSymbol = _d[1], fn = _d[2], docString = _d[3];
-        assertUserDefinedSymbolNode(functionSymbol, node[2]);
-        assertNameNotDefined(functionSymbol[1], contextStack, builtin, node[2]);
-        var evaluatedFunction = evaluateFunction(fn, contextStack, builtin, getUndefinedSymbols, evaluateNode);
-        var min = evaluatedFunction[0].filter(function (arg) { return arg[0] !== bindingTargetTypes.rest && arg[1][1] === undefined; }).length;
-        var max = evaluatedFunction[0].some(function (arg) { return arg[0] === bindingTargetTypes.rest; }) ? undefined : evaluatedFunction[0].length;
-        var arity = { min: min > 0 ? min : undefined, max: max };
-        var litsFunction = (_b = {},
-            _b[FUNCTION_SYMBOL] = true,
-            _b.sourceCodeInfo = node[2],
-            _b.functionType = 'UserDefined',
-            _b.name = functionSymbol[1],
-            _b.evaluatedfunction = evaluatedFunction,
-            _b.arity = arity,
-            _b.docString = docString,
-            _b);
-        contextStack.addValues((_c = {}, _c[functionSymbol[1]] = litsFunction, _c), functionSymbol[2]);
-        return litsFunction;
-    },
-    getUndefinedSymbols: function (node, contextStack, _a) {
-        var _b, _c;
-        var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
-        var functionName = node[1][1][1];
-        contextStack.addValues((_b = {}, _b[functionName] = true, _b), node[1][1][2]);
-        var newContext = (_c = {}, _c[functionName] = { value: true }, _c);
-        return getFunctionUnresolvedSymbols(node[1][2], contextStack, getUndefinedSymbols, builtin, evaluateNode, newContext);
-    },
-};
-var defnSpecialExpression = {
-    arity: {},
-    evaluate: function (node, contextStack, _a) {
-        var _b, _c;
-        var builtin = _a.builtin, getUndefinedSymbols = _a.getUndefinedSymbols, evaluateNode = _a.evaluateNode;
-        var _d = __read(node[1], 4), functionSymbol = _d[1], fn = _d[2], docString = _d[3];
-        assertUserDefinedSymbolNode(functionSymbol, node[2]);
-        assertNameNotDefined(functionSymbol[1], contextStack, builtin, node[2]);
-        var evaluatedFunction = evaluateFunction(fn, contextStack, builtin, getUndefinedSymbols, evaluateNode);
-        var min = evaluatedFunction[0].filter(function (arg) { return arg[0] !== bindingTargetTypes.rest && arg[1][1] === undefined; }).length;
-        var arity = { min: min };
-        var litsFunction = (_b = {},
-            _b[FUNCTION_SYMBOL] = true,
-            _b.sourceCodeInfo = node[2],
-            _b.functionType = 'UserDefined',
-            _b.name = functionSymbol[1],
-            _b.evaluatedfunction = evaluatedFunction,
-            _b.arity = arity,
-            _b.docString = docString,
-            _b);
-        contextStack.exportValues((_c = {}, _c[functionSymbol[1]] = litsFunction, _c), functionSymbol[2]);
-        return litsFunction;
-    },
-    getUndefinedSymbols: function (node, contextStack, _a) {
-        var _b, _c;
-        var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
-        var functionName = node[1][1][1];
-        var fn = node[1][2];
-        contextStack.exportValues((_b = {}, _b[functionName] = true, _b), node[1][1][2]);
-        var newContext = (_c = {}, _c[functionName] = { value: true }, _c);
-        return getFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin, evaluateNode, newContext);
-    },
-};
-var fnSpecialExpression = {
+var lambdaSpecialExpression = {
     arity: {},
     evaluate: function (node, contextStack, _a) {
         var _b;
         var builtin = _a.builtin, getUndefinedSymbols = _a.getUndefinedSymbols, evaluateNode = _a.evaluateNode;
         var fn = node[1][1];
+        var docString = node[1][2];
         var evaluatedFunction = evaluateFunction(fn, contextStack, builtin, getUndefinedSymbols, evaluateNode);
         var min = evaluatedFunction[0].filter(function (arg) { return arg[0] !== bindingTargetTypes.rest && arg[1][1] === undefined; }).length;
         var max = evaluatedFunction[0].some(function (arg) { return arg[0] === bindingTargetTypes.rest; }) ? undefined : evaluatedFunction[0].length;
@@ -11868,8 +11716,9 @@ var fnSpecialExpression = {
             _b.name = undefined,
             _b.evaluatedfunction = evaluatedFunction,
             _b.arity = arity,
-            _b.docString = '',
+            _b.docString = docString,
             _b);
+        evaluatedFunction[2].self = { value: litsFunction };
         return litsFunction;
     },
     getUndefinedSymbols: function (node, contextStack, _a) {
@@ -11900,17 +11749,16 @@ function evaluateFunction(fn, contextStack, builtin, getUndefinedSymbols, evalua
     ];
     return evaluatedFunction;
 }
-function getFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin, evaluateNode, functionNameContext) {
+function getFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin, evaluateNode) {
     var result = new Set();
-    var contextStackWithFunctionName = functionNameContext ? contextStack.create(functionNameContext) : contextStack;
-    var newContext = {};
+    var newContext = { self: { value: null } };
     fn[0].forEach(function (arg) {
         Object.assign(newContext, getAllBindingTargetNames(arg));
         walkDefaults(arg, function (defaultNode) {
             addToSet(result, getUndefinedSymbols([defaultNode], contextStack, builtin, evaluateNode));
         });
     });
-    var newContextStack = contextStackWithFunctionName.create(newContext);
+    var newContextStack = contextStack.create(newContext);
     var overloadResult = getUndefinedSymbols(fn[1], newContextStack, builtin, evaluateNode);
     addToSet(result, overloadResult);
     return result;
@@ -11997,22 +11845,9 @@ var loopSpecialExpression = {
         var newContextStack = contextStack.create(bindingContext);
         var body = node[1][2];
         var _loop_1 = function () {
-            var e_1, _b;
             var result = null;
             try {
-                try {
-                    for (var body_1 = (e_1 = void 0, __values(body)), body_1_1 = body_1.next(); !body_1_1.done; body_1_1 = body_1.next()) {
-                        var form = body_1_1.value;
-                        result = evaluateNode(form, newContextStack);
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (body_1_1 && !body_1_1.done && (_b = body_1.return)) _b.call(body_1);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
+                result = evaluateNode(body, newContextStack);
             }
             catch (error) {
                 if (error instanceof RecurSignal) {
@@ -12021,20 +11856,20 @@ var loopSpecialExpression = {
                         throw new LitsError("recur expected ".concat(bindingNodes.length, " parameters, got ").concat(valueToString(params_1.length)), node[2]);
                     }
                     bindingNodes.forEach(function (bindingNode, index) {
-                        var e_2, _a;
+                        var e_1, _a;
                         var valueRecord = evalueateBindingNodeValues(bindingNode[1][0], asAny(params_1[index]), function (Node) { return evaluateNode(Node, contextStack); });
                         try {
-                            for (var _b = (e_2 = void 0, __values(Object.entries(valueRecord))), _c = _b.next(); !_c.done; _c = _b.next()) {
+                            for (var _b = (e_1 = void 0, __values(Object.entries(valueRecord))), _c = _b.next(); !_c.done; _c = _b.next()) {
                                 var _d = __read(_c.value, 2), name_1 = _d[0], value = _d[1];
                                 bindingContext[name_1].value = value;
                             }
                         }
-                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
                         finally {
                             try {
                                 if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                             }
-                            finally { if (e_2) throw e_2.error; }
+                            finally { if (e_1) throw e_1.error; }
                         }
                     });
                     return "continue";
@@ -12062,7 +11897,7 @@ var loopSpecialExpression = {
         }, {});
         var bindingValueNodes = bindingNodes.map(function (bindingNode) { return bindingNode[1][1]; });
         var bindingsResult = getUndefinedSymbols(bindingValueNodes, contextStack, builtin, evaluateNode);
-        var paramsResult = getUndefinedSymbols(node[1][2], contextStack.create(newContext), builtin, evaluateNode);
+        var paramsResult = getUndefinedSymbols([node[1][2]], contextStack.create(newContext), builtin, evaluateNode);
         return joinSets(bindingsResult, paramsResult);
     },
 };
@@ -12449,6 +12284,31 @@ var objectSpecialExpression = {
     },
 };
 
+var specialExpressionTypes = {
+    '??': 0,
+    '&&': 1,
+    '||': 2,
+    'array': 3,
+    'cond': 4,
+    '0_def': 5,
+    'defined?': 6,
+    // '0_defn': 7,
+    'block': 7,
+    'doseq': 8,
+    '0_lambda': 9,
+    'for': 10,
+    // 'function': 10,
+    'if': 11,
+    'let': 12,
+    'loop': 13,
+    'object': 14,
+    'recur': 15,
+    'switch': 16,
+    'throw': 17,
+    'try': 18,
+    'unless': 19,
+};
+
 var specialExpressions = [
     qqSpecialExpression,
     andSpecialExpression,
@@ -12457,12 +12317,12 @@ var specialExpressions = [
     condSpecialExpression,
     defSpecialExpression,
     definedSpecialExpression,
-    defnSpecialExpression,
+    // defnSpecialExpression,
     doSpecialExpression,
     doseqSpecialExpression,
-    fnSpecialExpression,
+    lambdaSpecialExpression,
     forSpecialExpression,
-    functionSpecialExpression,
+    // functionSpecialExpression,
     ifSpecialExpression,
     letSpecialExpression,
     loopSpecialExpression,
@@ -12574,6 +12434,53 @@ function findUnresolvedSymbolsInNode(node, contextStack, builtin, evaluateNode)
     }
 }
 
+var nonNumberReservedSymbolRecord = {
+    true: true,
+    false: false,
+    null: null,
+    else: null,
+    case: null,
+    each: null,
+    in: null,
+    when: null,
+    while: null,
+    catch: null,
+    function: null,
+    export: null,
+    as: null,
+    then: null,
+    end: null,
+    _: null,
+};
+var phi = (1 + Math.sqrt(5)) / 2;
+var numberReservedSymbolRecord = {
+    'E': Math.E,
+    '-E': -Math.E,
+    'ε': Math.E,
+    '-ε': -Math.E,
+    'PI': Math.PI,
+    '-PI': -Math.PI,
+    'π': Math.PI,
+    '-π': -Math.PI,
+    'PHI': phi,
+    '-PHI': -phi,
+    'φ': phi,
+    '-φ': -phi,
+    'POSITIVE_INFINITY': Number.POSITIVE_INFINITY,
+    '∞': Number.POSITIVE_INFINITY,
+    'NEGATIVE_INFINITY': Number.NEGATIVE_INFINITY,
+    '-∞': Number.NEGATIVE_INFINITY,
+    'MAX_SAFE_INTEGER': Number.MAX_SAFE_INTEGER,
+    'MIN_SAFE_INTEGER': Number.MIN_SAFE_INTEGER,
+    'MAX_VALUE': Number.MAX_VALUE,
+    'MIN_VALUE': Number.MIN_VALUE,
+    'NaN': Number.NaN,
+};
+var reservedSymbolRecord = __assign(__assign({}, nonNumberReservedSymbolRecord), numberReservedSymbolRecord);
+function isNumberReservedSymbol(symbol) {
+    return symbol in numberReservedSymbolRecord;
+}
+
 var functionExecutors = {
     NativeJsFunction: function (fn, params, sourceCodeInfo) {
         var _a;
@@ -13022,6 +12929,9 @@ var ContextStackImpl = /** @class */ (function () {
                 if (normalExpressionKeys.includes(name_1)) {
                     throw new LitsError("Cannot shadow builtin function \"".concat(name_1, "\""), sourceCodeInfo);
                 }
+                if (name_1 === 'self') {
+                    throw new LitsError("Cannot shadow builtin value \"".concat(name_1, "\""), sourceCodeInfo);
+                }
                 this.globalContext[name_1] = { value: value };
             }
         }
@@ -13051,6 +12961,9 @@ var ContextStackImpl = /** @class */ (function () {
                 if (normalExpressionKeys.includes(name_2)) {
                     throw new LitsError("Cannot shadow builtin function \"".concat(name_2, "\""), sourceCodeInfo);
                 }
+                if (name_2 === 'self') {
+                    throw new LitsError("Cannot shadow builtin value \"".concat(name_2, "\""), sourceCodeInfo);
+                }
                 currentContext[name_2] = { value: toAny(value) };
             }
         }
@@ -14046,9 +13959,6 @@ var Parser = /** @class */ (function () {
                     break;
             }
         }
-        else if (isReservedSymbolToken(firstToken, 'function')) {
-            return this.parseFunction(firstToken);
-        }
         else if (isReservedSymbolToken(firstToken, 'export')) {
             if (!moduleScope) {
                 throw new LitsError('export is only allowed in module scope', firstToken[2]);
@@ -14341,9 +14251,8 @@ var Parser = /** @class */ (function () {
                     var _c = __read(params, 1), param = _c[0];
                     return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, param]], symbol[2]);
                 }
-                case specialExpressionTypes['0_fn']:
+                case specialExpressionTypes['0_lambda']:
                 case specialExpressionTypes['0_def']:
-                case specialExpressionTypes['0_defn']:
                     throw new LitsError("".concat(type, " is not allowed"), symbol[2]);
                 /* v8 ignore next 2 */
                 default:
@@ -14370,11 +14279,27 @@ var Parser = /** @class */ (function () {
                 return null;
             }
             this.advance();
-            var body = this.parseExpression();
-            return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_fn'], [
+            var nodes = void 0;
+            var docString = '';
+            if (isLBraceToken(this.peek())) {
+                var parsedBlock = this.parseBlock(true);
+                docString = parsedBlock[1];
+                nodes = parsedBlock[0][1][1];
+            }
+            else {
+                nodes = [this.parseExpression()];
+            }
+            return withSourceCodeInfo([
+                NodeTypes.SpecialExpression,
+                [
+                    specialExpressionTypes['0_lambda'],
+                    [
                         functionArguments,
-                        [body],
-                    ]]], firstToken[2]);
+                        nodes,
+                    ],
+                    docString,
+                ],
+            ], firstToken[2]);
         }
         catch (_a) {
             return null;
@@ -14423,7 +14348,16 @@ var Parser = /** @class */ (function () {
         var firstToken = this.asToken(this.peek());
         this.advance();
         var startPos = this.parseState.position;
-        var exprNode = this.parseExpression();
+        var nodes;
+        var docString = '';
+        if (isLBraceToken(this.peek())) {
+            var parsedBlock = this.parseBlock(true);
+            docString = parsedBlock[1];
+            nodes = parsedBlock[0][1][1];
+        }
+        else {
+            nodes = [this.parseExpression()];
+        }
         var endPos = this.parseState.position - 1;
         var arity = 0;
         var dollar1 = 'NOT_SET'; // referring to argument bindings. $ = NAKED, $1, $2, $3, etc = WITH_1
@@ -14454,10 +14388,10 @@ var Parser = /** @class */ (function () {
                 functionArguments.push(withSourceCodeInfo([bindingTargetTypes.symbol, [[NodeTypes.UserDefinedSymbol, "$".concat(i)], undefined]], firstToken[2]));
             }
         }
-        var node = withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_fn'], [
+        var node = withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_lambda'], [
                     functionArguments,
-                    [exprNode],
-                ]]], firstToken[2]);
+                    nodes,
+                ], docString]], firstToken[2]);
         return node;
     };
     Parser.prototype.parseOptionalDefaulValue = function () {
@@ -14627,6 +14561,48 @@ var Parser = /** @class */ (function () {
             docString,
         ];
     };
+    Parser.prototype.parseImplicitBlock = function (ends) {
+        var nodes = [];
+        while (!this.isAtEnd() && !this.isImplicitBlockEnd(ends)) {
+            if (isOperatorToken(this.peek(), ';')) {
+                this.advance();
+            }
+            else {
+                nodes.push(this.parseExpression());
+            }
+        }
+        this.assertImplicitBlockEnd(ends);
+        if (nodes.length === 0) {
+            throw new LitsError('Expected expression', this.peekSourceCodeInfo());
+        }
+        return nodes.length === 1
+            ? nodes[0]
+            : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.block, nodes]], this.peekSourceCodeInfo());
+    };
+    Parser.prototype.assertImplicitBlockEnd = function (ends) {
+        if (!this.isImplicitBlockEnd(ends)) {
+            throw new LitsError("Expected ".concat(ends.map(function (e) { return e[1]; }).join(' or ')), this.peekSourceCodeInfo());
+        }
+    };
+    Parser.prototype.isImplicitBlockEnd = function (ends) {
+        var e_1, _a;
+        try {
+            for (var ends_1 = __values(ends), ends_1_1 = ends_1.next(); !ends_1_1.done; ends_1_1 = ends_1.next()) {
+                var end = ends_1_1.value;
+                if (isReservedSymbolToken(this.peek(), end)) {
+                    return true;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (ends_1_1 && !ends_1_1.done && (_a = ends_1.return)) _a.call(ends_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return false;
+    };
     Parser.prototype.parseLoop = function (firstToken) {
         this.advance();
         assertLParenToken(this.peek());
@@ -14648,21 +14624,10 @@ var Parser = /** @class */ (function () {
         }
         assertRParenToken(token);
         this.advance();
-        assertLBraceToken(this.peek());
-        this.advance();
-        var params = [];
-        while (!this.isAtEnd() && !isRBraceToken(this.peek())) {
-            params.push(this.parseExpression());
-            if (isOperatorToken(this.peek(), ';')) {
-                this.advance();
-            }
-            else if (!isRBraceToken(this.peek())) {
-                throw new LitsError('Expected ;', this.peekSourceCodeInfo());
-            }
-        }
-        assertRBraceToken(this.peek());
+        assertOperatorToken(this.peek(), '->');
         this.advance();
-        return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.loop, bindingNodes, params]], firstToken[2]);
+        var expression = this.parseExpression();
+        return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.loop, bindingNodes, expression]], firstToken[2]);
     };
     Parser.prototype.parseTry = function (token) {
         this.advance();
@@ -14693,7 +14658,7 @@ var Parser = /** @class */ (function () {
                 throw new LitsError('Duplicate binding', loopBinding[0][2]);
             }
             forLoopBindings.push(loopBinding);
-            if (isOperatorToken(this_1.peek(), ';')) {
+            if (isOperatorToken(this_1.peek(), ',')) {
                 this_1.advance();
             }
         };
@@ -14703,6 +14668,8 @@ var Parser = /** @class */ (function () {
         }
         assertRParenToken(this.peek());
         this.advance();
+        assertOperatorToken(this.peek(), '->');
+        this.advance();
         var expression = this.parseExpression();
         return isDoseq
             ? withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.doseq, forLoopBindings, expression]], firstToken[2])
@@ -14712,20 +14679,7 @@ var Parser = /** @class */ (function () {
         var bindingNode = this.parseBinding();
         var modifiers = [];
         var token = this.asToken(this.peek());
-        if (!isRParenToken(token) && !isOperatorToken(this.peek(), ';') && !isOperatorToken(token, ',')) {
-            throw new LitsError('Expected ")", ";" or ","', token[2]);
-        }
-        if (isOperatorToken(token, ',')) {
-            this.advance();
-            token = this.asToken(this.peek());
-        }
-        if (!isSymbolToken(token, 'let')
-            && !isReservedSymbolToken(token, 'when')
-            && !isReservedSymbolToken(token, 'while')
-            && !isRParenToken(token)
-            && !isOperatorToken(token, ';')) {
-            throw new LitsError('Expected symbol ";", ")", let, when or while', token[2]);
-        }
+        this.assertInternalLoopBindingDelimiter(token, ['let', 'when', 'while']);
         var letBindings = [];
         if (token[1] === 'let') {
             modifiers.push('&let');
@@ -14738,12 +14692,7 @@ var Parser = /** @class */ (function () {
                 }
                 letBindings.push(letNode[1][1]);
                 token = this_2.asToken(this_2.peek());
-                if (!isRParenToken(token) && !isOperatorToken(token, ';') && !isOperatorToken(token, ',')) {
-                    throw new LitsError('Expected ")", ";" or ","', token[2]);
-                }
-                if (isOperatorToken(token, ',')) {
-                    this_2.advance();
-                }
+                this_2.assertInternalLoopBindingDelimiter(token, ['let', 'when', 'while']);
                 token = this_2.asToken(this_2.peek());
             };
             var this_2 = this;
@@ -14757,33 +14706,57 @@ var Parser = /** @class */ (function () {
             || isReservedSymbolToken(token, 'while')) {
             this.advance();
             if (token[1] === 'when') {
-                if (modifiers.includes('&when')) {
-                    throw new LitsError('Multiple when modifiers in for loop', token[2]);
-                }
                 modifiers.push('&when');
                 whenNode = this.parseExpression();
             }
             else {
-                if (modifiers.includes('&while')) {
-                    throw new LitsError('Multiple while modifiers in for loop', token[2]);
-                }
                 modifiers.push('&while');
                 whileNode = this.parseExpression();
             }
             token = this.asToken(this.peek());
-            if (!isRParenToken(token) && !isOperatorToken(token, ';') && !isOperatorToken(token, ',')) {
-                throw new LitsError('Expected do or comma', token[2]);
-            }
-            if (isOperatorToken(token, ',')) {
-                this.advance();
-            }
+            var symbols = modifiers.includes('&when') && modifiers.includes('&while')
+                ? []
+                : modifiers.includes('&when')
+                    ? ['while']
+                    : ['when'];
+            this.assertInternalLoopBindingDelimiter(token, symbols);
             token = this.asToken(this.peek());
         }
-        if (!isRParenToken(token) && !isOperatorToken(token, ';')) {
-            throw new LitsError('Expected "{" or ";"', token[2]);
-        }
+        this.assertInternalLoopBindingDelimiter(token, []);
         return [bindingNode, letBindings, whenNode, whileNode];
     };
+    Parser.prototype.assertInternalLoopBindingDelimiter = function (token, symbols) {
+        if (!this.isInternalLoopBindingDelimiter(token, symbols)) {
+            var symbolsString = "".concat(__spreadArray(__spreadArray([], __read(symbols), false), [','], false).map(function (symbol) { return "\"".concat(symbol, "\""); }).join(', '), " or \")\"");
+            throw new LitsError("Expected symbol ".concat(symbolsString), token[2]);
+        }
+    };
+    Parser.prototype.isInternalLoopBindingDelimiter = function (token, symbols) {
+        var e_2, _a;
+        // end of loop binding
+        if (isOperatorToken(token, ',') || isRParenToken(token)) {
+            return true;
+        }
+        try {
+            for (var symbols_1 = __values(symbols), symbols_1_1 = symbols_1.next(); !symbols_1_1.done; symbols_1_1 = symbols_1.next()) {
+                var symbol = symbols_1_1.value;
+                if (symbol === 'let' && isSymbolToken(token, 'let')) {
+                    return true;
+                }
+                if (['when', 'while'].includes(symbol) && isReservedSymbolToken(token, symbol)) {
+                    return true;
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (symbols_1_1 && !symbols_1_1.done && (_a = symbols_1.return)) _a.call(symbols_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return false;
+    };
     Parser.prototype.parseBinding = function () {
         var firstToken = asSymbolToken(this.peek());
         var name = asUserDefinedSymbolNode(this.parseSymbol());
@@ -14802,116 +14775,59 @@ var Parser = /** @class */ (function () {
     Parser.prototype.parseIfOrUnless = function (token) {
         var isUnless = token[1] === 'unless';
         this.advance();
-        assertLParenToken(this.peek());
-        this.advance();
         var condition = this.parseExpression();
-        assertRParenToken(this.peek());
+        assertReservedSymbolToken(this.peek(), 'then');
         this.advance();
-        var thenExpression = this.parseExpression();
+        var thenExpression = this.parseImplicitBlock(['else', 'end']);
         var elseExpression;
         if (isReservedSymbolToken(this.peek(), 'else')) {
             this.advance();
-            elseExpression = this.parseExpression();
+            elseExpression = this.parseImplicitBlock(['end']);
         }
+        this.advance();
         return isUnless
             ? withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.unless, [condition, thenExpression, elseExpression]]], token[2])
             : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.if, [condition, thenExpression, elseExpression]]], token[2]);
     };
     Parser.prototype.parseCond = function (token) {
-        this.advance();
-        assertLBraceToken(this.peek());
         this.advance();
         var params = [];
-        while (!this.isAtEnd() && !isRBraceToken(this.peek())) {
+        while (!this.isAtEnd() && !isReservedSymbolToken(this.peek(), 'end')) {
             assertReservedSymbolToken(this.peek(), 'case');
             this.advance();
             var caseExpression = this.parseExpression();
-            assertOperatorToken(this.peek(), ':');
+            assertReservedSymbolToken(this.peek(), 'then');
             this.advance();
-            var expressions = [];
-            while (!this.isAtEnd()
-                && !isReservedSymbolToken(this.peek(), 'case')
-                && !isRBraceToken(this.peek())) {
-                expressions.push(this.parseExpression());
-                if (isOperatorToken(this.peek(), ';')) {
-                    this.advance();
-                }
-                else if (!isReservedSymbolToken(this.peek(), 'case') && !isRBraceToken(this.peek())) {
-                    throw new LitsError('Expected ;', this.peekSourceCodeInfo());
-                }
-            }
-            var thenExpression = expressions.length === 1
-                ? expressions[0]
-                : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.block, expressions]], token[2]);
+            var thenExpression = this.parseImplicitBlock(['case', 'end']);
             params.push([caseExpression, thenExpression]);
-            if (isRBraceToken(this.peek())) {
+            if (isReservedSymbolToken(this.peek(), 'end')) {
                 break;
             }
-            assertReservedSymbolToken(this.peek(), 'case');
         }
-        assertRBraceToken(this.peek());
+        assertReservedSymbolToken(this.peek());
         this.advance();
         return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.cond, params]], token[2]);
     };
     Parser.prototype.parseSwitch = function (token) {
-        this.advance();
-        assertLParenToken(this.peek());
         this.advance();
         var valueExpression = this.parseExpression();
-        assertRParenToken(this.peek());
-        this.advance();
-        assertLBraceToken(this.peek());
-        this.advance();
         var params = [];
-        while (!this.isAtEnd() && !isRBraceToken(this.peek())) {
+        while (!this.isAtEnd() && !isReservedSymbolToken(this.peek(), 'end')) {
             assertReservedSymbolToken(this.peek(), 'case');
             this.advance();
             var caseExpression = this.parseExpression();
-            assertOperatorToken(this.peek(), ':');
+            assertReservedSymbolToken(this.peek(), 'then');
             this.advance();
-            var expressions = [];
-            while (!this.isAtEnd()
-                && !isReservedSymbolToken(this.peek(), 'case')
-                && !isRBraceToken(this.peek())) {
-                expressions.push(this.parseExpression());
-                if (isOperatorToken(this.peek(), ';')) {
-                    this.advance();
-                }
-                else if (!isReservedSymbolToken(this.peek(), 'case') && !isRBraceToken(this.peek())) {
-                    throw new LitsError('Expected ;', this.peekSourceCodeInfo());
-                }
-            }
-            var thenExpression = expressions.length === 1
-                ? expressions[0]
-                : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.block, expressions]], token[2]);
+            var thenExpression = this.parseImplicitBlock(['case', 'end']);
             params.push([caseExpression, thenExpression]);
-            if (isRBraceToken(this.peek())) {
+            if (isReservedSymbolToken(this.peek(), 'end')) {
                 break;
             }
-            assertReservedSymbolToken(this.peek(), 'case');
         }
-        assertRBraceToken(this.peek());
+        assertReservedSymbolToken(this.peek(), 'end');
         this.advance();
         return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.switch, valueExpression, params]], token[2]);
     };
-    Parser.prototype.parseFunction = function (token) {
-        this.advance();
-        var symbol = this.parseSymbol();
-        var functionArguments = this.parseFunctionArguments();
-        var _a = __read(this.parseBlock(true), 2), block = _a[0], docString = _a[1];
-        return withSourceCodeInfo([
-            NodeTypes.SpecialExpression,
-            [
-                specialExpressionTypes.function,
-                symbol,
-                [
-                    functionArguments,
-                    block[1][1],
-                ],
-                docString,
-            ],
-        ], token[2]);
-    };
     Parser.prototype.isAtEnd = function () {
         return this.parseState.position >= this.tokenStream.tokens.length;
     };
@@ -14924,7 +14840,7 @@ var Parser = /** @class */ (function () {
             return [';', ',', ':'].includes(token[1]);
         }
         if (isReservedSymbolToken(token)) {
-            return ['else', 'when', 'while', 'case', 'catch'].includes(token[1]);
+            return ['else', 'when', 'while', 'case', 'catch', 'let', 'then'].includes(token[1]);
         }
         return false;
     };
@@ -14935,13 +14851,8 @@ var Parser = /** @class */ (function () {
             var letNode = this.parseLet(asSymbolToken(token));
             return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_def'], letNode[1][1]]], exportToken[2]);
         }
-        else if (isReservedSymbolToken(token, 'function')) {
-            var functionNode = this.parseFunction(token);
-            functionNode[1][0] = specialExpressionTypes['0_defn'];
-            return functionNode;
-        }
         else {
-            throw new LitsError('Expected let or function', this.peekSourceCodeInfo());
+            throw new LitsError('Expected let', this.peekSourceCodeInfo());
         }
     };
     Parser.prototype.stringToSymbolNode = function (value, sourceCodeInfo) {
@@ -15131,7 +15042,7 @@ var AutoCompleter = /** @class */ (function () {
     };
     AutoCompleter.prototype.generateSuggestions = function (params) {
         var _this = this;
-        var blacklist = new Set(['0_def', '0_defn', '0_fn']);
+        var blacklist = new Set(['0_def', '0_defn', '0_lambda']);
         var startsWithCaseSensitive = this.generateWithPredicate(params, function (suggestion) {
             return !blacklist.has(suggestion) && suggestion.startsWith(_this.searchString);
         });
@@ -15781,7 +15692,7 @@ var arrayReference = {
             '[[3, 2, 1, 0], [6, 5, 4], [9, 8, 7]] mapcat reverse',
             'mapcat([[3, 2, 1, 0], [6, 5, 4], [9, 8, 7]], reverse)',
             '[[3, 2, 1, 0,], [6, 5, 4,], [9, 8, 7]] mapcat reverse',
-            "\nfunction foo(n) {\n  [n - 1, n, n + 1]\n};\n[1, 2, 3] mapcat foo",
+            "\nlet foo = (n) -> {\n  [n - 1, n, n + 1]\n};\n[1, 2, 3] mapcat foo",
             "\nmapcat(\n  [[1, 2], [2, 2], [2, 3]],\n  -> $ remove even?\n)",
         ],
     },
@@ -20512,7 +20423,7 @@ var metaReference = {
         description: 'Returns documentation string of the $fun.',
         examples: [
             'doc(+)',
-            "\nfunction add(x, y) {\n  \"\"\"\n  Adds two numbers.\n  Args:\n    x: First number.\n    y: Second number.\n  Returns:\n    Sum of x and y.\n  \"\"\"\n  x + y;\n};\n\ndoc(add)",
+            "\nlet add = (x, y) -> {\n  \"\"\"\n  Adds two numbers.\n  Args:\n    x: First number.\n    y: Second number.\n  Returns:\n    Sum of x and y.\n  \"\"\"\n  x + y;\n};\n\ndoc(add)",
         ],
     },
     arity: {
@@ -20533,8 +20444,8 @@ var metaReference = {
         examples: [
             'arity(+)',
             'arity(defined?)',
-            "\nfunction add(x, y = 0) {\n  x + y;\n};\n\narity(add)",
-            "\nfunction foo(k, ...x) {\n  k + x;\n};\n  arity(foo)",
+            "\nlet add = (x, y = 0) -> {\n  x + y;\n};\n\narity(add)",
+            "\nlet foo = (k, ...x) -> {\n  k + x;\n};\n  arity(foo)",
         ],
     },
 };
@@ -26414,8 +26325,8 @@ var sequenceReference = {
         examples: [
             '[3, 1, 2] sort (a, b) -> b - a',
             'sort([3, 1, 2])',
-            "\nsort(\n  [3, 1, 2],\n  (a, b) -> cond { case a < b: -1 case a > b: 1 case true: -1 }\n)",
-            "\nsort(\n  [3, 1, 2],\n  (a, b) -> cond { case a > b: -1 case a < b: 1 case true: -1 }\n)",
+            "\nsort(\n  [3, 1, 2],\n  (a, b) -> cond case a < b then -1 case a > b then 1 case true then -1 end\n)",
+            "\nsort(\n  [3, 1, 2],\n  (a, b) -> cond case a > b then -1 case a < b then 1 case true then -1 end\n)",
         ],
     },
     'sort-by': {
@@ -26892,26 +26803,6 @@ var specialExpressionsReference = {
         description: "\n  Binds local variables s to `value`. `value` can be any expression. The scope of the variables is the body of the let expression.",
         examples: ["\nlet a = 1 + 2 + 3 + 4;\nlet b = -> $ * ( $ + 1 );\nwrite!(\"a\", a, \"b\", b)"],
     },
-    'function': {
-        title: 'function',
-        category: 'Special expression',
-        customVariants: ['function name(...arg) { body }'],
-        details: [
-            ['name', 'symbol', 'The name of the function.'],
-            ['arg', '[...]arg-name [= value]', 'Arguments of the function.'],
-            ['...', 'rest-symbol', 'Optional. The rest argument of the function.'],
-            ['arg-name', 'symbol', 'The name of the argument.'],
-            ['value', 'any', 'Optional. The default value of the argument.'],
-            ['let-binding', 'symbol', 'Optional. The let bindings of the function.'],
-            ['body', 'one or more expressions', 'The body of the function.'],
-        ],
-        description: 'Creates a named function. When called, evaluation of the last expression in the body is returned.',
-        examples: [
-            "\nfunction hyp (a, b) {\n  sqrt(a * a + b * b)\n};\n\nhyp(3, 4)",
-            "\nfunction sumOfSquares(...s) {\n  apply(\n    +,\n    map(s, -> $ ^ 2)\n  )\n};\n\nsumOfSquares(1, 2, 3, 4, 5)",
-            "\nfunction withOptional(a, b = 42) {\n  a + b\n};\n\nwrite!(withOptional(1), withOptional(1, 2))",
-        ],
-    },
     'try': {
         title: 'try',
         category: 'Special expression',
@@ -26951,7 +26842,7 @@ var specialExpressionsReference = {
     'if': {
         title: 'if',
         category: 'Special expression',
-        customVariants: ['if (test) true-expr else false-expr', 'if (test) true-expr'],
+        customVariants: ['if test then true-expr else false-expr', 'if test then true-expr'],
         details: [
             ['test', 'expression', 'The condition to test.'],
             ['true-expr', 'expression', 'The expression to evaluate if the test is truthy.'],
@@ -26959,16 +26850,16 @@ var specialExpressionsReference = {
         ],
         description: 'Either `true-expr` or `false-expr` branch is taken. `true-expr` is selected when $test is truthy. If $test is falsy `false-expr` is executed, if no `false-expr` exists, `null` is returned.',
         examples: [
-            "\nif (true) {\n  write!(\"TRUE\")\n} else {\n  write!(\"FALSE\")\n}",
-            'if (false) write!("TRUE") else write!("FALSE")',
-            'if (true) write!("TRUE")',
-            'if (false) write!("TRUE")',
+            "\nif true then\n  write!(\"TRUE\")\nelse\n  write!(\"FALSE\")\nend",
+            'if false then write!("TRUE") else write!("FALSE") end',
+            'if true then write!("TRUE") end',
+            'if false then write!("TRUE") end',
         ],
     },
     'unless': {
         title: 'unless',
         category: 'Special expression',
-        customVariants: ['unless (test) true-expr else false-expr end', 'unless test true-expr end'],
+        customVariants: ['unless test then true-expr else false-expr end', 'unless test true-expr end'],
         details: [
             ['test', 'expression', 'The condition to test.'],
             ['true-expr', 'expression', 'The expressions to evaluate if the test is falsy.'],
@@ -26976,16 +26867,16 @@ var specialExpressionsReference = {
         ],
         description: 'Either `true-expr` or `false-expr` branch is taken. `true-expr` is selected when $test is falsy. If $test is truthy `false-expr` is executed, if no `false-expr` exists, `null` is returned.',
         examples: [
-            "\nunless (true) {\n  write!(\"TRUE\")\n} else {\n  write!(\"FALSE\")\n}",
-            'unless (false) write!("TRUE") else write!("FALSE")',
-            'unless (true) write!("TRUE")',
-            'unless (false) write!("TRUE")',
+            "\nunless true then\n  write!(\"TRUE\")\nelse\n  write!(\"FALSE\")\nend",
+            'unless false then write!("TRUE") else write!("FALSE") end',
+            'unless true then write!("TRUE") end',
+            'unless false then write!("TRUE") end',
         ],
     },
     'cond': {
         title: 'cond',
         category: 'Special expression',
-        customVariants: ['cond { cond-branch cond-branch ... }'],
+        customVariants: ['cond cond-branch cond-branch ... end'],
         details: [
             ['cond-branch', 'case test then body', 'A branch of the cond expression.'],
             ['test', 'expression', 'The condition to test.'],
@@ -26993,15 +26884,15 @@ var specialExpressionsReference = {
         ],
         description: 'Used for branching. `cond-branches` are tested sequentially from the top. If no branch is tested truthy, `null` is returned.',
         examples: [
-            "\ncond {\n  case false: write!(\"FALSE\")\n  case true: write!(\"TRUE\")\n}",
-            "\ncond {\n  case false: write!(\"FALSE\")\n  case null: write!(\"null\")\n} ?? write!(\"TRUE\")",
-            "\ncond {\n  case false: write!(\"FALSE\")\n  case null: write!(\"null\")\n} ?? write!(\"TRUE\")",
+            "\ncond\n  case false then write!(\"FALSE\")\n  case true then write!(\"TRUE\")\nend",
+            "\ncond\n  case false then write!(\"FALSE\")\n  case null then write!(\"null\")\nend ?? write!(\"TRUE\")",
+            "\ncond\n  case false then write!(\"FALSE\")\n  case null then write!(\"null\")\nend ?? write!(\"TRUE\")",
         ],
     },
     'switch': {
         title: 'switch',
         category: 'Special expression',
-        customVariants: ['switch (value) { switch-branch switch-branch ... }'],
+        customVariants: ['switch value switch-branch switch-branch ... end'],
         details: [
             ['value', 'any', 'The value to test.'],
             ['switch-branch', 'case test then body', 'A branch of the switch expression.'],
@@ -27010,9 +26901,9 @@ var specialExpressionsReference = {
         ],
         description: 'Used for branching. `switch-branches` are tested sequentially from the top against `value`. If no branch is tested truthy, `null` is returned.',
         examples: [
-            "\nswitch (1) {\n  case 1: write!(\"One\")\n  case 2: write!(\"Two\")\n}",
-            "\nswitch (2) {\n  case 1: write!(\"One\")\n  case 2: write!(\"Two\")\n}",
-            "\nswitch (3) {\n  case 1: write!(\"One\")\n  case 2: write!(\"Two\")\n}",
+            "\nswitch 1\n  case 1 then write!(\"One\")\n  case 2 then write!(\"Two\")\nend",
+            "\nswitch 2\n  case 1 then write!(\"One\")\n  case 2 then write!(\"Two\")\nend",
+            "\nswitch 3\n  case 1 then write!(\"One\")\n  case 2 then write!(\"Two\")\nend",
         ],
     },
     'block': {
@@ -27033,9 +26924,9 @@ var specialExpressionsReference = {
         customVariants: ['recur(...recur-args)'],
         description: 'Recursevly calls enclosing function or loop with its evaluated `recur-args`.',
         examples: [
-            "\nfunction foo(n) {\n  write!(n);\n  if (!(zero?(n))) {\n    recur(n - 1)\n  }\n};\nfoo(3)",
-            "\n(n -> {\n  write!(n);\n  if (!(zero?(n))) {\n    recur(n - 1)\n  }\n})(3)",
-            "\nloop (n = 3) {\n  write!(n);\n  if (!(zero?(n))) {\n    recur(n - 1)\n  }\n}",
+            "\nlet foo = (n) -> {\n  write!(n);\n  if !(zero?(n)) then\n    recur(n - 1)\n  end\n};\nfoo(3)",
+            "\n(n -> {\n  write!(n);\n  if !(zero?(n)) then\n    recur(n - 1)\n  end\n})(3)",
+            "\nloop (n = 3) -> {\n  write!(n);\n  if !(zero?(n)) then\n    recur(n - 1)\n  end\n}",
         ],
     },
 };