@mojir/lits 2.1.5 → 2.1.6

package/dist/cli/cli.js

@@ -92,7 +92,7 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-var version = "2.1.5";
+var version = "2.1.6";
 
 function getCodeMarker(sourceCodeInfo) {
     if (!sourceCodeInfo.position || !sourceCodeInfo.code)
@@ -942,6 +942,32 @@ function assertCharArray(value, sourceCodeInfo) {
         throw getAssertionError('array of strings', value, sourceCodeInfo);
 }
 
+function mapObjects(_a) {
+    var colls = _a.colls, contextStack = _a.contextStack, executeFunction = _a.executeFunction, fn = _a.fn, sourceCodeInfo = _a.sourceCodeInfo;
+    assertObj(colls[0], sourceCodeInfo);
+    var keys = Object.keys(colls[0]);
+    var params = {};
+    colls.forEach(function (obj) {
+        assertObj(obj, sourceCodeInfo);
+        var objKeys = Object.keys(obj);
+        if (objKeys.length !== keys.length) {
+            throw new LitsError("All objects must have the same keys. Expected: ".concat(keys.join(', '), ". Found: ").concat(objKeys.join(', ')), sourceCodeInfo);
+        }
+        if (!objKeys.every(function (key) { return keys.includes(key); })) {
+            throw new LitsError("All objects must have the same keys. Expected: ".concat(keys.join(', '), ". Found: ").concat(objKeys.join(', ')), sourceCodeInfo);
+        }
+        Object.entries(obj).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            if (!params[key])
+                params[key] = [];
+            params[key].push(value);
+        });
+    });
+    return keys.reduce(function (result, key) {
+        result[key] = executeFunction(fn, params[key], contextStack, sourceCodeInfo);
+        return result;
+    }, {});
+}
 function cloneAndGetMeta(originalColl, keys, sourceCodeInfo) {
     var coll = cloneColl(originalColl);
     var butLastKeys = keys.slice(0, keys.length - 1);
@@ -1034,6 +1060,188 @@ function assoc(coll, key, value, sourceCodeInfo) {
     return copy;
 }
 var collectionNormalExpression = {
+    'filter': {
+        evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
+            var _c = __read(_a, 2), coll = _c[0], fn = _c[1];
+            var executeFunction = _b.executeFunction;
+            assertColl(coll, sourceCodeInfo);
+            assertFunctionLike(fn, sourceCodeInfo);
+            if (Array.isArray(coll)) {
+                var result = coll.filter(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); });
+                return result;
+            }
+            if (isString(coll)) {
+                return coll
+                    .split('')
+                    .filter(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); })
+                    .join('');
+            }
+            return Object.entries(coll)
+                .filter(function (_a) {
+                var _b = __read(_a, 2), value = _b[1];
+                return executeFunction(fn, [value], contextStack, sourceCodeInfo);
+            })
+                .reduce(function (result, _a) {
+                var _b = __read(_a, 2), key = _b[0], value = _b[1];
+                result[key] = value;
+                return result;
+            }, {});
+        },
+        paramCount: 2,
+    },
+    'map': {
+        evaluate: function (params, sourceCodeInfo, contextStack, _a) {
+            var executeFunction = _a.executeFunction;
+            var fn = asFunctionLike(params.at(-1), sourceCodeInfo);
+            if (isObj(params[0])) {
+                return mapObjects({
+                    colls: params.slice(0, -1),
+                    fn: fn,
+                    sourceCodeInfo: sourceCodeInfo,
+                    contextStack: contextStack,
+                    executeFunction: executeFunction,
+                });
+            }
+            var seqs = params.slice(0, -1);
+            assertSeq(seqs[0], sourceCodeInfo);
+            var isStr = typeof seqs[0] === 'string';
+            var len = seqs[0].length;
+            seqs.slice(1).forEach(function (seq) {
+                if (isStr) {
+                    assertString(seq, sourceCodeInfo);
+                }
+                else {
+                    assertArray(seq, sourceCodeInfo);
+                }
+                len = Math.min(len, seq.length);
+            });
+            var paramArray = [];
+            var _loop_1 = function (i) {
+                paramArray.push(seqs.map(function (seq) { return seq[i]; }));
+            };
+            for (var i = 0; i < len; i++) {
+                _loop_1(i);
+            }
+            var mapped = paramArray.map(function (p) { return executeFunction(fn, p, contextStack, sourceCodeInfo); });
+            if (!isStr) {
+                return mapped;
+            }
+            mapped.forEach(function (char) { return assertString(char, sourceCodeInfo); });
+            return mapped.join('');
+        },
+        paramCount: { min: 2 },
+    },
+    'reduce': {
+        evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
+            var _c = __read(_a, 3), coll = _c[0], fn = _c[1], initial = _c[2];
+            var executeFunction = _b.executeFunction;
+            assertColl(coll, sourceCodeInfo);
+            assertFunctionLike(fn, sourceCodeInfo);
+            assertAny(initial, sourceCodeInfo);
+            if (typeof coll === 'string') {
+                assertString(initial, sourceCodeInfo);
+                if (coll.length === 0)
+                    return initial;
+                return coll.split('').reduce(function (result, elem) {
+                    return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
+                }, initial);
+            }
+            else if (Array.isArray(coll)) {
+                if (coll.length === 0)
+                    return initial;
+                return coll.reduce(function (result, elem) {
+                    return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
+                }, initial);
+            }
+            else {
+                if (Object.keys(coll).length === 0)
+                    return initial;
+                return Object.entries(coll).reduce(function (result, _a) {
+                    var _b = __read(_a, 2), elem = _b[1];
+                    return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
+                }, initial);
+            }
+        },
+        paramCount: 3,
+    },
+    'reduce-right': {
+        evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
+            var _c = __read(_a, 3), coll = _c[0], fn = _c[1], initial = _c[2];
+            var executeFunction = _b.executeFunction;
+            assertColl(coll, sourceCodeInfo);
+            assertFunctionLike(fn, sourceCodeInfo);
+            assertAny(initial, sourceCodeInfo);
+            if (typeof coll === 'string') {
+                if (coll.length === 0)
+                    return initial;
+                return coll.split('').reduceRight(function (result, elem) {
+                    return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
+                }, initial);
+            }
+            else if (Array.isArray(coll)) {
+                if (coll.length === 0)
+                    return initial;
+                return coll.reduceRight(function (result, elem) {
+                    return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
+                }, initial);
+            }
+            else {
+                if (Object.keys(coll).length === 0)
+                    return initial;
+                return Object.entries(coll).reduceRight(function (result, _a) {
+                    var _b = __read(_a, 2), elem = _b[1];
+                    return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
+                }, initial);
+            }
+        },
+        paramCount: 3,
+    },
+    'reductions': {
+        evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
+            var _c = __read(_a, 3), coll = _c[0], fn = _c[1], initial = _c[2];
+            var executeFunction = _b.executeFunction;
+            assertColl(coll, sourceCodeInfo);
+            assertFunctionLike(fn, sourceCodeInfo);
+            assertAny(initial, sourceCodeInfo);
+            assertAny(initial, sourceCodeInfo);
+            if (typeof coll === 'string') {
+                assertString(initial, sourceCodeInfo);
+                if (coll.length === 0)
+                    return [initial];
+                var resultArray_1 = [initial];
+                coll.split('').reduce(function (result, elem) {
+                    var newVal = executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
+                    resultArray_1.push(newVal);
+                    return newVal;
+                }, initial);
+                return resultArray_1;
+            }
+            else if (Array.isArray(coll)) {
+                if (coll.length === 0)
+                    return [initial];
+                var resultArray_2 = [initial];
+                coll.reduce(function (result, elem) {
+                    var newVal = executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
+                    resultArray_2.push(newVal);
+                    return newVal;
+                }, initial);
+                return resultArray_2;
+            }
+            else {
+                if (Object.keys(coll).length === 0)
+                    return [initial];
+                var resultArray_3 = [initial];
+                Object.entries(coll).reduce(function (result, _a) {
+                    var _b = __read(_a, 2), elem = _b[1];
+                    var newVal = executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
+                    resultArray_3.push(newVal);
+                    return newVal;
+                }, initial);
+                return resultArray_3;
+            }
+        },
+        paramCount: 3,
+    },
     'get': {
         evaluate: function (params, sourceCodeInfo) {
             var _a = __read(params, 2), coll = _a[0], key = _a[1];
@@ -1376,23 +1584,6 @@ var sequenceNormalExpression = {
         },
         paramCount: { min: 2, max: 3 },
     },
-    'filter': {
-        evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
-            var _c = __read(_a, 2), seq = _c[0], fn = _c[1];
-            var executeFunction = _b.executeFunction;
-            assertSeq(seq, sourceCodeInfo);
-            assertFunctionLike(fn, sourceCodeInfo);
-            if (Array.isArray(seq)) {
-                var result = seq.filter(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); });
-                return result;
-            }
-            return seq
-                .split('')
-                .filter(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); })
-                .join('');
-        },
-        paramCount: 2,
-    },
     'first': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), array = _b[0];
@@ -1415,39 +1606,6 @@ var sequenceNormalExpression = {
         },
         paramCount: 1,
     },
-    'map': {
-        evaluate: function (params, sourceCodeInfo, contextStack, _a) {
-            var executeFunction = _a.executeFunction;
-            var fn = asFunctionLike(params.at(-1), sourceCodeInfo);
-            var seqs = params.slice(0, -1);
-            assertSeq(seqs[0], sourceCodeInfo);
-            var isString = typeof seqs[0] === 'string';
-            var len = seqs[0].length;
-            seqs.slice(1).forEach(function (seq) {
-                if (isString) {
-                    assertString(seq, sourceCodeInfo);
-                }
-                else {
-                    assertArray(seq, sourceCodeInfo);
-                }
-                len = Math.min(len, seq.length);
-            });
-            var paramArray = [];
-            var _loop_1 = function (i) {
-                paramArray.push(seqs.map(function (seq) { return seq[i]; }));
-            };
-            for (var i = 0; i < len; i++) {
-                _loop_1(i);
-            }
-            var mapped = paramArray.map(function (p) { return executeFunction(fn, p, contextStack, sourceCodeInfo); });
-            if (!isString) {
-                return mapped;
-            }
-            mapped.forEach(function (char) { return assertString(char, sourceCodeInfo); });
-            return mapped.join('');
-        },
-        paramCount: { min: 2 },
-    },
     'pop': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), seq = _b[0];
@@ -1530,160 +1688,6 @@ var sequenceNormalExpression = {
         },
         paramCount: { min: 2 },
     },
-    'reductions': {
-        evaluate: function (params, sourceCodeInfo, contextStack, _a) {
-            var executeFunction = _a.executeFunction;
-            var _b = __read(params, 2), seq = _b[0], fn = _b[1];
-            assertSeq(seq, sourceCodeInfo);
-            assertFunctionLike(fn, sourceCodeInfo);
-            if (params.length === 2) {
-                if (seq.length === 0)
-                    return [executeFunction(fn, [], contextStack, sourceCodeInfo)];
-                else if (seq.length === 1)
-                    return [toAny(seq[0])];
-                if (typeof seq === 'string') {
-                    var chars = seq.split('');
-                    var resultArray_1 = [asAny(chars[0], sourceCodeInfo)];
-                    chars.slice(1).reduce(function (result, elem) {
-                        var newVal = executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
-                        resultArray_1.push(newVal);
-                        return newVal;
-                    }, asAny(chars[0], sourceCodeInfo));
-                    return resultArray_1;
-                }
-                else {
-                    var resultArray_2 = [toAny(seq[0])];
-                    seq.slice(1).reduce(function (result, elem) {
-                        var newVal = executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
-                        resultArray_2.push(newVal);
-                        return newVal;
-                    }, toAny(seq[0]));
-                    return resultArray_2;
-                }
-            }
-            else {
-                var val = params[2];
-                assertAny(val, sourceCodeInfo);
-                if (typeof seq === 'string') {
-                    assertString(val, sourceCodeInfo);
-                    if (seq.length === 0)
-                        return [val];
-                    var resultArray_3 = [val];
-                    seq.split('').reduce(function (result, elem) {
-                        var newVal = executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
-                        resultArray_3.push(newVal);
-                        return newVal;
-                    }, val);
-                    return resultArray_3;
-                }
-                else {
-                    if (seq.length === 0)
-                        return [val];
-                    var resultArray_4 = [val];
-                    seq.reduce(function (result, elem) {
-                        var newVal = executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
-                        resultArray_4.push(newVal);
-                        return newVal;
-                    }, val);
-                    return resultArray_4;
-                }
-            }
-        },
-        paramCount: { min: 2, max: 3 },
-    },
-    'reduce': {
-        evaluate: function (params, sourceCodeInfo, contextStack, _a) {
-            var executeFunction = _a.executeFunction;
-            var _b = __read(params, 2), seq = _b[0], fn = _b[1];
-            assertSeq(seq, sourceCodeInfo);
-            assertFunctionLike(fn, sourceCodeInfo);
-            if (params.length === 2) {
-                if (seq.length === 0)
-                    return executeFunction(fn, [], contextStack, sourceCodeInfo);
-                else if (seq.length === 1)
-                    return toAny(seq[0]);
-                if (typeof seq === 'string') {
-                    var chars = seq.split('');
-                    return chars.slice(1).reduce(function (result, elem) {
-                        var val = executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
-                        return val;
-                    }, asAny(chars[0], sourceCodeInfo));
-                }
-                else {
-                    return seq.slice(1).reduce(function (result, elem) {
-                        return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
-                    }, toAny(seq[0]));
-                }
-            }
-            else {
-                var val = params[2];
-                assertAny(val, sourceCodeInfo);
-                if (typeof seq === 'string') {
-                    assertString(val, sourceCodeInfo);
-                    if (seq.length === 0)
-                        return val;
-                    return seq.split('').reduce(function (result, elem) {
-                        return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
-                    }, val);
-                }
-                else {
-                    if (seq.length === 0)
-                        return val;
-                    return seq.reduce(function (result, elem) {
-                        return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
-                    }, val);
-                }
-            }
-        },
-        paramCount: { min: 2, max: 3 },
-    },
-    'reduce-right': {
-        evaluate: function (params, sourceCodeInfo, contextStack, _a) {
-            var executeFunction = _a.executeFunction;
-            var _b = __read(params, 2), seq = _b[0], fn = _b[1];
-            assertSeq(seq, sourceCodeInfo);
-            assertFunctionLike(fn, sourceCodeInfo);
-            if (params.length === 2) {
-                if (seq.length === 0)
-                    return executeFunction(fn, [], contextStack, sourceCodeInfo);
-                else if (seq.length === 1)
-                    return toAny(seq[0]);
-                if (typeof seq === 'string') {
-                    var chars = seq.split('');
-                    return chars.slice(0, chars.length - 1).reduceRight(function (result, elem) {
-                        var newVal = executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
-                        assertString(newVal, sourceCodeInfo);
-                        return newVal;
-                    }, chars[chars.length - 1]);
-                }
-                else {
-                    return seq.slice(0, seq.length - 1).reduceRight(function (result, elem) {
-                        return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
-                    }, asAny(seq[seq.length - 1], sourceCodeInfo));
-                }
-            }
-            else {
-                var val = params[2];
-                assertAny(val, sourceCodeInfo);
-                assertSeq(seq, sourceCodeInfo);
-                if (typeof seq === 'string') {
-                    if (seq.length === 0)
-                        return val;
-                    return seq.split('').reduceRight(function (result, elem) {
-                        return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
-                    }, val);
-                }
-                else {
-                    if (seq.length === 0)
-                        return val;
-                    return seq.reduceRight(function (result, elem) {
-                        return executeFunction(fn, [result, elem], contextStack, sourceCodeInfo);
-                    }, val);
-                }
-            }
-        },
-        paramCount: { min: 2, max: 3 },
-    },
     'rest': {
         evaluate: function (_a, sourceCodeInfo) {
             var _b = __read(_a, 1), seq = _b[0];
@@ -2002,7 +2006,7 @@ var sequenceNormalExpression = {
             assertSeq(input, sourceCodeInfo);
             if (Array.isArray(input)) {
                 var result = [];
-                var _loop_2 = function (item) {
+                var _loop_1 = function (item) {
                     assertAny(item, sourceCodeInfo);
                     if (!result.some(function (existingItem) { return deepEqual(existingItem, item, sourceCodeInfo); })) {
                         result.push(item);
@@ -2011,7 +2015,7 @@ var sequenceNormalExpression = {
                 try {
                     for (var input_1 = __values(input), input_1_1 = input_1.next(); !input_1_1.done; input_1_1 = input_1.next()) {
                         var item = input_1_1.value;
-                        _loop_2(item);
+                        _loop_1(item);
                     }
                 }
                 catch (e_2_1) { e_2 = { error: e_2_1 }; }
@@ -4315,6 +4319,15 @@ function applyPlaceholders(templateString, placeholders, sourceCodeInfo) {
 }
 
 var functionalNormalExpression = {
+    '|>': {
+        evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
+            var _c = __read(_a, 2), value = _c[0], func = _c[1];
+            var executeFunction = _b.executeFunction;
+            assertFunctionLike(func, sourceCodeInfo);
+            return executeFunction(func, [value], contextStack, sourceCodeInfo);
+        },
+        paramCount: 2,
+    },
     'apply': {
         evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
             var _c = __read(_a), func = _c[0], params = _c.slice(1);
@@ -4335,20 +4348,6 @@ var functionalNormalExpression = {
         },
         paramCount: 1,
     },
-    'partial': {
-        evaluate: function (_a, sourceCodeInfo) {
-            var _b;
-            var _c = __read(_a), fn = _c[0], params = _c.slice(1);
-            return _b = {},
-                _b[FUNCTION_SYMBOL] = true,
-                _b.sourceCodeInfo = sourceCodeInfo,
-                _b.functionType = 'Partial',
-                _b.function = asFunctionLike(fn, sourceCodeInfo),
-                _b.params = params,
-                _b;
-        },
-        paramCount: { min: 1 },
-    },
     'comp': {
         evaluate: function (params, sourceCodeInfo) {
             var _a;
@@ -11275,6 +11274,7 @@ var nonNumberReservedSymbolRecord = {
     function: null,
     export: null,
     as: null,
+    _: null,
 };
 var phi = (1 + Math.sqrt(5)) / 2;
 var numberReservedSymbolRecord = {
@@ -12124,8 +12124,27 @@ var functionExecutors = {
         }
     },
     Partial: function (fn, params, sourceCodeInfo, contextStack, _a) {
+        var e_2, _b;
         var executeFunction = _a.executeFunction;
-        return executeFunction(fn.function, __spreadArray(__spreadArray([], __read(fn.params), false), __read(params), false), contextStack, sourceCodeInfo);
+        var actualParams = __spreadArray([], __read(fn.params), false);
+        if (params.length !== fn.placeholders.length) {
+            throw new LitsError("(partial) expects ".concat(fn.placeholders.length, " arguments, got ").concat(params.length, "."), sourceCodeInfo);
+        }
+        var paramsCopy = __spreadArray([], __read(params), false);
+        try {
+            for (var _c = __values(fn.placeholders), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var placeholderIndex = _d.value;
+                actualParams.splice(placeholderIndex, 0, paramsCopy.shift());
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return executeFunction(fn.function, actualParams, contextStack, sourceCodeInfo);
     },
     Comp: function (fn, params, sourceCodeInfo, contextStack, _a) {
         var executeFunction = _a.executeFunction;
@@ -12151,66 +12170,66 @@ var functionExecutors = {
         return !executeFunction(fn.function, params, contextStack, sourceCodeInfo);
     },
     EveryPred: function (fn, params, sourceCodeInfo, contextStack, _a) {
-        var e_2, _b, e_3, _c;
+        var e_3, _b, e_4, _c;
         var executeFunction = _a.executeFunction;
         try {
             for (var _d = __values(fn.params), _e = _d.next(); !_e.done; _e = _d.next()) {
                 var f = _e.value;
                 try {
-                    for (var params_1 = (e_3 = void 0, __values(params)), params_1_1 = params_1.next(); !params_1_1.done; params_1_1 = params_1.next()) {
+                    for (var params_1 = (e_4 = void 0, __values(params)), params_1_1 = params_1.next(); !params_1_1.done; params_1_1 = params_1.next()) {
                         var param = params_1_1.value;
                         var result = executeFunction(asFunctionLike(f, sourceCodeInfo), [param], contextStack, sourceCodeInfo);
                         if (!result)
                             return false;
                     }
                 }
-                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                catch (e_4_1) { e_4 = { error: e_4_1 }; }
                 finally {
                     try {
                         if (params_1_1 && !params_1_1.done && (_c = params_1.return)) _c.call(params_1);
                     }
-                    finally { if (e_3) throw e_3.error; }
+                    finally { if (e_4) throw e_4.error; }
                 }
             }
         }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
         finally {
             try {
                 if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
             }
-            finally { if (e_2) throw e_2.error; }
+            finally { if (e_3) throw e_3.error; }
         }
         return true;
     },
     SomePred: function (fn, params, sourceCodeInfo, contextStack, _a) {
-        var e_4, _b, e_5, _c;
+        var e_5, _b, e_6, _c;
         var executeFunction = _a.executeFunction;
         try {
             for (var _d = __values(fn.params), _e = _d.next(); !_e.done; _e = _d.next()) {
                 var f = _e.value;
                 try {
-                    for (var params_2 = (e_5 = void 0, __values(params)), params_2_1 = params_2.next(); !params_2_1.done; params_2_1 = params_2.next()) {
+                    for (var params_2 = (e_6 = void 0, __values(params)), params_2_1 = params_2.next(); !params_2_1.done; params_2_1 = params_2.next()) {
                         var param = params_2_1.value;
                         var result = executeFunction(asFunctionLike(f, sourceCodeInfo), [param], contextStack, sourceCodeInfo);
                         if (result)
                             return true;
                     }
                 }
-                catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                catch (e_6_1) { e_6 = { error: e_6_1 }; }
                 finally {
                     try {
                         if (params_2_1 && !params_2_1.done && (_c = params_2.return)) _c.call(params_2);
                     }
-                    finally { if (e_5) throw e_5.error; }
+                    finally { if (e_6) throw e_6.error; }
                 }
             }
         }
-        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
         finally {
             try {
                 if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
             }
-            finally { if (e_4) throw e_4.error; }
+            finally { if (e_5) throw e_5.error; }
         }
         return false;
     },
@@ -12283,6 +12302,9 @@ function evaluateString(node) {
 }
 function evaluateReservedSymbol(node) {
     var reservedName = node[1];
+    if (!['true', 'false', 'null'].includes(reservedName)) {
+        throw new LitsError("Reserved symbol ".concat(reservedName, " cannot be evaluated"), node[2]);
+    }
     var value = reservedSymbolRecord[reservedName];
     return asNonUndefined(value, node[2]);
 }
@@ -12290,7 +12312,8 @@ function evaluateNormalExpression(node, contextStack) {
     var sourceCodeInfo = node[2];
     var paramNodes = node[1][1];
     var params = [];
-    paramNodes.forEach(function (paramNode) {
+    var placeholders = [];
+    paramNodes.forEach(function (paramNode, index) {
         if (isSpreadNode(paramNode)) {
             var spreadValue = evaluateNode(paramNode[1], contextStack);
             if (Array.isArray(spreadValue)) {
@@ -12300,12 +12323,27 @@ function evaluateNormalExpression(node, contextStack) {
                 throw new LitsError("Spread operator requires an array, got ".concat(valueToString(paramNode)), paramNode[2]);
             }
         }
+        else if (paramNode[0] === NodeTypes.ReservedSymbol && paramNode[1] === '_') {
+            placeholders.push(index);
+        }
         else {
             params.push(evaluateNode(paramNode, contextStack));
         }
     });
     if (isNormalExpressionNodeWithName(node)) {
         var nameSymbol = node[1][0];
+        if (placeholders.length > 0) {
+            var fn = evaluateNode(nameSymbol, contextStack);
+            var partialFunction = {
+                '^^fn^^': true,
+                'function': asFunctionLike(fn, sourceCodeInfo),
+                'functionType': 'Partial',
+                params: params,
+                placeholders: placeholders,
+                sourceCodeInfo: sourceCodeInfo,
+            };
+            return partialFunction;
+        }
         if (isNormalBuiltinSymbolNode(nameSymbol)) {
             var type = nameSymbol[1];
             var normalExpression = builtin.allNormalExpressions[type];
@@ -12322,6 +12360,17 @@ function evaluateNormalExpression(node, contextStack) {
     else {
         var fnNode = node[1][0];
         var fn = asFunctionLike(evaluateNode(fnNode, contextStack), sourceCodeInfo);
+        if (placeholders.length > 0) {
+            var partialFunction = {
+                '^^fn^^': true,
+                'function': asFunctionLike(fn, sourceCodeInfo),
+                'functionType': 'Partial',
+                params: params,
+                placeholders: placeholders,
+                sourceCodeInfo: sourceCodeInfo,
+            };
+            return partialFunction;
+        }
         return executeFunction(fn, params, contextStack, sourceCodeInfo);
     }
 }
@@ -12627,6 +12676,7 @@ var binaryOperators = [
     '&&', // logical AND
     '||', // logical OR
     '??', // nullish coalescing
+    '|>', // pipe
 ];
 var otherOperators = [
     '->', // lambda
@@ -13220,8 +13270,8 @@ function untokenize(tokenStream) {
     }, '');
 }
 
-var exponentiationPrecedence = 10;
-var binaryFunctionalOperatorPrecedence = 1;
+var exponentiationPrecedence = 11;
+var binaryFunctionalOperatorPrecedence = 2;
 var placeholderRegexp = /^\$([1-9]\d?)?$/;
 function withSourceCodeInfo(node, sourceCodeInfo) {
     if (sourceCodeInfo) {
@@ -13236,38 +13286,40 @@ function getPrecedence(operatorSign, sourceCodeInfo) {
         case '*': // multiplication
         case '/': // division
         case '%': // remainder
-            return 9;
+            return 10;
         case '+': // addition
         case '-': // subtraction
-            return 8;
+            return 9;
         case '<<': // left shift
         case '>>': // signed right shift
         case '>>>': // unsigned right shift
-            return 7;
+            return 8;
         case '++': // string concatenation
-            return 6;
+            return 7;
         case '<': // less than
         case '<=': // less than or equal
         case '≤': // less than or equal
         case '>': // greater than
         case '>=': // greater than or equal
         case '≥': // greater than or equal
-            return 5;
+            return 6;
         case '=': // equal
         case '!=': // not equal
         case '≠': // not equal
         case '~': // approximate
         case '≈': // approximate
-            return 4;
+            return 5;
         case '&': // bitwise AND
         case 'xor': // bitwise XOR
         case '|': // bitwise OR
-            return 3;
+            return 4;
         case '&&': // logical AND
         case '||': // logical OR
         case '??': // nullish coalescing
-            return 2;
-        // leave room for binaryFunctionalOperatorPrecedence = 1
+            return 3;
+        case '|>': // pipe
+            return 1;
+        // leave room for binaryFunctionalOperatorPrecedence = 2
         /* v8 ignore next 2 */
         default:
             throw new LitsError("Unknown binary operator: ".concat(operatorSign), sourceCodeInfo);
@@ -13311,6 +13363,7 @@ function fromBinaryOperatorToNode(operator, symbolNode, left, right, sourceCodeI
         case '|':
         case '~':
         case '≈':
+        case '|>':
             return createNamedNormalExpressionNode(symbolNode, [left, right], sourceCodeInfo);
         case '&&':
         case '||':
@@ -14768,6 +14821,11 @@ function getVectorReductionNames(name) {
 }
 var api = {
     collection: [
+        'filter',
+        'map',
+        'reduce',
+        'reduce-right',
+        'reductions',
         'count',
         'get',
         'get-in',
@@ -14797,11 +14855,6 @@ var api = {
         'shift',
         'slice',
         'splice',
-        'reductions',
-        'reduce',
-        'reduce-right',
-        'map',
-        'filter',
         'position',
         'index-of',
         'last-index-of',
@@ -14874,9 +14927,9 @@ var api = {
         'atanh',
     ],
     functional: [
+        '|>',
         'apply',
         'identity',
-        'partial',
         'comp',
         'constantly',
         'juxt',
@@ -15971,6 +16024,142 @@ var bitwiseReference = {
 };
 
 var collectionReference = {
+    'filter': {
+        title: 'filter',
+        category: 'Collection',
+        linkName: 'filter',
+        returns: {
+            type: 'collection',
+        },
+        args: __assign(__assign({}, getOperatorArgs('collection', 'function')), { coll: {
+                type: 'collection',
+            }, fun: {
+                type: 'function',
+            } }),
+        variants: [
+            { argumentNames: ['coll', 'fun'] },
+        ],
+        description: 'Creates a new collection with all elements that pass the test implemented by $fun.',
+        examples: [
+            "\nfilter(\n  [\"Albert\", \"Mojir\", 160, [1, 2]],\n  string?\n)",
+            "\nfilter(\n  [5, 10, 15, 20],\n  -> $ > 10\n)",
+            "\nfilter(\n  { a := 1, b := 2 },\n  odd?\n)",
+        ],
+    },
+    'map': {
+        title: 'map',
+        category: 'Collection',
+        linkName: 'map',
+        returns: {
+            type: 'collection',
+        },
+        args: __assign(__assign({}, getOperatorArgs('collection', 'function')), { colls: {
+                type: 'collection',
+                rest: true,
+                description: 'At least one.',
+            }, fun: {
+                type: 'function',
+            } }),
+        variants: [
+            { argumentNames: ['colls', 'fun'] },
+        ],
+        description: 'Creates a new collection populated with the results of calling $fun on every element in $colls.',
+        examples: [
+            '[1, 2, 3] map -',
+            '[1, 2, 3] map -> -($)',
+            'map(["Albert", "Mojir", 42], str)',
+            'map([1, 2, 3], inc)',
+            'map([1, 2, 3], [1, 10, 100], *)',
+            'map({ a := 1, b := 2 }, inc)',
+            'map({ a := 1, b := 2 }, { a := 10, b := 20 }, +)',
+        ],
+    },
+    'reduce': {
+        title: 'reduce',
+        category: 'Collection',
+        linkName: 'reduce',
+        returns: {
+            type: 'any',
+        },
+        args: {
+            fun: {
+                type: 'function',
+            },
+            coll: {
+                type: 'collection',
+            },
+            initial: {
+                type: 'any',
+            },
+        },
+        variants: [
+            { argumentNames: ['coll', 'fun', 'initial'] },
+        ],
+        description: 'Runs $fun function on each element of the $coll, passing in the return value from the calculation on the preceding element. The final result of running the reducer across all elements of the $coll is a single value.',
+        examples: [
+            'reduce([1, 2, 3], +, 0)',
+            'reduce([], +, 0)',
+            'reduce({ a := 1, b := 2 }, +, 0)',
+            "\nreduce(\n  [1, 2, 3, 4, 5, 6, 7, 8, 9],\n  (result, value) -> result + if even?(value) then value else 0 end,\n  0)",
+        ],
+    },
+    'reduce-right': {
+        title: 'reduce-right',
+        category: 'Collection',
+        linkName: 'reduce-right',
+        returns: {
+            type: 'any',
+        },
+        args: {
+            fun: {
+                type: 'function',
+            },
+            coll: {
+                type: 'collection',
+            },
+            initial: {
+                type: 'any',
+            },
+        },
+        variants: [
+            { argumentNames: ['coll', 'fun', 'initial'] },
+        ],
+        description: 'Runs $fun function on each element of the $coll (starting from the last item), passing in the return value from the calculation on the preceding element. The final result of running the reducer across all elements of the $coll is a single value.',
+        examples: [
+            'reduce-right(["A", "B", "C"], str, "")',
+            'reduce-right({ a := 1, b := 2 }, +, 0)',
+        ],
+    },
+    'reductions': {
+        title: 'reductions',
+        category: 'Collection',
+        linkName: 'reductions',
+        returns: {
+            type: 'any',
+        },
+        args: {
+            fun: {
+                type: 'function',
+            },
+            coll: {
+                type: 'collection',
+            },
+            initial: {
+                type: 'any',
+            },
+        },
+        variants: [
+            { argumentNames: ['coll', 'fun', 'initial'] },
+        ],
+        description: 'Returns an array of the intermediate values of the reduction (see `reduce`) of $coll by $fun.',
+        examples: [
+            'reductions([1, 2, 3], +, 0)',
+            'reductions([1, 2, 3], +, 10)',
+            'reductions([], +, 0)',
+            'reductions({ a := 1, b := 2 }, +, 0)',
+            "\nreductions(\n  [1, 2, 3, 4, 5, 6, 7, 8, 9],\n  (result, value) -> result + if even?(value) then value else 0 end,\n  0\n)",
+        ],
+    },
     'count': {
         title: 'count',
         category: 'Collection',
@@ -16354,6 +16543,23 @@ var collectionReference = {
 };
 
 var functionalReference = {
+    '|>': {
+        title: '|>',
+        category: 'Functional',
+        linkName: '-or-gt',
+        returns: {
+            type: 'any',
+        },
+        args: __assign({}, getOperatorArgs('any', 'function')),
+        variants: [
+            { argumentNames: ['a', 'b'] },
+        ],
+        description: 'Takes a value $a and a function $b, and returns the result of applying $b to $a.',
+        examples: [
+            "\n1 |> inc |> inc",
+            "range(10)\n  |> map(_, -> $ ^ 2) // [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n  |> filter(_, odd?)  // [1, 9, 25, 49, 81]\n  |> reduce(_, +, 0)  // 165\n  |> sqrt             // 12.84523257866513\n  |> round(_, 2)",
+        ],
+    },
     'apply': {
         title: 'apply',
         category: 'Functional',
@@ -16394,33 +16600,6 @@ var functionalReference = {
         description: 'Returns $x.',
         examples: ['identity(1)', 'identity("Albert")', 'identity({ a := 1 })', 'identity(null)'],
     },
-    'partial': {
-        title: 'partial',
-        category: 'Functional',
-        linkName: 'partial',
-        returns: {
-            type: 'function',
-        },
-        args: {
-            fun: {
-                type: 'function',
-            },
-            args: {
-                type: 'any',
-                rest: true,
-            },
-        },
-        variants: [
-            { argumentNames: ['fun', 'args'] },
-        ],
-        description: "Takes a function $fun and a optional number arguments $args to $fun.\nIt returns a function that takes the additional additional arguments.\nWhen called, the returned function calls `(`$fun `...`$args` ...additional_arguments)`.",
-        examples: [
-            'partial(+, 100)',
-            "\nlet plusMany := partial(+, 100, 1000);\nplusMany(1, 10)",
-            "\nlet addHundred := partial(+, 100);\naddHundred(10)",
-        ],
-        noOperatorDocumentation: true,
-    },
     'comp': {
         title: 'comp',
         category: 'Functional',
@@ -24732,134 +24911,6 @@ var sequenceReference = {
             'splice("Albert", 2, 2, "fo")',
         ],
     },
-    'reductions': {
-        title: 'reductions',
-        category: 'Sequence',
-        linkName: 'reductions',
-        returns: {
-            type: 'any',
-            rest: true,
-        },
-        args: __assign(__assign({}, getOperatorArgs('sequence', 'function')), { fun: {
-                type: 'function',
-            }, seq: {
-                type: 'sequence',
-                rest: true,
-            }, start: {
-                type: 'any',
-            } }),
-        variants: [
-            { argumentNames: ['seq', 'fun'] },
-            { argumentNames: ['seq', 'fun', 'start'] },
-        ],
-        description: 'Returns an array of the intermediate values of the reduction (see `reduce`) of $seq by $fun.',
-        examples: [
-            '[1, 2, 3] reductions +',
-            'reductions([1, 2, 3], +)',
-            'reductions([1, 2, 3], +, 10)',
-            'reductions([], +, 0)',
-            "\nreductions(\n  [1, 2, 3, 4, 5, 6, 7, 8, 9],\n  (result, value) -> result + if even?(value) then value else 0 end,\n  0\n)",
-        ],
-    },
-    'reduce': {
-        title: 'reduce',
-        category: 'Sequence',
-        linkName: 'reduce',
-        returns: {
-            type: 'any',
-        },
-        args: __assign(__assign({}, getOperatorArgs('sequence', 'function')), { fun: {
-                type: 'function',
-            }, seq: {
-                type: 'sequence',
-            }, start: {
-                type: 'any',
-            } }),
-        variants: [
-            { argumentNames: ['seq', 'fun'] },
-            { argumentNames: ['seq', 'fun', 'start'] },
-        ],
-        description: 'Runs $fun function on each element of the $seq, passing in the return value from the calculation on the preceding element. The final result of running the reducer across all elements of the $seq is a single value.',
-        examples: [
-            '[1, 2, 3] reduce +',
-            'reduce([1, 2, 3], +)',
-            'reduce([1, 2, 3], +, 0)',
-            'reduce([], +, 0)',
-            "\nreduce(\n  [1, 2, 3, 4, 5, 6, 7, 8, 9],\n  (result, value) -> result + if even?(value) then value else 0 end,\n  0)",
-        ],
-    },
-    'reduce-right': {
-        title: 'reduce-right',
-        category: 'Sequence',
-        linkName: 'reduce-right',
-        returns: {
-            type: 'sequence',
-        },
-        args: __assign(__assign({}, getOperatorArgs('sequence', 'function')), { fun: {
-                type: 'function',
-            }, seq: {
-                type: 'sequence',
-            }, start: {
-                type: 'any',
-            } }),
-        variants: [
-            { argumentNames: ['seq', 'fun'] },
-            { argumentNames: ['seq', 'fun', 'start'] },
-        ],
-        description: 'Runs $fun function on each element of the $seq (starting from the last item), passing in the return value from the calculation on the preceding element. The final result of running the reducer across all elements of the $seq is a single value.',
-        examples: [
-            'range(1, 10) reduce-right *',
-            'reduce-right(["A", "B", "C"], str, "")',
-        ],
-    },
-    'map': {
-        title: 'map',
-        category: 'Sequence',
-        linkName: 'map',
-        returns: {
-            type: 'any',
-            rest: true,
-        },
-        args: __assign(__assign({}, getOperatorArgs('sequence', 'function')), { seqs: {
-                type: 'sequence',
-                rest: true,
-                description: 'At least one.',
-            }, fun: {
-                type: 'function',
-            } }),
-        variants: [
-            { argumentNames: ['seqs', 'fun'] },
-        ],
-        description: 'Creates a new array populated with the results of calling $fun on every element in $seqs.',
-        examples: [
-            '[1, 2, 3] map -',
-            '[1, 2, 3] map -> -($)',
-            'map(["Albert", "Mojir", 42], str)',
-            'map([1, 2, 3], inc)',
-            'map([1, 2, 3], [1, 10, 100], *)',
-        ],
-    },
-    'filter': {
-        title: 'filter',
-        category: 'Sequence',
-        linkName: 'filter',
-        returns: {
-            type: 'sequence',
-        },
-        args: __assign(__assign({}, getOperatorArgs('sequence', 'function')), { seq: {
-                type: 'sequence',
-            }, fun: {
-                type: 'function',
-            } }),
-        variants: [
-            { argumentNames: ['seq', 'fun'] },
-        ],
-        description: 'Creates a new array with all elements that pass the test implemented by $fun.',
-        examples: [
-            "\nfilter(\n  [\"Albert\", \"Mojir\", 160, [1, 2]],\n  string?\n)",
-            "\nfilter(\n  [5, 10, 15, 20],\n  -> $ > 10\n)",
-        ],
-    },
     'position': {
         title: 'position',
         category: 'Sequence',