functionalscript 0.0.190 → 0.0.191

package/btree/index.js

@@ -305,28 +305,25 @@ const replaceVisitor = {
     notFound: notFoundGet,
 }
 
-/** @type {<T>(...array: readonly seq.Sequence<T>[]) => seq.Sequence<T>} */
-const flatArray = (...array) => seq.flat(seq.fromArray(array))
-
 /** @type {<T>(node: Node<T>) => seq.Sequence<T>} */
-const valuesList = node => () => {
+const values = node => () => {
     const f = () => {
         switch (node.length) {
-            case 1: case 2: { return seq.fromArray(node) }
+            case 1: case 2: { return seq.list(...node) }
             case 3: { 
-                return flatArray(
-                    valuesList(node[0]), 
-                    seq.one(node[1]), 
-                    valuesList(node[2])
+                return seq.concat(
+                    values(node[0]), 
+                    seq.list(node[1]), 
+                    values(node[2])
                 )
             }
             default: {
-                return flatArray(
-                    valuesList(node[0]),
-                    seq.one(node[1]),
-                    valuesList(node[2]),
-                    seq.one(node[3]),
-                    valuesList(node[4])
+                return seq.concat(
+                    values(node[0]),
+                    seq.list(node[1]),
+                    values(node[2]),
+                    seq.list(node[3]),
+                    values(node[4])
                 )
             }
         }
@@ -336,7 +333,7 @@ const valuesList = node => () => {
 
 module.exports = {
     /** @readonly */
-    valuesList,
+    values,
     /** 
      * @readonly
      * @type { <T>(cmp: Cmp<T>) => (node: Node<T>) => T|undefined }

package/btree/test.js

@@ -1,5 +1,5 @@
 const btree = require('.')
-const { setVisitor, valuesList } = btree
+const { setVisitor, values: valuesList } = btree
 const { cmp } = require('../cmp') 
 const list = require('../sequence')
 

package/json/index.js

@@ -26,10 +26,10 @@ const addProperty = value => {
 }
 
 /** @type {(kv: readonly[string, seq.Sequence<string>]) => seq.Sequence<string>} */
-const property = ([k, v]) => seq.concat(seq.one(JSON.stringify(k)), seq.one(':'), v)
+const property = ([k, v]) => seq.concat(seq.list(JSON.stringify(k)), seq.list(':'), v)
 
 /** @type {op.Scan<seq.Sequence<string>, seq.Sequence<string>>} */
-const commaValue = a => [seq.concat(seq.one(','), a), commaValue]
+const commaValue = a => [seq.concat(seq.list(','), a), commaValue]
 
 /** @type {op.Scan<seq.Sequence<string>, seq.Sequence<string>>} */
 const joinScan = value => [value, commaValue]
@@ -39,8 +39,8 @@ const join = input => seq.flat(seq.scan(joinScan)(input))
 
 /** @type {(open: string) => (close: string) => (input: seq.Sequence<seq.Sequence<string>>) => seq.Sequence<string>} */
 const list = open => close => {
-    const seqOpen = seq.one(open)
-    const seqClose = seq.one(close)
+    const seqOpen = seq.list(open)
+    const seqClose = seq.list(close)
     return input => seq.concat(seqOpen, join(input), seqClose)
 }
 
@@ -51,10 +51,7 @@ const arrayList = list('[')(']')
 /** @type {(object: Object) => seq.Sequence<string>} */
 const objectStringify = object => {
     /** @type {map.Map<seq.Sequence<string>>} */
-    let m = map.empty
-    for (const [k, v] of Object.entries(object)) {
-        m = m.set(k)(stringSeq(v))
-    }
+    const m = seq.fold(m => ([k, v]) => m.set(k)(stringSeq(v)))(map.empty)(seq.fromArray(Object.entries(object)))
     return objectList(seq.map(property)(m.entries))
 }
 
@@ -65,12 +62,12 @@ const arrayStringify = array => arrayList(seq.map(stringSeq)(seq.fromArray(array
 const stringSeq = value => {
     const x = typeof value
     switch (typeof value) {
-        case 'boolean': { return seq.one(value ? "true" : "false") }
+        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.one(JSON.stringify(value)) }
+        case 'number': case 'string': { return seq.list(JSON.stringify(value)) }
         default: {
-            if (value === null) { return seq.one("null") }
+            if (value === null) { return seq.list("null") }
             if (value instanceof Array) { return arrayStringify(value) }
             return objectStringify(value)
         }

package/map/index.js

@@ -1,7 +1,8 @@
 const option = require("../option")
-const { getVisitor, setVisitor, valuesList } = require("../btree")
+const { getVisitor, setVisitor, values: valuesList } = require("../btree")
 const { cmp } = require("../cmp")
-const list = require("../sequence")
+const seq = require("../sequence")
+const op = require("../sequence/operator")
 
 /** @typedef {import("../cmp").Sign} Sign */
 
@@ -30,7 +31,7 @@ const list = require("../sequence")
  * @typedef {{
  *  readonly get: (name: string) => T|undefined
  *  readonly set: (name: string) => (value: T) => Map<T> 
- *  readonly entries: list.Sequence<Entry<T>>
+ *  readonly entries: seq.Sequence<Entry<T>>
  *  readonly root: undefined|TNode<Entry<T>>
  * }} Map
  */
@@ -62,11 +63,16 @@ const create = root => ({
 const empty = {
     get: () => undefined,
     set: name => value => create([[name, value]]),
-    entries: list.empty,
+    entries: seq.empty,
     root: undefined
 }
 
+/** @type {<T>(entries: seq.Sequence<Entry<T>>) => Map<T>} */
+const fromEntries = seq.fold(map => entry => map.set(entry))(empty)
+
 module.exports = {
     /** @readonly */
     empty,
+    /** @readonly */
+    fromEntries,
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.190",
+  "version": "0.0.191",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "index.js",
   "scripts": {

package/sequence/index.js

@@ -1,6 +1,7 @@
 const array = require('./array')
 const seqOp = require('./operator')
 const { pipe } = require('../function')
+const op = require('../function/operator')
 const { logicalNot, strictEqual } = require('../function/operator')
 
 /**
@@ -77,8 +78,20 @@ const first = input => {
  * @typedef {(list: Sequence<T>) => R} SequenceReduce
  */
 
-/** @type {<T>(first: T) => Sequence<T>} */
-const one = first => () => [first, empty]
+/** @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 }
+        i = i - 1
+        /** @type {FirstAndTail<T>} */
+        const result = [array[i], tail]
+        tail = () => result
+    }
+}
 
 /** @type {<T>(array: array.Array<T>) => Sequence<T>} */
 const fromArray = a => {
@@ -92,11 +105,28 @@ const fromArray = a => {
     return at(0)
 }
 
-/** @type {<T>(a: Sequence<T>) => SequenceMap<T, T>} */
-const concat2 = a => b => [a, b]
-
 /** @type {<T>(...array: readonly Sequence<T>[]) => Sequence<T>} */
-const concat = (...a) => flat(fromArray(a))
+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 }
+        i = i - 1
+        tail = [array[i], tail]
+    }
+}
+
+/** @type {(_: number) => Sequence<number>} */
+const generate = n => {
+    /** @type {(_: number) => Sequence<number>} */
+    const f = i => () => {
+        if (n <= i) { return undefined }
+        return [i, f(i + 1)]
+    }
+    return f(0)
+}
 
 /** @type {<T, R>(f: (value: T) => Sequence<R>) => SequenceMap<T, R>} */
 const flatMap = f => input => () => {
@@ -117,16 +147,16 @@ const flatMap = f => input => () => {
 const flat = flatMap(i => i)
 
 /** @type {<T, R>(f: (value: T) => R) => SequenceMap<T, R>} */
-const map = f => flatMap(i => one(f(i)))
+const map = f => flatMap(i => list(f(i)))
 
 /** @type {<T>(f: (value: T) => boolean) => SequenceMap<T, T>} */
-const filter = f => flatMap(i => f(i) ? one(i) : empty)
+const filter = f => flatMap(i => f(i) ? list(i) : empty)
 
 /** @type {<T, R>(f: (value: T) => R|undefined) => (value: T) => Sequence<R>} */
 const filterMapFunc = f => i => {
     const result = f(i)
     if (result === undefined) { return empty }
-    return one(result)
+    return list(result)
 }
 
 /** @type {<T, R>(f: (value: T) => R|undefined) => SequenceMap<T, R>} */
@@ -163,6 +193,9 @@ const last = def => input => {
 /** @type {<T, R>(s: seqOp.ExclusiveScan<T, R>) => (input: Sequence<T>) => R} */
 const reduce = ([first, s]) => input => last(first)(scan(s)(input))
 
+/** @type {<T, R>(ro: op.ReduceOperator<R, T>) => (first: R) => (input: Sequence<T>) => R} */
+const fold = ro => first => reduce(seqOp.exclusiveScan(ro)(first))
+
 const entries = scan(seqOp.entries)
 
 const sum = reduce(seqOp.sum)
@@ -247,7 +280,7 @@ module.exports = {
     /** @readonly */
     next,
     /** @readonly */
-    one,
+    list,
     /** @readonly */
     empty,
     /** @readonly */
@@ -255,7 +288,7 @@ module.exports = {
     /** @readonly */
     concat,
     /** @readonly */
-    concat2,
+    generate,
     /** @readonly */
     first,
     /** @readonly */
@@ -283,6 +316,8 @@ module.exports = {
     /** @readonly */
     last,
     /** @readonly */
+    fold,
+    /** @readonly */
     reduce,
     /** @readonly */
     entries,

package/sequence/test.js

@@ -8,7 +8,7 @@ const print = input => {
     while (true) {
         const result = seq.next(i)
         if (result === undefined) { return }
-        // console.log(result[0])
+        console.log(result[0])
         i = result[1]
     }
 }
@@ -25,11 +25,23 @@ const print = input => {
     if (seq.some(x => x > 100)(big) !== false) { throw 'x' }
     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 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 r = seq.next(x)
+        // print(x)
+    }
     {
         let x = big
         for (let i = 0; i < 1_000_000; ++i) {
-            // concat() still causes a stack overflow
-            x = seq.concat2(seq.empty)(x)
+            x = seq.concat(seq.empty, x)
         }
         const r = seq.next(x)
         // print(x)
@@ -37,8 +49,7 @@ const print = input => {
     {
         let x = big
         for (let i = 0; i < 1_000_000; ++i) {
-            // concat() still causes a stack overflow
-            x = seq.concat2(x)(seq.one(i))
+            x = seq.concat(x, seq.list(i))
         }
         const r = seq.next(x)
         // print(x)