@mojir/lits 2.0.15 → 2.0.16

package/dist/testFramework.js

@@ -428,20 +428,15 @@ var nonFunctionOperators = [
     '&&',
     'comment',
     'cond',
-    'declared?',
+    'defined?',
     'if',
-    'if_not',
+    'unless',
     '||',
-    'when',
-    'when_not',
     'do',
     'throw',
     'let',
     'def',
     'defs',
-    'if_let',
-    'when_let',
-    'when_first',
     'fn',
     'defn',
     'defns',
@@ -467,16 +462,22 @@ var symbolicOperatorSet = new Set(symbolicOperators);
 function isSymbolicOperator(operator) {
     return symbolicOperatorSet.has(operator);
 }
-function isA_SymbolToken(token) {
-    return (token === null || token === void 0 ? void 0 : token[0]) === 'A_Symbol';
+function isA_SymbolToken(token, symbolName) {
+    if ((token === null || token === void 0 ? void 0 : token[0]) !== 'A_Symbol') {
+        return false;
+    }
+    if (symbolName && token[1] !== symbolName) {
+        return false;
+    }
+    return true;
 }
-function assertA_SymbolToken(token) {
-    if (!isA_SymbolToken(token)) {
+function assertA_SymbolToken(token, symbolName) {
+    if (!isA_SymbolToken(token, symbolName)) {
         throwUnexpectedToken('A_Symbol', undefined, token);
     }
 }
-function asA_SymbolToken(token) {
-    assertA_SymbolToken(token);
+function asA_SymbolToken(token, symbolName) {
+    assertA_SymbolToken(token, symbolName);
     return token;
 }
 function isA_BinaryOperatorToken(token) {
@@ -839,7 +840,7 @@ var specialExpressionCommentRemovers = {
         removeOptions.removeCommenNodesFromArray(node.p);
         node.p.forEach(removeOptions.recursivelyRemoveCommentNodes);
     },
-    'declared?': function (node, removeOptions) {
+    'defined?': function (node, removeOptions) {
         removeOptions.removeCommenNodesFromArray(node.p);
         node.p.forEach(removeOptions.recursivelyRemoveCommentNodes);
     },
@@ -860,12 +861,11 @@ var specialExpressionCommentRemovers = {
     'doseq': function (_node, _removeOptions) { },
     'fn': function (_node, _removeOptions) { },
     'for': function (_node, _removeOptions) { },
-    'if_let': function (_node, _removeOptions) { },
     'if': function (node, removeOptions) {
         removeOptions.removeCommenNodesFromArray(node.p);
         node.p.forEach(removeOptions.recursivelyRemoveCommentNodes);
     },
-    'if_not': function (node, removeOptions) {
+    'unless': function (node, removeOptions) {
         removeOptions.removeCommenNodesFromArray(node.p);
         node.p.forEach(removeOptions.recursivelyRemoveCommentNodes);
     },
@@ -894,10 +894,6 @@ var specialExpressionCommentRemovers = {
         node.p.forEach(removeOptions.recursivelyRemoveCommentNodes);
     },
     'try': function (_node, _removeOptions) { },
-    'when_first': function (_node, _removeOptions) { },
-    'when_let': function (_node, _removeOptions) { },
-    'when': function (_node, _removeOptions) { },
-    'when_not': function (_node, _removeOptions) { },
 };
 function removeCommentNodesFromSpecialExpression(node, removeOptions) {
     var uncommenter = specialExpressionCommentRemovers[node.n];
@@ -4407,7 +4403,7 @@ var switchSpecialExpression = {
 };
 
 var declaredSpecialExpression = {
-    polishParse: getCommonPolishSpecialExpressionParser('declared?'),
+    polishParse: getCommonPolishSpecialExpressionParser('defined?'),
     validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
     evaluate: function (node, contextStack) {
         var lookUpResult = contextStack.lookUp(node.p[0]);
@@ -4462,9 +4458,7 @@ var defSpecialExpression = {
         var sourceCodeInfo = (_b = getTokenDebugData(node.token)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo;
         var name = node.p[0].v;
         assertNameNotDefined(name, contextStack, builtin, sourceCodeInfo);
-        contextStack.globalContext[name] = {
-            value: evaluateAstNode(node.p[1], contextStack),
-        };
+        contextStack.exportValue(name, evaluateAstNode(node.p[1], contextStack));
         return null;
     },
     findUnresolvedIdentifiers: function (node, contextStack, _a) {
@@ -4475,7 +4469,7 @@ var defSpecialExpression = {
         var result = findUnresolvedIdentifiers([subNode], contextStack, builtin);
         var name = asSymbolNode(node.p[0]).v;
         assertNameNotDefined(name, contextStack, builtin, sourceCodeInfo);
-        contextStack.globalContext[name] = { value: true };
+        contextStack.exportValue(name, true);
         return result;
     },
 };
@@ -4501,9 +4495,7 @@ var defsSpecialExpression = {
         var name = evaluateAstNode(node.p[0], contextStack);
         assertString(name, sourceCodeInfo);
         assertNameNotDefined(name, contextStack, builtin, (_c = getTokenDebugData(node.token)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo);
-        contextStack.globalContext[name] = {
-            value: evaluateAstNode(node.p[1], contextStack),
-        };
+        contextStack.exportValue(name, evaluateAstNode(node.p[1], contextStack));
         return null;
     },
     findUnresolvedIdentifiers: function (node, contextStack, _a) {
@@ -4515,7 +4507,7 @@ var defsSpecialExpression = {
         var name = evaluateAstNode(node.p[0], contextStack);
         assertString(name, sourceCodeInfo);
         assertNameNotDefined(name, contextStack, builtin, sourceCodeInfo);
-        contextStack.globalContext[name] = { value: true };
+        contextStack.exportValue(name, true);
         return result;
     },
 };
@@ -4546,7 +4538,7 @@ var doSpecialExpression = {
     },
     findUnresolvedIdentifiers: function (node, contextStack, _a) {
         var findUnresolvedIdentifiers = _a.findUnresolvedIdentifiers, builtin = _a.builtin;
-        return findUnresolvedIdentifiers(node.p, contextStack, builtin);
+        return findUnresolvedIdentifiers(node.p, contextStack.create({}), builtin);
     },
 };
 
@@ -4575,11 +4567,6 @@ function joinAnalyzeResults() {
 function addAnalyzeResults(target, source) {
     source.forEach(function (symbol) { return target.add(symbol); });
 }
-function combinate(arrays) {
-    return arrays.reduce(function (acc, curr) {
-        return acc.flatMap(function (a) { return curr.map(function (c) { return __spreadArray(__spreadArray([], __read(a), false), [c], false); }); });
-    }, [[]]);
-}
 
 var defnSpecialExpression = {
     polishParse: function (tokenStream, parseState, firstToken, parsers) {
@@ -4614,13 +4601,13 @@ var defnSpecialExpression = {
             _b.n = name,
             _b.o = evaluatedFunctionOverloades,
             _b);
-        contextStack.globalContext[name] = { value: litsFunction };
+        contextStack.exportValue(name, litsFunction);
         return null;
     },
     findUnresolvedIdentifiers: function (node, contextStack, _a) {
         var _b;
         var findUnresolvedIdentifiers = _a.findUnresolvedIdentifiers, builtin = _a.builtin;
-        contextStack.globalContext[node.f.v] = { value: true };
+        contextStack.exportValue(node.f.v, true);
         var newContext = (_b = {}, _b[node.f.v] = { value: true }, _b);
         return addOverloadsUnresolvedIdentifiers(node.o, contextStack, findUnresolvedIdentifiers, builtin, newContext);
     },
@@ -4656,7 +4643,7 @@ var defnsSpecialExpression = {
             _b.n = name,
             _b.o = evaluatedFunctionOverloades,
             _b);
-        contextStack.globalContext[name] = { value: litsFunction };
+        contextStack.exportValue(name, litsFunction);
         return null;
     },
     findUnresolvedIdentifiers: function (node, contextStack, _a) {
@@ -4667,7 +4654,7 @@ var defnsSpecialExpression = {
         var name = evaluateAstNode(asAstNode(node.f, sourceCodeInfo), contextStack);
         assertString(name, sourceCodeInfo);
         assertNameNotDefined(name, contextStack, builtin, sourceCodeInfo);
-        contextStack.globalContext[name] = { value: true };
+        contextStack.exportValue(name, true);
         var newContext = (_b = {}, _b[name] = { value: true }, _b);
         return addOverloadsUnresolvedIdentifiers(node.o, contextStack, findUnresolvedIdentifiers, builtin, newContext);
     },
@@ -4940,56 +4927,8 @@ var ifSpecialExpression = {
     },
 };
 
-var ifLetSpecialExpression = {
-    polishParse: function (tokenStream, parseState, firstToken, _a) {
-        var _b, _c;
-        var parseBindings = _a.parseBindings, parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-        var bindings = parseBindings(tokenStream, parseState);
-        if (bindings.length !== 1) {
-            throw new LitsError("Expected exactly one binding, got ".concat(valueToString(bindings.length)), (_b = getTokenDebugData(firstToken)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
-        }
-        var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-        assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'if_let',
-            b: asNonUndefined(bindings[0], (_c = getTokenDebugData(firstToken)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo),
-            p: params,
-            token: getTokenDebugData(firstToken) && firstToken,
-        };
-        return node;
-    },
-    validateParameterCount: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
-    evaluate: function (node, contextStack, _a) {
-        var _b;
-        var evaluateAstNode = _a.evaluateAstNode;
-        var sourceCodeInfo = (_b = getTokenDebugData(node.token)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo;
-        var locals = {};
-        var bindingValue = evaluateAstNode(node.b.v, contextStack);
-        if (bindingValue) {
-            locals[node.b.n] = { value: bindingValue };
-            var newContextStack = contextStack.create(locals);
-            var thenForm = asAstNode(node.p[0], sourceCodeInfo);
-            return evaluateAstNode(thenForm, newContextStack);
-        }
-        if (node.p.length === 2) {
-            var elseForm = asAstNode(node.p[1], sourceCodeInfo);
-            return evaluateAstNode(elseForm, contextStack);
-        }
-        return null;
-    },
-    findUnresolvedIdentifiers: function (node, contextStack, _a) {
-        var _b;
-        var findUnresolvedIdentifiers = _a.findUnresolvedIdentifiers, builtin = _a.builtin;
-        var newContext = (_b = {}, _b[node.b.n] = { value: true }, _b);
-        var bindingResult = findUnresolvedIdentifiers([node.b.v], contextStack, builtin);
-        var paramsResult = findUnresolvedIdentifiers(node.p, contextStack.create(newContext), builtin);
-        return joinAnalyzeResults(bindingResult, paramsResult);
-    },
-};
-
-var ifNotSpecialExpression = {
-    polishParse: getCommonPolishSpecialExpressionParser('if_not'),
+var unlessSpecialExpression = {
+    polishParse: getCommonPolishSpecialExpressionParser('unless'),
     validateParameterCount: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     evaluate: function (node, contextStack, _a) {
         var _b;
@@ -5014,55 +4953,39 @@ var ifNotSpecialExpression = {
 
 var letSpecialExpression = {
     polishParse: function (tokenStream, parseState, firstToken, _a) {
-        var parseBindings = _a.parseBindings, parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
+        var parseBindings = _a.parseBindings;
         var bindings = parseBindings(tokenStream, parseState);
-        var params = parseTokensUntilClosingBracket(tokenStream, parseState);
+        // const params = parseTokensUntilClosingBracket(tokenStream, parseState)
         assertRParenToken(tokenStream.tokens[parseState.position++]);
         var node = {
             t: AstNodeType.SpecialExpression,
             n: 'let',
-            p: params,
+            p: [],
             bs: bindings,
             token: getTokenDebugData(firstToken) && firstToken,
         };
         return node;
     },
-    validateParameterCount: function () { return undefined; },
+    validateParameterCount: function (node) { return assertNumberOfParams(0, node); },
     evaluate: function (node, contextStack, _a) {
-        var e_1, _b, e_2, _c;
+        var e_1, _b;
         var evaluateAstNode = _a.evaluateAstNode;
-        var locals = {};
-        var newContextStack = contextStack.create(locals);
         try {
-            for (var _d = __values(node.bs), _e = _d.next(); !_e.done; _e = _d.next()) {
-                var binding = _e.value;
+            for (var _c = __values(node.bs), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var binding = _d.value;
                 var bindingValueNode = binding.v;
-                var bindingValue = evaluateAstNode(bindingValueNode, newContextStack);
-                locals[binding.n] = { value: bindingValue };
+                var bindingValue = evaluateAstNode(bindingValueNode, contextStack);
+                contextStack.addValue(binding.n, bindingValue);
             }
         }
         catch (e_1_1) { e_1 = { error: e_1_1 }; }
         finally {
             try {
-                if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
+                if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
             }
             finally { if (e_1) throw e_1.error; }
         }
-        var result = null;
-        try {
-            for (var _f = __values(node.p), _g = _f.next(); !_g.done; _g = _f.next()) {
-                var astNode = _g.value;
-                result = evaluateAstNode(astNode, newContextStack);
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_g && !_g.done && (_c = _f.return)) _c.call(_f);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-        return result;
+        return null;
     },
     findUnresolvedIdentifiers: function (node, contextStack, _a) {
         var findUnresolvedIdentifiers = _a.findUnresolvedIdentifiers, builtin = _a.builtin;
@@ -5072,11 +4995,10 @@ var letSpecialExpression = {
             context[name] = { value: true };
             return context;
         }, {});
-        var bindingContext = {};
         var bindingResults = node.bs.map(function (bindingNode) {
             var valueNode = bindingNode.v;
-            var bindingsResult = findUnresolvedIdentifiers([valueNode], contextStack.create(bindingContext), builtin);
-            bindingContext[bindingNode.n] = { value: true };
+            var bindingsResult = findUnresolvedIdentifiers([valueNode], contextStack, builtin);
+            contextStack.addValue(bindingNode.n, { value: true });
             return bindingsResult;
         });
         var paramsResult = findUnresolvedIdentifiers(node.p, contextStack.create(newContext), builtin);
@@ -5527,9 +5449,10 @@ var trySpecialExpression = {
             return evaluateAstNode(tryExpressions[0], contextStack);
         }
         catch (error) {
-            var newContext = (_b = {},
-                _b[errorNode.v] = { value: asAny(error, (_c = getTokenDebugData(node.token)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo) },
-                _b);
+            var newContext = errorNode
+                ? (_b = {},
+                    _b[errorNode.v] = { value: asAny(error, (_c = getTokenDebugData(node.token)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo) },
+                    _b) : {};
             return evaluateAstNode(catchExpression, contextStack.create(newContext));
         }
     },
@@ -5538,199 +5461,15 @@ var trySpecialExpression = {
         var findUnresolvedIdentifiers = _a.findUnresolvedIdentifiers, builtin = _a.builtin;
         var tryExpressions = node.p, catchExpression = node.ce, errorNode = node.e;
         var tryResult = findUnresolvedIdentifiers(tryExpressions, contextStack, builtin);
-        var newContext = (_b = {},
-            _b[errorNode.v] = { value: true },
-            _b);
+        var newContext = errorNode
+            ? (_b = {},
+                _b[errorNode.v] = { value: true },
+                _b) : {};
         var catchResult = findUnresolvedIdentifiers([catchExpression], contextStack.create(newContext), builtin);
         return joinAnalyzeResults(tryResult, catchResult);
     },
 };
 
-var whenSpecialExpression = {
-    polishParse: getCommonPolishSpecialExpressionParser('when'),
-    validateParameterCount: function (node) { return assertNumberOfParams({ min: 1 }, node); },
-    evaluate: function (node, contextStack, _a) {
-        var e_1, _b;
-        var _c;
-        var evaluateAstNode = _a.evaluateAstNode;
-        var _d = __read(node.p), whenExpression = _d[0], body = _d.slice(1);
-        assertAstNode(whenExpression, (_c = getTokenDebugData(node.token)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo);
-        if (!evaluateAstNode(whenExpression, contextStack))
-            return null;
-        var result = null;
-        try {
-            for (var body_1 = __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 = evaluateAstNode(form, contextStack);
-            }
-        }
-        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; }
-        }
-        return result;
-    },
-    findUnresolvedIdentifiers: function (node, contextStack, _a) {
-        var findUnresolvedIdentifiers = _a.findUnresolvedIdentifiers, builtin = _a.builtin;
-        return findUnresolvedIdentifiers(node.p, contextStack, builtin);
-    },
-};
-
-var whenFirstSpecialExpression = {
-    polishParse: function (tokenStream, parseState, firstToken, _a) {
-        var _b, _c;
-        var parseBindings = _a.parseBindings, parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-        var bindings = parseBindings(tokenStream, parseState);
-        if (bindings.length !== 1) {
-            throw new LitsError("Expected exactly one binding, got ".concat(valueToString(bindings.length)), (_b = getTokenDebugData(firstToken)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
-        }
-        var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-        assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'when_first',
-            b: asNonUndefined(bindings[0], (_c = getTokenDebugData(firstToken)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo),
-            p: params,
-            token: getTokenDebugData(firstToken) && firstToken,
-        };
-        return node;
-    },
-    validateParameterCount: function () { return undefined; },
-    evaluate: function (node, contextStack, _a) {
-        var e_1, _b;
-        var _c;
-        var evaluateAstNode = _a.evaluateAstNode;
-        var locals = {};
-        var binding = node.b;
-        var evaluatedBindingForm = evaluateAstNode(binding.v, contextStack);
-        if (!isSeq(evaluatedBindingForm)) {
-            throw new LitsError("Expected undefined or a sequence, got ".concat(valueToString(evaluatedBindingForm)), (_c = getTokenDebugData(node.token)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo);
-        }
-        if (evaluatedBindingForm.length === 0)
-            return null;
-        var bindingValue = toAny(evaluatedBindingForm[0]);
-        locals[binding.n] = { value: bindingValue };
-        var newContextStack = contextStack.create(locals);
-        var result = null;
-        try {
-            for (var _d = __values(node.p), _e = _d.next(); !_e.done; _e = _d.next()) {
-                var form = _e.value;
-                result = evaluateAstNode(form, newContextStack);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return result;
-    },
-    findUnresolvedIdentifiers: function (node, contextStack, _a) {
-        var _b;
-        var findUnresolvedIdentifiers = _a.findUnresolvedIdentifiers, builtin = _a.builtin;
-        var binding = node.b;
-        var newContext = (_b = {}, _b[binding.n] = { value: true }, _b);
-        var bindingResult = findUnresolvedIdentifiers([binding.v], contextStack, builtin);
-        var paramsResult = findUnresolvedIdentifiers(node.p, contextStack.create(newContext), builtin);
-        return joinAnalyzeResults(bindingResult, paramsResult);
-    },
-};
-
-var whenLetSpecialExpression = {
-    polishParse: function (tokenStream, parseState, firstToken, _a) {
-        var _b, _c;
-        var parseBindings = _a.parseBindings, parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-        var bindings = parseBindings(tokenStream, parseState);
-        if (bindings.length !== 1) {
-            throw new LitsError("Expected exactly one binding, got ".concat(valueToString(bindings.length)), (_b = getTokenDebugData(firstToken)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
-        }
-        var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-        assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'when_let',
-            b: asNonUndefined(bindings[0], (_c = getTokenDebugData(firstToken)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo),
-            p: params,
-            token: getTokenDebugData(firstToken) && firstToken,
-        };
-        return node;
-    },
-    validateParameterCount: function () { return undefined; },
-    evaluate: function (node, contextStack, _a) {
-        var e_1, _b;
-        var evaluateAstNode = _a.evaluateAstNode;
-        var binding = node.b;
-        var locals = {};
-        var bindingValue = evaluateAstNode(binding.v, contextStack);
-        if (!bindingValue)
-            return null;
-        locals[binding.n] = { value: bindingValue };
-        var newContextStack = contextStack.create(locals);
-        var result = null;
-        try {
-            for (var _c = __values(node.p), _d = _c.next(); !_d.done; _d = _c.next()) {
-                var form = _d.value;
-                result = evaluateAstNode(form, newContextStack);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return result;
-    },
-    findUnresolvedIdentifiers: function (node, contextStack, _a) {
-        var _b;
-        var findUnresolvedIdentifiers = _a.findUnresolvedIdentifiers, builtin = _a.builtin;
-        var binding = node.b;
-        var newContext = (_b = {}, _b[binding.n] = { value: true }, _b);
-        var bindingResult = findUnresolvedIdentifiers([binding.v], contextStack, builtin);
-        var paramsResult = findUnresolvedIdentifiers(node.p, contextStack.create(newContext), builtin);
-        return joinAnalyzeResults(bindingResult, paramsResult);
-    },
-};
-
-var whenNotSpecialExpression = {
-    polishParse: getCommonPolishSpecialExpressionParser('when_not'),
-    validateParameterCount: function (node) { return assertNumberOfParams({ min: 1 }, node); },
-    evaluate: function (node, contextStack, _a) {
-        var e_1, _b;
-        var _c;
-        var evaluateAstNode = _a.evaluateAstNode;
-        var _d = __read(node.p), whenExpression = _d[0], body = _d.slice(1);
-        assertAstNode(whenExpression, (_c = getTokenDebugData(node.token)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo);
-        if (evaluateAstNode(whenExpression, contextStack))
-            return null;
-        var result = null;
-        try {
-            for (var body_1 = __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 = evaluateAstNode(form, contextStack);
-            }
-        }
-        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; }
-        }
-        return result;
-    },
-    findUnresolvedIdentifiers: function (node, contextStack, _a) {
-        var findUnresolvedIdentifiers = _a.findUnresolvedIdentifiers, builtin = _a.builtin;
-        return findUnresolvedIdentifiers(node.p, contextStack, builtin);
-    },
-};
-
 var specialExpressions = {
     '&&': andSpecialExpression,
     'comment': commentSpecialExpression,
@@ -5745,19 +5484,14 @@ var specialExpressions = {
     'for': forSpecialExpression,
     'fn': fnSpecialExpression,
     'if': ifSpecialExpression,
-    'if_let': ifLetSpecialExpression,
-    'if_not': ifNotSpecialExpression,
+    'unless': unlessSpecialExpression,
     'let': letSpecialExpression,
     'loop': loopSpecialExpression,
     '||': orSpecialExpression,
     'recur': recurSpecialExpression,
     'throw': throwSpecialExpression,
     'try': trySpecialExpression,
-    'when': whenSpecialExpression,
-    'when_first': whenFirstSpecialExpression,
-    'when_let': whenLetSpecialExpression,
-    'when_not': whenNotSpecialExpression,
-    'declared?': declaredSpecialExpression,
+    'defined?': declaredSpecialExpression,
     '??': qqSpecialExpression,
 };
 Object.keys(specialExpressions).forEach(function (key) {
@@ -5779,8 +5513,8 @@ function isContextEntry(value) {
 var ContextStackImpl = /** @class */ (function () {
     function ContextStackImpl(_a) {
         var contexts = _a.contexts, hostValues = _a.values, lazyHostValues = _a.lazyValues, nativeJsFunctions = _a.nativeJsFunctions;
-        this.contexts = contexts;
         this.globalContext = asNonUndefined(contexts[0]);
+        this.contexts = contexts;
         this.values = hostValues;
         this.lazyValues = lazyHostValues;
         this.nativeJsFunctions = nativeJsFunctions;
@@ -5796,6 +5530,35 @@ var ContextStackImpl = /** @class */ (function () {
         contextStack.globalContext = globalContext;
         return contextStack;
     };
+    ContextStackImpl.prototype.exportValue = function (name, value) {
+        if (this.globalContext[name]) {
+            throw new Error("Cannot redefine exported value \"".concat(name, "\""));
+        }
+        if (specialExpressionKeys.includes(name)) {
+            throw new Error("Cannot shadow special expression \"".concat(name, "\""));
+        }
+        if (normalExpressionKeys.includes(name)) {
+            throw new Error("Cannot shadow builtin function \"".concat(name, "\""));
+        }
+        this.addValue(name, value);
+        this.globalContext[name] = { value: value };
+    };
+    ContextStackImpl.prototype.addValue = function (name, value) {
+        var currentContext = this.contexts[0];
+        if (!currentContext) {
+            throw new Error('No context to add value to');
+        }
+        if (currentContext[name]) {
+            throw new Error("Cannot redefine value \"".concat(name, "\""));
+        }
+        if (specialExpressionKeys.includes(name)) {
+            throw new Error("Cannot shadow special expression \"".concat(name, "\""));
+        }
+        if (normalExpressionKeys.includes(name)) {
+            throw new Error("Cannot shadow builtin function \"".concat(name, "\""));
+        }
+        currentContext[name] = { value: toAny(value) };
+    };
     ContextStackImpl.prototype.clone = function () {
         // eslint-disable-next-line ts/no-unsafe-argument
         return new ContextStackImpl(JSON.parse(JSON.stringify({
@@ -5925,7 +5688,7 @@ function createContextStack(params) {
                 return acc;
             }, {}),
     });
-    return contextStack;
+    return contextStack.create({});
 }
 
 var _a;
@@ -6237,7 +6000,14 @@ function evaluateNumberAsFunction(fn, params, sourceCodeInfo) {
 
 var findUnresolvedIdentifiers = function (ast, contextStack, builtin) {
     var e_1, _a;
-    var astNodes = Array.isArray(ast) ? ast : ast.b;
+    var astNodes = Array.isArray(ast)
+        ? ast
+        : [{
+                t: AstNodeType.SpecialExpression,
+                n: 'do',
+                p: ast.b,
+                token: undefined,
+            }];
     var unresolvedIdentifiers = new Set();
     try {
         for (var astNodes_1 = __values(astNodes), astNodes_1_1 = astNodes_1.next(); !astNodes_1_1.done; astNodes_1_1 = astNodes_1.next()) {
@@ -6309,537 +6079,9 @@ function findUnresolvedIdentifiersInAstNode(astNode, contextStack, builtin) {
     }
 }
 
-var calculateAndOutcomes = function (_a) {
-    var astNode = _a.astNode, combinateAstNodes = _a.combinateAstNodes;
-    return combinateAstNodes(astNode.p)
-        .map(function (p) { return ({
-        n: '&&',
-        t: AstNodeType.SpecialExpression,
-        p: p,
-        token: astNode.token,
-    }); });
-};
-
-var calculateCondOutcomes = function (_a) {
-    var astNode = _a.astNode, nilNode = _a.nilNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes, isAstComputable = _a.isAstComputable;
-    var testNodes = arrayToPairs(astNode.p).map(function (_a) {
-        var _b = __read(_a, 1), t = _b[0];
-        return t;
-    });
-    if (isAstComputable(testNodes)) {
-        return combinate(arrayToPairs(astNode.p)
-            // Create a list of ast nodes from the test and form of each condition
-            .reduce(function (acc, _a) {
-            var _b = __read(_a, 2), test = _b[0], form = _b[1];
-            acc.push(calculatePossibleAstNodes(test), calculatePossibleAstNodes(form));
-            return acc;
-        }, []))
-            // Create a new CondNode for each combination of test and form outcomes
-            .map(function (conditionAsts) { return (__assign(__assign({}, astNode), { c: arrayToPairs(conditionAsts).map(function (_a) {
-                var _b = __read(_a, 2), t = _b[0], f = _b[1];
-                return ({ t: t, f: f });
-            }) })); });
-    }
-    return __spreadArray(__spreadArray([], __read(arrayToPairs(astNode.p).flatMap(function (_a) {
-        var _b = __read(_a, 2); _b[0]; var form = _b[1];
-        return calculatePossibleAstNodes(form);
-    })), false), [
-        nilNode,
-    ], false);
-};
-
-var trueNode = { t: AstNodeType.ReservedSymbol, v: 'true', token: undefined, p: [], n: undefined };
-var falseNode = { t: AstNodeType.ReservedSymbol, v: 'false', token: undefined, p: [], n: undefined };
-var calculateDeclaredOutcomes = function (_a) {
-    var astNode = _a.astNode, isAstComputable = _a.isAstComputable;
-    if (isAstComputable(astNode.p))
-        return [trueNode];
-    return [trueNode, falseNode];
-};
-
-var calculateDefOutcomes = function (_a) {
-    var astNode = _a.astNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes, addGlobalIdentifier = _a.addGlobalIdentifier;
-    var nameNode = asSymbolNode(astNode.p[0]);
-    var valueNode = astNode.p[1];
-    addGlobalIdentifier(nameNode.v);
-    return calculatePossibleAstNodes(valueNode)
-        .map(function (node) { return (__assign(__assign({}, astNode), { p: [nameNode, node] })); });
-};
-
-var calculateDefsOutcomes = function (_a) {
-    var astNode = _a.astNode, combinateAstNodes = _a.combinateAstNodes;
-    return combinateAstNodes(astNode.p)
-        .map(function (p) { return (__assign(__assign({}, astNode), { p: p })); });
-};
-
-var calculateDoOutcomes = function (_a) {
-    var astNode = _a.astNode, combinateAstNodes = _a.combinateAstNodes;
-    return combinateAstNodes(astNode.p).map(function (p) { return (__assign(__assign({}, astNode), { p: p })); });
-};
-
-function calculateFunctionOverloadOutcomes(combinateAstNodes, functionOverloads) {
-    return combinate(functionOverloads
-        // For each overload, calculate the possible outcomes for each parameter
-        .map(function (functionOverload) {
-        var _a;
-        return combinateAstNodes(functionOverload.b, [
-            functionOverload.as.m,
-            functionOverload.as.b.map(function (bindingNode) { return bindingNode.n; }),
-            (_a = functionOverload.as.r) !== null && _a !== void 0 ? _a : [],
-        ].flat())
-            // For each combination of parameter outcomes, create a new overload
-            .map(function (body) { return (__assign(__assign({}, functionOverload), { b: body })); });
-    }));
-}
-var calculateDefnOutcomes = function (_a) {
-    var astNode = _a.astNode, combinateAstNodes = _a.combinateAstNodes, addGlobalIdentifier = _a.addGlobalIdentifier;
-    addGlobalIdentifier(astNode.f.v);
-    // astNode.o is an array of overloads
-    return calculateFunctionOverloadOutcomes(combinateAstNodes, astNode.o).map(function (functionOverloads) { return (__assign(__assign({}, astNode), { o: functionOverloads })); });
-};
-var calculateDefnsOutcomes = function (_a) {
-    var astNode = _a.astNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes, combinateAstNodes = _a.combinateAstNodes;
-    // astNode.o is an array of overloads
-    return calculatePossibleAstNodes(astNode.f).flatMap(function (functionName) {
-        return calculateFunctionOverloadOutcomes(combinateAstNodes, astNode.o).map(function (functionOverloads) { return (__assign(__assign({}, astNode), { f: functionName, o: functionOverloads })); });
-    });
-};
-var calculateFnOutcomes = function (_a) {
-    var astNode = _a.astNode, combinateAstNodes = _a.combinateAstNodes;
-    // astNode.o is an array of overloads
-    return calculateFunctionOverloadOutcomes(combinateAstNodes, astNode.o).map(function (functionOverloads) { return (__assign(__assign({}, astNode), { o: functionOverloads })); });
-};
-
-var calculateIfLetOutcomes = function (_a) {
-    var _b;
-    var astNode = _a.astNode, nilNode = _a.nilNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes, combinateAstNodes = _a.combinateAstNodes, isAstComputable = _a.isAstComputable;
-    var bindingNode = astNode.b;
-    var thenBranch = astNode.p[0];
-    var elseBranch = (_b = astNode.p[1]) !== null && _b !== void 0 ? _b : nilNode;
-    if (!isAstComputable(bindingNode.v)) {
-        return __spreadArray(__spreadArray([], __read(calculatePossibleAstNodes(thenBranch)), false), __read(calculatePossibleAstNodes(elseBranch)), false);
-    }
-    var newIdentifier = bindingNode.n;
-    return calculatePossibleAstNodes(bindingNode.v)
-        .map(function (bindingValue) { return (__assign(__assign({}, bindingNode), { v: bindingValue })); })
-        .flatMap(function (b) { return combinateAstNodes(astNode.p, [newIdentifier])
-        .map(function (p) { return (__assign(__assign({}, astNode), { b: b, p: p })); }); });
-};
-
-var calculateIfNotOutcomes = function (_a) {
-    var _b;
-    var astNode = _a.astNode, nilNode = _a.nilNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes, combinateAstNodes = _a.combinateAstNodes, isAstComputable = _a.isAstComputable;
-    var condition = astNode.p[0];
-    var thenBranch = astNode.p[1];
-    var elseBranch = (_b = astNode.p[2]) !== null && _b !== void 0 ? _b : nilNode;
-    if (isAstComputable(condition)) {
-        return combinateAstNodes(astNode.p)
-            .map(function (p) { return ({
-            n: 'if_not',
-            t: astNode.t,
-            p: p,
-            token: astNode.token,
-        }); });
-    }
-    return __spreadArray(__spreadArray([], __read(calculatePossibleAstNodes(thenBranch)), false), __read(calculatePossibleAstNodes(elseBranch)), false);
-};
-
-var calculateIfOutcomes = function (_a) {
-    var _b;
-    var astNode = _a.astNode, nilNode = _a.nilNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes, combinateAstNodes = _a.combinateAstNodes, isAstComputable = _a.isAstComputable;
-    var condition = astNode.p[0];
-    var thenBranch = astNode.p[1];
-    var elseBranch = (_b = astNode.p[2]) !== null && _b !== void 0 ? _b : nilNode;
-    if (isAstComputable(condition)) {
-        return combinateAstNodes(astNode.p)
-            .map(function (p) { return ({
-            n: 'if',
-            t: astNode.t,
-            p: p,
-            token: astNode.token,
-        }); });
-    }
-    return __spreadArray(__spreadArray([], __read(calculatePossibleAstNodes(thenBranch)), false), __read(calculatePossibleAstNodes(elseBranch)), false);
-};
-
-var calculateLetOutcomes = function (_a) {
-    var astNode = _a.astNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes, combinateAstNodes = _a.combinateAstNodes, isAstComputable = _a.isAstComputable;
-    try {
-        // check bindings, if any binding value cannot be calculated, convert the whole let to a do-expression
-        if (!isAstComputable(astNode.bs.map(function (b) { return calculatePossibleAstNodes(b.v); })))
-            throw new Error('Could not calculate binding value');
-    }
-    catch (_b) {
-        var doNodes = combinateAstNodes(astNode.p)
-            .map(function (p) {
-            return {
-                n: 'do',
-                t: AstNodeType.SpecialExpression,
-                p: p,
-                token: astNode.token,
-            };
-        });
-        return doNodes;
-    }
-    var newIdentifiers = astNode.bs.map(function (bindingNode) { return bindingNode.n; });
-    var letNodes = combinate(astNode.bs.map(function (bindingNode) {
-        return calculatePossibleAstNodes(bindingNode.v)
-            .map(function (bindingValues) { return (__assign(__assign({}, bindingNode), { v: bindingValues })); });
-    }))
-        .flatMap(function (bindingNodes) { return combinate(astNode.p.map(function (p) { return calculatePossibleAstNodes(p, newIdentifiers); }))
-        .map(function (p) {
-        return {
-            n: 'let',
-            bs: bindingNodes,
-            t: AstNodeType.SpecialExpression,
-            p: p,
-            token: astNode.token,
-        };
-    }); });
-    return letNodes;
-};
-
-var calculateForOutcomes = function (_a) {
-    var astNode = _a.astNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes;
-    if (!isDeterministic(calculatePossibleAstNodes, astNode))
-        throw new Error('Could not calculate for loop, not deterministic');
-    return [astNode];
-};
-var calculateDoSeqOutcomes = function (_a) {
-    var astNode = _a.astNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes;
-    if (!isDeterministic(calculatePossibleAstNodes, astNode))
-        throw new Error('Could not calculate doSeq node, not deterministic');
-    return [astNode];
-};
-function isDeterministic(calculatePossibleAstNodes, astNode) {
-    var e_1, _a;
-    try {
-        for (var _b = __values(astNode.l), _c = _b.next(); !_c.done; _c = _b.next()) {
-            var _d = _c.value, b = _d.b, l = _d.l, wn = _d.wn, we = _d.we;
-            if (l && l.some(function (_a) {
-                var v = _a.v;
-                return !astIsDeterministic(calculatePossibleAstNodes, v);
-            }))
-                return false;
-            if (!astIsDeterministic(calculatePossibleAstNodes, b.v))
-                return false;
-            if (wn && !astIsDeterministic(calculatePossibleAstNodes, wn))
-                return false;
-            if (we && !astIsDeterministic(calculatePossibleAstNodes, we))
-                return false;
-        }
-    }
-    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_1) throw e_1.error; }
-    }
-    if (!astIsDeterministic(calculatePossibleAstNodes, astNode.p[0]))
-        return false;
-    return true;
-}
-function astIsDeterministic(calculatePossibleAstNodes, astNode) {
-    return calculatePossibleAstNodes(astNode).length === 1;
-}
-
-var calculateOrOutcomes = function (_a) {
-    var astNode = _a.astNode, combinateAstNodes = _a.combinateAstNodes;
-    return combinateAstNodes(astNode.p)
-        .map(function (p) { return ({
-        n: '||',
-        t: AstNodeType.SpecialExpression,
-        p: p,
-        token: astNode.token,
-    }); });
-};
-
-var calculateQqOutcomes = function (_a) {
-    var astNode = _a.astNode, combinateAstNodes = _a.combinateAstNodes, isAstComputable = _a.isAstComputable;
-    if (!isAstComputable(astNode.p[0]))
-        throw new Error('First argument of ?? not computable');
-    return combinateAstNodes(astNode.p)
-        .map(function (p) { return (__assign(__assign({}, astNode), { p: p })); });
-};
-
-var calculateThrowOutcomes = function (_a) {
-    var astNode = _a.astNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes;
-    return calculatePossibleAstNodes(astNode.p[0]).map(function (m) { return (__assign(__assign({}, astNode), { p: [m] })); });
-};
-
-var calculateTryOutcomes = function (_a) {
-    var astNode = _a.astNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes;
-    var _b = calculatePossibleAstNodes(astNode.p[0]).reduce(function (acc, node) {
-        if (node.n === 'throw') {
-            acc.throws.push(node.p[0]);
-        }
-        else {
-            acc.vals.push(node);
-        }
-        return acc;
-    }, { vals: [], throws: [] }), vals = _b.vals, throws = _b.throws;
-    var catches = throws.flatMap(function (throwNode) {
-        var letNode = {
-            t: AstNodeType.SpecialExpression,
-            n: 'let',
-            bs: [{
-                    t: AstNodeType.Binding,
-                    n: astNode.e.v,
-                    v: throwNode,
-                    token: undefined,
-                    p: [],
-                }],
-            p: [astNode.ce],
-            token: undefined,
-        };
-        return calculatePossibleAstNodes(letNode);
-    });
-    return __spreadArray(__spreadArray([], __read(vals), false), __read(catches), false);
-};
-
-var calculateWhenFirstOutcomes = function (_a) {
-    var astNode = _a.astNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes, combinateAstNodes = _a.combinateAstNodes, isAstComputable = _a.isAstComputable;
-    var bindingNode = astNode.b;
-    if (!isAstComputable(bindingNode.v))
-        throw new Error('Could not calculate binding value');
-    var newIdentifier = bindingNode.n;
-    return calculatePossibleAstNodes(bindingNode.v)
-        .map(function (bindingValue) { return (__assign(__assign({}, bindingNode), { v: bindingValue })); })
-        .flatMap(function (b) {
-        return combinateAstNodes(astNode.p, [newIdentifier])
-            .map(function (p) { return (__assign(__assign({}, astNode), { b: b, p: p })); });
-    });
-};
-
-var calculateWhenLetOutcomes = function (_a) {
-    var astNode = _a.astNode, nilNode = _a.nilNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes, combinateAstNodes = _a.combinateAstNodes, isAstComputable = _a.isAstComputable;
-    var bindingNode = astNode.b;
-    if (!isAstComputable(bindingNode.v)) {
-        return __spreadArray(__spreadArray([], __read(combinateAstNodes(astNode.p)
-            .map(function (p) { return ({
-            n: 'do',
-            t: astNode.t,
-            p: p,
-            token: astNode.token,
-        }); })), false), [
-            nilNode,
-        ], false);
-    }
-    var newIdentifier = bindingNode.n;
-    return calculatePossibleAstNodes(bindingNode.v)
-        .map(function (bindingValue) { return (__assign(__assign({}, bindingNode), { v: bindingValue })); })
-        .flatMap(function (b) {
-        return combinateAstNodes(astNode.p, [newIdentifier])
-            .map(function (p) { return (__assign(__assign({}, astNode), { b: b, p: p })); });
-    });
-};
-
-var calculateWhenNotOutcomes = function (_a) {
-    var astNode = _a.astNode, combinateAstNodes = _a.combinateAstNodes, nilNode = _a.nilNode, isAstComputable = _a.isAstComputable;
-    var condition = astNode.p[0];
-    if (isAstComputable(condition)) {
-        return combinateAstNodes(astNode.p)
-            .map(function (p) { return ({
-            n: 'when_not',
-            t: astNode.t,
-            p: p,
-            token: astNode.token,
-        }); });
-    }
-    var body = astNode.p.slice(1);
-    return __spreadArray(__spreadArray([], __read(combinateAstNodes(body)
-        .map(function (p) { return ({
-        n: 'do',
-        t: astNode.t,
-        p: p,
-        token: astNode.token,
-    }); })), false), [
-        nilNode,
-    ], false);
-};
-
-var calculateWhenOutcomes = function (_a) {
-    var astNode = _a.astNode, combinateAstNodes = _a.combinateAstNodes, nilNode = _a.nilNode, isAstComputable = _a.isAstComputable;
-    var condition = astNode.p[0];
-    if (isAstComputable(condition)) {
-        return combinateAstNodes(astNode.p)
-            .map(function (p) { return ({
-            n: 'when',
-            t: astNode.t,
-            p: p,
-            token: astNode.token,
-        }); });
-    }
-    var body = astNode.p.slice(1);
-    return __spreadArray(__spreadArray([], __read(combinateAstNodes(body)
-        .map(function (p) { return ({
-        n: 'do',
-        t: astNode.t,
-        p: p,
-        token: astNode.token,
-    }); })), false), [
-        nilNode,
-    ], false);
-};
-
-var calculateRecurOutcomes = function (_a) {
-    var astNode = _a.astNode, combinateAstNodes = _a.combinateAstNodes;
-    return combinateAstNodes(astNode.p)
-        .map(function (p) { return (__assign(__assign({}, astNode), { p: p })); });
-};
-
-var calculateCommentOutcomes = function (_a) {
-    var nilNode = _a.nilNode;
-    return [nilNode];
-};
-
-var calculateLoopOutcomes = function (_a) {
-    var astNode = _a.astNode, combinateAstNodes = _a.combinateAstNodes;
-    return combinateAstNodes(astNode.p, astNode.bs.map(function (bindingNode) { return bindingNode.n; }))
-        .map(function (p) { return (__assign(__assign({}, astNode), { p: p })); });
-};
-
-var calculateSwitchOutcomes = function (_a) {
-    var astNode = _a.astNode, nilNode = _a.nilNode, calculatePossibleAstNodes = _a.calculatePossibleAstNodes;
-    // TODO be smarter about this
-    return __spreadArray(__spreadArray([], __read(arrayToPairs(astNode.p.slice(1)).flatMap(function (_a) {
-        var _b = __read(_a, 2); _b[0]; var form = _b[1];
-        return calculatePossibleAstNodes(form);
-    })), false), [
-        nilNode,
-    ], false);
-};
-
-var specialExpressionCalculator = {
-    '&&': function (astNode, helperOptions) { return calculateAndOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'comment': function (astNode, helperOptions) { return calculateCommentOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'cond': function (astNode, helperOptions) { return calculateCondOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'switch': function (astNode, helperOptions) { return calculateSwitchOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'declared?': function (astNode, helperOptions) { return calculateDeclaredOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'defn': function (astNode, helperOptions) { return calculateDefnOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'def': function (astNode, helperOptions) { return calculateDefOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'defns': function (astNode, helperOptions) { return calculateDefnsOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'defs': function (astNode, helperOptions) { return calculateDefsOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'do': function (astNode, helperOptions) { return calculateDoOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'doseq': function (astNode, helperOptions) { return calculateDoSeqOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'fn': function (astNode, helperOptions) { return calculateFnOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'for': function (astNode, helperOptions) { return calculateForOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'if_let': function (astNode, helperOptions) { return calculateIfLetOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'if': function (astNode, helperOptions) { return calculateIfOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'if_not': function (astNode, helperOptions) { return calculateIfNotOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'let': function (astNode, helperOptions) { return calculateLetOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'loop': function (astNode, helperOptions) { return calculateLoopOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    '||': function (astNode, helperOptions) { return calculateOrOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    '??': function (astNode, helperOptions) { return calculateQqOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'recur': function (astNode, helperOptions) { return calculateRecurOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'throw': function (astNode, helperOptions) { return calculateThrowOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'try': function (astNode, helperOptions) { return calculateTryOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'when_first': function (astNode, helperOptions) { return calculateWhenFirstOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'when_let': function (astNode, helperOptions) { return calculateWhenLetOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'when': function (astNode, helperOptions) { return calculateWhenOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-    'when_not': function (astNode, helperOptions) { return calculateWhenNotOutcomes(__assign({ astNode: astNode }, helperOptions)); },
-};
-
-function calculateOutcomes(contextStack, astNodes) {
-    // First, we try to calculate outcomes for the whole astNodes array.
-    // If that fails, we try to calculate outcomes for the array without the first element.
-    // If that fails, we try to calculate outcomes for the array without the first two elements.
-    // And so on.
-    // This makes it possible to calculate outcomes for e.g.
-    // (write! x) x
-    // Problems occur for e.g.
-    // (def x 1) (write! x) x
-    // This should output [1], but since (write! x) fails to calculate outcomes, we get null.
-    // Ok, but not optimal
-    // The contract is that when an array is returned, it must be correct.
-    // But returning null (indicating that the calculation failed) is always a way out.
-    for (var i = 0; i < astNodes.length; i++) {
-        var usingAstNode = astNodes.slice(i);
-        var outcomes = calculateOutcomesInner(contextStack, usingAstNode);
-        if (outcomes !== null)
-            return outcomes;
-    }
-    return null;
-}
-function calculateOutcomesInner(contextStack, astNodes) {
-    var e_1, _a;
-    var possibleAsts = calculatePossibleAsts(contextStack.clone(), astNodes);
-    if (possibleAsts === null)
-        return null;
-    var outcomes = [];
-    try {
-        for (var possibleAsts_1 = __values(possibleAsts), possibleAsts_1_1 = possibleAsts_1.next(); !possibleAsts_1_1.done; possibleAsts_1_1 = possibleAsts_1.next()) {
-            var possibleAst = possibleAsts_1_1.value;
-            var unresolvedIdentifiers = findUnresolvedIdentifiers(possibleAst, contextStack.clone(), builtin);
-            if (unresolvedIdentifiers.size !== 0)
-                return null;
-            var ast = {
-                b: possibleAst,
-                hasDebugData: true,
-            };
-            try {
-                outcomes.push(evaluate(ast, contextStack.clone()));
-            }
-            catch (e) {
-                outcomes.push(e);
-            }
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (possibleAsts_1_1 && !possibleAsts_1_1.done && (_a = possibleAsts_1.return)) _a.call(possibleAsts_1);
-        }
-        finally { if (e_1) throw e_1.error; }
-    }
-    return outcomes;
-}
-function calculatePossibleAsts(contextStack, astNodes) {
-    var possibleAsts;
-    try {
-        possibleAsts = combinate(astNodes.map(function (astNode) { return calculatePossibleAstNodes(contextStack, astNode); }));
-    }
-    catch (e) {
-        return null;
-    }
-    return possibleAsts;
-}
-var nilNode = { t: AstNodeType.ReservedSymbol, v: 'nil', token: undefined, p: [], n: undefined };
-function calculatePossibleAstNodes(contextStack, astNode, newIndentifiers) {
-    var newContext = newIndentifiers
-        ? newIndentifiers.reduce(function (acc, identity) {
-            acc[identity] = { value: null };
-            return acc;
-        }, {})
-        : undefined;
-    var newContextStack = newContext ? contextStack.create(newContext) : contextStack;
-    if (astNode.t === AstNodeType.NormalExpression) {
-        return combinate(astNode.p.map(function (n) { return calculatePossibleAstNodes(newContextStack, n); }))
-            .map(function (p) { return (__assign(__assign({}, astNode), { p: p })); });
-    }
-    else if (astNode.t === AstNodeType.SpecialExpression) {
-        var helperOptions = {
-            nilNode: nilNode,
-            calculatePossibleAstNodes: function (node, identifiers) { return calculatePossibleAstNodes(newContextStack.clone(), node, identifiers); },
-            combinateAstNodes: function (nodes, identifiers) {
-                return combinate(nodes.map(function (node) { return calculatePossibleAstNodes(newContextStack.clone(), node, identifiers); }));
-            },
-            isAstComputable: function (node) {
-                return calculateOutcomesInner(newContextStack, Array.isArray(node) ? node.flat() : [node]) !== null;
-            },
-            addGlobalIdentifier: function (name) { return newContextStack.globalContext[name] = { value: null }; },
-        };
-        // eslint-disable-next-line ts/no-unsafe-argument
-        return specialExpressionCalculator[astNode.n](astNode, helperOptions);
-    }
-    return [astNode];
-}
-
 function analyze(ast, params) {
     return {
         unresolvedIdentifiers: findUnresolvedIdentifiers(ast, createContextStack(params), builtin),
-        outcomes: calculateOutcomes(createContextStack(params), ast.b),
     };
 }
 
@@ -7121,38 +6363,43 @@ var AlgebraicParser = /** @class */ (function () {
         var _a;
         if (precedence === void 0) { precedence = 0; }
         var firstToken = this.peek();
-        if (isA_SymbolToken(firstToken) && firstToken[1] === 'def') {
-            return this.parseDef(firstToken);
-        }
-        else if (isA_SymbolToken(firstToken) && firstToken[1] === 'defn') {
-            return this.parseDefn(firstToken);
-        }
         var left;
-        if (isA_SymbolToken(firstToken) && firstToken[1] === 'if') {
-            left = this.parseIf(firstToken);
-        }
-        else if (isA_SymbolToken(firstToken) && firstToken[1] === 'cond') {
-            left = this.parseCond(firstToken);
-        }
-        else if (isA_SymbolToken(firstToken) && firstToken[1] === 'switch') {
-            left = this.parseSwitch(firstToken);
-        }
-        else if (isA_SymbolToken(firstToken) && firstToken[1] === 'for') {
-            left = this.parseFor(firstToken);
-        }
-        else {
-            left = this.parseOperand();
+        if (isA_SymbolToken(firstToken)) {
+            switch (firstToken[1]) {
+                case 'def':
+                    return this.parseDef(firstToken);
+                case 'defn':
+                    return this.parseDefn(firstToken);
+                case 'let':
+                    return this.parseLet(firstToken);
+                case 'if':
+                case 'unless':
+                    left = this.parseIfOrUnless(firstToken);
+                    break;
+                case 'cond':
+                    left = this.parseCond(firstToken);
+                    break;
+                case 'switch':
+                    left = this.parseSwitch(firstToken);
+                    break;
+                case 'for':
+                case 'doseq':
+                    left = this.parseForOrDoseq(firstToken);
+                    break;
+                case 'do':
+                    left = this.parseDo(firstToken);
+                    break;
+                case 'loop':
+                    left = this.parseLoop(firstToken);
+                    break;
+                case 'try':
+                    left = this.parseTry(firstToken);
+                    break;
+            }
         }
+        left || (left = this.parseOperand());
         var operator = this.peek();
-        while (!this.isAtEnd()
-            && !isA_OperatorToken(operator, ',')
-            && !isA_OperatorToken(operator, ';')
-            && !isRBracketToken(operator)
-            && !isA_ReservedSymbolToken(operator, 'else')
-            && !isA_ReservedSymbolToken(operator, 'then')
-            && !isA_ReservedSymbolToken(operator, 'end')
-            && !isA_ReservedSymbolToken(operator, 'case')
-            && !isRParenToken(operator)) {
+        while (!this.isAtExpressionEnd()) {
             if (isA_BinaryOperatorToken(operator)) {
                 var name_1 = operator[1];
                 var newPrecedece = getPrecedence(name_1);
@@ -7405,12 +6652,9 @@ var AlgebraicParser = /** @class */ (function () {
                     case '??':
                     case '&&':
                     case 'comment':
-                    case 'declared?':
-                    case 'if_not':
+                    case 'defined?':
                     case '||':
-                    case 'when':
-                    case 'when_not':
-                    case 'do':
+                    case 'recur':
                     case 'throw': {
                         var node = {
                             t: AstNodeType.SpecialExpression,
@@ -7421,17 +6665,10 @@ var AlgebraicParser = /** @class */ (function () {
                         builtin.specialExpressions[node.n].validateParameterCount(node);
                         return node;
                     }
-                    case 'let':
-                        return this.parseLet(symbol, params);
                     case 'defs':
-                    case 'if_let':
-                    case 'when_let':
-                    case 'when_first':
                     case 'fn':
                     case 'defns':
                     case 'try':
-                    case 'recur':
-                    case 'loop':
                     case 'doseq':
                         throw new Error("Special expression ".concat(name_2, " is not available in algebraic notation"));
                     default:
@@ -7594,36 +6831,142 @@ var AlgebraicParser = /** @class */ (function () {
         };
         return node;
     };
-    AlgebraicParser.prototype.parseLet = function (letSymbol, params) {
-        var _a, _b;
-        if (params.length !== 2) {
-            throw new LitsError('let expects two arguments', (_a = getTokenDebugData(letSymbol.token)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
-        }
-        var letObject = params[0];
-        if (letObject.t !== AstNodeType.NormalExpression || letObject.n !== 'object') {
-            throw new LitsError('let expects an object as first argument', (_b = getTokenDebugData(letObject.token)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
-        }
-        var letBindings = arrayToPairs(letObject.p);
-        var expression = params[1];
+    AlgebraicParser.prototype.parseLet = function (token) {
+        this.advance();
+        var letSymbol = parseSymbol(this.tokenStream, this.parseState);
+        assertA_OperatorToken(this.peek(), '=');
+        this.advance();
+        var value = this.parseExpression();
         return {
             t: AstNodeType.SpecialExpression,
             n: 'let',
-            p: [expression],
+            p: [],
             token: getTokenDebugData(letSymbol.token) && letSymbol.token,
-            bs: letBindings.map(function (pair) {
-                var key = pair[0];
-                var value = pair[1];
-                return {
+            bs: [{
                     t: AstNodeType.Binding,
-                    n: key.v,
+                    n: letSymbol.v,
                     v: value,
                     p: [],
-                    token: getTokenDebugData(key.token) && key.token,
-                };
-            }),
+                    token: getTokenDebugData(token) && token,
+                }],
+        };
+    };
+    AlgebraicParser.prototype.parseDo = function (token) {
+        this.advance();
+        var expressions = [];
+        while (!this.isAtEnd() && !isA_ReservedSymbolToken(this.peek(), 'end')) {
+            expressions.push(this.parseExpression());
+            if (isA_OperatorToken(this.peek(), ';')) {
+                this.advance();
+            }
+        }
+        assertA_ReservedSymbolToken(this.peek(), 'end');
+        this.advance();
+        return {
+            t: AstNodeType.SpecialExpression,
+            n: 'do',
+            p: expressions,
+            token: getTokenDebugData(token) && token,
+        };
+    };
+    AlgebraicParser.prototype.parseLoop = function (token) {
+        var _a;
+        this.advance();
+        assertLParenToken(this.peek());
+        this.advance();
+        var bindingNodes = [];
+        while (!this.isAtEnd() && !isRParenToken(this.peek())) {
+            var symbol = parseSymbol(this.tokenStream, this.parseState);
+            assertA_OperatorToken(this.peek(), '=');
+            this.advance();
+            var value = this.parseExpression();
+            bindingNodes.push({
+                t: AstNodeType.Binding,
+                n: symbol.v,
+                v: value,
+                p: [],
+                token: getTokenDebugData(symbol.token) && symbol.token,
+            });
+            if (isA_OperatorToken(this.peek(), ',')) {
+                this.advance();
+            }
+        }
+        if (bindingNodes.length === 0) {
+            throw new LitsError('Expected binding', (_a = getTokenDebugData(this.peek())) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
+        }
+        assertRParenToken(this.peek());
+        this.advance();
+        var params = [];
+        while (!this.isAtEnd() && !isA_ReservedSymbolToken(this.peek(), 'end')) {
+            params.push(this.parseExpression());
+            if (isA_OperatorToken(this.peek(), ';')) {
+                this.advance();
+            }
+        }
+        assertA_ReservedSymbolToken(this.peek(), 'end');
+        this.advance();
+        return {
+            t: AstNodeType.SpecialExpression,
+            n: 'loop',
+            p: params,
+            bs: bindingNodes,
+            token: getTokenDebugData(token) && token,
+        };
+    };
+    AlgebraicParser.prototype.parseTry = function (token) {
+        this.advance();
+        var tryExpressions = [];
+        while (!this.isAtEnd() && !isA_SymbolToken(this.peek(), 'catch')) {
+            tryExpressions.push(this.parseExpression());
+            if (isA_OperatorToken(this.peek(), ';')) {
+                this.advance();
+            }
+        }
+        var tryExpression = tryExpressions.length === 1
+            ? tryExpressions[0]
+            : {
+                t: AstNodeType.SpecialExpression,
+                n: 'do',
+                p: tryExpressions,
+                token: getTokenDebugData(token) && token,
+            };
+        assertA_SymbolToken(this.peek(), 'catch');
+        this.advance();
+        var errorSymbol;
+        if (isLParenToken(this.peek())) {
+            this.advance();
+            errorSymbol = parseSymbol(this.tokenStream, this.parseState);
+            assertRParenToken(this.peek());
+            this.advance();
+        }
+        var catchExpressions = [];
+        while (!this.isAtEnd() && !isA_ReservedSymbolToken(this.peek(), 'end')) {
+            catchExpressions.push(this.parseExpression());
+            if (isA_OperatorToken(this.peek(), ';')) {
+                this.advance();
+            }
+        }
+        assertA_ReservedSymbolToken(this.peek(), 'end');
+        this.advance();
+        var catchExpression = catchExpressions.length === 1
+            ? catchExpressions[0]
+            : {
+                t: AstNodeType.SpecialExpression,
+                n: 'do',
+                p: catchExpressions,
+                token: getTokenDebugData(token) && token,
+            };
+        return {
+            t: AstNodeType.SpecialExpression,
+            n: 'try',
+            p: [tryExpression],
+            ce: catchExpression,
+            e: errorSymbol,
+            token: getTokenDebugData(token) && token,
         };
     };
-    AlgebraicParser.prototype.parseFor = function (token) {
+    AlgebraicParser.prototype.parseForOrDoseq = function (token) {
+        var isDoseq = token[1] === 'doseq';
         this.advance();
         assertLParenToken(this.peek());
         this.advance();
@@ -7643,7 +6986,7 @@ var AlgebraicParser = /** @class */ (function () {
         this.advance();
         return {
             t: AstNodeType.SpecialExpression,
-            n: 'for',
+            n: isDoseq ? 'doseq' : 'for',
             p: [expression],
             token: getTokenDebugData(token) && token,
             l: forLoopBindings,
@@ -7663,33 +7006,26 @@ var AlgebraicParser = /** @class */ (function () {
         }
         var modifiers = [];
         var token = this.peek();
-        if (!isA_SymbolToken(token)) {
+        if (!isA_SymbolToken(token, 'let')
+            && !isA_ReservedSymbolToken(token, 'when')
+            && !isA_ReservedSymbolToken(token, 'while')) {
             throw new LitsError('Expected symbol let, when or while', (_a = getTokenDebugData(token)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo);
         }
         var letBindings;
         if (token[1] === 'let') {
             modifiers.push('&let');
             letBindings = [];
-            this.advance();
-            var letObject = this.parseObject();
-            letBindings = arrayToPairs(letObject.p).map(function (pair) {
-                var key = pair[0];
-                var value = pair[1];
-                return {
-                    t: AstNodeType.Binding,
-                    n: key.v,
-                    v: value,
-                    p: [],
-                    token: getTokenDebugData(key.token) && key.token,
-                };
-            });
+            while (isA_SymbolToken(token, 'let')) {
+                var letNode = this.parseLet(token);
+                letBindings.push(letNode.bs[0]);
+                token = this.peek();
+            }
         }
         token = this.peek();
         var whenNode;
         var whileNode;
-        while (isA_SymbolToken(token)
-            && ((token[1] === 'when' && !modifiers.includes('&when'))
-                || (token[1] === 'while' && !modifiers.includes('&while')))) {
+        while (isA_ReservedSymbolToken(token, 'when')
+            || isA_ReservedSymbolToken(token, 'while')) {
             this.advance();
             if (token[1] === 'when') {
                 modifiers.push('&when');
@@ -7732,7 +7068,8 @@ var AlgebraicParser = /** @class */ (function () {
         };
         return node;
     };
-    AlgebraicParser.prototype.parseIf = function (token) {
+    AlgebraicParser.prototype.parseIfOrUnless = function (token) {
+        var isUnless = token[1] === 'unless';
         this.advance();
         var condition = this.parseExpression();
         assertA_ReservedSymbolToken(this.peek(), 'then');
@@ -7781,7 +7118,7 @@ var AlgebraicParser = /** @class */ (function () {
         }
         return {
             t: AstNodeType.SpecialExpression,
-            n: 'if',
+            n: isUnless ? 'unless' : 'if',
             p: params,
             token: getTokenDebugData(token) && token,
         };
@@ -7908,6 +7245,22 @@ var AlgebraicParser = /** @class */ (function () {
     AlgebraicParser.prototype.isAtEnd = function () {
         return this.parseState.position >= this.tokenStream.tokens.length;
     };
+    AlgebraicParser.prototype.isAtExpressionEnd = function () {
+        if (this.isAtEnd()) {
+            return true;
+        }
+        var token = this.peek();
+        if (isA_OperatorToken(token)) {
+            return [';', ','].includes(token[1]);
+        }
+        if (isA_SymbolToken(token)) {
+            return ['catch'].includes(token[1]);
+        }
+        if (isA_ReservedSymbolToken(token)) {
+            return ['else', 'when', 'while', 'then', 'end', 'case'].includes(token[1]);
+        }
+        return false;
+    };
     AlgebraicParser.prototype.peek = function () {
         return this.tokenStream.tokens[this.parseState.position];
     };
@@ -8372,17 +7725,12 @@ var validAlgebraicReservedNamesRecord = {
     else: { value: null, forbidden: false },
     end: { value: null, forbidden: false },
     case: { value: null, forbidden: false },
+    when: { value: null, forbidden: false },
+    while: { value: null, forbidden: false },
 };
 var forbiddenAlgebraicReservedNamesRecord = {
-    if_let: { value: null, forbidden: true },
-    when_let: { value: null, forbidden: true },
-    when_first: { value: null, forbidden: true },
     fn: { value: null, forbidden: true },
     defns: { value: null, forbidden: true },
-    try: { value: null, forbidden: true },
-    recur: { value: null, forbidden: true },
-    loop: { value: null, forbidden: true },
-    doseq: { value: null, forbidden: true },
 };
 var algebraicReservedNamesRecord = __assign(__assign({}, validAlgebraicReservedNamesRecord), forbiddenAlgebraicReservedNamesRecord);