functionalscript 0.0.504 → 0.0.505

package/fjson/README.md

@@ -0,0 +1,8 @@
+# FJSON, FJS Object Notation
+
+- additional types: bigint
+
+## Rules
+
+- can serialize/deserialize without reading source code
+  - no function serialization/deserialization

package/fjson/module.f.cjs

@@ -0,0 +1,111 @@
+const list = require('../types/list/module.f.cjs')
+const { next, flat, reduce, map, empty } = list
+const { concat } = require('../types/string/module.f.cjs')
+const object = require('../types/object/module.f.cjs')
+const { at } = object
+const operator = require('../types/function/operator/module.f.cjs')
+const { compose, fn } = require('../types/function/module.f.cjs')
+const { entries } = Object
+const { serialize: bigintSerialize } = require('../types/bigint/module.f.cjs')
+
+/**
+ * @typedef {{
+ *  readonly [k in string]: Unknown
+ * }} Object
+ */
+
+/** @typedef {readonly Unknown[]} Array */
+
+/** @typedef {Object|boolean|string|number|null|Array|bigint} Unknown */
+
+const jsonStringify = JSON.stringify
+
+/** @type {(_: string) => list.List<string>} */
+const stringSerialize = input => [jsonStringify(input)]
+
+/** @type {(_: number) => list.List<string>} */
+const numberSerialize = input => [jsonStringify(input)]
+
+const nullSerialize = ['null']
+
+const trueSerialize = ['true']
+
+const falseSerialize = ['false']
+
+/** @type {(_: boolean) => list.List<string>} */
+const boolSerialize = value => value ? trueSerialize : falseSerialize
+
+const colon = [':']
+const comma = [',']
+
+/** @type {operator.Reduce<list.List<string>>} */
+const joinOp = b => prior => flat([prior, comma, b])
+
+/** @type {(input: list.List<list.List<string>>) => list.List<string>} */
+const join = reduce(joinOp)(empty)
+
+/** @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 => flat([seqOpen, join(input), seqClose])
+}
+
+const objectWrap = wrap('{')('}')
+
+const arrayWrap = wrap('[')(']')
+
+/** @typedef {object.Entry<Unknown>} Entry*/
+
+/** @typedef {(list.List<Entry>)} Entries */
+
+/** @typedef {(entries: Entries) => Entries} MapEntries */
+
+/** @type {(mapEntries: MapEntries) => (value: Unknown) => list.List<string>} */
+const serialize = sort => {
+    /** @type {(kv: readonly[string, Unknown]) => list.List<string>} */
+    const propertySerialize = ([k, v]) => flat([
+        stringSerialize(k),
+        colon,
+        f(v)
+    ])
+    const mapPropertySerialize = map(propertySerialize)
+    /** @type {(object: Object) => list.List<string>} */
+    const objectSerialize = fn(entries)
+        .then(sort)
+        .then(mapPropertySerialize)
+        .then(objectWrap)
+        .result
+    /** @type {(value: Unknown) => list.List<string>} */
+    const f = value => {
+        switch (typeof value) {
+            case 'boolean': { return boolSerialize(value) }
+            case 'number': { return numberSerialize(value) }
+            case 'string': { return stringSerialize(value) }
+            case 'bigint': { return [bigintSerialize(value)] }
+            default: {
+                if (value === null) { return nullSerialize }
+                if (value instanceof Array) { return arraySerialize(value) }
+                return objectSerialize(value)
+            }
+        }
+    }
+    const arraySerialize = compose(map(f))(arrayWrap)
+    return f
+}
+
+/**
+ * The standard `JSON.stringify` rules determined by
+ * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
+ *
+ * @type {(mapEntries: MapEntries) => (value: Unknown) => string}
+ */
+const stringify = sort => compose(serialize(sort))(concat)
+
+module.exports = {
+
+    /** @readonly */
+    stringify,
+    /** @readonly */
+    serialize,
+}

package/fjson/test.f.cjs

@@ -0,0 +1,65 @@
+const json = require('../json/module.f.cjs')
+const { sort } = require('../types/object/module.f.cjs')
+const { identity } = require('../types/function/module.f.cjs')
+const fjson= require('./module.f.cjs')
+
+module.exports = {
+    stringify: [
+        {
+            sort: () => {
+                const r = json.setProperty("Hello")(['a'])({})
+                const x = fjson.stringify(sort)(r)
+                if (x !== '{"a":"Hello"}') { throw x }
+            },
+            identity: () => {
+                const x = fjson.stringify(identity)(json.setProperty("Hello")(['a'])({}))
+                if (x !== '{"a":"Hello"}') { throw x }
+            },
+        },
+        {
+            sort: () => {
+                const x = fjson.stringify(sort)(json.setProperty("Hello")(['a'])({ c: [], b: 12 }))
+                if (x !== '{"a":"Hello","b":12,"c":[]}') { throw x }
+            },
+            identity: () => {
+                const x = fjson.stringify(identity)(json.setProperty("Hello")(['a'])({ c: [], b: 12 }))
+                if (x !== '{"c":[],"b":12,"a":"Hello"}') { throw x }
+            },
+        },
+        {
+            sort: () => {
+                const _0 = { a: { y: [24] }, c: [], b: 12 }
+                const _1 = json.setProperty("Hello")(['a', 'x'])(_0)
+                const _2 = fjson.stringify(sort)(_1)
+                if (_2 !== '{"a":{"x":"Hello","y":[24]},"b":12,"c":[]}') { throw _2 }
+            },
+            identity: () => {
+                const _0 = { a: { y: [24] }, c: [], b: 12 }
+                const _1 = json.setProperty("Hello")(['a', 'x'])(_0)
+                const _2 = fjson.stringify(identity)(_1)
+                if (_2 !== '{"a":{"y":[24],"x":"Hello"},"c":[],"b":12}') { throw _2 }
+            }
+        },
+        {
+            stringify: () => {
+                const bi = 1234567890n
+                const result = fjson.stringify(sort)(bi)
+                if (result !== '1234567890n') { throw result }
+            }
+        },
+        {
+            stringify: () => {
+                const arr = [0n, 1, 2n]
+                const result = fjson.stringify(sort)(arr)
+                if (result !== '[0n,1,2n]') { throw result }
+            }
+        },
+        {
+            stringify: () => {
+                const obj = {"a": 0n, "b": 1, "c": 2n}
+                const result = fjson.stringify(sort)(obj)
+                if (result !== '{"a":0n,"b":1,"c":2n}') { throw result }
+            }
+        }
+    ]
+}

package/package.json

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

package/types/bigint/module.f.cjs

@@ -13,6 +13,9 @@ const abs = a => a >= 0 ? a : -a
 /** @type {(a: bigint) => compare.Sign} */
 const sign = a => unsafeCmp(a)(0n)
 
+/** @type {(a: bigint) => string} */
+const serialize = a => `${a}n`
+
 module.exports = {
     /** @readonly */
     addition,
@@ -22,4 +25,6 @@ module.exports = {
     abs,
     /** @readonly */
     sign,
+    /** @readonly */
+    serialize,
 }

package/types/bigint/test.f.cjs

@@ -1,4 +1,4 @@
-const { sum, abs } = require('./module.f.cjs')
+const { sum, abs, serialize } = require('./module.f.cjs')
 
 module.exports = {
     sum: () => {
@@ -14,5 +14,19 @@ module.exports = {
             const result = abs(-10n)
             if (result !== 10n) { throw result }
         }
+    ],
+    serialize: [
+        () => {
+            const result = serialize(0n)
+            if (result !== '0n') { throw result }
+        },
+        () => {
+            const result = serialize(123456789012345678901234567890n)
+            if (result !== '123456789012345678901234567890n') { throw result }
+        },
+        () => {
+            const result = serialize(-55555n)
+            if (result !== '-55555n') { throw result }
+        },
     ]
 }