functionalscript 0.0.194 → 0.0.201

package/btree/index.js

@@ -1,4 +1,5 @@
-const { index3, index5 } = require('../cmp')
+const cmp = require('../cmp')
+const { index3, index5 } = cmp
 const seq = require('../sequence')
 
 /**
@@ -8,29 +9,29 @@ const seq = require('../sequence')
 
 /**
  * @template T
- * @typedef {import('../cmp').Cmp<T>} Cmp
+ * @typedef {cmp.Cmp<T>} Cmp
  */
 
 /**
  * @template T
- * @typedef {import('../sequence/array').Array1<T>} Array1
+ * @typedef {readonly[T]} Array1
  */
 
 /**
  * @template T
- * @typedef {import('../sequence/array').Array2<T>} Array2
+ * @typedef {readonly[T,T]} Array2
  */
 
 /**
  * @template T
- * @typedef {import('../sequence/array').Array3<T>} Array3
+ * @typedef {readonly[T,T,T]} Array3
  */
 
-/** @typedef {import('../sequence/array').Index2} Index2 */
+/** @typedef {0|1} Index2 */
 
-/** @typedef {import('../sequence/array').Index3} Index3 */
+/** @typedef {0|1|2} Index3 */
 
-/** @typedef {import('../sequence/array').Index5} Index5 */
+/** @typedef {0|1|2|3|4} Index5 */
 
 //
 
@@ -59,14 +60,11 @@ const seq = require('../sequence')
  * @typedef { Leaf1<T> | Leaf2<T> | Branch3<T> | Branch5<T>} Node
  */
 
-/** @typedef {{ readonly done: false }} NotFoundDone */
+/** @typedef {readonly['done']} NotFoundDone */
 
 /** 
  * @template T
- * @typedef {{ 
- *  readonly done: true 
- *  readonly value: T 
- * }} FoundDone 
+ * @typedef {readonly['done', T]} FoundDone 
  */
 
 /**
@@ -76,12 +74,12 @@ const seq = require('../sequence')
 
 /**
  * @template T
- * @typedef {{ readonly replace: Node<T> }} Replace
+ * @typedef {readonly['replace', Node<T>]} Replace
  */
 
 /**
  * @template T
- * @typedef {{ readonly overflow: Branch3<T> }} Overflow
+ * @typedef {readonly['overflow', Branch3<T>]} Overflow
  */
 
 /**
@@ -137,9 +135,11 @@ const split = ([n0, v1, n2, v3, n4, v5, n6]) => [[n0, v1, n2], v3, [n4, v5, n6]]
  *  Result<T>} 
  */
 const merge = overflow => replace => result => {
-    if ('done' in result) { return result }
-    if ('replace' in result) { return { replace: replace(result.replace) } }
-    return overflow(result.overflow)
+    switch (result[0]) {
+        case 'done': { return result }
+        case 'replace': { return ['replace', replace(result[1])] }
+        default: { return overflow(result[1]) }
+    }
 }
 
 /** 
@@ -148,7 +148,7 @@ const merge = overflow => replace => result => {
  *  (result: Result<T>) => 
  *  Result<T>} 
  */
-const merge2 = overflow => merge(o => ({ replace: overflow(o) }))
+const merge2 = overflow => merge(o => ['replace', overflow(o)])
 
 /** 
  * @type {<T>(overflow: (o: Branch3<T>) => Branch7<T>) => 
@@ -156,7 +156,7 @@ const merge2 = overflow => merge(o => ({ replace: overflow(o) }))
  *  (result: Result<T>) => 
  *  Result<T>} 
  */
-const merge3 = overflow => merge(o => ({ overflow: split(overflow(o)) }))
+const merge3 = overflow => merge(o => ['overflow', split(overflow(o))])
 
 /** @type {(visitor: Visitor) => <T>(cmp: Cmp<T>) => (init: Lazy<T>) => (node: Node<T>) => Result<T>} */
 const visit = ({ found, notFound }) => cmp => {
@@ -233,7 +233,7 @@ const visit = ({ found, notFound }) => cmp => {
 }
 
 /** @type { <T>(_: T) => Done<T> } */
-const found = value => ({ done: true, value })
+const found = value => ['done', value]
 
 /** @type {Found} */
 const foundGet = {
@@ -245,7 +245,7 @@ const foundGet = {
     branch5_right: () => ([, , , value]) => found(value),
 }
 /** @type { () => () => NotFoundDone } */
-const notFound = () => () => ({ done: false })
+const notFound = () => () => ['done']
 
 /** @type {NotFound} */
 const notFoundGet = {
@@ -257,7 +257,7 @@ const notFoundGet = {
 }
 
 /** @type { <T>(_: Node<T>) => Replace<T> } */
-const replace = node => ({ replace: node })
+const replace = node => ['replace', node]
 
 /** @type {Found} */
 const foundReplace = {
@@ -270,7 +270,7 @@ const foundReplace = {
 }
 
 /** @type {<T>(leaf3: Array3<T>) => Result<T>} */
-const overflow = ([v0, v1, v2]) => ({ overflow: [[v0], v1, [v2]] })
+const overflow = ([v0, v1, v2]) => ['overflow', [[v0], v1, [v2]]]
 
 /** @type {NotFound} */
 const notFoundInsert = {
@@ -340,7 +340,7 @@ module.exports = {
      */
     getVisitor: cmp => node => {
         const result = visit(getVisitor)(cmp)(() => { throw '' })(node)
-        if ('done' in result && result.done) { return result.value }
+        if (result[0] === 'done') { return result[1] }
         return undefined
     },
     /** @readonly */

package/btree/test.js

@@ -1,30 +1,31 @@
 const btree = require('.')
-const { setVisitor, values: valuesList } = btree
+const { setVisitor, values } = btree
 const { cmp } = require('../cmp') 
 const list = require('../sequence')
 
 /** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string>} */
 const set = node => value => {
     const result = setVisitor(cmp(value))(() => value)(node)
-    if ('replace' in result) { return result.replace }
-    if ('overflow' in result) { return result.overflow }
-    return node
+    switch (result[0]) {
+        case 'replace': case 'overflow': { return result[1] }
+        default: { return node }
+    }
 }
 
 const test = () => {
     /** @type {btree.Node<string>} */
-    let node = ['a']
-    node = set(node)('b')
-    node = set(node)('c')
-    node = set(node)('d')
-    node = set(node)('e')
-    node = set(node)('f')
+    let _map = ['a']
+    _map = set(_map)('b')
+    _map = set(_map)('c')
+    _map = set(_map)('d')
+    _map = set(_map)('e')
+    _map = set(_map)('f')
     //
     {
         /** @type {import('../sequence').Result<string>} */
-        let result = list.next(valuesList(node))
-        while (result !== undefined) {
-            result = list.next(result[1])
+        let _item = list.next(values(_map))
+        while (_item !== undefined) {
+            _item = list.next(_item[1])
         }
     }
 }

package/cmp/index.js

@@ -18,8 +18,8 @@ const index3 = cmp => value => /** @type {Index3} */ (cmp(value) + 1)
 
 /** @type {<T>(cmp: Cmp<T>) => (v2: Array2<T>) => Index5} */
 const index5 = cmp => ([v0, v1]) => {
-    const cmpV0 = cmp(v0)
-    return /** @type {Index5} */ (cmpV0 <= 0 ? cmpV0 + 1 : cmp(v1) + 3)
+    const _0 = cmp(v0)
+    return /** @type {Index5} */ (_0 <= 0 ? _0 + 1 : cmp(v1) + 3)
 }
 
 /** @type {(a: string) => (b: string) => Sign} */

package/json/index.js

@@ -1,7 +1,8 @@
 const seq = require('../sequence')
 const map = require('../map')
 const op = require('../sequence/operator')
-const option = require('../option')
+const object = require('../object')
+const array = require('../sequence/array')
 
 /** 
  * @typedef {{
@@ -23,15 +24,31 @@ const addProperty = value => {
         const [name, tail] = result
         return { ...srcObject, [name]: f(tail)(srcObject[name]) }
     }
-    return path => f(seq.fromArray(path))
+    return path => f(array.sequence(path))
 }
 
+/** @type {(_: string) => seq.Sequence<string>} */
+const stringSerialize = input => seq.list(JSON.stringify(input))
+
+/** @type {(_: number) => seq.Sequence<string>} */
+const numberSerialize = input => seq.list(JSON.stringify(input))
+
+const nullSerialize = seq.list('null')
+
+const trueSerialize = seq.list('true')
+
+const falseSerialize = seq.list('false')
+
+/** @type {(_: boolean) => seq.Sequence<string>} */
+const boolSerialize = value => value ? trueSerialize : falseSerialize
+
 /** @type {(kv: readonly[string, Json]) => seq.Sequence<string>} */
-const property = ([k, v]) => seq.concat(
-    seq.list(JSON.stringify(k)), 
-    seq.list(':'), 
-    stringSequence(v))
+const propertySerialize = ([k, v]) => seq.concat(
+    stringSerialize(k), 
+    colon, 
+    serialize(v))
 
+const colon = seq.list(':')
 const comma = seq.list(',')
 
 /** @type {op.Scan<seq.Sequence<string>, seq.Sequence<string>>} */
@@ -58,48 +75,54 @@ const objectList = list('{')('}')
 const arrayList = list('[')(']')
 
 /** @type {(object: Object) => seq.Sequence<string>} */
-const objectStringify = object => {
-    const _0 = Object.entries(object)
-    const _1 = seq.fromArray(_0)
-    const _2 = map.fromEntries(_1)
-    const _3 = _2.entries
-    const _4 = seq.map(property)(_3)
-    return objectList(_4)
+const objectSerialize = input => {
+    const _0 = object.entries(input)
+    const _1 = map.fromEntries(_0).entries
+    const _2 = seq.map(propertySerialize)(_1)
+    return objectList(_2)
 }
 
-/** @type {(array: Array) => seq.Sequence<string>} */
-const arrayStringify = array => {
-    const _0 = seq.fromArray(array)
-    const _1 = seq.map(stringSequence)(_0)
+/** @type {(input: Array) => seq.Sequence<string>} */
+const arraySerialize = input => {
+    const _0 = array.sequence(input)
+    const _1 = seq.map(serialize)(_0)
     return arrayList(_1)
 }
 
 /** @type {(value: Json) => seq.Sequence<string>} */
-const stringSequence = value => {
-    const x = typeof value
+const serialize = value => {
     switch (typeof value) {
-        case 'boolean': { return seq.list(value ? "true" : "false") }
-        // Note: we shouldn't use JSON.stringify since it has non determenistic behavior.
-        // In particular: property order could be different.
-        case 'number': case 'string': { return seq.list(JSON.stringify(value)) }
+        case 'boolean': { return boolSerialize(value) }
+        case 'number': { return numberSerialize(value) }
+        case 'string': { return stringSerialize(value) }
         default: {
-            if (value === null) { return seq.list("null") }
-            if (value instanceof Array) { return arrayStringify(value) }
-            return objectStringify(value)
+            if (value === null) { return nullSerialize }
+            if (value instanceof Array) { return arraySerialize(value) }
+            return objectSerialize(value)
         }
     }
 }
 
 /**
- * A deterministic version of `JSON.stringify`
+ * A version of `JSON.stringify` with an alphabeticly ordered `keys`.
+ * 
+ * The standard `JSON.stringify` rules determines by 
+ * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
  *  
  * @type {(value: Json) => string} 
  */
-const stringify = value => seq.join('')(stringSequence(value))
+const stringify = value => seq.join('')(serialize(value))
+
+/** @type {(value: string) => Json} */
+const parse = value => JSON.parse(value)
 
 module.exports = {
     /** @readonly */
     addProperty,
     /** @readonly */
     stringify,
+    /** @readonly */
+    serialize,
+    /** @readonly */
+    parse,
 }

package/map/index.js

@@ -44,9 +44,10 @@ const create = root => ({
     get: name => option.map(([,value]) => value)(getVisitor(keyCmp(name))(root)),
     set: name => value => {
         const result = setVisitor(keyCmp(name))(() => [name, value])(root)
-        if ('replace' in result) { return create(result.replace) }
-        if ('overflow' in result) { return create(result.overflow) }
-        throw ''
+        switch (result[0]) {
+            case 'replace': case 'overflow': { return create(result[1]) }
+            default: { throw '' }
+        }
     },
     entries: values(root),
     root,

package/object/index.js

@@ -0,0 +1,17 @@
+const array = require('../sequence/array')
+const seq = require('../sequence')
+
+/**
+ * @template T
+ * @typedef {{
+ *  readonly [k in string]: T
+ * }} Object_
+ */
+
+/** @type {<T>(object: Object_<T>) => seq.Sequence<readonly[string, T]>} */
+const entries = object => array.sequence(Object.entries(object))
+
+module.exports = {
+    /** @readonly */
+    entries,
+}

package/package.json

@@ -1,25 +1,25 @@
 {
-  "name": "functionalscript",
-  "version": "0.0.194",
-  "description": "FunctionalScript is a functional subset of JavaScript",
-  "main": "index.js",
-  "scripts": {
-    "tsc": "tsc",
-    "test": "tsc && npm run test-only",
-    "test-only": "node --trace-uncaught ./test"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/functionalscript/functionalscript.git"
-  },
-  "author": "Natfoam",
-  "license": "Apache-2.0",
-  "bugs": {
-    "url": "https://github.com/functionalscript/functionalscript/issues"
-  },
-  "homepage": "https://github.com/functionalscript/functionalscript#readme",
-  "devDependencies": {
-    "@types/node": "^16.11.9",
-    "typescript": "^4.5.2"
-  }
+   "name": "functionalscript",
+   "version": "0.0.201",
+   "description": "FunctionalScript is a functional subset of JavaScript",
+   "main": "index.js",
+   "scripts": {
+      "tsc": "tsc",
+      "test": "tsc && npm run test-only",
+      "test-only": "node --trace-uncaught ./test"
+   },
+   "repository": {
+      "type": "git",
+      "url": "git+https://github.com/functionalscript/functionalscript.git"
+   },
+   "author": "Natfoam",
+   "license": "Apache-2.0",
+   "bugs": {
+      "url": "https://github.com/functionalscript/functionalscript/issues"
+   },
+   "homepage": "https://github.com/functionalscript/functionalscript#readme",
+   "devDependencies": {
+      "@types/node": "^16.11.9",
+      "typescript": "^4.5.2"
+   }
 }

package/sequence/array/index.js

@@ -1,4 +1,5 @@
 const option = require('../../option')
+const seq = require('..')
 
 /**
  * @template T
@@ -94,6 +95,21 @@ const splitLast = a => {
 /** @type {(index: number) => <T>(a: Array<T>) => readonly[T]|undefined} */
 const at = index => a => index < a.length ? [a[index]] : undefined
 
+/** @type {<T>(array: Array<T>) => seq.Sequence<T>} */
+const sequence = a => {
+    /** @typedef {typeof a extends Array<infer T> ? T : never} T */
+    /** @type {(index: number) => seq.Sequence<T>} */
+    const seq = index => () => {
+        const result = at(index)(a)
+        if (result === undefined) { return undefined }
+        return [result[0], seq(index + 1)]
+    }
+    return seq(0)
+}
+
+/** @type {<T>(list: seq.Sequence<T>) => readonly T[]} */
+const fromSequence = input => Array.from(seq.iterable(input))
+
 module.exports = {
     /** @readonly */
     at,
@@ -109,4 +125,8 @@ module.exports = {
     splitFirst,
     /** @readonly */
     splitLast,
+    /** @readonly */
+    sequence,
+    /** @readonly */
+    fromSequence,
 }

package/sequence/index.js

@@ -1,4 +1,3 @@
-const array = require('./array')
 const seqOp = require('./operator')
 const { combine } = require('../function')
 const op = require('../function/operator')
@@ -33,7 +32,7 @@ const { logicalNot, strictEqual } = require('../function/operator')
 
 /**
  * @template T
- * @typedef {array.Tuple2<T, Sequence<T>>} FirstAndTail
+ * @typedef {readonly[T, Sequence<T>]} FirstAndTail
  */
 
 const empty = () => undefined
@@ -78,31 +77,23 @@ const first = input => {
  * @typedef {(list: Sequence<T>) => R} SequenceReduce
  */
 
-/** @type {<T>(...array: readonly T[]) => Sequence<T>} */
+/**
+ * Note: the operation is not lazy. It traverse the given array and creates a linked list.
+ *  
+ * @type {<T>(...array: readonly T[]) => Sequence<T>} 
+ */
 const list = (...array) => {
     /** @typedef {typeof array extends readonly(infer T)[] ? T : never} T */
     let i = array.length
     /** @type {Sequence<T>} */
-    let tail = empty
-    while (true) {
-        if (i === 0) { return tail }
+    let result = empty
+    while (i !== 0) {
         i = i - 1
         /** @type {FirstAndTail<T>} */
-        const result = [array[i], tail]
-        tail = () => result
-    }
-}
-
-/** @type {<T>(array: array.Array<T>) => Sequence<T>} */
-const fromArray = a => {
-    /** @typedef {typeof a extends array.Array<infer T> ? T : never} T */
-    /** @type {(index: number) => Sequence<T>} */
-    const at = index => () => {
-        const result = array.at(index)(a)
-        if (result === undefined) { return undefined }
-        return [result[0], at(index + 1)]
+        const listResult = [array[i], result]
+        result = () => listResult
     }
-    return at(0)
+    return result
 }
 
 /** @type {<T>(...array: readonly Sequence<T>[]) => Sequence<T>} */
@@ -110,12 +101,12 @@ const concat = (...array) => {
     let i = array.length
     if (i == 0) { return empty }
     i = i - 1
-    let tail = array[i]
-    while (true) {        
-        if (i === 0) { return tail }
+    let result = array[i]
+    while (i !== 0) {
         i = i - 1
-        tail = [array[i], tail]
+        result = [array[i], result]
     }
+    return result
 }
 
 /** @type {(_: number) => Sequence<number>} */
@@ -265,7 +256,7 @@ const asyncIterable = list => ({
     }
 })
 
-/** @type {<A>(a: Sequence<A>) => <B>(b: Sequence<B>) => Sequence<array.Tuple2<A, B>>} */
+/** @type {<A>(a: Sequence<A>) => <B>(b: Sequence<B>) => Sequence<readonly[A, B]>} */
 const zip = a => b => () => {
     const resultA = next(a)
     if (resultA === undefined) { return undefined }
@@ -274,9 +265,6 @@ const zip = a => b => () => {
     return [[resultA[0], resultB[0]], zip(resultA[1])(resultB[1])]
 }
 
-/** @type {<T>(list: Sequence<T>) => readonly T[]} */
-const toArray = input => Array.from(iterable(input))
-
 module.exports = {
     /** @readonly */
     next,
@@ -293,10 +281,6 @@ module.exports = {
     /** @readonly */
     first,
     /** @readonly */
-    fromArray,
-    /** @readonly */
-    toArray,
-    /** @readonly */
     iterable,
     /** @readonly */
     asyncIterable,

package/sequence/iterable/index.js

@@ -1,3 +1,4 @@
+const { iterable } = require('..')
 const { combine } = require('../../function')
 const seq = require('../operator')
 

package/sequence/test.js

@@ -1,6 +1,7 @@
 const seq = require('.')
 const { sum } = require('./operator')
 const op = require('./operator')
+const array = require('./array')
 
 /** @type {<T>(input: seq.Sequence<T>) => void} */
 const print = input => {
@@ -14,9 +15,9 @@ const print = input => {
 }
 
 {
-    const big = seq.fromArray([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 42, 60])
-    const list0 = seq.fromArray([0, 1, 2, 3])
-    const list1 = seq.flatMap(x => seq.fromArray([x, x * 2, x * 3]))(list0)
+    const big = seq.list(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 42, 60)
+    const list0 = seq.list(0, 1, 2, 3)
+    const list1 = seq.flatMap(x => seq.list(x, x * 2, x * 3))(list0)
     const list2 = seq.concat(list0, list0)
     const list3 = seq.exclusiveScan(sum)(list0)
     const r = seq.find(x => x === 42)(big)
@@ -26,15 +27,18 @@ const print = input => {
     if (seq.some(x => x > 50)(big) !== true) { throw 'x' }
     if (seq.first(seq.drop(16)(big)) !== 42) { throw 'drop'}
     {
-        const a = seq.toArray(seq.generate(1_000_000))
-        let x = seq.concat(seq.fromArray(a), big)
+        const a = seq.map(seq.generate)(seq.generate(100_000))
+        const ar = array.fromSequence(a)
+        // This operation use a lot of stack because `...` 
+        // puts array items on a stack.
+        // Use `array.sequence` instead
+        const x = seq.concat(...ar)
         const r = seq.next(x)
         // print(x)
     }
     {
-        const a = seq.map(seq.generate)(seq.generate(100_000))
-        const array = seq.toArray(a)
-        const x = seq.concat(...array)
+        const a = array.fromSequence(seq.generate(1_000_000))
+        let x = seq.concat(array.sequence(a), big)
         const r = seq.next(x)
         // print(x)
     }
@@ -57,6 +61,6 @@ const print = input => {
 }
 
 {
-    const x = seq.join(':')(seq.fromArray(["1", "2", "3", "4", "5", "6"]))
+    const x = seq.join(':')(seq.list("1", "2", "3", "4", "5", "6"))
     if (x !== "1:2:3:4:5:6") { throw x }
 }

package/version.js

@@ -1,5 +1,6 @@
 const cp = require('child_process')
 const fs = require('fs')
+const json = require('./json')
 
 const b =cp.execSync('git log --oneline')
 
@@ -9,8 +10,8 @@ const v = `0.0.${r}`
 
 console.log(`version: ${v}`)
 
-const package_json = JSON.parse(fs.readFileSync('package.json').toString())
+let package_json = json.parse(fs.readFileSync('package.json').toString())
 
-package_json.version = v
+package_json = json.addProperty(v)(['version'])(package_json)
 
-fs.writeFileSync('package.json', JSON.stringify(package_json, null, 2))
+fs.writeFileSync('package.json', JSON.stringify(package_json, null, 3))