@mojir/lits 2.2.4 → 2.3.1

package/dist/cli/cli.js

@@ -7,7 +7,7 @@ var readline = require('node:readline');
 var os = require('node:os');
 var process$1 = require('node:process');
 
-var version = "2.2.4";
+var version = "2.3.1";
 
 function getCodeMarker(sourceCodeInfo) {
     if (!sourceCodeInfo.position || !sourceCodeInfo.code)
@@ -858,6 +858,200 @@ function assertCharArray(value, sourceCodeInfo) {
         throw getAssertionError('array of strings', value, sourceCodeInfo);
 }
 
+/**
+ * MaybePromise utilities for transparent async support.
+ *
+ * The sync path stays zero-overhead — when no async JS functions are involved,
+ * everything runs synchronously with only `instanceof Promise` checks as overhead.
+ * When an async value is detected, the evaluation chain switches to Promise-based
+ * execution for the remainder.
+ */
+/**
+ * Chain a value that might be a Promise. If the value is sync, calls fn synchronously.
+ * If it's a Promise, chains with .then().
+ */
+function chain(value, fn) {
+    if (value instanceof Promise) {
+        return value.then(fn);
+    }
+    return fn(value);
+}
+/**
+ * Like Array.map but handles MaybePromise callbacks sequentially.
+ * In the sync case, runs as a simple loop. Switches to async only when needed.
+ */
+function mapSequential(arr, fn) {
+    const results = [];
+    for (let i = 0; i < arr.length; i++) {
+        const result = fn(arr[i], i);
+        if (result instanceof Promise) {
+            return chainRemainingMap(result, results, arr, fn, i);
+        }
+        results.push(result);
+    }
+    return results;
+}
+async function chainRemainingMap(currentPromise, results, arr, fn, startIndex) {
+    results.push(await currentPromise);
+    for (let i = startIndex + 1; i < arr.length; i++) {
+        results.push(await fn(arr[i], i));
+    }
+    return results;
+}
+/**
+ * Like Array.reduce but handles MaybePromise callbacks sequentially.
+ * In the sync case, runs as a simple loop. Switches to async only when needed.
+ */
+function reduceSequential(arr, fn, initial) {
+    let result = initial;
+    for (let i = 0; i < arr.length; i++) {
+        const next = fn(result, arr[i], i);
+        if (next instanceof Promise) {
+            return chainRemainingReduce(next, arr, fn, i);
+        }
+        result = next;
+    }
+    return result;
+}
+async function chainRemainingReduce(currentPromise, arr, fn, startIndex) {
+    let result = await currentPromise;
+    for (let i = startIndex + 1; i < arr.length; i++) {
+        result = await fn(result, arr[i], i);
+    }
+    return result;
+}
+/**
+ * Like Array.forEach but handles MaybePromise callbacks sequentially.
+ * In the sync case, runs as a simple loop. Switches to async only when needed.
+ */
+function forEachSequential(arr, fn) {
+    for (let i = 0; i < arr.length; i++) {
+        const result = fn(arr[i], i);
+        if (result instanceof Promise) {
+            return chainRemainingForEach(result, arr, fn, i);
+        }
+    }
+}
+async function chainRemainingForEach(currentPromise, arr, fn, startIndex) {
+    await currentPromise;
+    for (let i = startIndex + 1; i < arr.length; i++) {
+        await fn(arr[i], i);
+    }
+}
+/**
+ * Try/catch that handles MaybePromise values correctly.
+ * If tryFn returns a Promise, catches both sync throws and Promise rejections.
+ */
+function tryCatch(tryFn, catchFn) {
+    try {
+        const result = tryFn();
+        if (result instanceof Promise) {
+            return result.catch(catchFn);
+        }
+        return result;
+    }
+    catch (error) {
+        return catchFn(error);
+    }
+}
+/**
+ * Like Array.some but handles MaybePromise callbacks sequentially.
+ * Returns the first truthy MaybePromise result, or false.
+ */
+function someSequential(arr, fn) {
+    for (let i = 0; i < arr.length; i++) {
+        const result = fn(arr[i], i);
+        if (result instanceof Promise) {
+            return chainRemainingSome(result, arr, fn, i);
+        }
+        if (result)
+            return true;
+    }
+    return false;
+}
+async function chainRemainingSome(currentPromise, arr, fn, startIndex) {
+    if (await currentPromise)
+        return true;
+    for (let i = startIndex + 1; i < arr.length; i++) {
+        if (await fn(arr[i], i))
+            return true;
+    }
+    return false;
+}
+/**
+ * Like Array.every but handles MaybePromise callbacks sequentially.
+ * Returns false as soon as a falsy result is found.
+ */
+function everySequential(arr, fn) {
+    for (let i = 0; i < arr.length; i++) {
+        const result = fn(arr[i], i);
+        if (result instanceof Promise) {
+            return chainRemainingEvery(result, arr, fn, i);
+        }
+        if (!result)
+            return false;
+    }
+    return true;
+}
+async function chainRemainingEvery(currentPromise, arr, fn, startIndex) {
+    if (!await currentPromise)
+        return false;
+    for (let i = startIndex + 1; i < arr.length; i++) {
+        if (!await fn(arr[i], i))
+            return false;
+    }
+    return true;
+}
+/**
+ * Like Array.filter but handles MaybePromise callbacks sequentially.
+ * Returns the filtered array.
+ */
+function filterSequential(arr, fn) {
+    const results = [];
+    for (let i = 0; i < arr.length; i++) {
+        const result = fn(arr[i], i);
+        if (result instanceof Promise) {
+            return chainRemainingFilter(result, results, arr, fn, i);
+        }
+        if (result)
+            results.push(arr[i]);
+    }
+    return results;
+}
+async function chainRemainingFilter(currentPromise, results, arr, fn, startIndex) {
+    if (await currentPromise)
+        results.push(arr[startIndex]);
+    for (let i = startIndex + 1; i < arr.length; i++) {
+        if (await fn(arr[i], i))
+            results.push(arr[i]);
+    }
+    return results;
+}
+/**
+ * Like Array.findIndex but handles MaybePromise callbacks sequentially.
+ * Returns -1 if no element matches.
+ */
+function findIndexSequential(arr, fn) {
+    for (let i = 0; i < arr.length; i++) {
+        const result = fn(arr[i], i);
+        if (result instanceof Promise) {
+            return chainRemainingFindIndex(result, arr, fn, i);
+        }
+        if (result)
+            return i;
+    }
+    return -1;
+}
+async function chainRemainingFindIndex(currentPromise, arr, fn, startIndex) {
+    if (await currentPromise)
+        return startIndex;
+    for (let i = startIndex + 1; i < arr.length; i++) {
+        if (await fn(arr[i], i))
+            return i;
+    }
+    return -1;
+}
+
 function mapObjects({ colls, contextStack, executeFunction, fn, sourceCodeInfo, }) {
     assertObj(colls[0], sourceCodeInfo);
     const keys = Object.keys(colls[0]);
@@ -877,10 +1071,13 @@ function mapObjects({ colls, contextStack, executeFunction, fn, sourceCodeInfo,
             params[key].push(value);
         });
     });
-    return keys.reduce((result, key) => {
-        result[key] = executeFunction(fn, params[key], contextStack, sourceCodeInfo);
-        return result;
-    }, {});
+    const initialObj = {};
+    return reduceSequential(keys, (result, key) => {
+        return chain(executeFunction(fn, params[key], contextStack, sourceCodeInfo), (value) => {
+            result[key] = value;
+            return result;
+        });
+    }, initialObj);
 }
 function get$1(coll, key) {
     if (isObj(coll)) {
@@ -919,21 +1116,33 @@ const collectionNormalExpression = {
             assertColl(coll, sourceCodeInfo);
             assertFunctionLike(fn, sourceCodeInfo);
             if (Array.isArray(coll)) {
-                const result = coll.filter(elem => executeFunction(fn, [elem], contextStack, sourceCodeInfo));
-                return result;
+                return reduceSequential(coll, (result, elem) => {
+                    return chain(executeFunction(fn, [elem], contextStack, sourceCodeInfo), (keep) => {
+                        if (keep)
+                            result.push(elem);
+                        return result;
+                    });
+                }, []);
             }
             if (isString(coll)) {
-                return coll
-                    .split('')
-                    .filter(elem => executeFunction(fn, [elem], contextStack, sourceCodeInfo))
-                    .join('');
-            }
-            return Object.entries(coll)
-                .filter(([, value]) => executeFunction(fn, [value], contextStack, sourceCodeInfo))
-                .reduce((result, [key, value]) => {
-                result[key] = value;
-                return result;
-            }, {});
+                const chars = coll.split('');
+                return chain(reduceSequential(chars, (result, elem) => {
+                    return chain(executeFunction(fn, [elem], contextStack, sourceCodeInfo), (keep) => {
+                        if (keep)
+                            result.push(elem);
+                        return result;
+                    });
+                }, []), filtered => filtered.join(''));
+            }
+            const entries = Object.entries(coll);
+            const initialObj = {};
+            return reduceSequential(entries, (result, [key, value]) => {
+                return chain(executeFunction(fn, [value], contextStack, sourceCodeInfo), (keep) => {
+                    if (keep)
+                        result[key] = value;
+                    return result;
+                });
+            }, initialObj);
         },
         arity: toFixedArity(2),
         docs: {
@@ -996,12 +1205,14 @@ filter(
             for (let i = 0; i < len; i++) {
                 paramArray.push(seqs.map(seq => seq[i]));
             }
-            const mapped = paramArray.map(p => executeFunction(fn, p, contextStack, sourceCodeInfo));
+            const mapped = mapSequential(paramArray, p => executeFunction(fn, p, contextStack, sourceCodeInfo));
             if (!isStr) {
                 return mapped;
             }
-            mapped.forEach(char => assertString(char, sourceCodeInfo));
-            return mapped.join('');
+            return chain(mapped, (resolvedMapped) => {
+                resolvedMapped.forEach(char => assertString(char, sourceCodeInfo));
+                return resolvedMapped.join('');
+            });
         },
         arity: { min: 2 },
         docs: {
@@ -1036,21 +1247,21 @@ filter(
                 assertString(initial, sourceCodeInfo);
                 if (coll.length === 0)
                     return initial;
-                return coll.split('').reduce((result, elem) => {
+                return reduceSequential(coll.split(''), (result, elem) => {
                     return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
                 }, initial);
             }
             else if (Array.isArray(coll)) {
                 if (coll.length === 0)
                     return initial;
-                return coll.reduce((result, elem) => {
+                return reduceSequential(coll, (result, elem) => {
                     return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
                 }, initial);
             }
             else {
                 if (Object.keys(coll).length === 0)
                     return initial;
-                return Object.entries(coll).reduce((result, [, elem]) => {
+                return reduceSequential(Object.entries(coll), (result, [, elem]) => {
                     return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
                 }, initial);
             }
@@ -1490,7 +1701,7 @@ flatten([
         evaluate: ([arr, fn], sourceCodeInfo, contextStack, { executeFunction }) => {
             assertArray(arr, sourceCodeInfo);
             assertFunctionLike(fn, sourceCodeInfo);
-            return arr.map(elem => executeFunction(fn, [elem], contextStack, sourceCodeInfo)).flat(1);
+            return chain(mapSequential(arr, elem => executeFunction(fn, [elem], contextStack, sourceCodeInfo)), mapped => mapped.flat(1));
         },
         arity: toFixedArity(2),
         docs: {
@@ -1527,13 +1738,11 @@ mapcat(
             assertArray(arr, sourceCodeInfo);
             assertNumber(windowSize, sourceCodeInfo, { integer: true, lte: arr.length });
             assertFunctionLike(fn, sourceCodeInfo);
-            const result = [];
+            const windows = [];
             for (let i = 0; i <= arr.length - windowSize; i++) {
-                const window = arr.slice(i, i + windowSize);
-                const value = executeFunction(fn, [window], contextStack, sourceCodeInfo);
-                result.push(value);
+                windows.push(arr.slice(i, i + windowSize));
             }
-            return result;
+            return mapSequential(windows, window => executeFunction(fn, [window], contextStack, sourceCodeInfo));
         },
         arity: toFixedArity(3),
         docs: {
@@ -1558,12 +1767,11 @@ mapcat(
         evaluate: ([arr, fn], sourceCodeInfo, contextStack, { executeFunction }) => {
             assertArray(arr, sourceCodeInfo);
             assertFunctionLike(fn, sourceCodeInfo);
-            const result = [];
+            const subArrays = [];
             for (let i = 0; i < arr.length; i += 1) {
-                const subArr = arr.slice(0, i + 1);
-                result.push(executeFunction(fn, [subArr], contextStack, sourceCodeInfo));
+                subArrays.push(arr.slice(0, i + 1));
             }
-            return result;
+            return mapSequential(subArrays, subArr => executeFunction(fn, [subArr], contextStack, sourceCodeInfo));
         },
         arity: toFixedArity(2),
         docs: {
@@ -1922,7 +2130,7 @@ For string $seq returns all but the first characters in $seq.`,
                 { argumentNames: ['seq', 'start', 'stop'] },
             ],
             description: 'Returns a copy of a portion of $seq from index $start (inclusive) to $stop (exclusive).',
-            seeAlso: ['sequence.take', 'sequence.drop', 'sequence.splice', 'nth'],
+            seeAlso: ['take', 'drop', 'sequence.splice', 'nth'],
             examples: [
                 '[1, 2, 3, 4, 5] slice 2',
                 'slice([1, 2, 3, 4, 5], 2, 4)',
@@ -1938,9 +2146,14 @@ For string $seq returns all but the first characters in $seq.`,
             assertSeq(seq, sourceCodeInfo);
             if (seq.length === 0)
                 return null;
-            if (typeof seq === 'string')
-                return seq.split('').find(elem => executeFunction(fn, [elem], contextStack, sourceCodeInfo)) ?? null;
-            return toAny(seq.find(elem => executeFunction(fn, [elem], contextStack, sourceCodeInfo)));
+            const items = typeof seq === 'string' ? seq.split('') : seq;
+            return reduceSequential(items, (found, elem) => {
+                if (found !== null)
+                    return found;
+                return chain(executeFunction(fn, [elem], contextStack, sourceCodeInfo), (result) => {
+                    return result ? toAny(elem) : null;
+                });
+            }, null);
         },
         arity: toFixedArity(2),
         docs: {
@@ -1985,7 +2198,7 @@ some(
         },
     },
     'sort': {
-        evaluate: (params, sourceCodeInfo, contextStack, { executeFunction }) => {
+        evaluate: (params, sourceCodeInfo, _contextStack, { executeFunction: _executeFunction }) => {
             const [seq] = params;
             const defaultComparer = params.length === 1;
             const comparer = defaultComparer ? null : params[1];
@@ -1997,8 +2210,12 @@ some(
                 }
                 else {
                     assertFunctionLike(comparer, sourceCodeInfo);
+                    // Note: sort comparator must be synchronous — async comparators would need a different approach
                     result.sort((a, b) => {
-                        const compareValue = executeFunction(comparer, [a, b], contextStack, sourceCodeInfo);
+                        const compareValue = _executeFunction(comparer, [a, b], _contextStack, sourceCodeInfo);
+                        if (compareValue instanceof Promise) {
+                            throw new TypeError('Async functions cannot be used as sort comparators');
+                        }
                         assertNumber(compareValue, sourceCodeInfo, { finite: true });
                         return compareValue;
                     });
@@ -2016,7 +2233,11 @@ some(
             else {
                 result.sort((a, b) => {
                     assertFunctionLike(comparer, sourceCodeInfo);
-                    const compareValue = executeFunction(comparer, [a, b], contextStack, sourceCodeInfo);
+                    // Note: sort comparator must be synchronous
+                    const compareValue = _executeFunction(comparer, [a, b], _contextStack, sourceCodeInfo);
+                    if (compareValue instanceof Promise) {
+                        throw new TypeError('Async functions cannot be used as sort comparators');
+                    }
                     assertNumber(compareValue, sourceCodeInfo, { finite: true });
                     return compareValue;
                 });
@@ -2051,6 +2272,191 @@ sort(
 sort(
   [3, 1, 2],
   (a, b) -> cond case a > b then -1 case a < b then 1 case true then -1 end
+)`,
+            ],
+        },
+    },
+    'take': {
+        evaluate: ([input, n], sourceCodeInfo) => {
+            assertNumber(n, sourceCodeInfo);
+            assertSeq(input, sourceCodeInfo);
+            const num = Math.max(Math.ceil(n), 0);
+            return input.slice(0, num);
+        },
+        arity: toFixedArity(2),
+        docs: {
+            category: 'sequence',
+            returns: { type: 'sequence' },
+            args: {
+                a: { type: 'sequence' },
+                b: { type: 'integer' },
+                n: { type: 'integer' },
+                seq: { type: 'sequence' },
+            },
+            variants: [{ argumentNames: ['seq', 'n'] }],
+            description: 'Constructs a new array/string with the $n first elements from $seq.',
+            seeAlso: ['take-last', 'take-while', 'drop', 'slice', 'sequence.split-at'],
+            examples: [
+                'take([1, 2, 3, 4, 5], 3)',
+                '[1, 2, 3, 4, 5] take 3',
+                'take([1, 2, 3, 4, 5], 0)',
+                'take("Albert", 2)',
+                'take("Albert", 50)',
+            ],
+        },
+    },
+    'take-last': {
+        evaluate: ([array, n], sourceCodeInfo) => {
+            assertSeq(array, sourceCodeInfo);
+            assertNumber(n, sourceCodeInfo);
+            const num = Math.max(Math.ceil(n), 0);
+            const from = array.length - num;
+            return array.slice(from);
+        },
+        arity: toFixedArity(2),
+        docs: {
+            category: 'sequence',
+            returns: { type: 'sequence' },
+            args: {
+                a: { type: 'sequence' },
+                b: { type: 'integer' },
+                n: { type: 'integer' },
+                seq: { type: 'sequence' },
+            },
+            variants: [{ argumentNames: ['seq', 'n'] }],
+            description: 'Constructs a new array with the $n last elements from $seq.',
+            seeAlso: ['take', 'drop-last'],
+            examples: [
+                'take-last([1, 2, 3, 4, 5], 3)',
+                '[1, 2, 3, 4, 5] take-last 3',
+                'take-last([1, 2, 3, 4, 5], 0)',
+            ],
+        },
+    },
+    'drop': {
+        evaluate: ([input, n], sourceCodeInfo) => {
+            assertNumber(n, sourceCodeInfo);
+            const num = Math.max(Math.ceil(n), 0);
+            assertSeq(input, sourceCodeInfo);
+            return input.slice(num);
+        },
+        arity: toFixedArity(2),
+        docs: {
+            category: 'sequence',
+            returns: { type: 'sequence' },
+            args: {
+                a: { type: 'sequence' },
+                b: { type: 'integer' },
+                seq: { type: 'sequence' },
+                n: { type: 'integer' },
+            },
+            variants: [{ argumentNames: ['seq', 'n'] }],
+            description: 'Constructs a new array/string with the $n first elements dropped from $seq.',
+            seeAlso: ['drop-last', 'drop-while', 'take', 'slice', 'sequence.split-at'],
+            examples: [
+                'drop([1, 2, 3, 4, 5], 3)',
+                '[1, 2, 3, 4, 5] drop 0',
+                'drop("Albert", 2)',
+                'drop("Albert", 50)',
+            ],
+        },
+    },
+    'drop-last': {
+        evaluate: ([array, n], sourceCodeInfo) => {
+            assertSeq(array, sourceCodeInfo);
+            assertNumber(n, sourceCodeInfo);
+            const num = Math.max(Math.ceil(n), 0);
+            const from = array.length - num;
+            return array.slice(0, from);
+        },
+        arity: toFixedArity(2),
+        docs: {
+            category: 'sequence',
+            returns: { type: 'sequence' },
+            args: {
+                a: { type: 'sequence' },
+                b: { type: 'integer' },
+                seq: { type: 'sequence' },
+                n: { type: 'integer' },
+            },
+            variants: [{ argumentNames: ['seq', 'n'] }],
+            description: 'Constructs a new array with the $n last elements dropped from $seq.',
+            seeAlso: ['drop', 'take-last'],
+            examples: [
+                'drop-last([1, 2, 3, 4, 5], 3)',
+                '[1, 2, 3, 4, 5] drop-last 3',
+                'drop-last([1, 2, 3, 4, 5], 0)',
+            ],
+        },
+    },
+    'take-while': {
+        evaluate: ([seq, fn], sourceCodeInfo, contextStack, { executeFunction }) => {
+            assertSeq(seq, sourceCodeInfo);
+            assertFunctionLike(fn, sourceCodeInfo);
+            const arr = typeof seq === 'string' ? seq.split('') : Array.from(seq);
+            // Find the first index where the predicate is false
+            return chain(findIndexSequential(arr, elem => chain(executeFunction(fn, [elem], contextStack, sourceCodeInfo), result => !result)), (index) => {
+                const taken = index === -1 ? arr : arr.slice(0, index);
+                return typeof seq === 'string' ? taken.join('') : taken;
+            });
+        },
+        arity: toFixedArity(2),
+        docs: {
+            category: 'sequence',
+            returns: { type: 'sequence' },
+            args: {
+                a: { type: 'sequence' },
+                b: { type: 'function' },
+                seq: { type: 'sequence' },
+                fun: { type: 'function' },
+            },
+            variants: [{ argumentNames: ['seq', 'fun'] }],
+            description: 'Returns the members of $seq in order, stopping before the first one for which `predicate` returns a falsy value.',
+            seeAlso: ['take', 'drop-while', 'sequence.split-with'],
+            examples: [
+                `take-while(
+  [1, 2, 3, 2, 1],
+  -> $ < 3
+)`,
+                `take-while(
+  [1, 2, 3, 2, 1],
+  -> $ > 3
+)`,
+            ],
+        },
+    },
+    'drop-while': {
+        evaluate: ([seq, fn], sourceCodeInfo, contextStack, { executeFunction }) => {
+            assertSeq(seq, sourceCodeInfo);
+            assertFunctionLike(fn, sourceCodeInfo);
+            const arr = Array.isArray(seq) ? seq : seq.split('');
+            return chain(findIndexSequential(arr, elem => chain(executeFunction(fn, [elem], contextStack, sourceCodeInfo), result => !result)), (from) => {
+                if (from === -1)
+                    return typeof seq === 'string' ? '' : [];
+                return typeof seq === 'string' ? arr.slice(from).join('') : seq.slice(from);
+            });
+        },
+        arity: toFixedArity(2),
+        docs: {
+            category: 'sequence',
+            returns: { type: 'sequence' },
+            args: {
+                a: { type: 'sequence' },
+                b: { type: 'function' },
+                seq: { type: 'sequence' },
+                fun: { type: 'function' },
+            },
+            variants: [{ argumentNames: ['seq', 'fun'] }],
+            description: 'Returns the members of $seq in order, skipping the fist elements for witch the `predicate` returns a truethy value.',
+            seeAlso: ['drop', 'take-while', 'sequence.split-with'],
+            examples: [
+                `drop-while(
+  [1, 2, 3, 2, 1],
+  -> $ < 3
+)`,
+                `drop-while(
+  [1, 2, 3, 2, 1],
+  -> $ > 3
 )`,
             ],
         },
@@ -2987,7 +3393,7 @@ const miscNormalExpression = {
                 { argumentNames: ['x', 'ys'] },
             ],
             description: 'Returns `true` if all `values` are structaul equal to each other, otherwise result is `false`.',
-            seeAlso: ['≠', 'identical?'],
+            seeAlso: ['!=', 'identical?'],
             examples: [
                 '1 == 1',
                 '[1, 2] == [1, 2]',
@@ -3009,7 +3415,7 @@ const miscNormalExpression = {
             ],
         },
     },
-    '≠': {
+    '!=': {
         evaluate: (params, sourceCodeInfo) => {
             return !isEqual(params, sourceCodeInfo);
         },
@@ -3027,15 +3433,15 @@ const miscNormalExpression = {
                 { argumentNames: ['x'] },
                 { argumentNames: ['x', 'ys'] },
             ],
-            description: 'Returns `true` if all `values` are not equal to each other, otherwise result is `false`. `(≠ a b c)` is same as `(! (== a b c))`.',
+            description: 'Returns `true` if all `values` are not equal to each other, otherwise result is `false`. `(!= a b c)` is same as `(not (== a b c))`.',
             seeAlso: ['==', 'identical?'],
             examples: [
-                '1 ≠ 2',
-                '3 ≠ 3',
-                '≠(3)',
-                '≠(3, 3, 2)',
-                '≠("3", "2", "1", "0",)',
-                '≠(0, -0)',
+                '1 != 2',
+                '3 != 3',
+                '!=(3)',
+                '!=(3, 3, 2)',
+                '!=("3", "2", "1", "0",)',
+                '!=(0, -0)',
             ],
         },
     },
@@ -3053,7 +3459,7 @@ const miscNormalExpression = {
             },
             variants: [{ argumentNames: ['a', 'b'] }],
             description: 'Returns true if $a and $b are referential equal.',
-            seeAlso: ['==', '≠'],
+            seeAlso: ['==', '!='],
             examples: [
                 'identical?({ a: 10, b: 20 }, { b: 20, a: 10 })',
                 'identical?([1, true, null], [1, true, null])',
@@ -3204,7 +3610,7 @@ const miscNormalExpression = {
             ],
         },
     },
-    '!': {
+    'not': {
         evaluate: ([first]) => !first,
         arity: toFixedArity(1),
         docs: {
@@ -3215,13 +3621,13 @@ const miscNormalExpression = {
             description: 'Computes logical negation. Note that any other $x than `false`, `0`, `null` and `\'\'` is truthy.',
             seeAlso: ['boolean'],
             examples: [
-                '!(3)',
-                '!(true)',
-                '!("A string")',
-                '!(0)',
-                '!(false)',
-                '!(null)',
-                '!("")',
+                'not(3)',
+                'not(true)',
+                'not("A string")',
+                'not(0)',
+                'not(false)',
+                'not(null)',
+                'not("")',
             ],
         },
     },
@@ -3302,7 +3708,7 @@ const miscNormalExpression = {
             args: { x: { type: 'any' } },
             variants: [{ argumentNames: ['x'] }],
             description: 'Coerces $x to boolean.',
-            seeAlso: ['!', 'boolean?', 'true?', 'false?'],
+            seeAlso: ['not', 'boolean?', 'true?', 'false?'],
             examples: [
                 'boolean(0)',
                 'boolean(1)',
@@ -3611,17 +4017,23 @@ If no arguments are provided \`null\` is returned.`,
             const rest = params.slice(1, -1);
             assertObj(first, sourceCodeInfo);
             assertFunctionLike(fn, sourceCodeInfo);
-            return rest.reduce((result, obj) => {
+            return reduceSequential(rest, (result, obj) => {
                 assertObj(obj, sourceCodeInfo);
-                Object.entries(obj).forEach((entry) => {
+                const entries = Object.entries(obj);
+                return chain(reduceSequential(entries, (res, entry) => {
                     const key = asString(entry[0], sourceCodeInfo);
                     const val = toAny(entry[1]);
-                    if (collHasKey(result, key))
-                        result[key] = executeFunction(fn, [result[key], val], contextStack, sourceCodeInfo);
-                    else
-                        result[key] = val;
-                });
-                return result;
+                    if (collHasKey(res, key)) {
+                        return chain(executeFunction(fn, [res[key], val], contextStack, sourceCodeInfo), (merged) => {
+                            res[key] = merged;
+                            return res;
+                        });
+                    }
+                    else {
+                        res[key] = val;
+                        return res;
+                    }
+                }, result), r => r);
             }, { ...first });
         },
         arity: { min: 2 },
@@ -5043,13 +5455,11 @@ const andSpecialExpression = {
     arity: {},
     docs: docs$f,
     evaluate: (node, contextStack, { evaluateNode }) => {
-        let value = true;
-        for (const param of node[1][1]) {
-            value = evaluateNode(param, contextStack);
-            if (!value)
-                break;
-        }
-        return value;
+        return reduceSequential(node[1][1], (acc, param) => {
+            if (!acc)
+                return acc;
+            return evaluateNode(param, contextStack);
+        }, true);
     },
     evaluateAsNormalExpression: (params, sourceCodeInfo) => {
         let value = true;
@@ -5095,13 +5505,17 @@ const condSpecialExpression = {
     docs: docs$e,
     evaluate: (node, contextStack, { evaluateNode }) => {
         const params = node[1][1];
-        for (const [test, form] of params) {
-            const value = evaluateNode(test, contextStack);
-            if (!value)
-                continue;
-            return evaluateNode(form, contextStack);
+        function processCase(index) {
+            if (index >= params.length)
+                return null;
+            const [test, form] = params[index];
+            return chain(evaluateNode(test, contextStack), (value) => {
+                if (!value)
+                    return processCase(index + 1);
+                return evaluateNode(form, contextStack);
+            });
         }
-        return null;
+        return processCase(0);
     },
     getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => getUndefinedSymbols(node[1][1].flat(), contextStack, builtin, evaluateNode),
 };
@@ -5139,14 +5553,20 @@ const switchSpecialExpression = {
     docs: docs$d,
     evaluate: (node, contextStack, { evaluateNode }) => {
         const [, switchValueNode, cases] = node[1];
-        const switchValue = evaluateNode(switchValueNode, contextStack);
-        for (const [test, form] of cases) {
-            const value = evaluateNode(test, contextStack);
-            if (value === switchValue) {
-                return evaluateNode(form, contextStack);
+        return chain(evaluateNode(switchValueNode, contextStack), (switchValue) => {
+            function processCase(index) {
+                if (index >= cases.length)
+                    return null;
+                const [test, form] = cases[index];
+                return chain(evaluateNode(test, contextStack), (value) => {
+                    if (value === switchValue) {
+                        return evaluateNode(form, contextStack);
+                    }
+                    return processCase(index + 1);
+                });
             }
-        }
-        return null;
+            return processCase(0);
+        });
     },
     getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => getUndefinedSymbols([node[1][1], ...node[1][2].flat()], contextStack, builtin, evaluateNode),
 };
@@ -5226,37 +5646,47 @@ function walkDefaults(bindingTarget, onDefault) {
 function evaluateBindingNodeValues(target, value, evaluate) {
     const sourceCodeInfo = target[2];
     const record = {};
-    createRecord(target, value, evaluate, sourceCodeInfo, record);
-    return record;
+    return chain(createRecord(target, value, evaluate, sourceCodeInfo, record), () => record);
 }
 function createRecord(bindingTarget, value, evaluate, sourceCodeInfo, record) {
     if (bindingTarget[0] === bindingTargetTypes.object) {
         assertUnknownRecord(value, sourceCodeInfo);
         const capturedKeys = new Set();
         let restElement;
-        Object.entries(bindingTarget[1][0]).forEach(([key, element]) => {
+        const entries = Object.entries(bindingTarget[1][0]);
+        return chain(forEachSequential(entries, ([key, element]) => {
             if (element[0] === bindingTargetTypes.rest) {
                 restElement = element;
                 return;
             }
             capturedKeys.add(key);
-            const val = (value[key] !== undefined ? value[key] : element[1][1] && evaluate(element[1][1])) ?? null;
-            assertAny(val, sourceCodeInfo);
-            createRecord(element, val, evaluate, sourceCodeInfo, record);
+            const existingVal = value[key];
+            const maybeVal = existingVal !== undefined
+                ? existingVal
+                : element[1][1]
+                    ? evaluate(element[1][1])
+                    : null;
+            return chain(maybeVal, (resolvedVal) => {
+                const val = resolvedVal ?? null;
+                assertAny(val, sourceCodeInfo);
+                return createRecord(element, val, evaluate, sourceCodeInfo, record);
+            });
+        }), () => {
+            if (restElement) {
+                const restValues = Object.entries(value)
+                    .filter(([key]) => !capturedKeys.has(key))
+                    .reduce((acc, [key, val]) => {
+                    acc[key] = asAny(val);
+                    return acc;
+                }, {});
+                record[restElement[1][0]] = restValues;
+            }
         });
-        if (restElement) {
-            const restValues = Object.entries(value)
-                .filter(([key]) => !capturedKeys.has(key))
-                .reduce((acc, [key, val]) => {
-                acc[key] = asAny(val);
-                return acc;
-            }, {});
-            record[restElement[1][0]] = restValues;
-        }
     }
     else if (bindingTarget[0] === bindingTargetTypes.array) {
         let restIndex = null;
         assertArray(value, sourceCodeInfo);
+        const elements = [];
         for (let index = 0; index < bindingTarget[1][0].length; index += 1) {
             const element = bindingTarget[1][0][index] ?? null;
             if (element === null) {
@@ -5266,15 +5696,27 @@ function createRecord(bindingTarget, value, evaluate, sourceCodeInfo, record) {
                 restIndex = index;
                 break;
             }
-            const val = (value[index] !== undefined ? value[index] : element[1][1] && evaluate(element[1][1])) ?? null;
-            assertAny(val, sourceCodeInfo);
-            createRecord(element, val, evaluate, sourceCodeInfo, record);
-        }
-        if (restIndex !== null) {
-            const restValues = value.slice(restIndex);
-            const restElement = bindingTarget[1][0][restIndex];
-            record[restElement[1][0]] = restValues;
-        }
+            elements.push({ element, index });
+        }
+        return chain(forEachSequential(elements, ({ element, index }) => {
+            const existingVal = value[index];
+            const maybeVal = existingVal !== undefined
+                ? existingVal
+                : element[1][1]
+                    ? evaluate(element[1][1])
+                    : null;
+            return chain(maybeVal, (resolvedVal) => {
+                const val = resolvedVal ?? null;
+                assertAny(val, sourceCodeInfo);
+                return createRecord(element, val, evaluate, sourceCodeInfo, record);
+            });
+        }), () => {
+            if (restIndex !== null) {
+                const restValues = value.slice(restIndex);
+                const restElement = bindingTarget[1][0][restIndex];
+                record[restElement[1][0]] = restValues;
+            }
+        });
     }
     else if (bindingTarget[0] === bindingTargetTypes.rest) {
         record[bindingTarget[1][0]] = asAny(value);
@@ -5322,10 +5764,12 @@ const defSpecialExpression = {
         const bindingNode = node[1][1];
         const target = bindingNode[1][0];
         const value = bindingNode[1][1];
-        const bindingValue = evaluateNode(value, contextStack);
-        const values = evaluateBindingNodeValues(target, bindingValue, Node => evaluateNode(Node, contextStack));
-        contextStack.exportValues(values, target[2]);
-        return bindingValue;
+        return chain(evaluateNode(value, contextStack), (bindingValue) => {
+            return chain(evaluateBindingNodeValues(target, bindingValue, Node => evaluateNode(Node, contextStack)), (values) => {
+                contextStack.exportValues(values, target[2]);
+                return bindingValue;
+            });
+        });
     },
     getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => {
         const bindingNode = node[1][1];
@@ -5362,10 +5806,7 @@ const doSpecialExpression = {
     evaluate: (node, contextStack, { evaluateNode }) => {
         const newContext = {};
         const newContextStack = contextStack.create(newContext);
-        let result = null;
-        for (const form of node[1][1])
-            result = evaluateNode(form, newContextStack);
-        return result;
+        return reduceSequential(node[1][1], (_acc, form) => evaluateNode(form, newContextStack), null);
     },
     getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => {
         return getUndefinedSymbols(node[1][1], contextStack.create({}), builtin, evaluateNode);
@@ -5460,13 +5901,15 @@ const ifSpecialExpression = {
     docs: docs$a,
     evaluate: (node, contextStack, { evaluateNode }) => {
         const [conditionNode, trueNode, falseNode] = node[1][1];
-        if (evaluateNode(conditionNode, contextStack)) {
-            return evaluateNode(trueNode, contextStack);
-        }
-        else if (falseNode) {
-            return evaluateNode(falseNode, contextStack);
-        }
-        return null;
+        return chain(evaluateNode(conditionNode, contextStack), (condition) => {
+            if (condition) {
+                return evaluateNode(trueNode, contextStack);
+            }
+            else if (falseNode) {
+                return evaluateNode(falseNode, contextStack);
+            }
+            return null;
+        });
     },
     getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => getUndefinedSymbols(node[1][1].filter(n => !!n), contextStack, builtin, evaluateNode),
 };
@@ -5497,13 +5940,15 @@ const unlessSpecialExpression = {
     docs: docs$9,
     evaluate: (node, contextStack, { evaluateNode }) => {
         const [conditionNode, trueNode, falseNode] = node[1][1];
-        if (!evaluateNode(conditionNode, contextStack)) {
-            return evaluateNode(trueNode, contextStack);
-        }
-        else if (falseNode) {
-            return evaluateNode(falseNode, contextStack);
-        }
-        return null;
+        return chain(evaluateNode(conditionNode, contextStack), (condition) => {
+            if (!condition) {
+                return evaluateNode(trueNode, contextStack);
+            }
+            else if (falseNode) {
+                return evaluateNode(falseNode, contextStack);
+            }
+            return null;
+        });
     },
     getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => getUndefinedSymbols(node[1][1].filter(n => !!n), contextStack, builtin, evaluateNode),
 };
@@ -5529,10 +5974,12 @@ const letSpecialExpression = {
         const bindingNode = node[1][1];
         const target = bindingNode[1][0];
         const value = bindingNode[1][1];
-        const bindingValue = evaluateNode(value, contextStack);
-        const values = evaluateBindingNodeValues(target, bindingValue, Node => evaluateNode(Node, contextStack));
-        contextStack.addValues(values, target[2]);
-        return bindingValue;
+        return chain(evaluateNode(value, contextStack), (bindingValue) => {
+            return chain(evaluateBindingNodeValues(target, bindingValue, Node => evaluateNode(Node, contextStack)), (values) => {
+                contextStack.addValues(values, target[2]);
+                return bindingValue;
+            });
+        });
     },
     getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => {
         const bindingNode = node[1][1];
@@ -5579,39 +6026,93 @@ const loopSpecialExpression = {
     docs: docs$7,
     evaluate: (node, contextStack, { evaluateNode }) => {
         const bindingNodes = node[1][1];
-        const bindingContext = bindingNodes.reduce((result, bindingNode) => {
-            const val = evaluateNode(bindingNode[1][1], contextStack.create(result));
-            const valueRecord = evaluateBindingNodeValues(bindingNode[1][0], val, Node => evaluateNode(Node, contextStack));
-            Object.entries(valueRecord).forEach(([name, value]) => {
-                result[name] = { value };
+        // Set up initial binding context sequentially (bindings may depend on each other)
+        const initialContext = {};
+        const setupBindings = reduceSequential(bindingNodes, (result, bindingNode) => {
+            return chain(evaluateNode(bindingNode[1][1], contextStack.create(result)), (val) => {
+                return chain(evaluateBindingNodeValues(bindingNode[1][0], val, Node => evaluateNode(Node, contextStack)), (valueRecord) => {
+                    Object.entries(valueRecord).forEach(([name, value]) => {
+                        result[name] = { value };
+                    });
+                    return result;
+                });
             });
-            return result;
-        }, {});
-        const newContextStack = contextStack.create(bindingContext);
-        const body = node[1][2];
-        for (;;) {
-            let result = null;
-            try {
-                result = evaluateNode(body, newContextStack);
-            }
-            catch (error) {
-                if (error instanceof RecurSignal) {
-                    const params = error.params;
-                    if (params.length !== bindingNodes.length) {
-                        throw new LitsError(`recur expected ${bindingNodes.length} parameters, got ${valueToString(params.length)}`, node[2]);
-                    }
-                    bindingNodes.forEach((bindingNode, index) => {
-                        const valueRecord = evaluateBindingNodeValues(bindingNode[1][0], asAny(params[index]), Node => evaluateNode(Node, contextStack));
+        }, initialContext);
+        return chain(setupBindings, (bindingContext) => {
+            const newContextStack = contextStack.create(bindingContext);
+            const body = node[1][2];
+            function rebindAndIterate(params) {
+                if (params.length !== bindingNodes.length) {
+                    throw new LitsError(`recur expected ${bindingNodes.length} parameters, got ${valueToString(params.length)}`, node[2]);
+                }
+                return chain(forEachSequential(bindingNodes, (bindingNode, index) => {
+                    return chain(evaluateBindingNodeValues(bindingNode[1][0], asAny(params[index]), Node => evaluateNode(Node, contextStack)), (valueRecord) => {
                         for (const [name, value] of Object.entries(valueRecord)) {
                             bindingContext[name].value = value;
                         }
                     });
-                    continue;
+                }), () => iterate());
+            }
+            function iterate() {
+                return tryCatch(() => evaluateNode(body, newContextStack), (error) => {
+                    if (error instanceof RecurSignal) {
+                        return rebindAndIterate(error.params);
+                    }
+                    throw error;
+                });
+            }
+            // Use sync for(;;) loop for the sync case to avoid stack overflow
+            for (;;) {
+                try {
+                    const result = evaluateNode(body, newContextStack);
+                    if (result instanceof Promise) {
+                        // Async path: handle recur via promise chain
+                        return result.catch((error) => {
+                            if (error instanceof RecurSignal) {
+                                return rebindAndIterate(error.params);
+                            }
+                            throw error;
+                        });
+                    }
+                    return result;
+                }
+                catch (error) {
+                    if (error instanceof RecurSignal) {
+                        const params = error.params;
+                        if (params.length !== bindingNodes.length) {
+                            throw new LitsError(`recur expected ${bindingNodes.length} parameters, got ${valueToString(params.length)}`, node[2]);
+                        }
+                        // rebindAndIterate returns MaybePromise — if any binding default is async,
+                        // we must switch to the async iterate path
+                        for (let index = 0; index < bindingNodes.length; index += 1) {
+                            const bindingNode = bindingNodes[index];
+                            const valueRecord = evaluateBindingNodeValues(bindingNode[1][0], asAny(params[index]), Node => evaluateNode(Node, contextStack));
+                            if (valueRecord instanceof Promise) {
+                                // Switch to fully async path
+                                return valueRecord.then((resolved) => {
+                                    for (const [name, value] of Object.entries(resolved)) {
+                                        bindingContext[name].value = value;
+                                    }
+                                    // Handle remaining bindings then iterate
+                                    return chain(forEachSequential(bindingNodes.slice(index + 1), (bn, subIndex) => {
+                                        return chain(evaluateBindingNodeValues(bn[1][0], asAny(params[index + 1 + subIndex]), Node => evaluateNode(Node, contextStack)), (vr) => {
+                                            for (const [name, value] of Object.entries(vr)) {
+                                                bindingContext[name].value = value;
+                                            }
+                                        });
+                                    }), () => iterate());
+                                });
+                            }
+                            for (const [name, value] of Object.entries(valueRecord)) {
+                                bindingContext[name].value = value;
+                            }
+                        }
+                        continue;
+                    }
+                    throw error;
                 }
-                throw error;
             }
-            return result;
-        }
+        });
     },
     getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => {
         const bindingNodes = node[1][1];
@@ -5631,74 +6132,107 @@ const loopSpecialExpression = {
 };
 
 function addToContext(bindings, context, contextStack, evaluateNode) {
+    let bindingChain = undefined;
     for (const bindingNode of bindings) {
-        const [target, bindingValue] = bindingNode[1];
-        const val = evaluateNode(bindingValue, contextStack);
-        const valueRecord = evaluateBindingNodeValues(target, val, Node => evaluateNode(Node, contextStack));
-        Object.entries(valueRecord).forEach(([name, value]) => {
-            context[name] = { value };
+        bindingChain = chain(bindingChain, () => {
+            const [target, bindingValue] = bindingNode[1];
+            return chain(evaluateNode(bindingValue, contextStack), (val) => {
+                return chain(evaluateBindingNodeValues(target, val, Node => evaluateNode(Node, contextStack)), (valueRecord) => {
+                    Object.entries(valueRecord).forEach(([name, value]) => {
+                        context[name] = { value };
+                    });
+                });
+            });
         });
     }
+    return bindingChain;
 }
 function evaluateLoop(returnResult, loopNode, contextStack, evaluateNode) {
     const sourceCodeInfo = loopNode[2];
     const [, loopBindings, body] = loopNode[1];
     const result = [];
     const bindingIndices = loopBindings.map(() => 0);
-    let abort = false;
-    while (!abort) {
+    function processIteration() {
         const context = {};
         const newContextStack = contextStack.create(context);
-        let skip = false;
-        bindingsLoop: for (let bindingIndex = 0; bindingIndex < loopBindings.length; bindingIndex += 1) {
+        function processBinding(bindingIndex) {
+            if (bindingIndex >= loopBindings.length)
+                return 'continue';
             const [bindingNode, letBindings, whenNode, whileNode] = loopBindings[bindingIndex];
             const [targetNode, valueNode] = bindingNode[1];
-            const coll = asColl(evaluateNode(valueNode, newContextStack), sourceCodeInfo);
-            const seq = isSeq(coll) ? coll : Object.entries(coll);
-            if (seq.length === 0) {
-                skip = true;
-                abort = true;
-                break;
-            }
-            const index = asNonUndefined(bindingIndices[bindingIndex], sourceCodeInfo);
-            if (index >= seq.length) {
-                skip = true;
-                if (bindingIndex === 0) {
-                    abort = true;
-                    break;
+            return chain(evaluateNode(valueNode, newContextStack), (rawColl) => {
+                const coll = asColl(rawColl, sourceCodeInfo);
+                const seq = isSeq(coll) ? coll : Object.entries(coll);
+                if (seq.length === 0) {
+                    return 'abort';
                 }
-                bindingIndices[bindingIndex] = 0;
-                bindingIndices[bindingIndex - 1] = asNonUndefined(bindingIndices[bindingIndex - 1], sourceCodeInfo) + 1;
-                break;
-            }
-            const val = asAny(seq[index], sourceCodeInfo);
-            const valueRecord = evaluateBindingNodeValues(targetNode, val, Node => evaluateNode(Node, newContextStack));
-            Object.entries(valueRecord).forEach(([name, value]) => {
-                context[name] = { value };
+                const index = asNonUndefined(bindingIndices[bindingIndex], sourceCodeInfo);
+                if (index >= seq.length) {
+                    if (bindingIndex === 0) {
+                        return 'abort';
+                    }
+                    bindingIndices[bindingIndex] = 0;
+                    bindingIndices[bindingIndex - 1] = asNonUndefined(bindingIndices[bindingIndex - 1], sourceCodeInfo) + 1;
+                    return 'skip';
+                }
+                const val = asAny(seq[index], sourceCodeInfo);
+                return chain(evaluateBindingNodeValues(targetNode, val, Node => evaluateNode(Node, newContextStack)), (valueRecord) => {
+                    Object.entries(valueRecord).forEach(([name, value]) => {
+                        context[name] = { value };
+                    });
+                    return chain(letBindings.length > 0
+                        ? addToContext(letBindings, context, newContextStack, evaluateNode)
+                        : undefined, () => {
+                        if (whenNode) {
+                            return chain(evaluateNode(whenNode, newContextStack), (whenResult) => {
+                                if (!whenResult) {
+                                    bindingIndices[bindingIndex] = asNonUndefined(bindingIndices[bindingIndex], sourceCodeInfo) + 1;
+                                    return 'skip';
+                                }
+                                if (whileNode) {
+                                    return chain(evaluateNode(whileNode, newContextStack), (whileResult) => {
+                                        if (!whileResult) {
+                                            bindingIndices[bindingIndex] = Number.POSITIVE_INFINITY;
+                                            return 'skip';
+                                        }
+                                        return processBinding(bindingIndex + 1);
+                                    });
+                                }
+                                return processBinding(bindingIndex + 1);
+                            });
+                        }
+                        if (whileNode) {
+                            return chain(evaluateNode(whileNode, newContextStack), (whileResult) => {
+                                if (!whileResult) {
+                                    bindingIndices[bindingIndex] = Number.POSITIVE_INFINITY;
+                                    return 'skip';
+                                }
+                                return processBinding(bindingIndex + 1);
+                            });
+                        }
+                        return processBinding(bindingIndex + 1);
+                    });
+                });
             });
-            if (letBindings) {
-                addToContext(letBindings, context, newContextStack, evaluateNode);
-            }
-            if (whenNode && !evaluateNode(whenNode, newContextStack)) {
-                bindingIndices[bindingIndex] = asNonUndefined(bindingIndices[bindingIndex], sourceCodeInfo) + 1;
-                skip = true;
-                break bindingsLoop;
+        }
+        return chain(processBinding(0), (status) => {
+            if (status === 'abort') {
+                return returnResult ? result : null;
             }
-            if (whileNode && !evaluateNode(whileNode, newContextStack)) {
-                bindingIndices[bindingIndex] = Number.POSITIVE_INFINITY;
-                skip = true;
-                break bindingsLoop;
+            if (status === 'skip') {
+                return processIteration();
             }
-        }
-        if (!skip) {
-            const value = evaluateNode(body, newContextStack);
-            if (returnResult)
-                result.push(value);
-            if (bindingIndices.length > 0)
-                bindingIndices[bindingIndices.length - 1] += 1;
-        }
+            // status === 'continue'
+            return chain(evaluateNode(body, newContextStack), (value) => {
+                if (returnResult)
+                    result.push(value);
+                if (bindingIndices.length > 0)
+                    bindingIndices[bindingIndices.length - 1] += 1;
+                return processIteration();
+            });
+        });
     }
-    return returnResult ? result : null;
+    return processIteration();
 }
 function analyze(loopNode, contextStack, getUndefinedSymbols, builtin, evaluateNode) {
     const result = new Set();
@@ -5787,8 +6321,7 @@ const doseqSpecialExpression = {
     arity: toFixedArity(1),
     docs: doseqDocs,
     evaluate: (node, contextStack, helpers) => {
-        evaluateLoop(false, node, contextStack, helpers.evaluateNode);
-        return null;
+        return chain(evaluateLoop(false, node, contextStack, helpers.evaluateNode), () => null);
     },
     getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => analyze(node, contextStack, getUndefinedSymbols, builtin, evaluateNode),
 };
@@ -5828,13 +6361,11 @@ const orSpecialExpression = {
     arity: {},
     docs: docs$6,
     evaluate: (node, contextStack, { evaluateNode }) => {
-        let value = false;
-        for (const param of node[1][1]) {
-            value = evaluateNode(param, contextStack);
-            if (value)
-                break;
-        }
-        return value;
+        return reduceSequential(node[1][1], (acc, param) => {
+            if (acc)
+                return acc;
+            return evaluateNode(param, contextStack);
+        }, false);
     },
     evaluateAsNormalExpression: (params, sourceCodeInfo) => {
         let value = false;
@@ -5887,16 +6418,21 @@ const qqSpecialExpression = {
     arity: { min: 1 },
     docs: docs$5,
     evaluate: (node, contextStack, { evaluateNode }) => {
-        for (const param of node[1][1]) {
+        // Use a sentinel to know we haven't found a non-null value yet
+        const SENTINEL = Symbol('qq-sentinel');
+        return chain(reduceSequential(node[1][1], (acc, param) => {
+            if (acc !== SENTINEL)
+                return acc;
             if (isUserDefinedSymbolNode(param) && contextStack.lookUp(param) === null) {
-                continue;
-            }
-            const result = evaluateNode(param, contextStack);
-            if (result !== null) {
-                return result;
+                return SENTINEL;
             }
-        }
-        return null;
+            return chain(evaluateNode(param, contextStack), (result) => {
+                if (result !== null) {
+                    return result;
+                }
+                return SENTINEL;
+            });
+        }, SENTINEL), result => result === SENTINEL ? null : result);
     },
     evaluateAsNormalExpression: (params, sourceCodeInfo) => {
         for (const param of params) {
@@ -5918,7 +6454,7 @@ const docs$4 = {
         `
 let foo = (n) -> do
   write!(n);
-  if !(zero?(n)) then
+  if not(zero?(n)) then
     recur(n - 1)
   end
 end;
@@ -5926,14 +6462,14 @@ foo(3)`,
         `
 (n -> do
   write!(n);
-  if !(zero?(n)) then
+  if not(zero?(n)) then
     recur(n - 1)
   end
 end)(3)`,
         `
 loop (n = 3) -> do
   write!(n);
-  if !(zero?(n)) then
+  if not(zero?(n)) then
     recur(n - 1)
   end
 end`,
@@ -5944,8 +6480,9 @@ const recurSpecialExpression = {
     docs: docs$4,
     evaluate: (node, contextStack, { evaluateNode }) => {
         const params = node[1][1];
-        const evaluatedParams = params.map(paramNode => evaluateNode(paramNode, contextStack));
-        throw new RecurSignal(evaluatedParams);
+        return chain(mapSequential(params, paramNode => evaluateNode(paramNode, contextStack)), (evaluatedParams) => {
+            throw new RecurSignal(evaluatedParams);
+        });
     },
     evaluateAsNormalExpression: (params) => {
         throw new RecurSignal(params);
@@ -5976,10 +6513,12 @@ const throwSpecialExpression = {
     arity: toFixedArity(1),
     docs: docs$3,
     evaluate: (node, contextStack, { evaluateNode }) => {
-        const message = asString(evaluateNode(node[1][1], contextStack), node[2], {
-            nonEmpty: true,
+        return chain(evaluateNode(node[1][1], contextStack), (result) => {
+            const message = asString(result, node[2], {
+                nonEmpty: true,
+            });
+            throw new UserDefinedError(message, node[2]);
         });
-        throw new UserDefinedError(message, node[2]);
     },
     evaluateAsNormalExpression: (params, sourceCodeInfo) => {
         const message = asString(params[0], sourceCodeInfo, {
@@ -6025,17 +6564,14 @@ const trySpecialExpression = {
     docs: docs$2,
     evaluate: (node, contextStack, { evaluateNode }) => {
         const [, tryExpression, errorSymbol, catchExpression] = node[1];
-        try {
-            return evaluateNode(tryExpression, contextStack);
-        }
-        catch (error) {
+        return tryCatch(() => evaluateNode(tryExpression, contextStack), (error) => {
             const newContext = errorSymbol
                 ? {
                     [errorSymbol[1]]: { value: error },
                 }
                 : {};
             return evaluateNode(catchExpression, contextStack.create(newContext));
-        }
+        });
     },
     getUndefinedSymbols: (node, contextStack, { getUndefinedSymbols, builtin, evaluateNode }) => {
         const [, tryExpression, errorSymbol, catchExpression] = node[1];
@@ -6082,19 +6618,21 @@ const arraySpecialExpression = {
     docs: docs$1,
     evaluate: (node, contextStack, { evaluateNode }) => {
         const result = [];
-        for (const param of node[1][1]) {
+        return chain(forEachSequential(node[1][1], (param) => {
             if (isSpreadNode(param)) {
-                const spreadValue = evaluateNode(param[1], contextStack);
-                if (!Array.isArray(spreadValue)) {
-                    throw new LitsError('Spread value is not an array', param[2]);
-                }
-                result.push(...spreadValue);
+                return chain(evaluateNode(param[1], contextStack), (spreadValue) => {
+                    if (!Array.isArray(spreadValue)) {
+                        throw new LitsError('Spread value is not an array', param[2]);
+                    }
+                    result.push(...spreadValue);
+                });
             }
             else {
-                result.push(evaluateNode(param, contextStack));
+                return chain(evaluateNode(param, contextStack), (value) => {
+                    result.push(value);
+                });
             }
-        }
-        return result;
+        }), () => result);
     },
     evaluateAsNormalExpression: (params, sourceCodeInfo) => {
         const result = [];
@@ -6147,28 +6685,34 @@ const objectSpecialExpression = {
     evaluate: (node, contextStack, { evaluateNode }) => {
         const result = {};
         const params = node[1][1];
-        for (let i = 0; i < params.length; i += 2) {
+        function processEntry(i) {
+            if (i >= params.length)
+                return result;
             const keyNode = params[i];
             if (isSpreadNode(keyNode)) {
-                const spreadObject = evaluateNode(keyNode[1], contextStack);
-                if (!isUnknownRecord(spreadObject)) {
-                    throw new LitsError('Spread value is not an object', keyNode[2]);
-                }
-                Object.assign(result, spreadObject);
-                i -= 1;
+                return chain(evaluateNode(keyNode[1], contextStack), (spreadObject) => {
+                    if (!isUnknownRecord(spreadObject)) {
+                        throw new LitsError('Spread value is not an object', keyNode[2]);
+                    }
+                    Object.assign(result, spreadObject);
+                    return processEntry(i + 1);
+                });
             }
             else {
-                const key = evaluateNode(keyNode, contextStack);
                 const valueNode = params[i + 1];
                 if (valueNode === undefined) {
                     throw new LitsError('Missing value for key', keyNode[2]);
                 }
-                const value = evaluateNode(valueNode, contextStack);
-                assertString(key, keyNode[2]);
-                result[key] = value;
+                return chain(evaluateNode(keyNode, contextStack), (key) => {
+                    return chain(evaluateNode(valueNode, contextStack), (value) => {
+                        assertString(key, keyNode[2]);
+                        result[key] = value;
+                        return processEntry(i + 2);
+                    });
+                });
             }
         }
-        return result;
+        return processEntry(0);
     },
     evaluateAsNormalExpression: (params, sourceCodeInfo) => {
         const result = {};
@@ -6267,7 +6811,19 @@ function isNumberReservedSymbol(symbol) {
 const functionExecutors = {
     NativeJsFunction: (fn, params, sourceCodeInfo) => {
         try {
-            return toAny(fn.nativeFn.fn(...params));
+            const result = fn.nativeFn.fn(...params);
+            // If the native function returns a Promise, await it transparently
+            if (result instanceof Promise) {
+                return result.then(resolved => toAny(resolved), (error) => {
+                    const message = typeof error === 'string'
+                        ? error
+                        : isUnknownRecord(error) && typeof error.message === 'string'
+                            ? error.message
+                            : '<no message>';
+                    throw new LitsError(`Native function threw: "${message}"`, sourceCodeInfo);
+                });
+            }
+            return toAny(result);
         }
         catch (error) {
             const message = typeof error === 'string'
@@ -6279,9 +6835,9 @@ const functionExecutors = {
         }
     },
     UserDefined: (fn, params, sourceCodeInfo, contextStack, { evaluateNode }) => {
-        for (;;) {
-            if (!arityAcceptsMin(fn.arity, params.length)) {
-                throw new LitsError(`Expected ${fn.arity} arguments, got ${params.length}.`, sourceCodeInfo);
+        function setupAndExecute(currentParams) {
+            if (!arityAcceptsMin(fn.arity, currentParams.length)) {
+                throw new LitsError(`Expected ${fn.arity} arguments, got ${currentParams.length}.`, sourceCodeInfo);
             }
             const evaluatedFunction = fn.evaluatedfunction;
             const args = evaluatedFunction[0];
@@ -6289,39 +6845,70 @@ const functionExecutors = {
             const newContextStack = contextStack.create(fn.evaluatedfunction[2]);
             const newContext = { self: { value: fn } };
             const rest = [];
-            for (let i = 0; i < params.length; i += 1) {
+            // Process non-rest params sequentially since binding evaluation may be async
+            let paramSetup = undefined;
+            for (let i = 0; i < currentParams.length; i += 1) {
                 if (i < nbrOfNonRestArgs) {
-                    const param = toAny(params[i]);
-                    const valueRecord = evaluateBindingNodeValues(args[i], param, node => evaluateNode(node, newContextStack.create(newContext)));
-                    Object.entries(valueRecord).forEach(([key, value]) => {
-                        newContext[key] = { value };
+                    const paramIndex = i;
+                    paramSetup = chain(paramSetup, () => {
+                        const param = toAny(currentParams[paramIndex]);
+                        return chain(evaluateBindingNodeValues(args[paramIndex], param, node => evaluateNode(node, newContextStack.create(newContext))), (valueRecord) => {
+                            Object.entries(valueRecord).forEach(([key, value]) => {
+                                newContext[key] = { value };
+                            });
+                        });
                     });
                 }
                 else {
-                    rest.push(toAny(params[i]));
+                    rest.push(toAny(currentParams[i]));
                 }
             }
-            for (let i = params.length; i < nbrOfNonRestArgs; i++) {
-                const arg = args[i];
-                const defaultValue = evaluateNode(arg[1][1], contextStack.create(newContext));
-                const valueRecord = evaluateBindingNodeValues(arg, defaultValue, node => evaluateNode(node, contextStack.create(newContext)));
-                Object.entries(valueRecord).forEach(([key, value]) => {
-                    newContext[key] = { value };
+            // Handle default values for optional params — chain sequentially since they may be async
+            let defaultSetup = undefined;
+            for (let i = currentParams.length; i < nbrOfNonRestArgs; i++) {
+                const argIndex = i;
+                defaultSetup = chain(defaultSetup, () => {
+                    const arg = args[argIndex];
+                    return chain(evaluateNode(arg[1][1], contextStack.create(newContext)), (defaultValue) => {
+                        return chain(evaluateBindingNodeValues(arg, defaultValue, node => evaluateNode(node, contextStack.create(newContext))), (valueRecord) => {
+                            Object.entries(valueRecord).forEach(([key, value]) => {
+                                newContext[key] = { value };
+                            });
+                        });
+                    });
                 });
             }
-            const restArgument = args.find(arg => arg[0] === bindingTargetTypes.rest);
-            if (restArgument !== undefined) {
-                const valueRecord = evaluateBindingNodeValues(restArgument, rest, node => evaluateNode(node, contextStack.create(newContext)));
-                Object.entries(valueRecord).forEach(([key, value]) => {
-                    newContext[key] = { value };
+            return chain(paramSetup, () => chain(defaultSetup, () => {
+                const restArgument = args.find(arg => arg[0] === bindingTargetTypes.rest);
+                const restSetup = restArgument !== undefined
+                    ? chain(evaluateBindingNodeValues(restArgument, rest, node => evaluateNode(node, contextStack.create(newContext))), (valueRecord) => {
+                        Object.entries(valueRecord).forEach(([key, value]) => {
+                            newContext[key] = { value };
+                        });
+                    })
+                    : undefined;
+                return chain(restSetup, () => {
+                    // Evaluate body nodes sequentially
+                    const newContextStack2 = newContextStack.create(newContext);
+                    const bodyResult = reduceSequential(evaluatedFunction[1], (_acc, node) => evaluateNode(node, newContextStack2), null);
+                    // Handle RecurSignal for async body results
+                    if (bodyResult instanceof Promise) {
+                        return bodyResult.catch((error) => {
+                            if (error instanceof RecurSignal) {
+                                return setupAndExecute(error.params);
+                            }
+                            throw error;
+                        });
+                    }
+                    return bodyResult;
                 });
-            }
+            }));
+        }
+        // Sync recur loop: use for(;;) to avoid stack overflow for sync tail recursion
+        for (;;) {
             try {
-                let result = null;
-                const newContextStack2 = newContextStack.create(newContext);
-                for (const node of evaluatedFunction[1]) {
-                    result = evaluateNode(node, newContextStack2);
-                }
+                const result = setupAndExecute(params);
+                // If result is async, the RecurSignal handling is inside the Promise chain
                 return result;
             }
             catch (error) {
@@ -6351,38 +6938,51 @@ const functionExecutors = {
                 throw new LitsError(`(comp) expects one argument, got ${valueToString(params.length)}.`, sourceCodeInfo);
             return asAny(params[0], sourceCodeInfo);
         }
-        return asAny(f.reduceRight((result, fun) => {
-            return [executeFunction(asFunctionLike(fun, sourceCodeInfo), result, contextStack, sourceCodeInfo)];
-        }, params)[0], sourceCodeInfo);
+        // reduceRight with MaybePromise: each step wraps result in array, passes to next function
+        let result = params;
+        for (let i = f.length - 1; i >= 0; i--) {
+            const fun = f[i];
+            result = chain(result, (currentParams) => {
+                return chain(executeFunction(asFunctionLike(fun, sourceCodeInfo), currentParams, contextStack, sourceCodeInfo), r => [r]);
+            });
+        }
+        return chain(result, finalArr => asAny(finalArr[0], sourceCodeInfo));
     },
     Constantly: (fn) => {
         return fn.value;
     },
     Juxt: (fn, params, sourceCodeInfo, contextStack, { executeFunction }) => {
-        return fn.params.map(fun => executeFunction(asFunctionLike(fun, sourceCodeInfo), params, contextStack, sourceCodeInfo));
+        return mapSequential(fn.params, fun => executeFunction(asFunctionLike(fun, sourceCodeInfo), params, contextStack, sourceCodeInfo));
     },
     Complement: (fn, params, sourceCodeInfo, contextStack, { executeFunction }) => {
-        return !executeFunction(fn.function, params, contextStack, sourceCodeInfo);
+        return chain(executeFunction(fn.function, params, contextStack, sourceCodeInfo), result => !result);
     },
     EveryPred: (fn, params, sourceCodeInfo, contextStack, { executeFunction }) => {
+        // Flatten to sequential checks: for each predicate, for each param
+        const checks = [];
         for (const f of fn.params) {
             for (const param of params) {
-                const result = executeFunction(asFunctionLike(f, sourceCodeInfo), [param], contextStack, sourceCodeInfo);
-                if (!result)
-                    return false;
+                checks.push(() => executeFunction(asFunctionLike(f, sourceCodeInfo), [param], contextStack, sourceCodeInfo));
             }
         }
-        return true;
+        return reduceSequential(checks, (acc, check) => {
+            if (!acc)
+                return false;
+            return chain(check(), result => !!result);
+        }, true);
     },
     SomePred: (fn, params, sourceCodeInfo, contextStack, { executeFunction }) => {
+        const checks = [];
         for (const f of fn.params) {
             for (const param of params) {
-                const result = executeFunction(asFunctionLike(f, sourceCodeInfo), [param], contextStack, sourceCodeInfo);
-                if (result)
-                    return true;
+                checks.push(() => executeFunction(asFunctionLike(f, sourceCodeInfo), [param], contextStack, sourceCodeInfo));
             }
         }
-        return false;
+        return reduceSequential(checks, (acc, check) => {
+            if (acc)
+                return true;
+            return chain(check(), result => !!result);
+        }, false);
     },
     Fnull: (fn, params, sourceCodeInfo, contextStack, { executeFunction }) => {
         const fnulledParams = params.map((param, index) => (param === null ? toAny(fn.params[index]) : param));
@@ -6416,11 +7016,7 @@ const functionExecutors = {
 };
 
 function evaluate(ast, contextStack) {
-    let result = null;
-    for (const node of ast.body) {
-        result = evaluateNode(node, contextStack);
-    }
-    return result;
+    return reduceSequential(ast.body, (_acc, node) => evaluateNode(node, contextStack), null);
 }
 function evaluateNode(node, contextStack) {
     switch (node[0]) {
@@ -6436,13 +7032,15 @@ function evaluateNode(node, contextStack) {
             return evaluateReservedSymbol(node);
         case NodeTypes.NormalExpression: {
             const result = evaluateNormalExpression(node, contextStack);
-            if (typeof result === 'number' && Number.isNaN(result)) {
-                throw new LitsError('Number is NaN', node[2]);
-            }
-            return annotate(result);
+            return chain(result, (resolved) => {
+                if (typeof resolved === 'number' && Number.isNaN(resolved)) {
+                    throw new LitsError('Number is NaN', node[2]);
+                }
+                return annotate(resolved);
+            });
         }
         case NodeTypes.SpecialExpression:
-            return annotate(evaluateSpecialExpression(node, contextStack));
+            return chain(evaluateSpecialExpression(node, contextStack), resolved => annotate(resolved));
         /* v8 ignore next 2 */
         default:
             throw new LitsError(`${getNodeTypeName(node[0])}-node cannot be evaluated`, node[2]);
@@ -6462,73 +7060,84 @@ function evaluateReservedSymbol(node) {
     const value = reservedSymbolRecord[reservedName];
     return asNonUndefined(value, node[2]);
 }
-function evaluateNormalExpression(node, contextStack) {
-    const sourceCodeInfo = node[2];
-    const paramNodes = node[1][1];
+function evaluateParams(paramNodes, contextStack) {
     const params = [];
     const placeholders = [];
-    paramNodes.forEach((paramNode, index) => {
+    const result = forEachSequential(paramNodes, (paramNode, index) => {
         if (isSpreadNode(paramNode)) {
-            const spreadValue = evaluateNode(paramNode[1], contextStack);
-            if (Array.isArray(spreadValue)) {
-                params.push(...spreadValue);
-            }
-            else {
-                throw new LitsError(`Spread operator requires an array, got ${valueToString(paramNode)}`, paramNode[2]);
-            }
+            return chain(evaluateNode(paramNode[1], contextStack), (spreadValue) => {
+                if (Array.isArray(spreadValue)) {
+                    params.push(...spreadValue);
+                }
+                else {
+                    throw new LitsError(`Spread operator requires an array, got ${valueToString(paramNode)}`, paramNode[2]);
+                }
+            });
         }
         else if (paramNode[0] === NodeTypes.ReservedSymbol && paramNode[1] === '_') {
             placeholders.push(index);
         }
         else {
-            params.push(evaluateNode(paramNode, contextStack));
+            return chain(evaluateNode(paramNode, contextStack), (value) => {
+                params.push(value);
+            });
         }
     });
-    if (isNormalExpressionNodeWithName(node)) {
-        const nameSymbol = node[1][0];
-        if (placeholders.length > 0) {
-            const fn = evaluateNode(nameSymbol, contextStack);
-            const partialFunction = {
-                [FUNCTION_SYMBOL]: true,
-                function: asFunctionLike(fn, sourceCodeInfo),
-                functionType: 'Partial',
-                params,
-                placeholders,
-                sourceCodeInfo,
-                arity: toFixedArity(placeholders.length),
-            };
-            return partialFunction;
-        }
-        if (isNormalBuiltinSymbolNode(nameSymbol)) {
-            const type = nameSymbol[1];
-            const normalExpression = builtin.allNormalExpressions[type];
-            return normalExpression.evaluate(params, node[2], contextStack, { executeFunction });
-        }
-        else {
-            const fn = contextStack.getValue(nameSymbol[1]);
-            if (fn !== undefined) {
-                return executeFunction(asFunctionLike(fn, sourceCodeInfo), params, contextStack, sourceCodeInfo);
+    return chain(result, () => ({ params, placeholders }));
+}
+function evaluateNormalExpression(node, contextStack) {
+    const sourceCodeInfo = node[2];
+    return chain(evaluateParams(node[1][1], contextStack), ({ params, placeholders }) => {
+        if (isNormalExpressionNodeWithName(node)) {
+            const nameSymbol = node[1][0];
+            if (placeholders.length > 0) {
+                const fn = evaluateNode(nameSymbol, contextStack);
+                return chain(fn, (resolvedFn) => {
+                    const partialFunction = {
+                        [FUNCTION_SYMBOL]: true,
+                        function: asFunctionLike(resolvedFn, sourceCodeInfo),
+                        functionType: 'Partial',
+                        params,
+                        placeholders,
+                        sourceCodeInfo,
+                        arity: toFixedArity(placeholders.length),
+                    };
+                    return partialFunction;
+                });
+            }
+            if (isNormalBuiltinSymbolNode(nameSymbol)) {
+                const type = nameSymbol[1];
+                const normalExpression = builtin.allNormalExpressions[type];
+                return normalExpression.evaluate(params, node[2], contextStack, { executeFunction });
+            }
+            else {
+                const fn = contextStack.getValue(nameSymbol[1]);
+                if (fn !== undefined) {
+                    return executeFunction(asFunctionLike(fn, sourceCodeInfo), params, contextStack, sourceCodeInfo);
+                }
+                throw new UndefinedSymbolError(nameSymbol[1], node[2]);
             }
-            throw new UndefinedSymbolError(nameSymbol[1], node[2]);
         }
-    }
-    else {
-        const fnNode = node[1][0];
-        const fn = asFunctionLike(evaluateNode(fnNode, contextStack), sourceCodeInfo);
-        if (placeholders.length > 0) {
-            const partialFunction = {
-                [FUNCTION_SYMBOL]: true,
-                function: fn,
-                functionType: 'Partial',
-                params,
-                placeholders,
-                sourceCodeInfo,
-                arity: toFixedArity(placeholders.length),
-            };
-            return partialFunction;
+        else {
+            const fnNode = node[1][0];
+            return chain(evaluateNode(fnNode, contextStack), (resolvedFn) => {
+                const fn = asFunctionLike(resolvedFn, sourceCodeInfo);
+                if (placeholders.length > 0) {
+                    const partialFunction = {
+                        [FUNCTION_SYMBOL]: true,
+                        function: fn,
+                        functionType: 'Partial',
+                        params,
+                        placeholders,
+                        sourceCodeInfo,
+                        arity: toFixedArity(placeholders.length),
+                    };
+                    return partialFunction;
+                }
+                return executeFunction(fn, params, contextStack, sourceCodeInfo);
+            });
         }
-        return executeFunction(fn, params, contextStack, sourceCodeInfo);
-    }
+    });
 }
 function executeFunction(fn, params, contextStack, sourceCodeInfo) {
     if (isLitsFunction(fn))
@@ -6804,7 +7413,7 @@ const binaryOperators = [
     '≥', // greater than or equal
     '==', // equal
     '!=', // not equal
-    '≠', // not equal
+    '!=', // not equal
     '&', // bitwise AND
     'xor', // bitwise XOR
     '|', // bitwise OR
@@ -7587,6 +8196,7 @@ class ParserContext {
         const token = this.tokens[this.position];
         if (!token) {
             const lastToken = this.tokens.at(-1);
+            /* v8 ignore next */
             const sourceCodeInfo = lastToken ? lastToken[2] : undefined;
             throw new LitsError('Unexpected end of input', sourceCodeInfo);
         }
@@ -7713,7 +8323,6 @@ function fromBinaryOperatorToNode(operator, symbolNode, left, right, sourceCodeI
         case '≥':
         case '==':
         case '!=':
-        case '≠':
         case '&':
         case 'xor':
         case '|':
@@ -8637,7 +9246,6 @@ function getPrecedence(operatorSign, sourceCodeInfo) {
             return 7;
         case '==': // equal
         case '!=': // not equal
-        case '≠': // not equal
             return 6;
         case '&': // bitwise AND
         case 'xor': // bitwise XOR
@@ -8863,15 +9471,36 @@ class Lits {
             debug: this.debug,
         };
     }
+    async = {
+        run: async (program, params = {}) => {
+            const ast = this.generateAst(program, params);
+            return this.evaluate(ast, params);
+        },
+        context: async (programOrAst, params = {}) => {
+            const ast = typeof programOrAst === 'string' ? this.generateAst(programOrAst, params) : programOrAst;
+            const contextStack = createContextStack(params, this.modules);
+            await evaluate(ast, contextStack);
+            return contextStack.globalContext;
+        },
+        apply: async (fn, fnParams, params = {}) => {
+            return this.apply(fn, fnParams, params);
+        },
+    };
     run(program, params = {}) {
         const ast = this.generateAst(program, params);
         const result = this.evaluate(ast, params);
+        if (result instanceof Promise) {
+            throw new TypeError('Unexpected async result in synchronous run(). Use lits.async.run() for async operations.');
+        }
         return result;
     }
     context(programOrAst, params = {}) {
         const ast = typeof programOrAst === 'string' ? this.generateAst(programOrAst, params) : programOrAst;
         const contextStack = createContextStack(params, this.modules);
-        evaluate(ast, contextStack);
+        const result = evaluate(ast, contextStack);
+        if (result instanceof Promise) {
+            throw new TypeError('Unexpected async result in synchronous context(). Use lits.async.context() for async operations.');
+        }
         return contextStack.globalContext;
     }
     getUndefinedSymbols(programOrAst, params = {}) {
@@ -10137,13 +10766,9 @@ const assertNormalExpression = {
             }
             message ??= '';
             assertFunctionLike(func, sourceCodeInfo);
-            try {
-                executeFunction(func, [], contextStack, sourceCodeInfo);
-            }
-            catch {
-                return null;
-            }
-            throw new AssertionError(`Expected function to throw.${message}`, sourceCodeInfo);
+            return tryCatch(() => chain(executeFunction(func, [], contextStack, sourceCodeInfo), () => {
+                throw new AssertionError(`Expected function to throw.${message}`, sourceCodeInfo);
+            }), () => null);
         },
         arity: { min: 1, max: 2 },
     },
@@ -10156,17 +10781,15 @@ const assertNormalExpression = {
             message ??= '';
             assertString(throwMessage, sourceCodeInfo);
             assertFunctionLike(func, sourceCodeInfo);
-            try {
-                executeFunction(func, [], contextStack, sourceCodeInfo);
-            }
-            catch (error) {
+            return tryCatch(() => chain(executeFunction(func, [], contextStack, sourceCodeInfo), () => {
+                throw new AssertionError(`Expected function to throw "${throwMessage}".${message}`, sourceCodeInfo);
+            }), (error) => {
                 const errorMessage = error.shortMessage;
                 if (errorMessage !== throwMessage) {
                     throw new AssertionError(`Expected function to throw "${throwMessage}", but thrown "${errorMessage}".${message}`, sourceCodeInfo);
                 }
                 return null;
-            }
-            throw new AssertionError(`Expected function to throw "${throwMessage}".${message}`, sourceCodeInfo);
+            });
         },
         arity: { min: 2, max: 3 },
     },
@@ -10178,13 +10801,9 @@ const assertNormalExpression = {
             }
             message ??= '';
             assertFunctionLike(func, sourceCodeInfo);
-            try {
-                executeFunction(func, [], contextStack, sourceCodeInfo);
-            }
-            catch {
+            return tryCatch(() => chain(executeFunction(func, [], contextStack, sourceCodeInfo), () => null), () => {
                 throw new AssertionError(`Expected function not to throw.${message}`, sourceCodeInfo);
-            }
-            return null;
+            });
         },
         arity: { min: 1, max: 2 },
     },
@@ -11572,14 +12191,13 @@ const gridFunctions = {
         evaluate: ([grid, predicate], sourceCodeInfo, contextStack, { executeFunction }) => {
             assertGrid(grid, sourceCodeInfo);
             assertFunctionLike(predicate, sourceCodeInfo);
+            const cells = [];
             for (const row of grid) {
                 for (const cell of row) {
-                    if (!executeFunction(predicate, [cell], contextStack, sourceCodeInfo)) {
-                        return false;
-                    }
+                    cells.push(cell);
                 }
             }
-            return true;
+            return everySequential(cells, cell => executeFunction(predicate, [cell], contextStack, sourceCodeInfo));
         },
         arity: toFixedArity(2),
     },
@@ -11587,14 +12205,13 @@ const gridFunctions = {
         evaluate: ([grid, predicate], sourceCodeInfo, contextStack, { executeFunction }) => {
             assertGrid(grid, sourceCodeInfo);
             assertFunctionLike(predicate, sourceCodeInfo);
+            const cells = [];
             for (const row of grid) {
                 for (const cell of row) {
-                    if (executeFunction(predicate, [cell], contextStack, sourceCodeInfo)) {
-                        return true;
-                    }
+                    cells.push(cell);
                 }
             }
-            return false;
+            return someSequential(cells, cell => executeFunction(predicate, [cell], contextStack, sourceCodeInfo));
         },
         arity: toFixedArity(2),
     },
@@ -11602,12 +12219,7 @@ const gridFunctions = {
         evaluate: ([grid, predicate], sourceCodeInfo, contextStack, { executeFunction }) => {
             assertGrid(grid, sourceCodeInfo);
             assertFunctionLike(predicate, sourceCodeInfo);
-            for (const row of grid) {
-                if (!executeFunction(predicate, [row], contextStack, sourceCodeInfo)) {
-                    return false;
-                }
-            }
-            return true;
+            return everySequential(Array.from(grid), row => executeFunction(predicate, [row], contextStack, sourceCodeInfo));
         },
         arity: toFixedArity(2),
     },
@@ -11615,12 +12227,7 @@ const gridFunctions = {
         evaluate: ([grid, predicate], sourceCodeInfo, contextStack, { executeFunction }) => {
             assertGrid(grid, sourceCodeInfo);
             assertFunctionLike(predicate, sourceCodeInfo);
-            for (const row of grid) {
-                if (executeFunction(predicate, [row], contextStack, sourceCodeInfo)) {
-                    return true;
-                }
-            }
-            return false;
+            return someSequential(Array.from(grid), row => executeFunction(predicate, [row], contextStack, sourceCodeInfo));
         },
         arity: toFixedArity(2),
     },
@@ -11629,12 +12236,7 @@ const gridFunctions = {
             assertGrid(grid, sourceCodeInfo);
             assertFunctionLike(predicate, sourceCodeInfo);
             const transposed = transpose(grid);
-            for (const row of transposed) {
-                if (!executeFunction(predicate, [row], contextStack, sourceCodeInfo)) {
-                    return false;
-                }
-            }
-            return true;
+            return everySequential(Array.from(transposed), row => executeFunction(predicate, [row], contextStack, sourceCodeInfo));
         },
         arity: toFixedArity(2),
     },
@@ -11643,12 +12245,7 @@ const gridFunctions = {
             assertGrid(grid, sourceCodeInfo);
             assertFunctionLike(predicate, sourceCodeInfo);
             const transposed = transpose(grid);
-            for (const row of transposed) {
-                if (executeFunction(predicate, [row], contextStack, sourceCodeInfo)) {
-                    return true;
-                }
-            }
-            return false;
+            return someSequential(Array.from(transposed), row => executeFunction(predicate, [row], contextStack, sourceCodeInfo));
         },
         arity: toFixedArity(2),
     },
@@ -11697,17 +12294,14 @@ const gridFunctions = {
             assertNumber(rows, sourceCodeInfo, { integer: true, positive: true });
             assertNumber(cols, sourceCodeInfo, { integer: true, positive: true });
             assertFunctionLike(generator, sourceCodeInfo);
-            const result = [];
-            for (let i = 0; i < rows; i += 1) {
-                const row = [];
-                for (let j = 0; j < cols; j += 1) {
-                    const value = executeFunction(generator, [i, j], contextStack, sourceCodeInfo);
-                    assertAny(value, sourceCodeInfo);
-                    row.push(value);
-                }
-                result.push(row);
-            }
-            return result;
+            return mapSequential(Array.from({ length: rows }), (_, i) => {
+                return mapSequential(Array.from({ length: cols }), (__, j) => {
+                    return chain(executeFunction(generator, [i, j], contextStack, sourceCodeInfo), (value) => {
+                        assertAny(value, sourceCodeInfo);
+                        return value;
+                    });
+                });
+            });
         },
         arity: toFixedArity(3),
     },
@@ -11994,16 +12588,12 @@ const gridFunctions = {
                     throw new LitsError(`All grids must have the same number of columns, but got ${cols} and ${grid[0].length}`, sourceCodeInfo);
                 }
             });
-            const result = [];
-            for (let i = 0; i < rows; i += 1) {
-                const row = [];
-                for (let j = 0; j < cols; j += 1) {
+            return mapSequential(Array.from({ length: rows }), (_, i) => {
+                return mapSequential(Array.from({ length: cols }), (__, j) => {
                     const args = grids.map(grid => grid[i][j]);
-                    row.push(asAny(executeFunction(fn, args, contextStack, sourceCodeInfo)));
-                }
-                result.push(row);
-            }
-            return result;
+                    return chain(executeFunction(fn, args, contextStack, sourceCodeInfo), val => asAny(val));
+                });
+            });
         },
         arity: { min: 2 },
     },
@@ -12013,15 +12603,11 @@ const gridFunctions = {
             assertFunctionLike(fn, sourceCodeInfo);
             const rows = grid.length;
             const cols = grid[0].length;
-            const result = [];
-            for (let i = 0; i < rows; i += 1) {
-                const row = [];
-                for (let j = 0; j < cols; j += 1) {
-                    row.push(asAny(executeFunction(fn, [grid[i][j], i, j], contextStack, sourceCodeInfo)));
-                }
-                result.push(row);
-            }
-            return result;
+            return mapSequential(Array.from({ length: rows }), (_, i) => {
+                return mapSequential(Array.from({ length: cols }), (__, j) => {
+                    return chain(executeFunction(fn, [grid[i][j], i, j], contextStack, sourceCodeInfo), val => asAny(val));
+                });
+            });
         },
         arity: toFixedArity(2),
     },
@@ -12029,13 +12615,13 @@ const gridFunctions = {
         evaluate: ([grid, fn, initialValue], sourceCodeInfo, contextStack, { executeFunction }) => {
             assertGrid(grid, sourceCodeInfo);
             assertFunctionLike(fn, sourceCodeInfo);
-            let accumulator = asAny(initialValue);
+            const cells = [];
             for (const row of grid) {
                 for (const cell of row) {
-                    accumulator = executeFunction(fn, [accumulator, cell], contextStack, sourceCodeInfo);
+                    cells.push(cell);
                 }
             }
-            return accumulator;
+            return reduceSequential(cells, (accumulator, cell) => executeFunction(fn, [accumulator, cell], contextStack, sourceCodeInfo), asAny(initialValue));
         },
         arity: toFixedArity(3),
     },
@@ -12043,13 +12629,13 @@ const gridFunctions = {
         evaluate: ([grid, fn, initialValue], sourceCodeInfo, contextStack, { executeFunction }) => {
             assertGrid(grid, sourceCodeInfo);
             assertFunctionLike(fn, sourceCodeInfo);
-            let accumulator = asAny(initialValue);
+            const cells = [];
             for (let i = 0; i < grid.length; i += 1) {
                 for (let j = 0; j < grid[i].length; j += 1) {
-                    accumulator = executeFunction(fn, [accumulator, grid[i][j], i, j], contextStack, sourceCodeInfo);
+                    cells.push({ cell: grid[i][j], i, j });
                 }
             }
-            return accumulator;
+            return reduceSequential(cells, (accumulator, { cell, i, j }) => executeFunction(fn, [accumulator, cell, i, j], contextStack, sourceCodeInfo), asAny(initialValue));
         },
         arity: toFixedArity(3),
     },
@@ -18165,10 +18751,11 @@ const vectorFunctions = {
         evaluate: ([length, generator], sourceCodeInfo, contextStack, { executeFunction }) => {
             assertNumber(length, sourceCodeInfo, { integer: true, nonNegative: true });
             assertFunctionLike(generator, sourceCodeInfo);
-            return Array.from({ length }, (_, i) => {
-                const value = executeFunction(generator, [i], contextStack, sourceCodeInfo);
-                assertNumber(value, sourceCodeInfo, { finite: true });
-                return value;
+            return mapSequential(Array.from({ length }), (_, i) => {
+                return chain(executeFunction(generator, [i], contextStack, sourceCodeInfo), (value) => {
+                    assertNumber(value, sourceCodeInfo, { finite: true });
+                    return value;
+                });
             });
         },
         arity: toFixedArity(2),
@@ -26799,16 +27386,17 @@ const abundantSequence = {
     'abundant?': n => isAbundant(n),
     'abundant-take-while': (takeWhile) => {
         const abundants = [];
-        for (let i = 2;; i += 1) {
-            if (!isAbundant(i)) {
-                continue;
-            }
-            if (!takeWhile(i, abundants.length)) {
-                break;
-            }
-            abundants.push(i);
+        function loop(i) {
+            if (!isAbundant(i))
+                return loop(i + 1);
+            return chain(takeWhile(i, abundants.length), (keep) => {
+                if (!keep)
+                    return abundants;
+                abundants.push(i);
+                return loop(i + 1);
+            });
         }
-        return abundants;
+        return loop(2);
     },
 };
 
@@ -26853,15 +27441,20 @@ const arithmeticNormalExpressions = {
             assertNumber(start, sourceCodeInfo, { finite: true });
             assertNumber(step, sourceCodeInfo, { finite: true });
             assertFunctionLike(fn, sourceCodeInfo);
+            const s = start;
+            const d = step;
+            const f = fn;
             const arithmetic = [];
-            for (let i = 0;; i += 1) {
-                const value = start + i * step;
-                if (!(executeFunction)(fn, [value, i], contextStack, sourceCodeInfo)) {
-                    break;
-                }
-                arithmetic[i] = value;
+            function loop(i) {
+                const value = s + i * d;
+                return chain(executeFunction(f, [value, i], contextStack, sourceCodeInfo), (keep) => {
+                    if (!keep)
+                        return arithmetic;
+                    arithmetic.push(value);
+                    return loop(i + 1);
+                });
             }
-            return arithmetic;
+            return loop(0);
         },
         arity: toFixedArity(3),
     },
@@ -26927,28 +27520,21 @@ function getBernoulliSeq(length) {
  * @returns Array of Bernoulli numbers generated until predicate returns false
  */
 function generateBernoulli(predicate) {
-    const batchSize = 100;
-    // Start with computing the Bernoulli numbers
     const bernoulli = [1];
-    let n = 1;
-    // Continue generating as long as the predicate returns true
-    while (true) {
-        // Generate a batch of numbers at a time for efficiency
-        const targetLength = bernoulli.length + batchSize;
-        for (; n < targetLength; n++) {
-            let sum = 0;
-            for (let k = 0; k < n; k++) {
-                sum += binomialCoefficient(n + 1, k) * bernoulli[k];
-            }
-            const newValue = n > 1 && n % 2 === 1 ? 0 : -sum / (n + 1);
-            // Check if we should continue
-            if (!predicate(newValue, n)) {
-                // We're done, return the generated sequence (including the last value)
+    function loop(n) {
+        let sum = 0;
+        for (let k = 0; k < n; k++) {
+            sum += binomialCoefficient(n + 1, k) * bernoulli[k];
+        }
+        const newValue = n > 1 && n % 2 === 1 ? 0 : -sum / (n + 1);
+        return chain(predicate(newValue, n), (keep) => {
+            if (!keep)
                 return bernoulli;
-            }
             bernoulli.push(newValue);
-        }
+            return loop(n + 1);
+        });
     }
+    return loop(1);
 }
 const bernoulliNormalExpressions = {
     'bernoulli-seq': {
@@ -26969,8 +27555,8 @@ const bernoulliNormalExpressions = {
     'bernoulli-take-while': {
         evaluate: ([fn], sourceCodeInfo, contextStack, { executeFunction }) => {
             assertFunctionLike(fn, sourceCodeInfo);
-            const bernoulli = generateBernoulli((value, index) => !!(executeFunction)(fn, [value, index], contextStack));
-            return bernoulli;
+            const f = fn;
+            return generateBernoulli((value, index) => chain(executeFunction(f, [value, index], contextStack), val => !!val));
         },
         arity: toFixedArity(1),
     },
@@ -27059,16 +27645,17 @@ const primeSequence = {
     'prime?': n => isPrime(n),
     'prime-take-while': (takeWhile) => {
         const primes = [];
-        for (let i = 2;; i += 1) {
-            if (!isPrime(i)) {
-                continue;
-            }
-            if (!takeWhile(i, primes.length)) {
-                break;
-            }
-            primes.push(i);
+        function loop(i) {
+            if (!isPrime(i))
+                return loop(i + 1);
+            return chain(takeWhile(i, primes.length), (keep) => {
+                if (!keep)
+                    return primes;
+                primes.push(i);
+                return loop(i + 1);
+            });
         }
-        return primes;
+        return loop(2);
     },
 };
 
@@ -27093,16 +27680,17 @@ const compositeSequence = {
     'composite?': n => isComposite(n),
     'composite-take-while': (takeWhile) => {
         const composites = [];
-        for (let i = 4;; i += 1) {
-            if (!isComposite(i)) {
-                continue;
-            }
-            if (!takeWhile(i, composites.length)) {
-                break;
-            }
-            composites.push(i);
+        function loop(i) {
+            if (!isComposite(i))
+                return loop(i + 1);
+            return chain(takeWhile(i, composites.length), (keep) => {
+                if (!keep)
+                    return composites;
+                composites.push(i);
+                return loop(i + 1);
+            });
         }
-        return composites;
+        return loop(4);
     },
 };
 
@@ -27126,16 +27714,17 @@ const deficientSequence = {
     'deficient?': n => isDeficient(n),
     'deficient-take-while': (takeWhile) => {
         const deficients = [];
-        for (let i = 1;; i += 1) {
-            if (!isDeficient(i)) {
-                continue;
-            }
-            if (!takeWhile(i, deficients.length)) {
-                break;
-            }
-            deficients.push(i);
+        function loop(i) {
+            if (!isDeficient(i))
+                return loop(i + 1);
+            return chain(takeWhile(i, deficients.length), (keep) => {
+                if (!keep)
+                    return deficients;
+                deficients.push(i);
+                return loop(i + 1);
+            });
         }
-        return deficients;
+        return loop(1);
     },
 };
 
@@ -27295,15 +27884,20 @@ const geometricNormalExpressions = {
             assertNumber(start, sourceCodeInfo, { finite: true });
             assertNumber(ratio, sourceCodeInfo, { finite: true });
             assertFunctionLike(fn, sourceCodeInfo);
+            const s = start;
+            const r = ratio;
+            const f = fn;
             const geometric = [];
-            for (let i = 0;; i += 1) {
-                const value = start * ratio ** i;
-                if (!(executeFunction)(fn, [value, i], contextStack, sourceCodeInfo)) {
-                    break;
-                }
-                geometric[i] = value;
+            function loop(i) {
+                const value = s * r ** i;
+                return chain(executeFunction(f, [value, i], contextStack, sourceCodeInfo), (keep) => {
+                    if (!keep)
+                        return geometric;
+                    geometric.push(value);
+                    return loop(i + 1);
+                });
             }
-            return geometric;
+            return loop(0);
         },
         arity: toFixedArity(3),
     },
@@ -27335,18 +27929,21 @@ function getGolombSeq(n) {
     return golomb.slice(1);
 }
 function generateGolombSeq(pred) {
-    if (!pred(1, 0)) {
-        return [];
-    }
     const golomb = [0, 1];
-    for (let i = 2;; i++) {
-        const golombNumber = 1 + golomb[i - golomb[golomb[i - 1]]];
-        if (!pred(golombNumber, i - 1)) {
-            break;
+    return chain(pred(1, 0), (keepFirst) => {
+        if (!keepFirst)
+            return [];
+        function loop(i) {
+            const golombNumber = 1 + golomb[i - golomb[golomb[i - 1]]];
+            return chain(pred(golombNumber, i - 1), (keep) => {
+                if (!keep)
+                    return golomb.slice(1);
+                golomb.push(golombNumber);
+                return loop(i + 1);
+            });
         }
-        golomb.push(golombNumber);
-    }
-    return golomb.slice(1);
+        return loop(2);
+    });
 }
 const golombSequence = {
     'golomb-seq': length => getGolombSeq(length),
@@ -27401,23 +27998,17 @@ const happySequence = {
     'happy?': n => isHappyNumber(n),
     'happy-take-while': (takeWhile) => {
         const happyNumbers = [];
-        for (let i = 1;; i++) {
-            let n = i;
-            const seen = new Set();
-            while (n !== 1 && !seen.has(n)) {
-                seen.add(n);
-                n = String(n)
-                    .split('')
-                    .reduce((sum, digit) => sum + Number(digit) ** 2, 0);
-            }
-            if (n === 1) {
-                if (!takeWhile(i, happyNumbers.length)) {
-                    break;
-                }
+        function loop(i) {
+            if (!isHappyNumber(i))
+                return loop(i + 1);
+            return chain(takeWhile(i, happyNumbers.length), (keep) => {
+                if (!keep)
+                    return happyNumbers;
                 happyNumbers.push(i);
-            }
+                return loop(i + 1);
+            });
         }
-        return happyNumbers;
+        return loop(1);
     },
 };
 
@@ -27500,19 +28091,23 @@ const lookAndSaySequence = {
         return lookAndSay;
     },
     'look-and-say-take-while': (takeWhile) => {
-        if (!takeWhile('1', 0)) {
-            return [];
-        }
-        const lookAndSay = ['1'];
-        for (let i = 1;; i += 1) {
-            const prev = lookAndSay[i - 1];
-            const next = prev.replace(/(\d)\1*/g, match => `${match.length}${match[0]}`);
-            if (!takeWhile(next, i)) {
-                break;
+        const lookAndSay = [];
+        return chain(takeWhile('1', 0), (keepFirst) => {
+            if (!keepFirst)
+                return lookAndSay;
+            lookAndSay.push('1');
+            function loop(i) {
+                const prev = lookAndSay[i - 1];
+                const next = prev.replace(/(\d)\1*/g, match => `${match.length}${match[0]}`);
+                return chain(takeWhile(next, i), (keep) => {
+                    if (!keep)
+                        return lookAndSay;
+                    lookAndSay.push(next);
+                    return loop(i + 1);
+                });
             }
-            lookAndSay[i] = next;
-        }
-        return lookAndSay;
+            return loop(1);
+        });
     },
     'look-and-say?': n => isLookAndSay(n),
 };
@@ -27620,42 +28215,45 @@ function generateLuckyNumbers(predicate) {
     const luckyNumbers = [1]; // 1 is always the first lucky number
     let count = 1;
     // Check if we should continue after the first number
-    if (!predicate(1, 0)) {
-        return [];
-    }
-    // Continue the sieve process
-    let index = 1; // Start with the second element (index 1, which is 3)
-    while (index < filteredNumbers.length) {
-        // Get the current lucky number
-        const luckyNumber = filteredNumbers[index];
-        // Check if we should continue
-        if (!predicate(luckyNumber, count)) {
-            break;
-        }
-        // Add to result
-        luckyNumbers.push(luckyNumber);
-        count++;
-        // Apply the sieve
-        const step = luckyNumber;
-        const newFiltered = [];
-        for (let i = 0; i < filteredNumbers.length; i++) {
-            if ((i + 1) % step !== 0) { // Keep numbers not at positions divisible by step
-                newFiltered.push(filteredNumbers[i]);
-            }
-        }
-        filteredNumbers = newFiltered;
-        index++;
-        // If we're running low on numbers, extend the sequence
-        if (index >= filteredNumbers.length - 5) {
-            const lastNum = filteredNumbers[filteredNumbers.length - 1];
-            let next = lastNum + 2;
-            while (filteredNumbers.length < index + 1000) {
-                filteredNumbers.push(next);
-                next += 2;
-            }
+    return chain(predicate(1, 0), (keepFirst) => {
+        if (!keepFirst)
+            return [];
+        // Continue the sieve process
+        let index = 1; // Start with the second element (index 1, which is 3)
+        function loop() {
+            // Get the current lucky number
+            const luckyNumber = filteredNumbers[index];
+            // Check if we should continue
+            return chain(predicate(luckyNumber, count), (keep) => {
+                if (!keep)
+                    return luckyNumbers;
+                // Add to result
+                luckyNumbers.push(luckyNumber);
+                count++;
+                // Apply the sieve
+                const step = luckyNumber;
+                const newFiltered = [];
+                for (let i = 0; i < filteredNumbers.length; i++) {
+                    if ((i + 1) % step !== 0) { // Keep numbers not at positions divisible by step
+                        newFiltered.push(filteredNumbers[i]);
+                    }
+                }
+                filteredNumbers = newFiltered;
+                index++;
+                // If we're running low on numbers, extend the sequence
+                if (index >= filteredNumbers.length - 5) {
+                    const lastNum = filteredNumbers[filteredNumbers.length - 1];
+                    let next = lastNum + 2;
+                    while (filteredNumbers.length < index + 1000) {
+                        filteredNumbers.push(next);
+                        next += 2;
+                    }
+                }
+                return loop();
+            });
         }
-    }
-    return luckyNumbers;
+        return loop();
+    });
 }
 /**
  * Generates lucky numbers up to a specified length or count
@@ -27818,32 +28416,37 @@ const padovanSequence = {
     'padovan?': n => isPadovan(n),
     'padovan-take-while': (takeWhile) => {
         const padovan = [];
-        if (!takeWhile(1, 0)) {
-            return padovan;
-        }
-        padovan.push(1);
-        if (!takeWhile(1, 1)) {
-            return padovan;
-        }
-        padovan.push(1);
-        if (!takeWhile(1, 2)) {
-            return padovan;
-        }
-        padovan.push(1);
-        let a = 1;
-        let b = 1;
-        let c = 1;
-        for (let i = 4;; i += 1) {
-            const temp = a + b;
-            a = b;
-            b = c;
-            c = temp;
-            if (!takeWhile(c, i)) {
-                break;
-            }
-            padovan.push(c);
-        }
-        return padovan;
+        return chain(takeWhile(1, 0), (keep0) => {
+            if (!keep0)
+                return padovan;
+            padovan.push(1);
+            return chain(takeWhile(1, 1), (keep1) => {
+                if (!keep1)
+                    return padovan;
+                padovan.push(1);
+                return chain(takeWhile(1, 2), (keep2) => {
+                    if (!keep2)
+                        return padovan;
+                    padovan.push(1);
+                    let a = 1;
+                    let b = 1;
+                    let c = 1;
+                    function loop(i) {
+                        const temp = a + b;
+                        a = b;
+                        b = c;
+                        c = temp;
+                        return chain(takeWhile(c, i), (keep) => {
+                            if (!keep)
+                                return padovan;
+                            padovan.push(c);
+                            return loop(i + 1);
+                        });
+                    }
+                    return loop(4);
+                });
+            });
+        });
     },
 };
 
@@ -27905,14 +28508,16 @@ const perfectCubeSequence = {
     'perfect-cube?': n => n > 0 && Number.isInteger(Math.cbrt(n)),
     'perfect-cube-take-while': (takeWhile) => {
         const perfectcubes = [];
-        for (let i = 1;; i++) {
+        function loop(i) {
             const value = i ** 3;
-            if (!takeWhile(value, i)) {
-                break;
-            }
-            perfectcubes.push(value);
+            return chain(takeWhile(value, i), (keep) => {
+                if (!keep)
+                    return perfectcubes;
+                perfectcubes.push(value);
+                return loop(i + 1);
+            });
         }
-        return perfectcubes;
+        return loop(1);
     },
 };
 
@@ -27957,15 +28562,17 @@ const perfectPowerSequence = {
     'perfect-power?': n => perfectPower(n) !== null,
     'perfect-power-take-while': (takeWhile) => {
         const perfectPowers = [];
-        for (let i = 1;; i++) {
-            if (perfectPower(i)) {
-                if (!takeWhile(i, perfectPowers.length)) {
-                    break;
-                }
+        function loop(i) {
+            if (!perfectPower(i))
+                return loop(i + 1);
+            return chain(takeWhile(i, perfectPowers.length), (keep) => {
+                if (!keep)
+                    return perfectPowers;
                 perfectPowers.push(i);
-            }
+                return loop(i + 1);
+            });
         }
-        return perfectPowers;
+        return loop(1);
     },
 };
 
@@ -27980,14 +28587,16 @@ const perfectSquareSequence = {
     'perfect-square?': n => n > 0 && Number.isInteger(Math.sqrt(n)),
     'perfect-square-take-while': (takeWhile) => {
         const perfectSquares = [];
-        for (let i = 1;; i++) {
+        function loop(i) {
             const value = i ** 2;
-            if (!takeWhile(value, i)) {
-                break;
-            }
-            perfectSquares.push(value);
+            return chain(takeWhile(value, i), (keep) => {
+                if (!keep)
+                    return perfectSquares;
+                perfectSquares.push(value);
+                return loop(i + 1);
+            });
         }
-        return perfectSquares;
+        return loop(1);
     },
 };
 
@@ -28008,15 +28617,19 @@ const poligonalNormalExpressions = {
         evaluate: ([sides, fn], sourceCodeInfo, contextStack, { executeFunction }) => {
             assertNumber(sides, sourceCodeInfo, { integer: true, gte: 3 });
             assertFunctionLike(fn, sourceCodeInfo);
+            const s = sides;
+            const f = fn;
             const polygonal = [];
-            for (let i = 1;; i += 1) {
-                const value = (i * i * (sides - 2) - i * (sides - 4)) / 2;
-                if (!(executeFunction)(fn, [value, i], contextStack, sourceCodeInfo)) {
-                    break;
-                }
-                polygonal[i - 1] = (i * i * (sides - 2) - i * (sides - 4)) / 2;
+            function loop(i) {
+                const value = (i * i * (s - 2) - i * (s - 4)) / 2;
+                return chain(executeFunction(f, [value, i], contextStack, sourceCodeInfo), (keep) => {
+                    if (!keep)
+                        return polygonal;
+                    polygonal.push(value);
+                    return loop(i + 1);
+                });
             }
-            return polygonal;
+            return loop(1);
         },
         arity: toFixedArity(2),
     },
@@ -28080,23 +28693,29 @@ function generateRecamanSequence(n) {
 const recamanSequence = {
     'recaman-seq': length => generateRecamanSequence(length),
     'recaman-take-while': (takeWhile) => {
-        if (!takeWhile(0, 0))
-            return [];
-        const sequence = [0];
+        const sequence = [];
         const seen = new Set([0]);
-        for (let i = 1;; i++) {
-            // Try to go backward
-            let next = sequence[i - 1] - i;
-            // If that's not positive or already seen, go forward
-            if (next <= 0 || seen.has(next)) {
-                next = sequence[i - 1] + i;
-            }
-            if (!takeWhile(next, i))
-                break;
-            sequence.push(next);
-            seen.add(next);
-        }
-        return sequence;
+        return chain(takeWhile(0, 0), (keepFirst) => {
+            if (!keepFirst)
+                return sequence;
+            sequence.push(0);
+            function loop(i) {
+                // Try to go backward
+                let next = sequence[i - 1] - i;
+                // If that's not positive or already seen, go forward
+                if (next <= 0 || seen.has(next)) {
+                    next = sequence[i - 1] + i;
+                }
+                return chain(takeWhile(next, i), (keep) => {
+                    if (!keep)
+                        return sequence;
+                    sequence.push(next);
+                    seen.add(next);
+                    return loop(i + 1);
+                });
+            }
+            return loop(1);
+        });
     },
     'recaman?': () => true,
 };
@@ -28120,14 +28739,16 @@ const thueMorseSequence = {
     },
     'thue-morse-take-while': (takeWhile) => {
         const thueMorse = [];
-        for (let i = 0;; i += 1) {
+        function loop(i) {
             const value = countSetBits(i) % 2;
-            if (!takeWhile(value, i)) {
-                break;
-            }
-            thueMorse[i] = value;
+            return chain(takeWhile(value, i), (keep) => {
+                if (!keep)
+                    return thueMorse;
+                thueMorse.push(value);
+                return loop(i + 1);
+            });
         }
-        return thueMorse;
+        return loop(0);
     },
     'thue-morse?': n => n === 1 || n === 0,
 };
@@ -28251,16 +28872,16 @@ function getFiniteNumberSequence(name, sequence) {
     return {
         [`${name}-seq`]: createSeqNormalExpression(length => sequence.slice(0, length), sequence.length),
         [`${name}-take-while`]: createTakeWhileNormalExpression((takeWhile) => {
-            let i = 0;
-            for (i = 0;; i += 1) {
-                if (i >= sequence.length) {
-                    break;
-                }
-                if (!takeWhile(sequence[i], i)) {
-                    break;
-                }
+            function loop(i) {
+                if (i >= sequence.length)
+                    return sequence.slice(0, i);
+                return chain(takeWhile(sequence[i], i), (keep) => {
+                    if (!keep)
+                        return sequence.slice(0, i);
+                    return loop(i + 1);
+                });
             }
-            return sequence.slice(0, i);
+            return loop(0);
         }, sequence.length),
         [`${name}-nth`]: createNthNormalExpression(() => sequence, sequence.length),
         [`${name}?`]: createNumberPredNormalExpression(n => sequence.includes(n)),
@@ -28313,14 +28934,16 @@ function createTakeWhileNormalExpression(takeWhileFunction, maxLength) {
         evaluate: (params, sourceCodeInfo, contextStack, { executeFunction }) => {
             const fn = params[0];
             assertFunctionLike(fn, sourceCodeInfo);
-            const result = takeWhileFunction((value, index) => !!executeFunction(fn, [value, index], contextStack), sourceCodeInfo);
-            if (typeof result[0] === 'number') {
-                /* v8 ignore next 3 */
-                if (result.some(n => n > Number.MAX_SAFE_INTEGER)) {
-                    throw new LitsError('Result exceeds maximum safe integer', sourceCodeInfo);
+            const result = takeWhileFunction((value, index) => chain(executeFunction(fn, [value, index], contextStack), val => !!val), sourceCodeInfo);
+            return chain(result, (resolved) => {
+                if (typeof resolved[0] === 'number') {
+                    /* v8 ignore next 3 */
+                    if (resolved.some(n => n > Number.MAX_SAFE_INTEGER)) {
+                        throw new LitsError('Result exceeds maximum safe integer', sourceCodeInfo);
+                    }
                 }
-            }
-            return result;
+                return resolved;
+            });
         },
         arity: typeof maxLength === 'number' ? { max: 1 } : toFixedArity(1),
     };
@@ -29789,38 +30412,30 @@ function update(coll, key, fn, params, contextStack, executeFunction, sourceCode
     if (isObj(coll)) {
         assertString(key, sourceCodeInfo);
         const result = { ...coll };
-        result[key] = executeFunction(fn, [result[key], ...params], contextStack, sourceCodeInfo);
-        return result;
+        return chain(executeFunction(fn, [result[key], ...params], contextStack, sourceCodeInfo), (val) => {
+            result[key] = val;
+            return result;
+        });
     }
     else {
         assertNumber(key, sourceCodeInfo);
         const intKey = toNonNegativeInteger(key);
         assertNumber(intKey, sourceCodeInfo, { lte: coll.length });
         if (Array.isArray(coll)) {
-            const result = coll.map((elem, index) => {
+            return chain(mapSequential(Array.from({ length: coll.length + (intKey === coll.length ? 1 : 0) }), (_, index) => {
                 if (intKey === index)
-                    return executeFunction(fn, [elem, ...params], contextStack, sourceCodeInfo);
-                return elem;
-            });
-            if (intKey === coll.length)
-                result[intKey] = executeFunction(fn, [undefined, ...params], contextStack, sourceCodeInfo);
-            return result;
+                    return executeFunction(fn, [coll[index], ...params], contextStack, sourceCodeInfo);
+                return coll[index];
+            }), result => result);
         }
         else {
-            const result = coll.split('').map((elem, index) => {
+            const chars = coll.split('');
+            return chain(mapSequential(Array.from({ length: chars.length + (intKey === chars.length ? 1 : 0) }), (_, index) => {
                 if (intKey === index) {
-                    return asString(executeFunction(fn, [elem, ...params], contextStack, sourceCodeInfo), sourceCodeInfo, {
-                        char: true,
-                    });
+                    return chain(executeFunction(fn, [chars[index], ...params], contextStack, sourceCodeInfo), val => asString(val, sourceCodeInfo, { char: true }));
                 }
-                return elem;
-            });
-            if (intKey === coll.length) {
-                result[intKey] = asString(executeFunction(fn, [undefined, ...params], contextStack, sourceCodeInfo), sourceCodeInfo, {
-                    char: true,
-                });
-            }
-            return result.join('');
+                return chars[index];
+            }), result => result.join(''));
         }
     }
 }
@@ -30025,13 +30640,18 @@ cu.update(
             const parentKey = asStringOrNumber(keys[keys.length - 2], sourceCodeInfo);
             if (Array.isArray(innerCollMeta.parent)) {
                 assertNumber(parentKey, sourceCodeInfo);
-                innerCollMeta.parent[parentKey] = update(innerCollMeta.coll, lastKey, fn, params, contextStack, executeFunction, sourceCodeInfo);
+                return chain(update(innerCollMeta.coll, lastKey, fn, params, contextStack, executeFunction, sourceCodeInfo), (updated) => {
+                    innerCollMeta.parent[parentKey] = updated;
+                    return coll;
+                });
             }
             else {
                 assertString(parentKey, sourceCodeInfo);
-                innerCollMeta.parent[parentKey] = update(innerCollMeta.coll, lastKey, fn, params, contextStack, executeFunction, sourceCodeInfo);
+                return chain(update(innerCollMeta.coll, lastKey, fn, params, contextStack, executeFunction, sourceCodeInfo), (updated) => {
+                    innerCollMeta.parent[parentKey] = updated;
+                    return coll;
+                });
             }
-            return coll;
         },
         arity: { min: 3 },
         docs: {
@@ -30092,21 +30712,15 @@ cu.update-in(
             assertColl(coll, sourceCodeInfo);
             assertFunctionLike(fn, sourceCodeInfo);
             if (Array.isArray(coll)) {
-                const result = coll.filter((elem, index) => executeFunction(fn, [elem, index], contextStack, sourceCodeInfo));
-                return result;
+                return filterSequential(coll, (elem, index) => executeFunction(fn, [elem, index], contextStack, sourceCodeInfo));
             }
             if (typeof coll === 'string') {
-                return coll
-                    .split('')
-                    .filter((elem, index) => executeFunction(fn, [elem, index], contextStack, sourceCodeInfo))
-                    .join('');
+                return chain(filterSequential(coll.split(''), (elem, index) => executeFunction(fn, [elem, index], contextStack, sourceCodeInfo)), filtered => filtered.join(''));
             }
-            return Object.entries(coll)
-                .filter(([key, value]) => executeFunction(fn, [value, key], contextStack, sourceCodeInfo))
-                .reduce((result, [key, value]) => {
+            return chain(filterSequential(Object.entries(coll), ([key, value]) => executeFunction(fn, [value, key], contextStack, sourceCodeInfo)), filtered => filtered.reduce((result, [key, value]) => {
                 result[key] = value;
                 return result;
-            }, {});
+            }, {}));
         },
         arity: toFixedArity(2),
         docs: {
@@ -30134,18 +30748,17 @@ cu.update-in(
             assertColl(coll, sourceCodeInfo);
             assertFunctionLike(fn, sourceCodeInfo);
             if (Array.isArray(coll)) {
-                return coll.map((elem, index) => executeFunction(fn, [elem, index], contextStack, sourceCodeInfo));
+                return mapSequential(coll, (elem, index) => executeFunction(fn, [elem, index], contextStack, sourceCodeInfo));
             }
             if (typeof coll === 'string') {
-                return coll
-                    .split('')
-                    .map((elem, index) => executeFunction(fn, [elem, index], contextStack, sourceCodeInfo))
-                    .join('');
+                return chain(mapSequential(coll.split(''), (elem, index) => executeFunction(fn, [elem, index], contextStack, sourceCodeInfo)), mapped => mapped.join(''));
             }
-            return Object.entries(coll)
-                .reduce((acc, [key, value]) => {
-                acc[key] = executeFunction(fn, [value, key], contextStack, sourceCodeInfo);
-                return acc;
+            const entries = Object.entries(coll);
+            return reduceSequential(entries, (acc, [key, value]) => {
+                return chain(executeFunction(fn, [value, key], contextStack, sourceCodeInfo), (result) => {
+                    acc[key] = result;
+                    return acc;
+                });
             }, {});
         },
         arity: toFixedArity(2),
@@ -30180,23 +30793,17 @@ cu.update-in(
                 assertString(initial, sourceCodeInfo);
                 if (coll.length === 0)
                     return initial;
-                return coll.split('').reduce((result, elem, index) => {
-                    return executeFunction(fn, [result, elem, index], contextStack, sourceCodeInfo);
-                }, initial);
+                return reduceSequential(coll.split('').map((elem, index) => ({ elem, index })), (result, { elem, index }) => executeFunction(fn, [result, elem, index], contextStack, sourceCodeInfo), initial);
             }
             else if (Array.isArray(coll)) {
                 if (coll.length === 0)
                     return initial;
-                return coll.reduce((result, elem, index) => {
-                    return executeFunction(fn, [result, elem, index], contextStack, sourceCodeInfo);
-                }, initial);
+                return reduceSequential(coll.map((elem, index) => ({ elem, index })), (result, { elem, index }) => executeFunction(fn, [result, elem, index], contextStack, sourceCodeInfo), initial);
             }
             else {
                 if (Object.keys(coll).length === 0)
                     return initial;
-                return Object.entries(coll).reduce((result, [key, elem]) => {
-                    return executeFunction(fn, [result, elem, key], contextStack, sourceCodeInfo);
-                }, initial);
+                return reduceSequential(Object.entries(coll), (result, [key, elem]) => executeFunction(fn, [result, elem, key], contextStack, sourceCodeInfo), initial);
             }
         },
         arity: toFixedArity(3),
@@ -30232,23 +30839,17 @@ cu.update-in(
             if (typeof coll === 'string') {
                 if (coll.length === 0)
                     return initial;
-                return coll.split('').reduceRight((result, elem) => {
-                    return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
-                }, initial);
+                return reduceSequential(Array.from(coll.split('')).reverse(), (result, elem) => executeFunction(fn, [result, elem], contextStack, sourceCodeInfo), initial);
             }
             else if (Array.isArray(coll)) {
                 if (coll.length === 0)
                     return initial;
-                return coll.reduceRight((result, elem) => {
-                    return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
-                }, initial);
+                return reduceSequential(Array.from(coll).reverse(), (result, elem) => executeFunction(fn, [result, elem], contextStack, sourceCodeInfo), initial);
             }
             else {
                 if (Object.keys(coll).length === 0)
                     return initial;
-                return Object.entries(coll).reduceRight((result, [, elem]) => {
-                    return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
-                }, initial);
+                return reduceSequential(Object.entries(coll).reverse(), (result, [, elem]) => executeFunction(fn, [result, elem], contextStack, sourceCodeInfo), initial);
             }
         },
         arity: toFixedArity(3),
@@ -30277,23 +30878,17 @@ cu.update-in(
             if (typeof coll === 'string') {
                 if (coll.length === 0)
                     return initial;
-                return coll.split('').reduceRight((result, elem, index) => {
-                    return executeFunction(fn, [result, elem, index], contextStack, sourceCodeInfo);
-                }, initial);
+                return reduceSequential(Array.from(coll.split('')).reverse().map((elem, _, arr) => ({ elem, index: arr.length - 1 - _ })), (result, { elem, index }) => executeFunction(fn, [result, elem, index], contextStack, sourceCodeInfo), initial);
             }
             else if (Array.isArray(coll)) {
                 if (coll.length === 0)
                     return initial;
-                return coll.reduceRight((result, elem, index) => {
-                    return executeFunction(fn, [result, elem, index], contextStack, sourceCodeInfo);
-                }, initial);
+                return reduceSequential(Array.from(coll).reverse().map((elem, _, arr) => ({ elem, index: arr.length - 1 - _ })), (result, { elem, index }) => executeFunction(fn, [result, elem, index], contextStack, sourceCodeInfo), initial);
             }
             else {
                 if (Object.keys(coll).length === 0)
                     return initial;
-                return Object.entries(coll).reduceRight((result, [key, elem]) => {
-                    return executeFunction(fn, [result, elem, key], contextStack, sourceCodeInfo);
-                }, initial);
+                return reduceSequential(Object.entries(coll).reverse(), (result, [key, elem]) => executeFunction(fn, [result, elem, key], contextStack, sourceCodeInfo), initial);
             }
         },
         arity: toFixedArity(3),
@@ -30327,40 +30922,20 @@ cu.update-in(
             assertFunctionLike(fn, sourceCodeInfo);
             assertAny(initial, sourceCodeInfo);
             assertAny(initial, sourceCodeInfo);
-            if (typeof coll === 'string') {
-                assertString(initial, sourceCodeInfo);
-                if (coll.length === 0)
-                    return [initial];
-                const resultArray = [initial];
-                coll.split('').reduce((result, elem) => {
-                    const newVal = executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
+            const items = typeof coll === 'string'
+                ? (assertString(initial, sourceCodeInfo), coll.length === 0 ? [] : coll.split(''))
+                : Array.isArray(coll)
+                    ? (coll.length === 0 ? [] : Array.from(coll))
+                    : (Object.keys(coll).length === 0 ? [] : Object.entries(coll).map(([, v]) => v));
+            if (items.length === 0)
+                return [initial];
+            const resultArray = [initial];
+            return chain(reduceSequential(items, (result, elem) => {
+                return chain(executeFunction(fn, [result, elem], contextStack, sourceCodeInfo), (newVal) => {
                     resultArray.push(newVal);
                     return newVal;
-                }, initial);
-                return resultArray;
-            }
-            else if (Array.isArray(coll)) {
-                if (coll.length === 0)
-                    return [initial];
-                const resultArray = [initial];
-                coll.reduce((result, elem) => {
-                    const newVal = executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
-                    resultArray.push(newVal);
-                    return newVal;
-                }, initial);
-                return resultArray;
-            }
-            else {
-                if (Object.keys(coll).length === 0)
-                    return [initial];
-                const resultArray = [initial];
-                Object.entries(coll).reduce((result, [, elem]) => {
-                    const newVal = executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
-                    resultArray.push(newVal);
-                    return newVal;
-                }, initial);
-                return resultArray;
-            }
+                });
+            }, initial), () => resultArray);
         },
         arity: toFixedArity(3),
         docs: {
@@ -30395,40 +30970,21 @@ cu.reductions(
             assertFunctionLike(fn, sourceCodeInfo);
             assertAny(initial, sourceCodeInfo);
             assertAny(initial, sourceCodeInfo);
-            if (typeof coll === 'string') {
-                assertString(initial, sourceCodeInfo);
-                if (coll.length === 0)
-                    return [initial];
-                const resultArray = [initial];
-                coll.split('').reduce((result, elem, index) => {
-                    const newVal = executeFunction(fn, [result, elem, index], contextStack, sourceCodeInfo);
+            const toIndexedItem = (elem, key) => ({ elem, key });
+            const items = typeof coll === 'string'
+                ? (assertString(initial, sourceCodeInfo), coll.length === 0 ? [] : coll.split('').map((elem, index) => toIndexedItem(elem, index)))
+                : Array.isArray(coll)
+                    ? (coll.length === 0 ? [] : coll.map((elem, index) => toIndexedItem(elem, index)))
+                    : (Object.keys(coll).length === 0 ? [] : Object.entries(coll).map(([key, v]) => toIndexedItem(v, key)));
+            if (items.length === 0)
+                return [initial];
+            const resultArray = [initial];
+            return chain(reduceSequential(items, (result, { elem, key }) => {
+                return chain(executeFunction(fn, [result, elem, key], contextStack, sourceCodeInfo), (newVal) => {
                     resultArray.push(newVal);
                     return newVal;
-                }, initial);
-                return resultArray;
-            }
-            else if (Array.isArray(coll)) {
-                if (coll.length === 0)
-                    return [initial];
-                const resultArray = [initial];
-                coll.reduce((result, elem, index) => {
-                    const newVal = executeFunction(fn, [result, elem, index], contextStack, sourceCodeInfo);
-                    resultArray.push(newVal);
-                    return newVal;
-                }, initial);
-                return resultArray;
-            }
-            else {
-                if (Object.keys(coll).length === 0)
-                    return [initial];
-                const resultArray = [initial];
-                Object.entries(coll).reduce((result, [key, elem]) => {
-                    const newVal = executeFunction(fn, [result, elem, key], contextStack, sourceCodeInfo);
-                    resultArray.push(newVal);
-                    return newVal;
-                }, initial);
-                return resultArray;
-            }
+                });
+            }, initial), () => resultArray);
         },
         arity: toFixedArity(3),
         docs: {
@@ -30491,11 +31047,12 @@ cu.reductions(
         evaluate: ([coll, fn], sourceCodeInfo, contextStack, { executeFunction }) => {
             assertColl(coll, sourceCodeInfo);
             assertFunctionLike(fn, sourceCodeInfo);
-            if (Array.isArray(coll))
-                return coll.every(elem => executeFunction(fn, [elem], contextStack, sourceCodeInfo));
-            if (typeof coll === 'string')
-                return coll.split('').every(elem => executeFunction(fn, [elem], contextStack, sourceCodeInfo));
-            return Object.entries(coll).every(elem => executeFunction(fn, [elem], contextStack, sourceCodeInfo));
+            const arr = Array.isArray(coll)
+                ? coll
+                : typeof coll === 'string'
+                    ? coll.split('')
+                    : Object.entries(coll);
+            return everySequential(arr, elem => executeFunction(fn, [elem], contextStack, sourceCodeInfo));
         },
         arity: toFixedArity(2),
         docs: {
@@ -30545,11 +31102,12 @@ cu.every?(
         evaluate: ([coll, fn], sourceCodeInfo, contextStack, { executeFunction }) => {
             assertFunctionLike(fn, sourceCodeInfo);
             assertColl(coll, sourceCodeInfo);
-            if (Array.isArray(coll))
-                return coll.some(elem => executeFunction(fn, [elem], contextStack, sourceCodeInfo));
-            if (typeof coll === 'string')
-                return coll.split('').some(elem => executeFunction(fn, [elem], contextStack, sourceCodeInfo));
-            return Object.entries(coll).some(elem => executeFunction(fn, [elem], contextStack, sourceCodeInfo));
+            const arr = Array.isArray(coll)
+                ? coll
+                : typeof coll === 'string'
+                    ? coll.split('')
+                    : Object.entries(coll);
+            return someSequential(arr, elem => executeFunction(fn, [elem], contextStack, sourceCodeInfo));
         },
         arity: toFixedArity(2),
         docs: {
@@ -30597,11 +31155,12 @@ cu.any?(
         evaluate: ([coll, fn], sourceCodeInfo, contextStack, { executeFunction }) => {
             assertFunctionLike(fn, sourceCodeInfo);
             assertColl(coll, sourceCodeInfo);
-            if (Array.isArray(coll))
-                return !coll.some(elem => executeFunction(fn, [elem], contextStack, sourceCodeInfo));
-            if (typeof coll === 'string')
-                return !coll.split('').some(elem => executeFunction(fn, [elem], contextStack, sourceCodeInfo));
-            return !Object.entries(coll).some(elem => executeFunction(fn, [elem], contextStack, sourceCodeInfo));
+            const arr = Array.isArray(coll)
+                ? coll
+                : typeof coll === 'string'
+                    ? coll.split('')
+                    : Object.entries(coll);
+            return chain(someSequential(arr, elem => executeFunction(fn, [elem], contextStack, sourceCodeInfo)), result => !result);
         },
         arity: toFixedArity(2),
         docs: {
@@ -30649,11 +31208,12 @@ cu.not-any?(
         evaluate: ([coll, fn], sourceCodeInfo, contextStack, { executeFunction }) => {
             assertFunctionLike(fn, sourceCodeInfo);
             assertColl(coll, sourceCodeInfo);
-            if (Array.isArray(coll))
-                return !coll.every(elem => executeFunction(fn, [elem], contextStack, sourceCodeInfo));
-            if (typeof coll === 'string')
-                return !coll.split('').every(elem => executeFunction(fn, [elem], contextStack, sourceCodeInfo));
-            return !Object.entries(coll).every(elem => executeFunction(fn, [elem], contextStack, sourceCodeInfo));
+            const arr = Array.isArray(coll)
+                ? coll
+                : typeof coll === 'string'
+                    ? coll.split('')
+                    : Object.entries(coll);
+            return chain(everySequential(arr, elem => executeFunction(fn, [elem], contextStack, sourceCodeInfo)), result => !result);
         },
         arity: toFixedArity(2),
         docs: {
@@ -30710,14 +31270,8 @@ const sequenceUtilsFunctions = {
             if (seq === null)
                 return null;
             assertSeq(seq, sourceCodeInfo);
-            if (typeof seq === 'string') {
-                const index = seq.split('').findIndex(elem => executeFunction(fn, [elem], contextStack, sourceCodeInfo));
-                return index !== -1 ? index : null;
-            }
-            else {
-                const index = seq.findIndex(elem => executeFunction(fn, [elem], contextStack, sourceCodeInfo));
-                return index !== -1 ? index : null;
-            }
+            const arr = typeof seq === 'string' ? seq.split('') : seq;
+            return chain(findIndexSequential(arr, elem => executeFunction(fn, [elem], contextStack, sourceCodeInfo)), index => index !== -1 ? index : null);
         },
         arity: toFixedArity(2),
         docs: {
@@ -30864,50 +31418,39 @@ su.position(
             assertSeq(seq, sourceCodeInfo);
             assertFunctionLike(keyfn, sourceCodeInfo);
             const comparer = defaultComparer ? null : params[2];
-            if (typeof seq === 'string') {
-                const result = seq.split('');
+            const isString = typeof seq === 'string';
+            const arr = isString ? seq.split('') : [...seq];
+            // Pre-compute all keys using mapSequential (async-safe)
+            return chain(mapSequential(arr, elem => executeFunction(keyfn, [elem], contextStack, sourceCodeInfo)), (keys) => {
                 if (defaultComparer) {
-                    result.sort((a, b) => {
-                        const aKey = executeFunction(keyfn, [a], contextStack, sourceCodeInfo);
-                        assertStringOrNumber(aKey, sourceCodeInfo);
-                        const bKey = executeFunction(keyfn, [b], contextStack, sourceCodeInfo);
-                        assertStringOrNumber(bKey, sourceCodeInfo);
-                        return compare(aKey, bKey, sourceCodeInfo);
+                    // Create indexed pairs, sort by pre-computed keys
+                    const indexed = arr.map((elem, i) => ({ elem, key: keys[i] }));
+                    indexed.sort((a, b) => {
+                        assertStringOrNumber(a.key, sourceCodeInfo);
+                        assertStringOrNumber(b.key, sourceCodeInfo);
+                        return compare(a.key, b.key, sourceCodeInfo);
                     });
+                    const sorted = indexed.map(x => x.elem);
+                    return isString ? sorted.join('') : sorted;
                 }
                 else {
                     assertFunctionLike(comparer, sourceCodeInfo);
-                    result.sort((a, b) => {
-                        const aKey = executeFunction(keyfn, [a], contextStack, sourceCodeInfo);
-                        const bKey = executeFunction(keyfn, [b], contextStack, sourceCodeInfo);
-                        const compareValue = executeFunction(comparer, [aKey, bKey], contextStack, sourceCodeInfo);
+                    // Pre-compute keys, then need pairwise comparisons — these may also be async
+                    // For sort-by with custom comparer, we must use a non-async sort since
+                    // Array.sort requires sync comparators
+                    const indexed = arr.map((elem, i) => ({ elem, key: keys[i] }));
+                    indexed.sort((a, b) => {
+                        const compareValue = executeFunction(comparer, [a.key, b.key], contextStack, sourceCodeInfo);
+                        if (compareValue instanceof Promise) {
+                            throw new TypeError('Async functions cannot be used as sort-by comparators');
+                        }
                         assertNumber(compareValue, sourceCodeInfo, { finite: true });
                         return compareValue;
                     });
+                    const sorted = indexed.map(x => x.elem);
+                    return isString ? sorted.join('') : sorted;
                 }
-                return result.join('');
-            }
-            const result = [...seq];
-            if (defaultComparer) {
-                result.sort((a, b) => {
-                    const aKey = executeFunction(keyfn, [a], contextStack, sourceCodeInfo);
-                    assertStringOrNumber(aKey, sourceCodeInfo);
-                    const bKey = executeFunction(keyfn, [b], contextStack, sourceCodeInfo);
-                    assertStringOrNumber(bKey, sourceCodeInfo);
-                    return compare(aKey, bKey, sourceCodeInfo);
-                });
-            }
-            else {
-                assertFunctionLike(comparer, sourceCodeInfo);
-                result.sort((a, b) => {
-                    const aKey = executeFunction(keyfn, [a], contextStack, sourceCodeInfo);
-                    const bKey = executeFunction(keyfn, [b], contextStack, sourceCodeInfo);
-                    const compareValue = executeFunction(comparer, [aKey, bKey], contextStack, sourceCodeInfo);
-                    assertNumber(compareValue, sourceCodeInfo, { finite: true });
-                    return compareValue;
-                });
-            }
-            return result;
+            });
         },
         arity: { min: 2, max: 3 },
         docs: {
@@ -30933,202 +31476,6 @@ su.position(
             ],
         },
     },
-    'take': {
-        evaluate: ([input, n], sourceCodeInfo) => {
-            assertNumber(n, sourceCodeInfo);
-            assertSeq(input, sourceCodeInfo);
-            const num = Math.max(Math.ceil(n), 0);
-            return input.slice(0, num);
-        },
-        arity: toFixedArity(2),
-        docs: {
-            category: 'sequence',
-            returns: { type: 'sequence' },
-            args: {
-                a: { type: 'sequence' },
-                b: { type: 'integer' },
-                n: { type: 'integer' },
-                seq: { type: 'sequence' },
-            },
-            variants: [{ argumentNames: ['seq', 'n'] }],
-            description: 'Constructs a new array/string with the $n first elements from $seq.',
-            seeAlso: ['sequence.take-last', 'sequence.take-while', 'sequence.drop', 'slice', 'sequence.split-at'],
-            examples: [
-                'let su = import("sequence"); su.take([1, 2, 3, 4, 5], 3)',
-                'let su = import("sequence"); su.take([1, 2, 3, 4, 5], 3)',
-                'let su = import("sequence"); su.take([1, 2, 3, 4, 5], 0)',
-                'let su = import("sequence"); su.take("Albert", 2)',
-                'let su = import("sequence"); su.take("Albert", 50)',
-            ],
-        },
-    },
-    'take-last': {
-        evaluate: ([array, n], sourceCodeInfo) => {
-            assertSeq(array, sourceCodeInfo);
-            assertNumber(n, sourceCodeInfo);
-            const num = Math.max(Math.ceil(n), 0);
-            const from = array.length - num;
-            return array.slice(from);
-        },
-        arity: toFixedArity(2),
-        docs: {
-            category: 'sequence',
-            returns: { type: 'sequence' },
-            args: {
-                a: { type: 'sequence' },
-                b: { type: 'integer' },
-                n: { type: 'integer' },
-                seq: { type: 'sequence' },
-            },
-            variants: [{ argumentNames: ['n', 'seq'] }],
-            description: 'Constructs a new array with the $n last elements from $seq.',
-            seeAlso: ['sequence.take', 'sequence.drop-last'],
-            examples: [
-                'let su = import("sequence"); su.take-last([1, 2, 3, 4, 5], 3)',
-                'let su = import("sequence"); su.take-last([1, 2, 3, 4, 5], 3)',
-                'let su = import("sequence"); su.take-last([1, 2, 3, 4, 5], 0)',
-            ],
-        },
-    },
-    'take-while': {
-        evaluate: ([seq, fn], sourceCodeInfo, contextStack, { executeFunction }) => {
-            assertSeq(seq, sourceCodeInfo);
-            assertFunctionLike(fn, sourceCodeInfo);
-            const result = [];
-            for (const item of seq) {
-                if (executeFunction(fn, [item], contextStack, sourceCodeInfo))
-                    result.push(item);
-                else
-                    break;
-            }
-            return typeof seq === 'string' ? result.join('') : result;
-        },
-        arity: toFixedArity(2),
-        docs: {
-            category: 'sequence',
-            returns: { type: 'sequence' },
-            args: {
-                a: { type: 'sequence' },
-                b: { type: 'function' },
-                seq: { type: 'sequence' },
-                fun: { type: 'function' },
-            },
-            variants: [{ argumentNames: ['seq', 'fun'] }],
-            description: 'Returns the members of $seq in order, stopping before the first one for which `predicate` returns a falsy value.',
-            seeAlso: ['sequence.take', 'sequence.drop-while', 'sequence.split-with'],
-            examples: [
-                `
-let su = import("sequence");
-su.take-while(
-  [1, 2, 3, 2, 1],
-  -> $ < 3
-)`,
-                `
-let su = import("sequence");
-su.take-while(
-  [1, 2, 3, 2, 1],
-  -> $ > 3
-)`,
-            ],
-        },
-    },
-    'drop': {
-        evaluate: ([input, n], sourceCodeInfo) => {
-            assertNumber(n, sourceCodeInfo);
-            const num = Math.max(Math.ceil(n), 0);
-            assertSeq(input, sourceCodeInfo);
-            return input.slice(num);
-        },
-        arity: toFixedArity(2),
-        docs: {
-            category: 'sequence',
-            returns: { type: 'sequence' },
-            args: {
-                a: { type: 'sequence' },
-                b: { type: 'integer' },
-                seq: { type: 'sequence' },
-                n: { type: 'integer' },
-            },
-            variants: [{ argumentNames: ['seq', 'n'] }],
-            description: 'Constructs a new array/string with the $n first elements dropped from $seq.',
-            seeAlso: ['sequence.drop-last', 'sequence.drop-while', 'sequence.take', 'slice', 'sequence.split-at'],
-            examples: [
-                'let su = import("sequence"); su.drop([1, 2, 3, 4, 5], 3)',
-                'let su = import("sequence"); su.drop([1, 2, 3, 4, 5], 0)',
-                'let su = import("sequence"); su.drop("Albert", 2)',
-                'let su = import("sequence"); su.drop("Albert", 50)',
-            ],
-        },
-    },
-    'drop-last': {
-        evaluate: ([array, n], sourceCodeInfo) => {
-            assertSeq(array, sourceCodeInfo);
-            assertNumber(n, sourceCodeInfo);
-            const num = Math.max(Math.ceil(n), 0);
-            const from = array.length - num;
-            return array.slice(0, from);
-        },
-        arity: toFixedArity(2),
-        docs: {
-            category: 'sequence',
-            returns: { type: 'sequence' },
-            args: {
-                a: { type: 'sequence' },
-                b: { type: 'integer' },
-                seq: { type: 'sequence' },
-                n: { type: 'integer' },
-            },
-            variants: [{ argumentNames: ['seq', 'n'] }],
-            description: 'Constructs a new array with the $n last elements dropped from $seq.',
-            seeAlso: ['sequence.drop', 'sequence.take-last'],
-            examples: [
-                'let su = import("sequence"); su.drop-last([1, 2, 3, 4, 5], 3)',
-                'let su = import("sequence"); su.drop-last([1, 2, 3, 4, 5], 3)',
-                'let su = import("sequence"); su.drop-last([1, 2, 3, 4, 5], 0)',
-            ],
-        },
-    },
-    'drop-while': {
-        evaluate: ([seq, fn], sourceCodeInfo, contextStack, { executeFunction }) => {
-            assertSeq(seq, sourceCodeInfo);
-            assertFunctionLike(fn, sourceCodeInfo);
-            if (Array.isArray(seq)) {
-                const from = seq.findIndex(elem => !executeFunction(fn, [elem], contextStack, sourceCodeInfo));
-                return seq.slice(from);
-            }
-            const charArray = seq.split('');
-            const from = charArray.findIndex(elem => !executeFunction(fn, [elem], contextStack, sourceCodeInfo));
-            return charArray.slice(from).join('');
-        },
-        arity: toFixedArity(2),
-        docs: {
-            category: 'sequence',
-            returns: { type: 'sequence' },
-            args: {
-                a: { type: 'sequence' },
-                b: { type: 'function' },
-                seq: { type: 'sequence' },
-                fun: { type: 'function' },
-            },
-            variants: [{ argumentNames: ['seq', 'fun'] }],
-            description: 'Returns the members of $seq in order, skipping the fist elements for witch the `predicate` returns a truethy value.',
-            seeAlso: ['sequence.drop', 'sequence.take-while', 'sequence.split-with'],
-            examples: [
-                `
-let su = import("sequence");
-su.drop-while(
-  [1, 2, 3, 2, 1],
-  -> $ < 3
-)`,
-                `
-let su = import("sequence");
-su.drop-while(
-  [1, 2, 3, 2, 1],
-  -> $ > 3
-)`,
-            ],
-        },
-    },
     'unshift': {
         evaluate: ([seq, ...values], sourceCodeInfo) => {
             assertSeq(seq, sourceCodeInfo);
@@ -31201,12 +31548,8 @@ l`,
         evaluate: ([input, fn], sourceCodeInfo, contextStack, { executeFunction }) => {
             assertFunctionLike(fn, sourceCodeInfo);
             assertSeq(input, sourceCodeInfo);
-            if (Array.isArray(input))
-                return input.filter(elem => !executeFunction(fn, [elem], contextStack, sourceCodeInfo));
-            return input
-                .split('')
-                .filter(elem => !executeFunction(fn, [elem], contextStack, sourceCodeInfo))
-                .join('');
+            const arr = Array.isArray(input) ? input : input.split('');
+            return chain(filterSequential(arr, elem => chain(executeFunction(fn, [elem], contextStack, sourceCodeInfo), result => !result)), filtered => typeof input === 'string' ? filtered.join('') : filtered);
         },
         arity: toFixedArity(2),
         docs: {
@@ -31281,7 +31624,7 @@ l`,
             },
             variants: [{ argumentNames: ['seq', 'n'] }],
             description: 'Returns a pair of sequence `[take(pos input), drop(pos input)]`.',
-            seeAlso: ['sequence.split-with', 'sequence.take', 'sequence.drop'],
+            seeAlso: ['sequence.split-with', 'take', 'drop'],
             examples: [
                 'let su = import("sequence"); su.split-at([1, 2, 3, 4, 5], 2)',
                 'let su = import("sequence"); su.split-at("Albert", -2)',
@@ -31296,10 +31639,11 @@ l`,
             assertSeq(seq, sourceCodeInfo);
             const seqIsArray = Array.isArray(seq);
             const arr = seqIsArray ? seq : seq.split('');
-            const index = arr.findIndex(elem => !executeFunction(fn, [elem], contextStack, sourceCodeInfo));
-            if (index === -1)
-                return [seq, seqIsArray ? [] : ''];
-            return [seq.slice(0, index), seq.slice(index)];
+            return chain(findIndexSequential(arr, elem => chain(executeFunction(fn, [elem], contextStack, sourceCodeInfo), result => !result)), (index) => {
+                if (index === -1)
+                    return [seq, seqIsArray ? [] : ''];
+                return [seq.slice(0, index), seq.slice(index)];
+            });
         },
         arity: toFixedArity(2),
         docs: {
@@ -31313,7 +31657,7 @@ l`,
             },
             variants: [{ argumentNames: ['seq', 'fun'] }],
             description: 'Returns a pair of sequences `[take-while(input, fun), drop-while(input, fun)]`.',
-            seeAlso: ['sequence.split-at', 'sequence.take-while', 'sequence.drop-while'],
+            seeAlso: ['sequence.split-at', 'take-while', 'drop-while'],
             examples: [
                 'let su = import("sequence"); su.split-with([1, 2, 3, 4, 5], odd?)',
                 'let su = import("sequence"); su.split-with([1, 2, 3, 4, 5], -> $ > 3)',
@@ -31353,13 +31697,14 @@ l`,
             assertFunctionLike(fn, sourceCodeInfo);
             assertSeq(seq, sourceCodeInfo);
             const arr = Array.isArray(seq) ? seq : seq.split('');
-            return arr.reduce((result, val) => {
-                const key = executeFunction(fn, [val], contextStack, sourceCodeInfo);
-                assertString(key, sourceCodeInfo);
-                if (!collHasKey(result, key))
-                    result[key] = [];
-                result[key].push(val);
-                return result;
+            return reduceSequential(arr, (result, val) => {
+                return chain(executeFunction(fn, [val], contextStack, sourceCodeInfo), (key) => {
+                    assertString(key, sourceCodeInfo);
+                    if (!collHasKey(result, key))
+                        result[key] = [];
+                    result[key].push(val);
+                    return result;
+                });
             }, {});
         },
         arity: toFixedArity(2),
@@ -31468,17 +31813,17 @@ l`,
             assertFunctionLike(fn, sourceCodeInfo);
             assertSeq(seq, sourceCodeInfo);
             const isStringSeq = typeof seq === 'string';
-            let oldValue;
-            const result = (isStringSeq ? seq.split('') : seq).reduce((acc, elem) => {
-                const value = executeFunction(fn, [elem], contextStack, sourceCodeInfo);
-                if (value !== oldValue) {
-                    acc.push([]);
-                    oldValue = value;
-                }
-                acc[acc.length - 1].push(elem);
-                return acc;
-            }, []);
-            return isStringSeq ? result.map(elem => elem.join('')) : result;
+            const arr = isStringSeq ? seq.split('') : seq;
+            return chain(reduceSequential(arr, (acc, elem) => {
+                return chain(executeFunction(fn, [elem], contextStack, sourceCodeInfo), (value) => {
+                    if (value !== acc.oldValue) {
+                        acc.result.push([]);
+                        acc.oldValue = value;
+                    }
+                    acc.result[acc.result.length - 1].push(elem);
+                    return acc;
+                });
+            }, { result: [], oldValue: undefined }), ({ result }) => isStringSeq ? result.map(elem => elem.join('')) : result);
         },
         arity: toFixedArity(2),
         docs: {
@@ -32734,6 +33079,12 @@ const api = {
         'next',
         'sort',
         'slice',
+        'take',
+        'take-last',
+        'drop',
+        'drop-last',
+        'take-while',
+        'drop-while',
     ],
     sequenceUtils: [
         'sequence.position',
@@ -32742,12 +33093,6 @@ const api = {
         'sequence.unshift',
         'sequence.splice',
         'sequence.sort-by',
-        'sequence.take',
-        'sequence.take-last',
-        'sequence.take-while',
-        'sequence.drop',
-        'sequence.drop-last',
-        'sequence.drop-while',
         'sequence.distinct',
         'sequence.remove',
         'sequence.remove-at',
@@ -32823,13 +33168,13 @@ const api = {
         'arity',
     ],
     misc: [
-        '≠',
+        '!=',
         '==',
         '<',
         '>',
         '<=',
         '>=',
-        '!',
+        'not',
         'write!',
         'iso-date->epoch',
         'epoch->iso-date',