functionalscript 0.0.162 → 0.0.167

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,47 +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.ExlusiveScan<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(seq.join)(apply)
+
+const size = apply(seq.size)
 
 module.exports = {
     /** @readonly */
     apply,
     /** @readonly */
-    cast,
+    concat,
     /** @readonly */
     map,
     /** @readonly */
@@ -106,6 +123,10 @@ module.exports = {
     /** @readonly */
     sum,
     /** @readonly */
+    size,
+    /** @readonly */
+    join,
+    /** @readonly */
     exclusiveScan,
     /** @readonly */
     inclusiveScan,

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,9 +16,70 @@ 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.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(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(seq.sum)
+
+const size = apply(seq.size)
+
+const join = pipe(seq.join)(apply)
+
+/** @type {<T, R>(f: (value: T) => R) => (c: Iterable<T>) => Iterable<R>} */
+const map = f => c => ({
+    *[Symbol.iterator]() {
+        for (const i of c) {
+            yield f(i)
+        }
+    }
+})
+
+/** @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,
@@ -21,33 +88,26 @@ module.exports = {
     reduce,
 
     /** @readonly */
-    join: pipe(mr.join)(apply),
+    join,
 
     /** @readonly */
-    sum: apply(mr.sum),
+    sum,
 
-    /** 
-     * @readonly
-     * @type {<T, R>(f: (value: T) => R) => (c: Iterable<T>) => Iterable<R>} 
-     */
-    map: f => c => ({
-        *[Symbol.iterator]() {
-            for (const i of c) {
-                yield f(i)
-            }
-        }
-    }),
+    /** @readonly */
+    size,
 
-    /** 
-     * @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 */
+    entries,
+
+    /** @readonly */
+    map,
+
+    /** @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.162",
+  "version": "0.0.167",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "index.js",
   "scripts": {

package/{map-reduce → sequence}/index.js

@@ -1,4 +1,4 @@
-const { pipe, id } = require('../func')
+const { pipe, id } = require('../function')
 
 /**
  * @template S
@@ -38,6 +38,45 @@ 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
+ * @template R
+ * @template I
+ * @typedef {{
+ *  readonly exlusive: ExlusiveScan<T, R>
+ *  readonly default: I
+ * }} InclusiveScan
+ */
+
+/** 
+ * @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 +84,8 @@ module.exports = {
     join,
     /** @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,
-}