functionalscript 0.0.163 → 0.0.168

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,13 +1,23 @@
-const { todo } = require('../../dev')
-const { pipe } = require('../../func')
-const mapReduce = require('../../map-reduce')
+const { pipe } = require('../../function')
+const seq = require('../../sequence')
 
 /** 
  * @template T
  * @typedef {Promise<T>|T} PromiseOrValue
  */
 
-/** @type {<T, R>(f: (value: T) => PromiseOrValue<R>) => (c: AsyncIterable<T>) => AsyncIterable<R>} */
+/** 
+ * @template T
+ * @template R
+ * @typedef {(f: (value: T) => PromiseOrValue<R>) => (c: AsyncIterable<T>) => AsyncIterable<R>} Map
+ */
+
+/**
+ * @template T
+ * @typedef {Iterable<T> | AsyncIterable<T>} AnyIterable
+ */
+
+/** @type {<T, R>(f: (value: T) => PromiseOrValue<R>) => (c: AnyIterable<T>) => AsyncIterable<R>} */
 const map = f => c => ({
     async *[Symbol.asyncIterator]() {
         for await (const i of c) {
@@ -16,7 +26,7 @@ const map = f => c => ({
     }
 })
 
-/** @type {<T>(c: AsyncIterable<AsyncIterable<T>>) => AsyncIterable<T>} */
+/** @type {<T>(c: AnyIterable<AnyIterable<T>>) => AsyncIterable<T>} */
 const flatten = c => ({
     async *[Symbol.asyncIterator]() {
         for await (const i of c) {
@@ -25,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: AnyIterable<T>) => AnyIterable<T>} */
 const filter = f => c => ({
     async *[Symbol.asyncIterator]() {
         for await (const i of c) {
@@ -36,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) => AnyIterable<R>) => (c: AnyIterable<T>) => AsyncIterable<R>} */
 const flatMap = f => pipe(map(f))(flatten)
 
 /** 
@@ -45,7 +55,7 @@ const flatMap = f => pipe(map(f))(flatten)
  * @typedef {(accumulator: A) => (value: T) => PromiseOrValue<A>} Merge
  */
 
-/** @type {<A, T>(f: Merge<A, T>) => (init: A) => (c: AsyncIterable<T>) => Promise<A>} */
+/** @type {<A, T>(merge: Merge<A, T>) => (init: A) => (c: AnyIterable<T>) => Promise<A>} */
 const reduce = merge => init => async c => {
     let result = init
     for await (const i of c) {
@@ -54,49 +64,54 @@ const reduce = merge => init => async c => {
     return result
 }
 
-/** @type {<A, T>(f: Merge<A, T>) => (init: A) => (c: AsyncIterable<T>) => AsyncIterable<A>} */
-const exclusiveScan = reduceFn => init => c => ({
+/** @type {<T>(a: AnyIterable<T>) => (b: AnyIterable<T>) => AsyncIterable<T>} */
+const concat = a => b => ({
+    async *[Symbol.asyncIterator]() {
+        yield* a
+        yield* b
+    }
+})
+
+/** @type {<A, T>(merg: Merge<A, T>) => (init: A) => (c: AnyIterable<T>) => AsyncIterable<A>} */
+const exclusiveScan = merge => init => c => ({
     async *[Symbol.asyncIterator]() {
         let result = init
         for await (const i of c) {
-            result = await reduceFn(result)(i)
+            result = await merge(result)(i)
             yield result
         }
     }
 })
 
-/** @type {<A, T>(f: Merge<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 => ({
+/** @type {<T, R>(es: seq.Scan<T, R>) => (c: AnyIterable<T>) => AsyncIterable<R>} */
+const applyExclusiveScan = es => c => ({
     async *[Symbol.asyncIterator]() {
-        for (const i of iterable) {
-            yield i
+        let ies = es
+        for await (const i of c) {
+            const result = ies(i)
+            ies = result[1]
+            yield result[0]
         }
     }
 })
 
-/** @type {<I, S, R>(op: mapReduce.Operation<I, S, R>) => (_: AsyncIterable<I>) => Promise<R>} */
+/** @type {<A, T>(merge: Merge<A, T>) => (init: A) => (c: AnyIterable<T>) => AsyncIterable<A>} */
+const inclusiveScan = merge => init => c => concat([init])(exclusiveScan(merge)(init)(c))
+
+/** @type {<I, S, R>(op: seq.Operation<I, S, R>) => (_: AnyIterable<I>) => Promise<R>} */
 const apply = ({ merge, init, result }) => async c => result(await reduce(merge)(init)(c))
 
-const sum = apply(mapReduce.sum)
+const sum = apply(seq.sum)
 
-const join = pipe(mapReduce.join)(apply)
+const join = pipe(seq.join)(apply)
+
+const size = apply(seq.size)
 
 module.exports = {
     /** @readonly */
     apply,
     /** @readonly */
-    cast,
+    concat,
     /** @readonly */
     map,
     /** @readonly */
@@ -108,6 +123,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/function/index.js

@@ -0,0 +1,40 @@
+/** 
+ * @template I
+ * @template O
+ * @typedef {(_: I) => O} Func 
+ */
+
+/** @type {<X, O>(f: Func<X, O>) => <I>(g: Func<I, X>) => Func<I, O>} */
+const combine = f => g => x => f(g(x))
+
+/** @type {<I, X>(g: Func<I, X>) => <O>(g: Func<X, O>) => Func<I, O>} */
+const pipe = g => f => x => f(g(x))
+
+/** @type {<T>(value: T) => T} */
+const id = value => value
+
+/**
+ * @template I
+ * @template O
+ * @typedef {{
+ *  readonly pipe: <R>(f: Func<O, R>) => Pipe<I, R>
+ *  readonly call: Func<I, O>
+ * }} Pipe
+ */
+
+/** @type {<I, O>(f: Func<I, O>) => Pipe<I, O>} */
+const pipex = call => ({
+    pipe: f => pipex(pipe(call)(f)),
+    call,
+}) 
+
+module.exports = {
+    /** @readonly */
+    id,
+    /** @readonly */
+    pipe,
+    /** @readonly */
+    combine,
+    /** @readonly */
+    pipex,
+}

package/iterable/index.js

@@ -1,7 +1,13 @@
-const { pipe } = require('../func')
-const mr = require('../map-reduce')
+const { pipe } = require('../function')
+const seq = require('../sequence')
 
-/** @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,12 +16,53 @@ const reduce = merge => init => c => {
     return result
 }
 
-/** @type {<I, S, R>(op: mr.Operation<I, S, R>) => (_: Iterable<I>) => R} */
+/** @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: seq.Scan<T, R>) => (c: Iterable<T>) => Iterable<R>} */
+const applyScan = es => c => ({
+    *[Symbol.iterator]() {
+        let ies = es
+        for (const i of c) {
+            const result = ies(i)
+            ies = result[1]
+            yield result[0]
+        }
+    }
+})
+
+/** @type {<T, R>(is: seq.InclusiveScan<T, R>) => (c: Iterable<T>) => Iterable<R>} */
+const applyInclusiveScan = ({scan, first}) => c => concat([first])(applyScan(scan)(c))
+
+const entries = applyScan(seq.entries)
+
+/** @type {<I, S, R>(op: seq.Operation<I, S, R>) => (_: Iterable<I>) => R} */
 const apply = ({ merge, init, result }) => pipe(reduce(merge)(init))(result)
 
-const sum = apply(mr.sum)
+const sum = apply(seq.sum)
+
+const size = apply(seq.size)
 
-const join = pipe(mr.join)(apply)
+const join = pipe(seq.join)(apply)
 
 /** @type {<T, R>(f: (value: T) => R) => (c: Iterable<T>) => Iterable<R>} */
 const map = f => c => ({
@@ -26,6 +73,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 +96,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

@@ -1,5 +1,5 @@
 const i = require('.')
-const { pipe } = require('../func')
+const { pipe } = require('../function')
 
 {
     const r = i.sum([120, 300, 42])
@@ -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/module-manager/index.js

@@ -1,9 +1,8 @@
 const array = require('../array')
-const { pipe } = require('../func')
+const { pipe } = require('../function')
 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('../sequence').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.163",
+  "version": "0.0.168",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "index.js",
   "scripts": {

package/sequence/index.js

@@ -0,0 +1,131 @@
+const { todo } = require('../dev')
+const { id } = require('../function')
+
+/**
+ * @template T0
+ * @template T1
+ * @typedef {import('../array').Tuple2<T0, T1>} Tuple2
+ */
+
+/**
+ * @template T
+ * @template R
+ * @typedef {Tuple2<R, Scan<T, R>>} ScanResult
+ */
+
+/**
+ * @template T
+ * @template R
+ * @typedef {(value: T) => ScanResult<T, R>} Scan
+ */
+
+/**
+ * @template T
+ * @template R
+ * @typedef {{
+ *  readonly scan: Scan<T, R>
+ *  readonly first: R
+ * }} InclusiveScan
+ */
+
+/**
+ * @template R
+ * @template T
+ * @typedef {(prior: R) => (value: T) => R} BinaryOperator
+ */
+
+/** @type {<R, T>(operator: BinaryOperator<R, T>) => (prior: R) => Scan<T, R>} */
+const operatorScan = operator => {
+    /** @typedef {typeof operator extends BinaryOperator<infer R, infer T> ? [R, T] : never} RT */
+    /** @typedef {RT[0]} R */
+    /** @typedef {RT[1]} T */
+    /** @type {(prior: R) => Scan<T, R>} */
+    const f = prior => value => {
+        const result = operator(prior)(value)
+        return [result, f(result)]
+    }
+    return f
+} 
+
+/** @type {<R, T>(operator: BinaryOperator<R, T>) => (first: R) => InclusiveScan<T, R>} */
+const inclusiveOperatorScan = operator => first => ({
+    scan: operatorScan(operator)(first),
+    first,
+})
+
+/** 
+ * @template T
+ * @typedef {Tuple2<number, T>} Entry
+ */
+
+/** @type {(index: number) => <T>(value: T) => ScanResult<T, Entry<T>>} */
+const createEntries = index => value => [[index, value], createEntries(index + 1)]
+
+const entries = createEntries(0)
+
+/** @type {(separator: string) => BinaryOperator<string, string>} */
+const joinOperation = separator => prior => value => `${prior}${separator}${value}`
+
+/** @type {(separator: string) => InclusiveScan<string, string>} */
+const join2 = separator => ({
+    scan: value => [value, operatorScan(joinOperation(separator))(value)],
+    first: ''
+})
+
+/** @type {(sum: number) => (value: number) => number} */
+const addition = a => b => a + b
+
+/** @type {InclusiveScan<number, number>} */
+const sum2 = inclusiveOperatorScan(addition)(0)
+
+////
+
+/**
+ * @template I
+ * @template S
+ * @template O
+ * @typedef {{
+ *  readonly merge: BinaryOperator<S, I>
+ *  readonly result: (state: S) => O
+ *  readonly init: S
+ * }} Operation
+ */
+
+/** @type {(separator: string) => Operation<string, string|undefined, string>} */
+const join = separator => ({ 
+    merge: s => i => s === undefined ? i : `${s}${separator}${i}`, 
+    init: undefined,
+    result: s => s === undefined ? '' : s
+})
+
+/** @type {Operation<number, number, number>} */
+const sum = { 
+    merge: a => i => a + i, 
+    result: id,
+    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,
+}
+
+module.exports = {
+    /** @readonly */
+    join,
+    join2,
+    /** @readonly */
+    sum,
+    /** @readonly */
+    size,
+    /** @readonly */
+    entries,
+}

package/test.js

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

package/func/index.js

@@ -1,12 +0,0 @@
-/** @type {<I, X>(_: (_: I) => X) => <O>(_: (_: X) => O) => (_: I) => O} */
-const pipe = g => f => x => f(g(x))
-
-/** @type {<T>(value: T) => T} */
-const id = value => value
-
-module.exports = {
-    /** @readonly */
-    id,
-    /** @readonly */
-    pipe,
-}

package/map-reduce/index.js

@@ -1,48 +0,0 @@
-const { pipe, id } = require('../func')
-
-/**
- * @template S
- * @template I
- * @typedef {(state: S) => (value: I) => S} Merge
- */
-
-/**
- * @template I
- * @template S
- * @template O
- * @typedef {{
- *  readonly merge: Merge<S, I>
- *  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 => ({ merge, result, init}) => ({
-    merge: pipe(merge)(pipe(mapFn)),
-    result,
-    init,
-})
-
-/** @type {(separator: string) => Operation<string, string|undefined, string>} */
-const join = separator => ({ 
-    merge: s => i => s === undefined ? i : `${s}${separator}${i}`, 
-    init: undefined,
-    result: s => s === undefined ? '' : s
-})
-
-/** @type {Operation<number, number, number>} */
-const sum = { 
-    merge: a => i => a + i, 
-    result: id,
-    init: 0,
-}
-
-module.exports = {
-    /** @readonly */
-    map,
-    /** @readonly */
-    join,
-    /** @readonly */
-    sum,
-}