functionalscript 0.0.389 → 0.0.392

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,96 +41,103 @@
 |`_`     |`\x5F`        | 1| 26|
 |`a`..`z`|`\x61`..`\x7A`|1A| 40|
 
-## Value
-
-Alignment: 8 bytes.
-
-Pointer: 2^64 / 2^3 = 2^61 bit
-
-- `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)
-
-|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   |
+Other values:
 
-Note: the type has no `+0`, `-0`, `+inf`, `-inf`, `NaN`.
-
-## Object Structure
-
-Value Size = 8
-Counter size = max_memory_size / value_size.
-
-### Type
+- `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`
 
-- `000`: double
-- `001`: string
-- `010`: array
-- `011`: object
-- `100`: bigInt
-- `101`: function
-- `110`:
-- `111`:
+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`|48|ptr          |?          |
+|`0011`| 0|undefined    |`undefined`|
+|`0010`|48|bigInt48     |`bigint`   |
+|`0001`| 0|bool         |`bool`     |
+|`0000`| 0|-inf         |`number`   |
+
+## Pointer Kind
+
+Alignment 8 bytes. 3 bits.
+
+|    |type      |               |
+|----|----------|---------------|
+|00.0|`object`  |object         |
+|00.1|          |array          |
+|01.0|`string`  |string         |
+|01.1|          |               |
+|10.0|`function`|function       |
+|10.1|          |static function|
+|11.0|`bigint`  |bigint         |
+|11.1|          |               |
+
+## Object
 
-### Type & Counter
+```rust
+struct Object {
+  propertySet: PropertySet
+  iterable: Func<Iterator>
+}
 
-- AtomicUSize:
-  - `3`: type
-  - `...`: counter
+struct Array {
+  length: u32,
+  array: [Value; self.lenght],
+}
+```
 
-### String
+## String
 
 ```rust
 struct String {
@@ -121,16 +146,16 @@ struct String {
 }
 ```
 
-### Function
+## Function
 
 ```rust
-struct Function<length: u32> {
-  func: pointer,
-  array: [value; length]
+struct Function {
+  pointer: FunctionBody,
+  array: [Value; length],
 }
 ```
 
-### BigInt
+## BigInt
 
 ```rust
 struct BigInt {
@@ -139,25 +164,8 @@ struct BigInt {
 }
 ```
 
-### 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],
-}
-```
+## Order of object properties
 
-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
+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,7 +1,12 @@
 const list = require('../types/list/module.f.cjs')
+const { map, flatMap, flat, concat, fold } = list
 const object = require('../types/object/module.f.cjs')
-const { operator, compose } = require('../types/function/module.f.cjs')
+const { compose } = require('../types/function/module.f.cjs')
 const encoding = require('../text/encoding/module.f.cjs');
+const { stringToUtf16List } = encoding
+
+const { fromCharCode } = String
+const { entries } = Object
 
 /**
  * @typedef {|
@@ -70,22 +75,22 @@ const escapeCharCode = code => {
         case 0x26: return '&'
         case 0x3C: return '<'
         case 0x3E: return '>'
-        default: return String.fromCharCode(code)
+        default: return fromCharCode(code)
     }
 }
 
-const escape = compose(encoding.stringToUtf16List)(list.map(escapeCharCode))
+const escape = compose(stringToUtf16List)(map(escapeCharCode))
 
 /** @type {(n: Node) => list.List<string>} */
 const node = n => typeof n === 'string' ? escape(n) : element(n)
 
-const nodes = list.flatMap(node)
+const nodes = flatMap(node)
 
 /** @type {(a: object.Entry<string>) => list.List<string>} */
-const attribute = ([name, value]) => list.flat([[' ', name, '="'], escape(value), ['"']])
+const attribute = ([name, value]) => flat([[' ', name, '="'], escape(value), ['"']])
 
 /** @type {(a: Attributes) => list.List<string>} */
-const attributes = compose(Object.entries)(list.flatMap(attribute))
+const attributes = compose(entries)(flatMap(attribute))
 
 /** @type {(element: Element) => list.List<string>} */
 const element = e => {
@@ -104,12 +109,12 @@ const element = e => {
             }
         }
     }
-    return list.flat(f())
+    return flat(f())
 }
 
-const html = compose(element)(list.concat(['<!DOCTYPE html>']))
+const html = compose(element)(concat(['<!DOCTYPE html>']))
 
-const htmlToString = compose(html)(list.fold(operator.concat)(''))
+const htmlToString =  compose(html)(list.stringConcat)
 
 module.exports = {
     /** @readonly */

package/json/module.f.cjs

@@ -1,7 +1,10 @@
 const list = require('../types/list/module.f.cjs')
+const { next, flat, fold, map, stringConcat } = list
 const object = require('../types/object/module.f.cjs')
+const { at } = object
 const operator = require('../types/function/operator/module.f.cjs')
 const { compose } = require('../types/function/module.f.cjs')
+const { entries } = Object
 
 /**
  * @typedef {{
@@ -17,20 +20,22 @@ const { compose } = require('../types/function/module.f.cjs')
 const setProperty = value => {
     /** @type {(path: list.List<string>) => (src: Unknown|undefined) => Unknown} */
     const f = path => src => {
-        const result = list.next(path)
+        const result = next(path)
         if (result === undefined) { return value }
         const srcObject = (src === undefined || src === null || typeof src !== 'object' || src instanceof Array) ? {} : src
         const { first, tail } = result
-        return { ...srcObject, [first]: f(tail)(object.at(first)(srcObject)) }
+        return { ...srcObject, [first]: f(tail)(at(first)(srcObject)) }
     }
     return f
 }
 
+const jsonStringify = JSON.stringify
+
 /** @type {(_: string) => list.List<string>} */
-const stringSerialize = input => [JSON.stringify(input)]
+const stringSerialize = input => [jsonStringify(input)]
 
 /** @type {(_: number) => list.List<string>} */
-const numberSerialize = input => [JSON.stringify(input)]
+const numberSerialize = input => [jsonStringify(input)]
 
 const nullSerialize = ['null']
 
@@ -45,16 +50,16 @@ const colon = [':']
 const comma = [',']
 
 /** @type {operator.Fold<list.List<string>>} */
-const joinOp = b => prior => list.flat([prior, comma, b])
+const joinOp = b => prior => flat([prior, comma, b])
 
 /** @type {(input: list.List<list.List<string>>) => list.List<string>} */
-const join = list.fold(joinOp)([])
+const join = fold(joinOp)([])
 
 /** @type {(open: string) => (close: string) => (input: list.List<list.List<string>>) => list.List<string>} */
 const wrap = open => close => {
     const seqOpen = [open]
     const seqClose = [close]
-    return input => list.flat([seqOpen, join(input), seqClose])
+    return input => flat([seqOpen, join(input), seqClose])
 }
 
 const objectWrap = wrap('{')('}')
@@ -70,13 +75,14 @@ const arrayWrap = wrap('[')(']')
 /** @type {(mapEntries: MapEntries) => (value: Unknown) => list.List<string>} */
 const serialize = sort => {
     /** @type {(kv: readonly[string, Unknown]) => list.List<string>} */
-    const propertySerialize = ([k, v]) => list.flat([
+    const propertySerialize = ([k, v]) => flat([
         stringSerialize(k),
         colon,
         f(v)
     ])
+    const mapPropertySerialize = map(propertySerialize)
     /** @type {(object: Object) => list.List<string>} */
-    const objectSerialize = input => objectWrap(list.map(propertySerialize)(sort(Object.entries(input))))
+    const objectSerialize = input => objectWrap(mapPropertySerialize(sort(entries(input))))
     /** @type {(value: Unknown) => list.List<string>} */
     const f = value => {
         switch (typeof value) {
@@ -90,8 +96,9 @@ const serialize = sort => {
             }
         }
     }
+    const mapF = map(f)
     /** @type {(input: Array) => list.List<string>} */
-    const arraySerialize = compose(list.map(f))(arrayWrap)
+    const arraySerialize = compose(mapF)(arrayWrap)
     return f
 }
 
@@ -101,7 +108,7 @@ const serialize = sort => {
  *
  * @type {(mapEntries: MapEntries) => (value: Unknown) => string}
  */
-const stringify = sort => compose(serialize(sort))(list.join(''))
+const stringify = sort => compose(serialize(sort))(stringConcat)
 
 /** @type {(value: string) => Unknown} */
 const parse = JSON.parse