functionalscript 0.0.167 → 0.0.168

package/async/iterable/index.js

@@ -83,7 +83,7 @@ const exclusiveScan = merge => init => c => ({
     }
 })
 
-/** @type {<T, R>(es: seq.ExlusiveScan<T, R>) => (c: AnyIterable<T>) => AsyncIterable<R>} */
+/** @type {<T, R>(es: seq.Scan<T, R>) => (c: AnyIterable<T>) => AsyncIterable<R>} */
 const applyExclusiveScan = es => c => ({
     async *[Symbol.asyncIterator]() {
         let ies = es

package/iterable/index.js

@@ -38,8 +38,8 @@ const exclusiveScan = merge => init => c => ({
 /** @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 => ({
+/** @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) {
@@ -50,7 +50,10 @@ const applyExclusiveScan = es => c => ({
     }
 })
 
-const entries = applyExclusiveScan(seq.entries)
+/** @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)

package/package.json

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

package/sequence/index.js

@@ -1,29 +1,96 @@
-const { pipe, id } = require('../function')
+const { todo } = require('../dev')
+const { id } = require('../function')
 
 /**
- * @template S
- * @template I
- * @typedef {(state: S) => (value: I) => S} Merge
+ * @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: Merge<S, I>
+ *  readonly merge: BinaryOperator<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}`, 
@@ -51,37 +118,10 @@ const size = {
     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,
     /** @readonly */
     join,
+    join2,
     /** @readonly */
     sum,
     /** @readonly */