functionalscript 0.0.387 → 0.0.390

package/doc/vm.md

@@ -1,17 +1,35 @@
-# VM
+# NaNVM
 
-[Tagged Pointer](https://en.wikipedia.org/wiki/Tagged_pointer).
+https://en.wikipedia.org/wiki/Double-precision_floating-point_format
 
-## Common (3 bit)
+https://anniecherkaev.com/the-secret-life-of-nan
+https://brionv.com/log/2018/05/17/javascript-engine-internals-nan-boxing/
 
-- `false`
-- `true`
-- `undefined`
-- `""`
-- `+infinity`
-- `-infinity`
-- `-0`
-- `NaN`
+
+- 1 bit - sign (S)
+- 11 bit - exponent (E)
+- 52 bit - fraction (F)
+
+|SE |F             |Value           |
+|---|--------------|----------------|
+|000|00000_00000000|+000000_00000000|
+|...|              |                |
+|3FF|00000_00000000|+000000_00000001|
+|...|              |                |
+|434|00000_00000000|+200000_00000000|
+|...|              |                |
+|7FF|00000_00000000|+inf            |
+|...|              |NaN             |
+|800|00000_00000000|-0.0            |
+|...|              |                |
+|BFF|00000_00000000|-000000_00000001|
+|...|              |                |
+|C34|00000_00000000|-200000_00000000|
+|...|              |                |
+|FFF|00000_00000000|-inf            |
+|...|              |NaN             |
+
+integer range: `[-2^53; +2^53]`.
 
 ## 6-bit Id String
 
@@ -23,143 +41,90 @@
 |`_`     |`\x5F`        | 1| 26|
 |`a`..`z`|`\x61`..`\x7A`|1A| 40|
 
-## 64 bit platform
-
-Alignment: 8 bytes.
-
-Pointer: 2^64 / 2^3 = 2^61 bit
-
-### Value
-
-- `63`: 9 x 7 bit string
-- `63`:
-  - `61`: pointer + null, alignment - 8 bytes
-  - `61`:
-    - `60`: 4 x 15 bit string
-    - `60`: 10 x 6 bit string
-  - `61`:
-    - `60`: 6 x 10 bit string
-    - `60`: 5 x 12 bit string
-  - `61`
-    - `60`: float60
-    - `60`:
-      - `59`: bigInt59 (-576_460_752_303_423_488..576_460_752_303_423_487)
-      - `59`:
-        - `56`: 8 x 7-bit string
-        - `56`: 7 x 8-bit string
-        - `53`: int53
-        - `53`: stringUInt53
-        - `48`: 3 x 16 bit string
-        - `32`: 2 x 16 bit string
-        - `16`: 1 x UTF16 string
-        - `3`: common
-
-## Float64
+## 7FF & FFF
 
-https://en.wikipedia.org/wiki/Double-precision_floating-point_format
+53 bits.
 
-- 1 bit - sign (S)
-- 11 bit - exponent (E)
-- 52 bit - fraction (F)
+Other values:
+
+- `NaN`
+- `+Inf`: 0x7FF00000_00000000
+- `-Inf`: 0xFFF00000_00000000
+- pointer + null:
+  - 32 bit for 32 bit platforms.
+  - 48 bit for current AMD64 https://en.wikipedia.org/wiki/X86-64#Canonical_form_addresses and ARM64
+    note: with alignments it can be further narrowed to 44-45 bit.
+- `true`
+- `false`
+- `undefined`
 
-|E            |Description             |
-|-------------|------------------------|
-|000_0000_0000|F = 0: signed zeros     |
-|             |F != 0: subnormals      |
-|000_0000_0001|E = 2^-1022             |
-|...          |                        |
-|011_1111_1111|E = 2^0                 |
-|100_0000_0000|E = 2^1                 |
-|...          |                        |
-|111_1111_1110|E = 2^1023              |
-|111_1111_1111|F = 0: signed infinities|
-|             |F != 0: NaN             |
-
-## Float60
-
-- 1 bit - sign
-- 7 bit - exponent
-- 52 bit - fraction
-
-|E       |Description|
-|--------|-----------|
-|000_0000|E = 2^-63  |
-|...     |           |
-|011_1111|E = 2^0    |
-|100_0000|E = 2^1    |
-|...     |           |
-|111_1111|E = 2^64   |
-
-Note: the type has no `+0`, `-0`, `+inf`, `-inf`, `NaN`.
-
-## Object Structure
-
-Value Size = 8
-Counter size = max_memory_size / value_size.
-
-### Type
-
-- `000`: double
-- `001`: string
-- `010`: array
-- `011`: object
-- `100`: bigInt
-- `101`: function
-- `110`:
-- `111`:
-
-### Type & Counter
-
-- AtomicUSize:
-  - `3`: type
-  - `...`: counter
-
-### String
-
-```rust
-struct String {
-  length: u32,
-  array: [u16; self.length],
-}
-```
-
-### Function
-
-```rust
-struct Function<length: u32> {
-  func: pointer,
-  array: [value; length]
-}
-```
-
-### BigInt
-
-```rust
-struct BigInt {
-  length: u32,
-  array: [u64; self.length],
-}
-```
-
-### Array
-
-```rust
-struct Array {
-  length: u32,
-  array: [Value; self.length],
-}
-```
-
-### Object
-
-```rust
-struct Object {
-  length: u32,
-  array: [(Value, Value), self.length],
-  indexArray: [u32, (self.length * log2(self.length) + 31) / u32],
-}
-```
-
-Note: see https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys and https://262.ecma-international.org/6.0/#sec-object-type
+Optimization for
+- string
+- bigInt
+
+Least used letters in English: Q, J, Z and X.
+
+### Layout 52
+
+Starts with `0xFFF`
+
+- `50`:
+  - `48`: stringUInt48 (0..281_474_976_710_655)
+  - `48`: 8 x 6 string
+  - `48`: `42` 7 x 6 string
+  - `48`: 6 x 8 string
+- `50`:
+  - `48`: `45` 5 x 9 string
+  - `48`: 4 x 12 string
+  - `48`: 3 x 16 string
+  - `48`: `32`: 2 x 16 string
+- `50`:
+  - `48`: `16`: 1 x 16 string
+  - `48`: `0`: ""
+  - `48`: false
+  - `48`: true
+- `50`:
+  - `48`: ptr
+  - `48`: bigInt48 (140_737_488_355_328..140_737_488_355_327)
+  - `48`: undefined
+  - `48`: `-inf`
+
+|      |  |             |type       |
+|------|--|-------------|-----------|
+|`1111`|48|stringUInt48 |`string`   |
+|`1110`|48|8 x 6 string |           |
+|`1101`|48|7 x 7 stringA|           |
+|`1100`|48|7 x 7 stringB|           |
+|`1011`|48|6 x 8 string |           |
+|`1010`|45|5 x 9 string |           |
+|`1001`|48|4 x 12 string|           |
+|`1000`|48|3 x 16 string|           |
+|`0111`|32|2 x 16 string|           |
+|`0110`|16|1 x 16 string|           |
+|`0101`| 0|empty string |           |
+|`0100`| 0|undefined    |`undefined`|
+|`0011`|48|ptr          |...        |
+|`0010`|48|bigInt48     |`bigint`   |
+|`0001`| 0|bool         |`bool`     |
+|`0000`| 0|-inf         |`number`   |
+
+## Pointer Kind
+
+Alignment 8 bytes. 3 bits.
+
+|    |type      |               |
+|----|----------|---------------|
+|00.0|`object`  |null           |
+|00.1|          |object         |
+|01.0|`string`  |string         |
+|01.1|          |               |
+|10.0|`function`|function       |
+|10.1|          |static function|
+|11.0|`bigint`  |bigint         |
+|11.1|          |               |
+
+## Order of object properties
+
+See https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys and https://262.ecma-international.org/6.0/#sec-object-type
 
 An integer index for Node.js, Deno and Bun means a value from `0` to `4294967294` including. 4_294_967_294 = 0xFFFF_FFFE. But an integer index in the ES6 standard is +0..2^53-1.

package/html/module.f.cjs

@@ -1,6 +1,7 @@
 const list = require('../types/list/module.f.cjs')
 const object = require('../types/object/module.f.cjs')
 const { operator, compose } = require('../types/function/module.f.cjs')
+const encoding = require('../text/encoding/module.f.cjs');
 
 /**
  * @typedef {|
@@ -73,7 +74,7 @@ const escapeCharCode = code => {
     }
 }
 
-const escape = compose(list.toCharCodeList)(list.map(escapeCharCode))
+const escape = compose(encoding.stringToUtf16List)(list.map(escapeCharCode))
 
 /** @type {(n: Node) => list.List<string>} */
 const node = n => typeof n === 'string' ? escape(n) : element(n)

package/json/tokenizer/test.f.cjs

@@ -2,9 +2,10 @@ const tokenizer = require('./module.f.cjs')
 const list = require('../../types/list/module.f.cjs')
 const json = require('../module.f.cjs')
 const { sort } = require('../../types/object/module.f.cjs')
+const encoding = require('../../text/encoding/module.f.cjs');
 
 /** @type {(s: string) => readonly tokenizer.JsonToken[]} */
-const tokenizeString = s => list.toArray(tokenizer.tokenize(list.toCharCodeList(s)))
+const tokenizeString = s => list.toArray(tokenizer.tokenize(encoding.stringToUtf16List(s)))
 
 const stringify = json.stringify(sort)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.387",
+  "version": "0.0.390",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "module.f.cjs",
   "scripts": {

package/text/encoding/module.f.cjs

@@ -3,6 +3,8 @@ const list = require('../../types/list/module.f.cjs')
 const operator = require('../../types/function/operator/module.f.cjs')
 const array = require('../../types/array/module.f.cjs')
 const { contains } = require('../../types/range/module.f.cjs')
+const { compose } = require('../../types/function/module.f.cjs')
+const { map, flat, stateScan, concat, fold, toArray, flatMap } = list
 const { ok, error } = result
 
 /** @typedef {result.Result<number,number>} ByteResult */
@@ -54,10 +56,10 @@ const codePointToUtf16 = input =>
 }
 
 /** @type {(input: list.List<number>) => list.List<ByteResult>} */
-const codePointListToUtf8List = list.flatMap(codePointToUtf8)
+const codePointListToUtf8List = flatMap(codePointToUtf8)
 
 /** @type {(input: list.List<i32>) => list.List<u16>} */
-const codePointListToUtf16List = list.flatMap(codePointToUtf16)
+const codePointListToUtf16List = flatMap(codePointToUtf16)
 
 /** @type {operator.StateScan<number, Utf8State, list.List<CodePointResult>>} */
 const utf8ByteToCodePointOp = state => byte => {
@@ -85,7 +87,7 @@ const utf8ByteToCodePointOp = state => byte => {
                 return [[ok(((state[0] & 0x07) << 18) + ((state[1] & 0x3f) << 12) + ((state[2] & 0x3f) << 6) + (byte & 0x3f))], undefined]
         }
     }
-    return [[error(list.toArray(list.concat(state)([byte])))], undefined]
+    return [[error(toArray(concat(state)([byte])))], undefined]
 }
 
 /** @type {(state: Utf8State) => readonly[list.List<CodePointResult>, Utf8State]} */
@@ -95,7 +97,7 @@ const utf8EofToCodePointOp = state => [state === undefined ? undefined : [error(
 const utf8ByteOrEofToCodePointOp = state => input => input === undefined ? utf8EofToCodePointOp(state) : utf8ByteToCodePointOp(state)(input)
 
 /** @type {(input: list.List<number>) => list.List<CodePointResult>} */
-const utf8ListToCodePointList = input => list.flat(list.stateScan(utf8ByteOrEofToCodePointOp)(undefined)(list.concat(/** @type {list.List<ByteOrEof>} */(input))([undefined])))
+const utf8ListToCodePointList = input => flat(stateScan(utf8ByteOrEofToCodePointOp)(undefined)(concat(/** @type {list.List<ByteOrEof>} */(input))([undefined])))
 
 /** @type {operator.StateScan<u16, Utf16State, list.List<i32>>} */
 const utf16ByteToCodePointOp = state => byte => {
@@ -124,7 +126,19 @@ const utf16EofToCodePointOp = state => [state === undefined ? undefined : [state
 const utf16ByteOrEofToCodePointOp = state => input => input === undefined ? utf16EofToCodePointOp(state) : utf16ByteToCodePointOp(state)(input)
 
 /** @type {(input: list.List<u16>) => list.List<i32>} */
-const utf16ListToCodePointList = input => list.flat(list.stateScan(utf16ByteOrEofToCodePointOp)(undefined)(list.concat(/** @type {list.List<WordOrEof>} */(input))([undefined])))
+const utf16ListToCodePointList = input => flat(stateScan(utf16ByteOrEofToCodePointOp)(undefined)(concat(/** @type {list.List<WordOrEof>} */(input))([undefined])))
+
+/** @type {(s: string) => list.List<u16>} */
+const stringToUtf16List = s => {
+    /** @type {(i: number) => list.Result<number>} */
+    const at = i => {
+        const first = s.charCodeAt(i)
+        return isNaN(first) ? undefined : { first, tail: () => at(i + 1) }
+    }
+    return at(0)
+}
+
+const utf16ListToString = compose(map(String.fromCharCode))(fold(operator.concat)(''))
 
 module.exports = {
     /** @readonly */
@@ -134,5 +148,9 @@ module.exports = {
     /** @readonly */
     utf8ListToCodePointList,
     /** @readonly */
-    utf16ListToCodePointList
+    utf16ListToCodePointList,
+    /** @readonly */
+    stringToUtf16List,
+    /** @readonly */
+    utf16ListToString
 }

package/text/encoding/test.f.cjs

@@ -206,4 +206,18 @@ const stringify = a => json.stringify(sort)(a)
     if (result !== '[-2147427328,0]') { throw result }
 }
 
+{
+    const utf16List = encoding.stringToUtf16List("Hello world!😂🚜🚲")
+    const result = encoding.utf16ListToString(utf16List)
+    if (result !== "Hello world!😂🚜🚲") { throw result }
+}
+
+{
+    const a = encoding.stringToUtf16List("Hello world!😂🚜🚲")
+    const b = encoding.utf16ListToCodePointList(a)
+    const c = encoding.codePointListToUtf16List(b)
+    const result = encoding.utf16ListToString(c)
+    if (result !== "Hello world!😂🚜🚲") { throw result }
+}
+
 module.exports = {}

package/types/list/module.f.cjs

@@ -296,18 +296,6 @@ const equalZip = e => a => b => () => {
 /** @type {<T>(e: operator.Equal<T>) => (a: List<T>) => (b: List<T>) => boolean} */
 const equal = e => a => b => every(equalZip(e)(a)(b))
 
-/** @type {(s: string) => List<number>} */
-const toCharCodeList = s => {
-    /** @type {(i: number) => Result<number>} */
-    const at = i => {
-        const first = s.charCodeAt(i)
-        return isNaN(first) ? undefined : { first, tail: () => at(i + 1) }
-    }
-    return at(0)
-}
-
-const fromCharCodeList = compose(map(String.fromCharCode))(fold(operator.concat)(''))
-
 module.exports = {
     /** @readonly */
     empty: undefined,
@@ -384,9 +372,5 @@ module.exports = {
     /** @readonly */
     zip,
     /** @readonly */
-    equal,
-    /** @readonly */
-    toCharCodeList,
-    /** @readonly */
-    fromCharCodeList,
+    equal
 }

package/types/list/test.f.cjs

@@ -236,11 +236,7 @@ const map5 = _.map(x => x > 5)
     if (result !== false) { throw result }
 }
 
-{
-    const r = _.toCharCodeList("Hello world!")
-    const x = _.fromCharCodeList(r)
-    if (x !== "Hello world!") { throw x }
-}
+
 
 // stress tests