@mojir/lits 2.1.38 → 2.1.40

package/README.md

@@ -4,6 +4,14 @@ A functional language with algebraic notation and JavaScript interoperability.
 
 Try it in the [Lits Playground](https://mojir.github.io/lits/).
 
+## TODO
+Fix playground, it looks a bit funky under modules.
+Also fix Header, were name, module and category should be presented
+
+Model cli as module, create a new bundle that include this module. The existing full bundle should not include this.
+
+
+
 ## Features
 
 - **Pure functional language** - Variables cannot be changed, ensuring predictable behavior and easier reasoning about code
@@ -90,10 +98,10 @@ let add = (a, b) -> a + b;
 let x = let y = 5;  // x becomes 5
 
 // Blocks are expressions - they return the last expression's value
-let value = {
+let value = do
   let temp = 42;
   temp * 2 + 1 // => 85
-};
+end;
 ```
 This expression-based design makes Lits highly composable and eliminates the statement/expression distinction found in many other languages.
 
@@ -159,9 +167,13 @@ numbers filter odd?;           // => [1, 3, 5]
 
 #### Vectors (Number Arrays)
 
-A vector is simply a non-empty array containing only numbers. The `vec:` namespace provides mathematical operations specifically for these number arrays:
+A vector is simply a non-empty array containing only numbers. The `vec` module provides mathematical operations specifically for these number arrays:
 
 ```lits
+// Import vector and linear algebra modules
+let vec = import("Vector");
+let lin = import("Linear-Algebra");
+
 // Vectors are just number arrays
 [1, 2, 3, 4, 5];              // This is a vector
 [3.14, 2.71, 1.41];           // This is also a vector
@@ -169,38 +181,38 @@ A vector is simply a non-empty array containing only numbers. The `vec:` namespa
 [];                            // This is NOT a vector (empty)
 
 // Vector creation functions
-vec:zeros(5);                  // => [0, 0, 0, 0, 0]
-vec:ones(3);                   // => [1, 1, 1]
-vec:linspace(0, 10, 5);        // => [0, 2.5, 5, 7.5, 10]
-vec:fill(4, 3.14);             // => [3.14, 3.14, 3.14, 3.14]
-vec:generate(5, -> $ * 2);     // => [0, 2, 4, 6, 8]
-
-// Vector mathematical operations (use lin: namespace for vector math)
-lin:dot([1, 2, 3], [4, 5, 6]);      // => 32 (dot product)
-lin:euclidean-norm([3, 4]);         // => 5.0 (Euclidean norm/magnitude)
-lin:normalize([3, 4]);              // => [0.6, 0.8] (unit vector)
-lin:euclidean-distance([0, 0], [3, 4]); // => 5.0 (Euclidean distance)
+vec.zeros(5);                  // => [0, 0, 0, 0, 0]
+vec.ones(3);                   // => [1, 1, 1]
+vec.linspace(0, 10, 5);        // => [0, 2.5, 5, 7.5, 10]
+vec.fill(4, 3.14);             // => [3.14, 3.14, 3.14, 3.14]
+vec.generate(5, -> $ * 2);     // => [0, 2, 4, 6, 8]
+
+// Vector mathematical operations (use lin module for vector math)
+lin.dot([1, 2, 3], [4, 5, 6]);      // => 32 (dot product)
+lin.euclidean-norm([3, 4]);         // => 5.0 (Euclidean norm/magnitude)
+lin.normalize-l2([3, 4]);           // => [0.6, 0.8] (unit vector)
+lin.euclidean-distance([0, 0], [3, 4]); // => 5.0 (Euclidean distance)
 
 // Vector statistical operations
-vec:sum([1, 2, 3, 4]);         // => 10
-vec:mean([1, 2, 3, 4]);        // => 2.5
-vec:median([1, 2, 3, 4, 5]);   // => 3
-vec:stdev([1, 2, 3, 4]);       // => 1.29... (standard deviation)
-vec:variance([1, 2, 3, 4]);    // => 1.67... (variance)
+vec.sum([1, 2, 3, 4]);         // => 10
+vec.mean([1, 2, 3, 4]);        // => 2.5
+vec.median([1, 2, 3, 4, 5]);   // => 3
+vec.stdev([1, 2, 3, 4]);       // => 1.29... (standard deviation)
+vec.variance([1, 2, 3, 4]);    // => 1.67... (variance)
 
 // Vector analysis
-vec:min([3, 1, 4, 1, 5]);      // => 1
-vec:max([3, 1, 4, 1, 5]);      // => 5
-vec:min-index([3, 1, 4]);      // => 1 (index of minimum)
-vec:max-index([3, 1, 4]);      // => 2 (index of maximum)
+vec.min([3, 1, 4, 1, 5]); // => 1
+vec.max([3, 1, 4, 1, 5]); // => 5
+vec.min-index([3, 1, 4]);      // => 1 (index of minimum)
+vec.max-index([3, 1, 4]);      // => 2 (index of maximum)
 
 // Cumulative operations
-vec:cumsum([1, 2, 3, 4]);      // => [1, 3, 6, 10]
-vec:cumprod([1, 2, 3, 4]);     // => [1, 2, 6, 24]
+vec.cumsum([1, 2, 3, 4]);      // => [1, 3, 6, 10]
+vec.cumprod([1, 2, 3, 4]);     // => [1, 2, 6, 24]
 
 // Vector predicates
-vec:increasing?([1, 1, 2, 3, 4]);          // => true
-vec:strictly-increasing?([1, 1, 2, 3, 4]); // => true
+vec.increasing?([1, 1, 2, 3, 4]);          // => true
+vec.strictly-increasing?([1, 1, 2, 3, 4]); // => false
 
 // Structural equality works with all vectors
 [1, 2, 3] == [1, 2, 3];       // => true
@@ -209,9 +221,12 @@ vec:strictly-increasing?([1, 1, 2, 3, 4]); // => true
 
 #### Matrices (2D Vectors)
 
-A matrix is a 2D array where each row is a vector (non-empty array of numbers) and all rows have the same length. The `mat:` namespace provides linear algebra operations for these structures:
+A matrix is a 2D array where each row is a vector (non-empty array of numbers) and all rows have the same length. The `mat` module provides linear algebra operations for these structures:
 
 ```lits
+// Import matrix module
+let mat = import("Matrix");
+
 // Matrices are 2D number arrays with consistent row lengths
 [[1, 2], [3, 4]];              // This is a 2x2 matrix
 [[1, 2, 3], [4, 5, 6]];        // This is a 2x3 matrix
@@ -223,34 +238,34 @@ A matrix is a 2D array where each row is a vector (non-empty array of numbers) a
 let matrixA = [[1, 2], [3, 4]];
 let matrixB = [[5, 6], [7, 8]];
 
-mat:mul(matrixA, matrixB);     // => [[19, 22], [43, 50]] (multiplication)
-mat:det(matrixA);              // => -2 (determinant)
-mat:inv(matrixA);              // => [[-2, 1], [1.5, -0.5]] (inverse)
-mat:trace(matrixA);            // => 5 (trace - sum of diagonal)
+mat.mul(matrixA, matrixB);     // => [[19, 22], [43, 50]] (multiplication)
+mat.det(matrixA);              // => -2 (determinant)
+mat.inv(matrixA);              // => [[-2, 1], [1.5, -0.5]] (inverse)
+mat.trace(matrixA);            // => 5 (trace - sum of diagonal)
 
 // Matrix construction
-mat:hilbert(3);                // => 3x3 Hilbert matrix
-mat:vandermonde([1, 2, 3]);    // => Vandermonde matrix from vector
-mat:band(4, 1, 1);             // => 4x4 band matrix
+mat.hilbert(3);                // => 3x3 Hilbert matrix
+mat.vandermonde([1, 2, 3]);    // => Vandermonde matrix from vector
+mat.band(4, 1, 1);             // => 4x4 band matrix
 
 // Matrix properties and predicates
-mat:symmetric?([[1, 2], [2, 1]]);    // => true
-mat:invertible?([[1, 2], [3, 4]]);   // => true
-mat:square?([[1, 2], [3, 4]]);       // => true
-mat:diagonal?([[1, 0], [0, 2]]);     // => true
-mat:identity?([[1, 0], [0, 1]]);     // => true
+mat.symmetric?([[1, 2], [2, 1]]);    // => true
+mat.invertible?([[1, 2], [3, 4]]);   // => true
+mat.square?([[1, 2], [3, 4]]);       // => true
+mat.diagonal?([[1, 0], [0, 2]]);     // => true
+mat.identity?([[1, 0], [0, 1]]);     // => true
 
 // Advanced matrix operations
-mat:adj(matrixA);              // => [[4, -2], [-3, 1]] (adjugate)
-mat:cofactor(matrixA);         // => cofactor matrix
-mat:minor(matrixA, 0, 1);      // => minor by removing row 0, col 1
-mat:frobenius-norm(matrixA);   // => Frobenius norm
-mat:1-norm(matrixA);           // => 1-norm (max column sum)
-mat:inf-norm(matrixA);         // => infinity norm (max row sum)
-mat:max-norm(matrixA);         // => max norm (largest absolute element)
+mat.adj(matrixA);              // => [[4, -2], [-3, 1]] (adjugate)
+mat.cofactor(matrixA);         // => cofactor matrix
+mat.minor(matrixA, 0, 1);      // => minor by removing row 0, col 1
+mat.frobenius-norm(matrixA);   // => Frobenius norm
+mat.one-norm(matrixA);         // => 1-norm (max column sum)
+mat.inf-norm(matrixA);         // => infinity norm (max row sum)
+mat.max-norm(matrixA);         // => max norm (largest absolute element)
 
 // Matrix analysis
-mat:rank(matrixA);             // => matrix rank
+mat.rank(matrixA);             // => matrix rank
 ```
 
 #### Objects (Maps)
@@ -376,10 +391,10 @@ let x = 10;
 // let x = 20; // Error: x is already defined
 
 // Shadowing in inner scopes
-let y = {
+let y = do
   let x = 20;
   x
-};
+end;
 // => 20, outer x is still 10
 ```
 
@@ -677,23 +692,23 @@ doseq (x in [1, 2, 3]) -> write!(x)
 
 ```lits
 // Loop with recur for tail recursion
-loop (n = 5, acc = 1) -> {
+loop (n = 5, acc = 1) -> do
   if zero?(n) then
     acc
   else
     recur(n - 1, acc * n)
   end
-};
+end;
 // => 120 (factorial of 5)
 
 // Complex loop with multiple variables
-loop (items = [1, 2, 3, 4, 5], sum = 0, cnt = 0) -> {
+loop (items = [1, 2, 3, 4, 5], sum = 0, cnt = 0) -> do
   if empty?(items) then
     { sum: sum, average: sum / cnt }
   else
     recur(rest(items), sum + first(items), cnt + 1)
   end
-};
+end;
 ```
 
 ### Recursion with Recur
@@ -702,22 +717,22 @@ loop (items = [1, 2, 3, 4, 5], sum = 0, cnt = 0) -> {
 
 ```lits
 // Simple recursive function with recur
-let factorial = (n) -> {
+let factorial = (n) -> do
   if n <= 1 then
     1
   else
     n * recur(n - 1)
   end
-};
+end;
 
 // Tail-recursive function
-let sumToN = (n, acc = 0) -> {
+let sumToN = (n, acc = 0) -> do
   if zero?(n) then
     acc
   else
     recur(n - 1, acc + n)
   end
-};
+end;
 ```
 
 ### Error Handling
@@ -786,24 +801,24 @@ let computeX = () -> 5;
 let computeY = () -> 10;
 let processResult = (z) -> z * 2;
 
-let result = {
+let result = do
   let x = computeX();
   let y = computeY();
   let z = x * y;
   processResult(z)
-};
+end;
 
 // Block with side effects
 let loadData = () -> [1, 2, 3];
 let processData = (data) -> data map -> $ * 2;
 
-{
+do
   write!("Starting process...");
   let data = loadData();
   let processed = processData(data);
   write!("Process completed");
   processed
-}
+end
 ```
 
 ### Array and Object Construction
@@ -1270,8 +1285,8 @@ Here's the complete precedence table, from highest to lowest:
 | 10 | `+` `-` | Addition, Subtraction | `10 - 3 + 2` → `7 + 2` → `9` |
 | 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` |
+| 7 | `<` `<=` `>` `>=` | Comparison operators | `3 + 2 > 4` → `5 > 4` → `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` |
@@ -1294,7 +1309,8 @@ Here's the complete precedence table, from highest to lowest:
 3 > 2 && 1 < 2;      // => true && true = true
 
 // Pipe has very low precedence
-[1, 2, 3] |> map(_, inc) |> vec:sum;  // Evaluates left to right
+let vec = import("Vector");
+[1, 2, 3] |> map(_, inc) |> vec.sum;  // Evaluates left to right
 
 // Conditional has lowest precedence
 true ? 2 + 3 : 4 + 5;             // => true ? 5 : 9 = 5
@@ -1443,17 +1459,53 @@ let users = [
 let grouped = users |> group-by(_, "department");
 let departmentAges = grouped
   |> entries(_)
-  |> map(_, ([dept, people]) -> {
+  |> map(_, ([dept, people]) -> do
        let ages = people |> map(_, "age");
        let total = ages |> reduce(_, +, 0);
        [dept, total / count(ages)]
-     })
+     end)
   |> (pairs -> zipmap(map(pairs, 0), map(pairs, 1)));
 // => { "Engineering": 32.5, "Marketing": 25 }
 ```
 
 ## JavaScript Interoperability
 
+### Entry Points and Bundles
+
+The package provides multiple entry points for different use cases:
+
+```javascript
+// Minimal entry — core Lits class, types, and type guards only.
+// No modules or reference data. Smallest bundle size.
+import { Lits } from '@mojir/lits';
+
+// Full entry — everything from minimal plus all modules,
+// reference data, and API helpers (e.g. apiReference, isApiName).
+import { Lits, allBuiltinModules, apiReference } from '@mojir/lits/full';
+
+// Individual module entries — import only the modules you need.
+import { vectorModule } from '@mojir/lits/modules/vector';
+import { matrixModule } from '@mojir/lits/modules/matrix';
+import { linearAlgebraModule } from '@mojir/lits/modules/linearAlgebra';
+import { gridModule } from '@mojir/lits/modules/grid';
+import { randomModule } from '@mojir/lits/modules/random';
+import { assertModule } from '@mojir/lits/modules/assert';
+import { numberTheoryModule } from '@mojir/lits/modules/numberTheory';
+```
+
+To make module functions available in Lits code, pass them to the `Lits` constructor:
+
+```javascript
+import { Lits } from '@mojir/lits';
+import { vectorModule } from '@mojir/lits/modules/vector';
+import { matrixModule } from '@mojir/lits/modules/matrix';
+
+const lits = new Lits({ modules: [vectorModule, matrixModule] });
+
+// Now you can use import("Vector") and import("Matrix") in Lits code
+lits.run('let v = import("Vector"); v.dot([1, 2, 3], [4, 5, 6])'); // => 32
+```
+
 ### Using Lits in JavaScript
 
 ```javascript

package/dist/cli/cli/src/cli.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export {};
+import '../../src/initReferenceData';

package/dist/cli/cli/src/js-interop/Cli/Fs/index.d.ts

@@ -0,0 +1,2 @@
+import type { GetFsModule } from '../../utils';
+export declare const getFsModule: GetFsModule;

package/dist/cli/cli/src/js-interop/Cli/Proc/index.d.ts

@@ -0,0 +1,3 @@
+import type { GetFsModule } from '../../utils';
+export declare function sys_cwd(): string;
+export declare const getProcModule: GetFsModule;

package/dist/cli/cli/src/js-interop/Cli/index.d.ts

@@ -0,0 +1,3 @@
+export declare function getCliModule(): {
+    [x: string]: unknown;
+};

package/dist/cli/cli/src/js-interop/utils.d.ts

@@ -0,0 +1,2 @@
+export type Module = Record<string, unknown>;
+export type GetFsModule = (modulePath: string[]) => Module;