functionalscript 0.0.152 → 0.0.156

package/async/index.js

@@ -0,0 +1,101 @@
+const { pipe } = require('../lib')
+
+/** @type {<T, R>(f: (value: T) => Promise<R>) => (c: AsyncIterable<T>) => AsyncIterable<R>} */
+const map = f => c => ({
+    async *[Symbol.asyncIterator]() {
+        for await (const i of c) {
+            yield f(i)
+        }
+    }
+})
+
+/** @type {<T>(c: AsyncIterable<AsyncIterable<T>>) => AsyncIterable<T>} */
+const flatten = c => ({
+    async *[Symbol.asyncIterator]() {
+        for await (const i of c) {
+            yield *i
+        }
+    }
+})
+
+/** @type {<T>(f: (value: T) => Promise<boolean>) => (c: AsyncIterable<T>) => AsyncIterable<T>} */
+const filter = f => c => ({
+    async *[Symbol.asyncIterator]() {
+        for await (const i of c) {
+            if (await f(i)) {
+                yield i
+            }
+        }
+    }
+})
+
+/** @type {<T, R>(f: (value: T) => AsyncIterable<R>) => (c: AsyncIterable<T>) => AsyncIterable<R>} */
+const flatMap = f => pipe(map(async x => f(x)))(flatten)
+
+/** 
+ * @template A
+ * @template T
+ * @typedef {(accumulator: A) => (value: T) => Promise<A>} ReduceFn
+ */
+
+/** @type {<A, T>(f: ReduceFn<A, T>) => (init: A) => (c: AsyncIterable<T>) => Promise<A>} */
+const reduce = reduceFn => init => async c => {
+    let result = init
+    for await (const i of c) {
+        result = await reduceFn(result)(i)
+    }
+    return result
+}
+
+/** @type {<A, T>(f: ReduceFn<A, T>) => (init: A) => (c: AsyncIterable<T>) => AsyncIterable<A>} */
+const exclusiveScan = reduceFn => init => c => ({
+    async *[Symbol.asyncIterator]() {
+        let result = init
+        for await (const i of c) {
+            result = await reduceFn(result)(i)
+            yield result
+        }
+    }
+})
+
+/** @type {<A, T>(f: ReduceFn<A, T>) => (init: A) => (c: AsyncIterable<T>) => AsyncIterable<A>} */
+const inclusiveScan = reduceFn => init => {
+    const e = exclusiveScan(reduceFn)(init)
+    return c => ({
+        async *[Symbol.asyncIterator]() {
+            yield init
+            yield *e(c)
+        }
+    })
+}
+
+/** @type {<T>(iterable: Iterable<T>) => AsyncIterable<T>} */
+const cast = iterable => ({
+    async *[Symbol.asyncIterator]() {
+        for (const i of iterable) {
+            yield i
+        }
+    }
+})
+
+/** @type {(c: AsyncIterable<number>) => Promise<number>} */
+const sum = reduce(a => async v => a + v)(0)
+
+module.exports = {
+    /** @readonly */
+    cast,
+    /** @readonly */
+    map,
+    /** @readonly */
+    filter,
+    /** @readonly */
+    flatMap,
+    /** @readonly */
+    reduce,
+    /** @readonly */
+    sum,
+    /** @readonly */
+    exclusiveScan,
+    /** @readonly */
+    inclusiveScan,
+}

package/async/test.js

@@ -0,0 +1,24 @@
+const { cast, map, filter, flatMap, sum } = require('.')
+
+const test = async () => {
+    {
+        const a = cast([1, 2, 3])
+        const m = map(async x => x * x)(a)
+        const result = await sum(m)
+        if (result !== 14) { throw 'filter' }
+    }
+    {
+        const a = cast([1, 2, 3, 4])
+        const f = filter(async x => x !== 2)(a)
+        const result = await sum(f)
+        if (result !== 8) { throw 'filter' }
+    }
+    {
+        const a = cast([1, 2])
+        const f = flatMap(x => cast([x, x * x]))(a)
+        const result = await sum(f)
+        if (result !== 8) { throw 'filter' }
+    }
+}
+
+test()

package/{lib/tree → btree}/index.js

@@ -1,35 +1,35 @@
-const { index3, index5 } = require('./cmp')
+const { index3, index5 } = require('../cmp')
 
 /**
  * @template T
- * @typedef {import('./lazy').Lazy<T>} Lazy
+ * @typedef {() => T} Lazy
  */
 
 /**
  * @template T
- * @typedef {import('./cmp').Cmp<T>} Cmp
+ * @typedef {import('../cmp').Cmp<T>} Cmp
  */
 
 /**
  * @template T
- * @typedef {import('./array').Array1<T>} Array1
+ * @typedef {import('../array').Array1<T>} Array1
  */
 
 /**
  * @template T
- * @typedef {import('./array').Array2<T>} Array2
+ * @typedef {import('../array').Array2<T>} Array2
  */
 
 /**
  * @template T
- * @typedef {import('./array').Array3<T>} Array3
+ * @typedef {import('../array').Array3<T>} Array3
  */
 
-/** @typedef {import('./array').Index2} Index2 */
+/** @typedef {import('../array').Index2} Index2 */
 
-/** @typedef {import('./array').Index3} Index3 */
+/** @typedef {import('../array').Index3} Index3 */
 
-/** @typedef {import('./array').Index5} Index5 */
+/** @typedef {import('../array').Index5} Index5 */
 
 //
 
@@ -319,49 +319,7 @@ const values = node => ({
     }
 })
 
-/**
- * @typedef {{}}
- */
-
-/** @type {(offset: string) => <T>(_: TNode<T>) => Iterable<string>} */
-const struct = offset => node => ({
-    *[Symbol.iterator]() {
-        const next = `${offset}  `
-        switch (node.length) {
-            case 1: {
-                yield `${offset}- [1]:`
-                yield `${next}- ${node[0]}`
-                return
-            }
-            case 2: {
-                yield `${offset}- [2]:`
-                yield `${next}- ${node[0]}`
-                yield `${next}- ${node[1]}`
-                return
-            }
-            case 3: {
-                yield  `${offset}- [3]:`
-                yield* struct(next)(node[0])
-                yield  `${next}- ${node[1]}`
-                yield* struct(next)(node[2])
-                return
-            }
-            default: {
-                yield `${offset}- [5]:`
-                yield* struct(next)(node[0])
-                yield  `${next}- ${node[1]}`
-                yield* struct(next)(node[2])
-                yield  `${next}- ${node[3]}`
-                yield* struct(next)(node[4])
-                return
-            }
-        }
-    }
-})
-
 module.exports = {
-    /** @readonly */
-    struct: struct(''),
     /** @readonly */
     values,
     /** 

package/{lib/tree/cmp.js → cmp/index.js}

@@ -1,9 +1,9 @@
-/** @typedef {import('./array').Index3} Index3 */
-/** @typedef {import('./array').Index5} Index5 */
+/** @typedef {import('../array').Index3} Index3 */
+/** @typedef {import('../array').Index5} Index5 */
 
 /**
  * @template T
- * @typedef {import('./array').Array2<T>} Array2 
+ * @typedef {import('../array').Array2<T>} Array2 
  */
 
 /** @typedef {-1|0|1} Sign */

package/{lib/iterable → iterable}/index.js

@@ -1,7 +1,9 @@
-const lib = require('../')
+const { pipe } = require('../lib')
+const lib = require('../lib')
+const mr = require('../map-reduce')
 
-/** @type {<T, R>(_: lib.Reduce<T, R>) => (_: Iterable<T>) => R} */
-const reduce = ({ merge, init }) => c => {
+/** @type {<T, R>(merge: (_: R) => (_: T) => R) => (init: R) => (_: Iterable<T>) => R} */
+const reduce = merge => init => c => {
     let result = init
     for (const i of c) {
         result = merge(result)(i)
@@ -9,15 +11,21 @@ const reduce = ({ merge, init }) => c => {
     return result
 }
 
+/** @type {<I, S, R>(op: mr.Operation<I, S, R>) => (_: Iterable<I>) => R} */
+const apply = op => pipe(reduce(op.reduce)(op.init))(op.result)
+
 module.exports = {
+    /** @readonly */
+    apply,
+
     /** @readonly */
     reduce,
 
     /** @readonly */
-    join: lib.pipe(lib.join)(reduce),
+    join: pipe(mr.join)(apply),
 
     /** @readonly */
-    sum: reduce(lib.sum),
+    sum: apply(mr.sum),
 
     /** 
      * @readonly
@@ -31,18 +39,6 @@ module.exports = {
         }
     }),
 
-    /**
-     * @readonly
-     * @type {<T, R>(f: (value: T) => Promise<R>) => (c: AsyncIterable<T>) => AsyncIterable<R>}
-     */
-    asyncMap: f => c => ({
-        async *[Symbol.asyncIterator]() {
-            for await (const i of c) {
-                yield* [f(i)]
-            }
-        }
-    }),
-
     /** 
      * @readonly
      * @type {<T>(_: (_: T) => boolean) => (_: Iterable<T>) => T|undefined} 

package/{lib/iterable → iterable}/test.js

@@ -1,5 +1,5 @@
 const i = require('.')
-const lib = require('..')
+const lib = require('../lib')
 
 {
     const r = i.sum([120, 300, 42])

package/lib/index.js

@@ -28,19 +28,6 @@
 /** @type {(_: string) => never} */
 const panic = message => { throw message }
 
-/** @type {<A>(_: A) => <B>(_: B) => [A, B]} */
-const tuple2 = a => b => [a, b]
-
-// /** @type {<T>(_: (_: string) => T) => (_: Dictionary<T>) => (_: string) => [T, Dictionary<T>]} */
-// const cache = f => d => k => {
-//     const set = () => {
-//         const r = f(k)                
-//         return tuple2(r)(d.set(k)(r))
-//     }
-//     const result = d.get(k) 
-//     return result !== undefined ? [result, d] : set()
-// }
-
 /**
  * @template T
  * @template R
@@ -88,12 +75,6 @@ const chain = value => ({
  * }} Pipe
  */
 
-/** @type {<I, T>(f: (input: I) => T) => Pipe<I, T>} */
-const pipex = f => ({
-    x: g => pipex(pipe(f)(g)),
-    f,
-})
-
 module.exports = {
 
     panic,
@@ -113,22 +94,8 @@ module.exports = {
         }
     },
 
-    /** @type {(s: string) => Reduce<string, string>} */
-    join: s => ({ merge: a => i => a === '' ? i : a + s + i, init: ''}),
-
     pipe,
 
-    pipex,
-
-    /** @type {Reduce<number, number>} */
-    sum: { merge: a => i => a + i, init: 0 },
-
-    /** @type {<I, X>(f: (init: I) => X) => <O>(reduce: Reduce<X, O>) => Reduce<I, O>} */
-    map: f => ({merge, init}) => ({
-        merge: pipe(merge)(pipe(f)),
-        init,
-    }),
-
     last,
 
     optionMap,

package/lib/test.js

@@ -1,5 +1,5 @@
 const lib = require('./index')
 
-require('./iterable/test')
-require('./map/test')
+require('../iterable/test')
+require('../map/test')
 

package/{lib/map → map}/index.js

@@ -1,21 +1,21 @@
-const { optionMap } = require("..")
-const { getVisitor, setVisitor, values, struct } = require("../tree")
+const { optionMap } = require("../lib")
+const { getVisitor, setVisitor, values } = require("../btree")
 
-/** @typedef {import("../tree/cmp").Sign} Sign */
+/** @typedef {import("../cmp").Sign} Sign */
 
 /**
  * @template T 
- * @typedef {import("../tree").Leaf1<T>} Leaf1 
+ * @typedef {import("../btree").Leaf1<T>} Leaf1 
  */
 
 /**
  * @template T
- * @typedef {import("../tree").TNode<T>} TNode
+ * @typedef {import("../btree").TNode<T>} TNode
  */
 
 /**
  * @template T
- * @typedef {import("../tree/cmp").Cmp<T>} Cmp
+ * @typedef {import("../cmp").Cmp<T>} Cmp
  */
 
 /**
@@ -29,7 +29,7 @@ const { getVisitor, setVisitor, values, struct } = require("../tree")
  *  readonly get: (name: string) => T|undefined
  *  readonly set: (name: string) => (value: T) => Map<T> 
  *  readonly entries: () => Iterable<Entry<T>>
- *  readonly struct: () => Iterable<string>
+ *  readonly root: undefined|TNode<Entry<T>>
  * }} Map
  */
 
@@ -37,16 +37,16 @@ const { getVisitor, setVisitor, values, struct } = require("../tree")
 const cmp = a => ([b]) => a < b ? -1 : a === b ? 0 : 1
 
 /** @type {<T>(node: TNode<Entry<T>>) => Map<T>} */
-const create = node => ({
-    get: name => optionMap(([,value]) => value)(getVisitor(cmp(name))(node)),
+const create = root => ({
+    get: name => optionMap(([,value]) => value)(getVisitor(cmp(name))(root)),
     set: name => value => {
-        const result = setVisitor(cmp(name))(() => [name, value])(node)
+        const result = setVisitor(cmp(name))(() => [name, value])(root)
         if ('replace' in result) { return create(result.replace) }
         if ('overflow' in result) { return create(result.overflow) }
         throw ''
     },
-    entries: () => values(node),
-    struct: () => struct(node),
+    entries: () => values(root),
+    root,
 })
 
 /** 
@@ -54,17 +54,17 @@ const create = node => ({
  *  readonly get: (name: string) => undefined
  *  readonly set: (name: string) => <T>(value: T) => Map<T>
  *  readonly entries: () => []
- *  readonly struct: () => []
+ *  readonly root: undefined
  * }} 
  */
-const map = {
+const empty = {
     get: () => undefined,
     set: name => value => create([[name, value]]),
     entries: () => [],
-    struct: () => [],
+    root: undefined
 }
 
 module.exports = {
     /** @readonly */
-    map,
+    empty,
 }

package/{lib/map → map}/test.js

@@ -1,8 +1,8 @@
-const { map } = require('.')
-const lib = require('..')
+const { empty } = require('.')
+const lib = require('../lib')
 
 {
-    let m = map.set('a')(1)
+    let m = empty.set('a')(1)
 
     if (m.get('a') !== 1) { throw 'error' }
     if (m.get('b') !== undefined) { throw 'error' }
@@ -41,7 +41,7 @@ const lib = require('..')
 }
 
 {
-    const m = map.set('x')(12).set('y')(44)
+    const m = empty.set('x')(12).set('y')(44)
     lib.panic_if('map.get(\'x\')')(m.get('x') !== 12)
     lib.panic_if('map.get(\'y\')')(m.get('y') !== 44)
     lib.panic_if('map.get(\'a\')')(m.get('a') !== undefined)
@@ -52,14 +52,16 @@ const lib = require('..')
 
 {
     /** @type {import('.').Map<number>} */
-    let m = map
-    for (let i = 0; i < 10; ++i) {
+    let m = empty
+    for (let i = 0; i < 100_000; ++i) {
         m = m.set((i*i).toString())(i)
+        /*
         console.log()
         console.log(`# ${i}`)
         console.log()
         for (const e of m.struct()) {
             console.log(e)
         }
+        */
     }
 }

package/map-reduce/index.js

@@ -0,0 +1,42 @@
+const { pipe } = require('../lib')
+
+/**
+ * @template I
+ * @template S
+ * @template O
+ * @typedef {{
+ *  readonly reduce: (state: S) => (value: I) => S
+ *  readonly result: (state: S) => O
+ *  readonly init: S
+ * }} Operation
+ */
+
+/** @type {<I, T>(mapFn: (value: I) => T) => <S, O>(op: Operation<T, S, O>) => Operation<I, S, O>} */
+const map = mapFn => ({ reduce, result, init}) => ({
+    reduce: pipe(reduce)(pipe(mapFn)),
+    result,
+    init,
+})
+
+/** @type {(separator: string) => Operation<string, string|undefined, string>} */
+const join = separator => ({ 
+    reduce: s => i => s === undefined ? i : `${s}${separator}${i}`, 
+    init: undefined,
+    result: s => s === undefined ? '' : s
+})
+
+/** @type {Operation<number, number, number>} */
+const sum = { 
+    reduce: a => i => a + i, 
+    result: a => a,
+    init: 0,
+}
+
+module.exports = {
+    /** @readonly */
+    map,
+    /** @readonly */
+    join,
+    /** @readonly */
+    sum,
+}

package/module-manager/index.js

@@ -1,5 +1,6 @@
 const lib = require('../lib')
-const iter = require('../lib/iterable')
+const iter = require('../iterable')
+const mr = require('../map-reduce')
 
 /** @typedef {(_: string) => string|undefined} ReadFile */
 
@@ -28,9 +29,9 @@ const iter = require('../lib/iterable')
 
 /** @typedef {(_: string) => undefined|Package|Dependencies} Dependencies */
 
-/** @type {lib.Reduce<string, undefined|string[]>} */
+/** @type {mr.Operation<string, undefined|string[], undefined|string[]>} */
 const pathNormReduce = {
-    merge: path => item =>
+    reduce: path => item =>
         path === undefined ?
             undefined :
         ['', '.'].includes(item) ?
@@ -38,13 +39,14 @@ const pathNormReduce = {
         item === '..' ?
             lib.head(path) :
             [...path, item],
-    init: []
+    init: [],
+    result: s => s,
 }
 
 /** @type {(_: string[]) => boolean} */
 const isRelative = localId => ['.', '..'].includes(localId[0])
 
-const pathNorm = iter.reduce(pathNormReduce)
+const pathNorm = iter.apply(pathNormReduce)
 
 /** @type {(_: Package) => (_: string[]) => Module|undefined} */
 const internal = pack => {
@@ -91,8 +93,12 @@ const getModule = ({pack, local}) => path => {
 const moduleId = module => [...module.location.pack.id, ...module.location.local, module.fileName].join('/') 
 
 module.exports = {
+    /** @readonly */
     isRelative,
+    /** @readonly */
     pathNorm,
+    /** @readonly */
     getModule,
+    /** @readonly */
     moduleId,
 }

package/module-manager/test.js

@@ -2,12 +2,6 @@ const i = require('.')
 
 const lib = require('../lib')
 
-{
-    if (require('./test0') !== 'test0.js') { throw './test0' }
-    if (require('./test0.js') !== 'test0.js') { throw './test0.js'}
-    if (require('./test0.js.js') !== 'test0.js.js') { throw './test0.js.js'}
-}
-
 require('./node/test')
 
 /** @type {<T>(_: T | undefined) => T} */

package/package.json

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

package/test.js

@@ -1,6 +1,7 @@
 const lib = require('./lib')
 const i = require('./')
 
+require('./async/test')
 require('./module-manager/test')
 require('./lib/test')
 

package/lib/tree/lazy.js

@@ -1,6 +0,0 @@
-/**
- * @template T
- * @typedef {() => T} Lazy
- */
-
-module.exports = {}

package/module-manager/test0.js

@@ -1 +0,0 @@
-module.exports = 'test0.js'

package/module-manager/test0.js.js

@@ -1 +0,0 @@
-module.exports = 'test0.js.js'