@mojir/lits 2.3.0 → 2.3.1

package/README.md

@@ -1279,7 +1279,7 @@ Here's the complete precedence table, from highest to lowest:
 | 9 | `<<` `>>` `>>>` | Bit shift operations | `8 >> 1 + 1` → `8 >> 2` → `2` |
 | 8 | `++` | String concatenation | `"a" ++ "b" ++ "c"` → `"abc"` |
 | 7 | `<` `<=` `>` `>=` | Comparison operators | `3 + 2 > 4` → `5 > 4` → `true` |
-| 6 | `==` `≠` | Equality operators | `2 * 3 == 6` → `6 == 6` → `true` |
+| 6 | `==` `!=` | Equality operators | `2 * 3 == 6` → `6 == 6` → `true` |
 | 5 | `&` `xor` `\|` | Bitwise operations | `4 \| 2 & 1` → `4 \| 0` → `4` |
 | 4 | `&&` `\|\|` `??` | Logical operations | `true && false \|\| true` → `false \|\| true` → `true` |
 | 3 | *function operators* | Binary functions used as operators | `5 max 3 + 2` → `5 max 5` → `5` |

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.3.0";
+var version = "2.3.1";
 
 function getCodeMarker(sourceCodeInfo) {
     if (!sourceCodeInfo.position || !sourceCodeInfo.code)
@@ -2130,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)',
@@ -2272,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
 )`,
             ],
         },
@@ -3208,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]',
@@ -3230,7 +3415,7 @@ const miscNormalExpression = {
             ],
         },
     },
-    '≠': {
+    '!=': {
         evaluate: (params, sourceCodeInfo) => {
             return !isEqual(params, sourceCodeInfo);
         },
@@ -3248,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)',
             ],
         },
     },
@@ -3274,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])',
@@ -3425,7 +3610,7 @@ const miscNormalExpression = {
             ],
         },
     },
-    '!': {
+    'not': {
         evaluate: ([first]) => !first,
         arity: toFixedArity(1),
         docs: {
@@ -3436,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("")',
             ],
         },
     },
@@ -3523,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)',
@@ -6269,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;
@@ -6277,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`,
@@ -7228,7 +7413,7 @@ const binaryOperators = [
     '≥', // greater than or equal
     '==', // equal
     '!=', // not equal
-    '≠', // not equal
+    '!=', // not equal
     '&', // bitwise AND
     'xor', // bitwise XOR
     '|', // bitwise OR
@@ -8138,7 +8323,6 @@ function fromBinaryOperatorToNode(operator, symbolNode, left, right, sourceCodeI
         case '≥':
         case '==':
         case '!=':
-        case '≠':
         case '&':
         case 'xor':
         case '|':
@@ -9062,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
@@ -31293,199 +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 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: ['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);
-            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: ['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);
@@ -31634,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)',
@@ -31667,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)',
@@ -33089,6 +33079,12 @@ const api = {
         'next',
         'sort',
         'slice',
+        'take',
+        'take-last',
+        'drop',
+        'drop-last',
+        'take-while',
+        'drop-while',
     ],
     sequenceUtils: [
         'sequence.position',
@@ -33097,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',
@@ -33178,13 +33168,13 @@ const api = {
         'arity',
     ],
     misc: [
-        '≠',
+        '!=',
         '==',
         '<',
         '>',
         '<=',
         '>=',
-        '!',
+        'not',
         'write!',
         'iso-date->epoch',
         'epoch->iso-date',