functionalscript 0.0.565 → 0.0.567

package/.github/workflows/ci.yml

@@ -87,6 +87,6 @@ jobs:
         name: package-lock.json
     - uses: actions/setup-dotnet@v3
       with:
-        dotnet-version: 8
+        dotnet-version: 9
     - run: npm ci
     - run: npm run comtest

package/.github/workflows/npm-publish.yml

@@ -16,7 +16,7 @@ jobs:
           fetch-depth: 0
       - uses: actions/setup-node@v2
         with:
-          node-version: 19
+          node-version: 22
           registry-url: https://registry.npmjs.org/
       # - run: npm ci
       - run: npm run version

package/doc/byte-code.md

@@ -42,19 +42,18 @@ struct Module {
 }
 ```
 
-|type|any           |tag|                       |                             |
-|----|--------------|---|-----------------------|-----------------------------|
-|JSON|null          | 00|                       |                             |
-|    |number        | 01|u64                    |                             |
-|    |false         | 02|                       |                             |
-|    |true          | 03|                       |                             |
-|    |string        | 04|String                 |                             |
-|    |object        | 05|Object                 |                             |
-|    |array         | 06|Array<Any>             |                             |
-|DJS |bigint+       | 07|BigUInt                |                             |
-|    |bigint-       | 08|BigUInt                |                             |
-|    |local_ref     | 09|u32                    |consts[i]                    |
-|FJS |arg_ref       | 0A|u32                    |args[i]                      |
-|    |undefined     | 0B|                       |                             |
-|    |function      | 0C|Function               |the last constant is a return|
-|    |...           |   |                       |                             |
+|format|any            |Tag|                       |
+|------|---------------|---|-----------------------|
+|JSON  |null           | 00|                       |
+|      |number         | 01|u64                    |
+|      |false          | 02|                       |
+|      |true           | 03|                       |
+|      |string         | 04|String                 |
+|      |object         | 05|Object                 |
+|      |array          | 06|Array<Any>             |
+|DJS   |ref            | 07|u32                    |
+|      |positive_bigint| 08|BigUInt                |
+|      |negative_bigint| 09|BigUInt                |
+|FJS   |function       | 0A|Function               |
+|      |arg_ref        | 0B|u32                    |
+|      |undefined      | 0C|                       |

package/doc/fa.md

@@ -1,10 +1,13 @@
 # FA
 
+```
 F ::= A 'hello'
 F ::= A 'help'
+```
 
 ## Classic FA
 
+```
 S0 ::= A 'h'
 S1 ::= S0 'e'
 S2 ::= S1 'l'
@@ -15,9 +18,11 @@ X0 ::= A 'h'
 X1 ::= X0 'e'
 X2 ::= X1 'l'
 F ::= X2 'p'
+```
 
 ## DFA
 
+```
 {S0,X0} = A 'h'
 {S1,X1} ::= {S0,X0} 'e'
 {S2,X2} ::= {S1,X1} 'l'
@@ -31,24 +36,29 @@ P2 ::= P1 'l'
 S3 ::= P2 'l'
 F ::= P2 'p'
 F ::= S3 'o'
+```
 
 ## Tokenizer FA
 
+```
 T ::= I 'true'  // T0, T1, T2
 F ::= I 'false' // F0, F2, F2, F3
 N ::= I 'null'  // N0, N1, N2
 Id ::= I letter
 Id ::= Id letter
 Id ::= Id digit
+```
 
 ## Tokenizer DFA
 
+```
 {T0,Id} = I 't'
 {T1,Id} = {T0,Id} 'r'
 Id = {T0,Id} letter(except 'r')
 Id = {T0,Id} digit
 
 {a..b}{c..d}{e..f}
+```
 
 ```js
 const t0 = [[init, one('t')]]

package/doc/proposals.md

@@ -0,0 +1,21 @@
+# ECMAScripts Proposals
+
+ECMAScript proposals that may affect FunctionalScript
+
+- Type Annotations: https://github.com/tc39/proposal-type-annotations
+  ```js
+  const add = (a: bigint) => (b: bigint) => a + b
+  ```
+- Deeply Immutable Record and Tuples: https://github.com/tc39/proposal-record-tuple
+  ```js
+  const r = #{ x: 4, y: "s" }
+  const t = #[5, "hello"] 
+  ```
+  Because these types are deeply immutable and the equality operator '===' works as deep equality, it's a good candidate for content-addressable type system.
+- Pipeline operator https://github.com/tc39/proposal-pipeline-operator
+  ```js
+  const double = a => a + a
+  const munis1 = a => a - 1
+  const f = a => a |> double(%) |> minus1(%) 
+  ```
+  I, Sergey, still prefer F# pipeline operator and strongly believe that it's possible to have both syntax in the language.

package/doc/vm/README.md

@@ -0,0 +1,24 @@
+# VM
+
+Two options:
+- using instances
+- using types. In this case, if we need multiple VMs in the same process, we need multiple types.
+
+## Rust Interface
+
+```rust
+trait Any {
+}
+
+trait String {
+}
+
+trait Bigint {
+}
+
+trait Object {
+}
+
+trait Array {
+}
+```

package/doc/vm-rearchitecture.md

@@ -0,0 +1,129 @@
+# NaNVM Re-Architecture
+
+About a year ago (Nov 2023), the FunctionalScript team started a new project called [NaNVM](https://github.com/functionalscript/nanvm). We have limited resources (⌛💰) for the projects, so progress has been slow. Since then, we’ve implemented several components from scratch in Rust:
+- An interface and multiple implementations for [Memory Management](https://github.com/functionalscript/nanvm/tree/main/nanvm-lib/src/mem), such as a [global](https://github.com/functionalscript/nanvm/blob/main/nanvm-lib/src/mem/global.rs) memory manager using standard `alloc/dealloc`, a [local](https://github.com/functionalscript/nanvm/blob/main/nanvm-lib/src/mem/local.rs) manager with a reference counter, and a simple [arena](https://github.com/functionalscript/nanvm/blob/main/nanvm-lib/src/mem/arena.rs) implementation.
+- [All FS data types](https://github.com/functionalscript/nanvm/tree/main/nanvm-lib/src/js) in the VM, such as [string](https://github.com/functionalscript/nanvm/blob/main/nanvm-lib/src/js/js_string.rs), [bigint](https://github.com/functionalscript/nanvm/blob/main/nanvm-lib/src/js/js_bigint.rs), [array](https://github.com/functionalscript/nanvm/blob/main/nanvm-lib/src/js/js_array.rs), [object](https://github.com/functionalscript/nanvm/blob/main/nanvm-lib/src/js/js_object.rs), and [any](https://github.com/functionalscript/nanvm/blob/main/nanvm-lib/src/js/any.rs).
+- And, of course, we've implemented a parser for JSON and DJS in Rust, which works well. See [this article about DJS](https://medium.com/@sasha.gil/bridging-the-gap-from-json-to-javascript-without-dsls-fee273573f1b) for more information.
+
+All of this code is written in Rust. Rust excels at runtime performance and system-level programming. However, developers often struggle when working with high-level and business logic. Its verbosity and various memory management models make developing components like parsers in Rust slow and complex. It’s great for implementing a memory manager, a VM, or a big integer but less suited for tasks like implementing a parser efficiently (and yes, we are aware of third-party parser generators). That’s why we want to use a high-level language for this purpose. Of course, we don't need to search for one because we already have FunctionalScript and JavaScript as glue. Additionally, because of our limited resources, we aim to use only a few repositories. As a result, we plan to merge the NaNVM code into the [FunctionalScript repo](https://github.com/functionalscript/functionalscript).
+
+## Stage 0: Current State
+
+Before we start rearchitecting the project, we should understand our current architecture. Here's the current module dependency graph for [nanvm_lib](https://github.com/functionalscript/nanvm/tree/main/nanvm-lib/src):
+
+```mermaid
+flowchart TB
+  app[Application] --> parser[Parser] --> js[VM] --> mem[Memory Manager]
+```
+
+The parser is written in Rust using VM types, such as `JsString` and `JsBigInt`. The application can parse JSON and DJS files and output in any of these formats as a standalone module.
+
+## Stage 1: Using a Third-Party JS Engine for Parsing
+
+Because FunctionalScript is a subset of JavaScript, we can use third-party JavaScript engines to bootstrap our parser, written on FunctionalScript, without circular dependencies. In Rust, we only need to implement a generic byte code deserializer that reads byte code and invokes VM API functions. We selected [Deno](https://deno.com/) and its [deno_core](https://crates.io/crates/deno_core/) package as a third-party JS engine because it's also written in Rust, has a crate and it's easy to integrate with our project.
+
+```mermaid
+flowchart TB
+  app[Application] --> deno(deno_core)
+  app --> bcd[Byte Code Deserializer] --> js[VM] --> mem[Memory Manager]
+```
+
+### Requirements 
+1. To restore previous functionality, we still need a parser that can convert FunctionalScript or DJS into byte code,
+2. We have to design byte code for FunctionalScript and implement its deserializer in Rust.
+
+### Build Process
+
+To satisfy the first requirement, we need a parser written in FunctionalScript. The build process should then take the parser source code and embed it into the application. See [include_str](https://doc.rust-lang.org/std/macro.include_str.html) for more details.
+
+```mermaid
+flowchart TB
+  app[Application] --> deno(deno_core)
+  app --> bcd[Byte Code Deserializer] --> js[VM] --> mem[Memory Manager]
+  app --> fsp[(Functional Script Parser Source Code)]
+```
+
+### Run-Time Process
+
+1. The application loads the parser source code from memory into the Deno engine.
+2. The application executes the parser in the JS engine with the command-line parameters provided by the user.
+3. After the parser generates the byte code, the application sends this byte code to the VM.
+
+This stage provides an interim solution to parse FunctionalScript using Deno while we develop the self-hosted parser.
+
+## Stage 2: Moving the Deno into `dev-dependencies`
+
+Once our parser can parse itself and convert it into byte code, we can move the `deno_core` to development dependencies. This means that we need it only for build time. This transition eliminates the runtime dependency on Deno, streamlining deployment and reducing overhead in production environments.
+
+### Build Process
+
+1. Run the parser on itself using Deno and generate byte code for the parser.
+2. Embed the generated byte code into our application ([include_bytes](https://doc.rust-lang.org/std/macro.include_bytes.html)).
+
+### Run-Time Process
+
+```mermaid
+flowchart TB
+  app[Application] --> bcd[Byte Code Deserializer] --> js[VM] --> mem[Memory Manager]
+  app --> fspbc[(Functional Script Parser Byte Code)]
+```
+
+The application can do two things:
+1. Convert FunctionalScript code into byte code using the parser source code and the VM.
+2. Execute byte code using the VM.
+
+## Byte code
+
+The byte code format is designed for fast and straightforward deserialization and doesn't depend on a particular VM implementation. This design ensures that the byte code remains portable and does not rely on a specific VM implementation, allowing flexibility in integrating with other environments, including content-addressable implementation of FunctionalScript.
+
+### Requirements
+
+- **Simple deserialization**: `string` is UTF16, `number` and `bigint` in a binary format, `usize` is 32 bits.
+- **No imports**: byte code describes a standalone module without dependencies. A parser should resolve all imports.
+- **No syntax sugar**: a parser should convert all syntax sugar operations into basic commands.
+- **One unit is one byte**: Byte code can be serialized into a byte array or a file.
+- **Least significant byte first**: Our `bigint` implementation is LSB first, and most current CPU architectures are.
+
+### Pseudo-Code for the byte code binary format
+
+We use syntax that looks like Rust to describe the binary format.
+
+```rust
+struct Array<T> {
+    len: u32,
+    array: [T; self.len],
+}
+ 
+type String = Array<u16>;
+
+// LSB first.
+type BigUInt = Array<u64>;
+
+type Object = Array<(String, Any)>;
+
+type Tag = u8
+
+// This is the main structure for serialization.
+type Code = Array<u8>;
+```
+
+### Tags/commands for JSON and DJS.
+
+|format|any           |Tag|                       |
+|------|--------------|---|-----------------------|
+|JSON  |null          | 00|                       |
+|      |number        | 01|u64                    |
+|      |false         | 02|                       |
+|      |true          | 03|                       |
+|      |string        | 04|String                 |
+|      |object        | 05|Object                 |
+|      |array         | 06|Array<Any>             |
+|DJS   |reference     | 07|u32                    |
+|      |bigint+       | 08|BigUInt                |
+|      |bigint-       | 09|BigUInt                |
+
+We will add new tags for FunctionalScript byte code in the future as they are not needed for Stage 1. 
+
+## Summary
+
+If you find this architecture promising and want to support the development of a standalone FunctionalScript VM, please consider [sponsoring the project ❤️](https://opencollective.com/functionalscript). Additionally, we welcome contributions and feedback from the open-source community to accelerate this initiative.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.565",
+  "version": "0.0.567",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "module.f.cjs",
   "scripts": {
@@ -30,7 +30,7 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@types/node": "^22.9.0",
+    "@types/node": "^22.9.1",
     "typescript": "^5.6.3"
   }
 }

package/text/utf8/module.f.cjs

@@ -34,15 +34,28 @@ const fromCodePointList = flatMap(codePointToUtf8)
 
 /** @type {(state: Utf8NonEmptyState) => i32}*/
 const utf8StateToError = state => {
+    let x
     switch (state.length) {
-        case 1:
-            return state[0] | errorMask
-        case 2:
-            if (state[0] < 0b1111_0000) return (((state[0] & 0b0000_1111) << 6) + (state[1] & 0b0011_1111) + 0b0000_0100_0000_0000) | errorMask
-            return (((state[0] & 0b0000_0111) << 6) + (state[1] & 0b0011_1111) + 0b0000_0010_0000_0000) | errorMask
-        case 3:
-            return (((state[0] & 0b0000_0111) << 12) + ((state[1] & 0b0011_1111) << 6) + (state[2] & 0b0011_1111) + 0b1000_0000_0000_0000) | errorMask
+        case 1: {
+            [x] = state
+            break
+        }
+        case 2: {
+            const [s0, s1] = state
+            x = s0 < 0b1111_0000
+                ? ((s0 & 0b0000_1111) << 6) + (s1 & 0b0011_1111) + 0b0000_0100_0000_0000
+                : ((s0 & 0b0000_0111) << 6) + (s1 & 0b0011_1111) + 0b0000_0010_0000_0000
+            break
+        }
+        case 3: {
+            const [s0, s1, s2] = state
+            x = ((s0 & 0b0000_0111) << 12) + ((s1 & 0b0011_1111) << 6) + (s2 & 0b0011_1111) + 0b1000_0000_0000_0000
+            break
+        }
+        default:
+            throw 'invalid state'
     }
+    return x | errorMask
 }
 
 /** @type {operator.StateScan<number, Utf8State, list.List<i32>>} */
@@ -57,16 +70,22 @@ const utf8ByteToCodePointOp = state => byte => {
     }
     if (byte >= 0b1000_0000 && byte < 0b1100_0000) {
         switch (state.length) {
-            case 1:
-                if (state[0] < 0b1110_0000) { return [[((state[0] & 0b0001_1111) << 6) + (byte & 0b0011_1111)], null] }
-                if (state[0] < 0b1111_1000) { return [[], [state[0], byte]] }
+            case 1: {
+                const [s0] = state
+                if (s0 < 0b1110_0000) { return [[((s0 & 0b0001_1111) << 6) + (byte & 0b0011_1111)], null] }
+                if (s0 < 0b1111_1000) { return [[], [s0, byte]] }
                 break
-            case 2:
-                if (state[0] < 0b1111_0000) { return [[((state[0] & 0b0000_1111) << 12) + ((state[1] & 0b0011_1111) << 6) + (byte & 0b0011_1111)], null] }
-                if (state[0] < 0b1111_1000) { return [[], [state[0], state[1], byte]] }
+            }
+            case 2: {
+                const [s0, s1] = state
+                if (s0 < 0b1111_0000) { return [[((s0 & 0b0000_1111) << 12) + ((s1 & 0b0011_1111) << 6) + (byte & 0b0011_1111)], null] }
+                if (s0 < 0b1111_1000) { return [[], [s0, s1, byte]] }
                 break
-            case 3:
-                return [[((state[0] & 0b0000_0111) << 18) + ((state[1] & 0b0011_1111) << 12) + ((state[2] & 0b0011_1111) << 6) + (byte & 0b0011_1111)], null]
+            }
+            case 3: {
+                const [s0, s1, s2] = state
+                return [[((s0 & 0b0000_0111) << 18) + ((s1 & 0b0011_1111) << 12) + ((s2 & 0b0011_1111) << 6) + (byte & 0b0011_1111)], null]
+            }
         }
     }
     const error = utf8StateToError(state)
@@ -76,10 +95,8 @@ const utf8ByteToCodePointOp = state => byte => {
 }
 
 /** @type {(state: Utf8State) => readonly[list.List<i32>, Utf8State]} */
-const utf8EofToCodePointOp = state => {
-    if (state === null) { return [null, null] }
-    return [[utf8StateToError(state)], null]
-}
+const utf8EofToCodePointOp = state =>
+    [state === null ? null : [utf8StateToError(state)], null]
 
 /** @type {operator.StateScan<ByteOrEof, Utf8State, list.List<i32>>} */
 const utf8ByteOrEofToCodePointOp = state => input => input === null ? utf8EofToCodePointOp(state) : utf8ByteToCodePointOp(state)(input)

package/types/range_map/test.f.cjs

@@ -7,7 +7,7 @@ const { list } = require('../module.f.cjs')
 const operator = require("../function/operator/module.f.cjs")
 
 /** @type {(a: readonly json.Unknown[]) => string} */
-const stringify = a => json.stringify(sort)(a)
+const stringify = json.stringify(sort)
 
 /** @type {_.Operators<sortedSet.SortedSet<string>>} */
 const op = { union: sortedSet.union(unsafeCmp), equal: list.equal(operator.strictEqual) }