@mojir/lits 2.1.32 → 2.1.34

package/dist/lits.iife.js

@@ -11699,165 +11699,13 @@ var Lits = (function (exports) {
         },
     };
 
-    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;
@@ -11869,8 +11717,9 @@ var Lits = (function (exports) {
                 _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) {
@@ -11901,17 +11750,16 @@ var Lits = (function (exports) {
         ];
         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;
@@ -11998,22 +11846,9 @@ var Lits = (function (exports) {
             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) {
@@ -12022,20 +11857,20 @@ var Lits = (function (exports) {
                             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";
@@ -12063,7 +11898,7 @@ var Lits = (function (exports) {
             }, {});
             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);
         },
     };
@@ -12450,6 +12285,31 @@ var Lits = (function (exports) {
         },
     };
 
+    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,
@@ -12458,12 +12318,12 @@ var Lits = (function (exports) {
         condSpecialExpression,
         defSpecialExpression,
         definedSpecialExpression,
-        defnSpecialExpression,
+        // defnSpecialExpression,
         doSpecialExpression,
         doseqSpecialExpression,
-        fnSpecialExpression,
+        lambdaSpecialExpression,
         forSpecialExpression,
-        functionSpecialExpression,
+        // functionSpecialExpression,
         ifSpecialExpression,
         letSpecialExpression,
         loopSpecialExpression,
@@ -12575,6 +12435,53 @@ var Lits = (function (exports) {
         }
     }
 
+    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;
@@ -13023,6 +12930,9 @@ var Lits = (function (exports) {
                     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 };
                 }
             }
@@ -13052,6 +12962,9 @@ var Lits = (function (exports) {
                     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) };
                 }
             }
@@ -14047,9 +13960,6 @@ var Lits = (function (exports) {
                         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]);
@@ -14342,9 +14252,8 @@ var Lits = (function (exports) {
                         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:
@@ -14371,11 +14280,27 @@ var Lits = (function (exports) {
                     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;
@@ -14424,7 +14349,16 @@ var Lits = (function (exports) {
             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
@@ -14455,10 +14389,10 @@ var Lits = (function (exports) {
                     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 () {
@@ -14628,6 +14562,48 @@ var Lits = (function (exports) {
                 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());
@@ -14649,21 +14625,10 @@ var Lits = (function (exports) {
             }
             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();
@@ -14694,7 +14659,7 @@ var Lits = (function (exports) {
                     throw new LitsError('Duplicate binding', loopBinding[0][2]);
                 }
                 forLoopBindings.push(loopBinding);
-                if (isOperatorToken(this_1.peek(), ';')) {
+                if (isOperatorToken(this_1.peek(), ',')) {
                     this_1.advance();
                 }
             };
@@ -14704,6 +14669,8 @@ var Lits = (function (exports) {
             }
             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])
@@ -14713,20 +14680,7 @@ var Lits = (function (exports) {
             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');
@@ -14739,12 +14693,7 @@ var Lits = (function (exports) {
                     }
                     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;
@@ -14758,33 +14707,57 @@ var Lits = (function (exports) {
                 || 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());
@@ -14803,116 +14776,59 @@ var Lits = (function (exports) {
         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;
         };
@@ -14925,7 +14841,7 @@ var Lits = (function (exports) {
                 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;
         };
@@ -14936,13 +14852,8 @@ var Lits = (function (exports) {
                 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) {
@@ -15132,7 +15043,7 @@ var Lits = (function (exports) {
         };
         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);
             });
@@ -15782,7 +15693,7 @@ var Lits = (function (exports) {
                 '[[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)",
             ],
         },
@@ -20513,7 +20424,7 @@ var Lits = (function (exports) {
             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: {
@@ -20534,8 +20445,8 @@ var Lits = (function (exports) {
             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)",
             ],
         },
     };
@@ -26415,8 +26326,8 @@ var Lits = (function (exports) {
             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': {
@@ -26893,26 +26804,6 @@ var Lits = (function (exports) {
             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',
@@ -26952,7 +26843,7 @@ var Lits = (function (exports) {
         '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.'],
@@ -26960,16 +26851,16 @@ var Lits = (function (exports) {
             ],
             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.'],
@@ -26977,16 +26868,16 @@ var Lits = (function (exports) {
             ],
             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.'],
@@ -26994,15 +26885,15 @@ var Lits = (function (exports) {
             ],
             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.'],
@@ -27011,9 +26902,9 @@ var Lits = (function (exports) {
             ],
             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': {
@@ -27034,9 +26925,9 @@ var Lits = (function (exports) {
             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}",
             ],
         },
     };