functionalscript 0.0.164 → 0.0.166

package/array/index.js

@@ -17,6 +17,12 @@ const option = require('../option')
  * @typedef {readonly [T, T]} Array2
  */
 
+/**
+ * @template T0
+ * @template T1
+ * @typedef {readonly [T0, T1]} Tuple2
+ */
+
 /** @typedef {0|1} Index2 */
 
 /**

package/async/iterable/index.js

@@ -1,5 +1,5 @@
 const { pipe } = require('../../func')
-const mapReduce = require('../../map-reduce')
+const mr = require('../../map-reduce')
 
 /** 
  * @template T
@@ -12,7 +12,12 @@ const mapReduce = require('../../map-reduce')
  * @typedef {(f: (value: T) => PromiseOrValue<R>) => (c: AsyncIterable<T>) => AsyncIterable<R>} Map
  */
 
-/** @type {<T, R>(f: (value: T) => PromiseOrValue<R>) => (c: AsyncIterable<T>) => AsyncIterable<R>} */
+/**
+ * @template T
+ * @typedef {Iterable<T> | AsyncIterable<T>} AnyIterator
+ */
+
+/** @type {<T, R>(f: (value: T) => PromiseOrValue<R>) => (c: AnyIterator<T>) => AsyncIterable<R>} */
 const map = f => c => ({
     async *[Symbol.asyncIterator]() {
         for await (const i of c) {
@@ -21,7 +26,7 @@ const map = f => c => ({
     }
 })
 
-/** @type {<T>(c: AsyncIterable<AsyncIterable<T>>) => AsyncIterable<T>} */
+/** @type {<T>(c: AnyIterator<AnyIterator<T>>) => AsyncIterable<T>} */
 const flatten = c => ({
     async *[Symbol.asyncIterator]() {
         for await (const i of c) {
@@ -30,7 +35,7 @@ const flatten = c => ({
     }
 })
 
-/** @type {<T>(f: (value: T) => Promise<boolean>) => (c: AsyncIterable<T>) => AsyncIterable<T>} */
+/** @type {<T>(f: (value: T) => Promise<boolean>) => (c: AnyIterator<T>) => AnyIterator<T>} */
 const filter = f => c => ({
     async *[Symbol.asyncIterator]() {
         for await (const i of c) {
@@ -41,7 +46,7 @@ const filter = f => c => ({
     }
 })
 
-/** @type {<T, R>(f: (value: T) => AsyncIterable<R>) => (c: AsyncIterable<T>) => AsyncIterable<R>} */
+/** @type {<T, R>(f: (value: T) => AnyIterator<R>) => (c: AnyIterator<T>) => AsyncIterable<R>} */
 const flatMap = f => pipe(map(f))(flatten)
 
 /** 
@@ -50,7 +55,7 @@ const flatMap = f => pipe(map(f))(flatten)
  * @typedef {(accumulator: A) => (value: T) => PromiseOrValue<A>} Merge
  */
 
-/** @type {<A, T>(merge: Merge<A, T>) => (init: A) => (c: AsyncIterable<T>) => Promise<A>} */
+/** @type {<A, T>(merge: Merge<A, T>) => (init: A) => (c: AnyIterator<T>) => Promise<A>} */
 const reduce = merge => init => async c => {
     let result = init
     for await (const i of c) {
@@ -59,7 +64,15 @@ const reduce = merge => init => async c => {
     return result
 }
 
-/** @type {<A, T>(merg: Merge<A, T>) => (init: A) => (c: AsyncIterable<T>) => AsyncIterable<A>} */
+/** @type {<T>(a: AnyIterator<T>) => (b: AnyIterator<T>) => AsyncIterable<T>} */
+const concat = a => b => ({
+    async *[Symbol.asyncIterator]() {
+        yield* a
+        yield* b
+    }
+})
+
+/** @type {<A, T>(merg: Merge<A, T>) => (init: A) => (c: AnyIterator<T>) => AsyncIterable<A>} */
 const exclusiveScan = merge => init => c => ({
     async *[Symbol.asyncIterator]() {
         let result = init
@@ -70,38 +83,23 @@ const exclusiveScan = merge => init => c => ({
     }
 })
 
-/** @type {<A, T>(merge: Merge<A, T>) => (init: A) => (c: AsyncIterable<T>) => AsyncIterable<A>} */
-const inclusiveScan = merge => init => {
-    const e = exclusiveScan(merge)(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 {<A, T>(merge: Merge<A, T>) => (init: A) => (c: AnyIterator<T>) => AsyncIterable<A>} */
+const inclusiveScan = merge => init => c => concat([init])(exclusiveScan(merge)(init)(c))
 
-/** @type {<I, S, R>(op: mapReduce.Operation<I, S, R>) => (_: AsyncIterable<I>) => Promise<R>} */
+/** @type {<I, S, R>(op: mr.Operation<I, S, R>) => (_: AnyIterator<I>) => Promise<R>} */
 const apply = ({ merge, init, result }) => async c => result(await reduce(merge)(init)(c))
 
-const sum = apply(mapReduce.sum)
+const sum = apply(mr.sum)
 
-const join = pipe(mapReduce.join)(apply)
+const join = pipe(mr.join)(apply)
+
+const size = apply(mr.size)
 
 module.exports = {
     /** @readonly */
     apply,
     /** @readonly */
-    cast,
+    concat,
     /** @readonly */
     map,
     /** @readonly */
@@ -113,6 +111,8 @@ module.exports = {
     /** @readonly */
     sum,
     /** @readonly */
+    size,
+    /** @readonly */
     join,
     /** @readonly */
     exclusiveScan,

package/async/iterable/test.js

@@ -1,21 +1,21 @@
-const { cast, map, filter, flatMap, sum } = require('.')
+const { map, filter, flatMap, sum } = require('.')
 
 const test = async () => {
     {
-        const a = cast([1, 2, 3])
+        const a = [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 a = [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 a = [1, 2]
+        const f = flatMap(x => [x, x * x])(a)
         const result = await sum(f)
         if (result !== 8) { throw 'filter' }
     }

package/iterable/index.js

@@ -1,7 +1,13 @@
 const { pipe } = require('../func')
 const mr = require('../map-reduce')
 
-/** @type {<T, R>(merge: (_: R) => (_: T) => R) => (init: R) => (_: Iterable<T>) => R} */
+/**
+ * @template S
+ * @template T
+ * @typedef {(_: S) => (_: T) => S} Merge
+ */
+
+/** @type {<T, R>(merge: Merge<R, T>) => (init: R) => (_: Iterable<T>) => R} */
 const reduce = merge => init => c => {
     let result = init
     for (const i of c) {
@@ -10,11 +16,49 @@ const reduce = merge => init => c => {
     return result
 }
 
+/** @type {<T>(a: Iterable<T>) => (b: Iterable<T>) => Iterable<T>} */
+const concat = a => b => ({
+    *[Symbol.iterator]() {
+        yield *a
+        yield *b
+    }
+})
+
+/** @type {<A, T>(merge: Merge<A, T>) => (init: A) => (c: Iterable<T>) => Iterable<A>} */
+const exclusiveScan = merge => init => c => ({
+    *[Symbol.iterator]() {
+        let result = init
+        for (const i of c) {
+            result = merge(result)(i)
+            yield result
+        }
+    }
+})
+
+/** @type {<A, T>(merge: Merge<A, T>) => (init: A) => (c: Iterable<T>) => Iterable<A>} */
+const inclusiveScan = merge => init => c => concat([init])(exclusiveScan(merge)(init)(c))
+
+/** @type {<T, R>(es: mr.ExlusiveScan<T, R>) => (c: Iterable<T>) => Iterable<R>} */
+const applyExclusiveScan = es => c => ({
+    *[Symbol.iterator]() {
+        let ies = es
+        for (const i of c) {
+            const result = ies(i)
+            ies = result[1]
+            yield result[0]
+        }
+    }
+})
+
+const entries = applyExclusiveScan(mr.entries)
+
 /** @type {<I, S, R>(op: mr.Operation<I, S, R>) => (_: Iterable<I>) => R} */
 const apply = ({ merge, init, result }) => pipe(reduce(merge)(init))(result)
 
 const sum = apply(mr.sum)
 
+const size = apply(mr.size)
+
 const join = pipe(mr.join)(apply)
 
 /** @type {<T, R>(f: (value: T) => R) => (c: Iterable<T>) => Iterable<R>} */
@@ -26,6 +70,16 @@ const map = f => c => ({
     }
 })
 
+/** @type {<T>(_: (_: T) => boolean) => (_: Iterable<T>) => T|undefined} */
+const find = f => c => {
+    for (const i of c) {
+        if (f(i)) {
+            return i
+        }
+    }
+    return undefined
+}
+
 module.exports = {
     /** @readonly */
     apply,
@@ -39,19 +93,21 @@ module.exports = {
     /** @readonly */
     sum,
 
+    /** @readonly */
+    size,
+
+    /** @readonly */
+    entries,
+
     /** @readonly */
     map,
 
-    /** 
-     * @readonly
-     * @type {<T>(_: (_: T) => boolean) => (_: Iterable<T>) => T|undefined} 
-     */
-    find: f => c => {
-        for (const i of c) {
-            if (f(i)) {
-                return i
-            }
-        }
-        return undefined
-    }
+    /** @readonly */
+    exclusiveScan,
+
+    /** @readonly */
+    inclusiveScan,
+
+    /** @readonly */
+    find,
 }

package/iterable/test.js

@@ -38,4 +38,14 @@ const { pipe } = require('../func')
         (i.find(x => x !== undefined))
         ([() => p, () => `${p}.js`, () => `${p}/index.js`])
     if (x('index.js') !== 'x') { throw 'error' }
+}
+
+{
+    const x = JSON.stringify(Array.from(i.entries(['a', 'b', 'c'])))
+    if (x !== '[[0,"a"],[1,"b"],[2,"c"]]') { throw x }
+}
+
+{
+    const x = JSON.stringify(Array.from(i.entries([])))
+    if (x !== '[]') { throw x }
 }

package/map-reduce/index.js

@@ -38,6 +38,35 @@ const sum = {
     init: 0,
 }
 
+/**
+ * @type {{
+ *  readonly merge: (counter: number) => () => number
+ *  readonly result: (counter: number) => number
+ *  readonly init: number
+ * }}
+ */
+const size = {
+    merge: counter => () => counter + 1,
+    init: 0,
+    result: id,
+}
+
+/**
+ * @template T
+ * @template R
+ * @typedef {(value: T) => readonly [R, ExlusiveScan<T, R>]} ExlusiveScan
+ */
+
+/** 
+ * @template T
+ * @typedef {readonly[number, T]} Entry
+ */
+
+/** @type {(index: number) => <T>(value: T) => readonly[Entry<T>, ExlusiveScan<T, Entry<T>>]} */
+const entriesFrom = index => value => [[index, value], entriesFrom(index + 1)]
+
+const entries = entriesFrom(0)
+
 module.exports = {
     /** @readonly */
     map,
@@ -45,4 +74,8 @@ module.exports = {
     join,
     /** @readonly */
     sum,
+    /** @readonly */
+    size,
+    /** @readonly */
+    entries,
 }

package/module-manager/index.js

@@ -3,7 +3,6 @@ const { pipe } = require('../func')
 const option = require('../option')
 const { head, last, splitLast, splitFirst } = array
 const iter = require('../iterable')
-const mr = require('../map-reduce')
 
 /**
  * @template T
@@ -39,7 +38,7 @@ const mr = require('../map-reduce')
 
 /** @typedef {(_: string) => undefined|Package|Dependencies} Dependencies */
 
-/** @type {mr.Operation<string, undefined|Path, undefined|Path>} */
+/** @type {import('../map-reduce').Operation<string, undefined|Path, undefined|Path>} */
 const pathNormReduce = {
     merge: path => item =>
         path === undefined ?

package/package.json

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

package/test.js

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