functionalscript 0.0.216 → 0.0.217

package/package.json

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

package/sequence/operator/README.md

@@ -1,41 +1,41 @@
-# Sequence Operators
+# Operator
 
-## A `FlatMap` Operator
-
-`flatMap = combine(flat)(map)`
-
-## A `Scan` Operator
-
-```ts
-type Scan<A, T> = (accumulator: A) => (value: T) => A
-type ExclusiveScan<A, T> = [first, Scan<A, T>]
-```
-
-`scan`
-
-`reduce = last(first)(scan)`
-
-An alternative definition of a scan:
+## Sequence
 
 ```ts
-type Scan2<A, T> = (value: T) => [A, Scan2<A, T>]
-type ExclusiveScan2<A, T> = [first, Scan2<A, T>]
+type Sequence<T> = SubSequence<T, undefined>
 ```
 
-`takeWhile`, `find` can use `scan`. Optimization: if a `Scan2` part is `emptyScan` then we can stop searching.
-
-## A Universal Operator `FlatScan`
+## SubSequence
 
 ```ts
-type FlatScan<A, T> = (value: T) => FlatScanSequence<A, T>
-type FlatScanSequence<A, T> = () => FlatScanResult<A, T>
-type FlatScanResult<A, T> =
-    ['value', A, FlatScanSequence<A, T>] | 
-    ['novalue', FlatScan<A, T>]
+type SubSequence<T, C> = () => SubSequenceResult<T, C>
+type SubSequenceResult<T, C> = [T, SubSequence<T, C>] | [C]
 ```
 
-Optimization: if result is `empty`, then we can stop.
+## The Main FlatScan Operator
 
 ```ts
-const empty = ['novalue', () => empty]
-```
+type FlatScanOperator<T, A> = (value: T) => SubSequence<A, FlatScanOp<T, A>>
+
+const flatScanConcat
+: SubSequence<A, FlatScanOp<T, A>> => Sequence<T> => Sequence<A>
+=> a => b => () => {
+    switch (next(a)) {
+        case [first, tail]: { return [first, flatScanConcat(tail)(b)] }
+        case [operator]: { return flatScan(operator)(b)() }
+    }
+}
+
+const flatScan 
+: FlatScanOperator<T, A> => Sequence<T> => Sequence<A>
+=> operator => sequence => () => {
+    // optimization for `takeWhile`, `find`
+    if (operator === flatScanEmpty) { return [undefined] }
+    //
+    switch (next(s)) {
+        case [first, tail]: { return flatScanConcat(operator(first))(tail)() }
+        case [undefined]: { return [undefined] }        
+    }
+}
+```