functionalscript 0.0.212 → 0.0.217

package/function/index.js

@@ -8,11 +8,11 @@
 const compose = f => g => x => f(g(x))
 
 /** @type {<T>(value: T) => T} */
-const id = value => value
+const identity = value => value
 
 module.exports = {
     /** @readonly */
-    id,
+    identity,
     /** @readonly */
     compose,
 }

package/json/test.js

@@ -1,6 +1,6 @@
 const json = require('.')
 const { sort } = require('../object')
-const { id } = require('../function')
+const { identity } = require('../function')
 
 if (json.addProperty("Hello")([])({}) !== "Hello") { throw 'error' }
 
@@ -10,7 +10,7 @@ if (json.addProperty("Hello")([])({}) !== "Hello") { throw 'error' }
 }
 
 {
-    const x = json.stringify(id)(json.addProperty("Hello")(['a'])({}))
+    const x = json.stringify(identity)(json.addProperty("Hello")(['a'])({}))
     if (x !== '{"a":"Hello"}') { throw x }
 }
 
@@ -20,7 +20,7 @@ if (json.addProperty("Hello")([])({}) !== "Hello") { throw 'error' }
 }
 
 {
-    const x = json.stringify(id)(json.addProperty("Hello")(['a'])({ c: [], b: 12 }))
+    const x = json.stringify(identity)(json.addProperty("Hello")(['a'])({ c: [], b: 12 }))
     if (x !== '{"c":[],"b":12,"a":"Hello"}') { throw x }
 }
 
@@ -34,6 +34,6 @@ if (json.addProperty("Hello")([])({}) !== "Hello") { throw 'error' }
 {
     const _0 = { a: { y: [24] }, c: [], b: 12 }
     const _1 = json.addProperty("Hello")(['a', 'x'])(_0)
-    const _2 = json.stringify(id)(_1)
+    const _2 = json.stringify(identity)(_1)
     if (_2 !== '{"a":{"y":[24],"x":"Hello"},"c":[],"b":12}') { throw _2 }
 }

package/package.json

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

package/sequence/index.js

@@ -18,7 +18,7 @@ const { logicalNot, strictEqual } = require('../function/operator')
  * 
  * Please note that the sequence also contains `Concat<T>. We need this as 
  * a workaround because modern JavaScript implementations don't support 
- * ES6 TCO (Tail Call Optimization). Without this wotkaround we may have 
+ * ES6 TCO (Tail Call Optimization). Without this workaround, we may have 
  * a stack overflow if a list contains a lot of concateneted lists. 
  *
  * @template T
@@ -37,6 +37,9 @@ const { logicalNot, strictEqual } = require('../function/operator')
 
 const empty = () => undefined
 
+/** @type {<T>(first: T) => (tail: Sequence<T>) => Sequence<T>} */
+const sequence = first => tail => () => [first, tail]
+
 /** @type {<F, T>(a: readonly[F, Sequence<T>]) => (b: Sequence<T>) => readonly[F, Sequence<T>]} */
 const norm = ([a0, a1]) => b => [a0, [a1, b]]
 
@@ -78,7 +81,7 @@ const first = input => {
  */
 
 /**
- * Note: the operation is not lazy. It traverse the given array and creates a linked list.
+ * Note: the operation is not lazy. It traverses the given array and creates a linked list.
  *  
  * @type {<T>(...array: readonly T[]) => Sequence<T>} 
  */
@@ -86,14 +89,12 @@ const list = (...array) => {
     /** @typedef {typeof array extends readonly(infer T)[] ? T : never} T */
     let i = array.length
     /** @type {Sequence<T>} */
-    let result = empty
+    let iResult = empty
     while (i !== 0) {
         i = i - 1
-        /** @type {FirstAndTail<T>} */
-        const listResult = [array[i], result]
-        result = () => listResult
+        iResult = sequence(array[i])(iResult)
     }
-    return result
+    return iResult
 }
 
 /** @type {<T>(...array: readonly Sequence<T>[]) => Sequence<T>} */
@@ -184,8 +185,8 @@ const last = def => input => {
 /** @type {<T, R>(s: seqOp.ExclusiveScan<T, R>) => (input: Sequence<T>) => R} */
 const reduce = ([first, s]) => input => last(first)(scan(s)(input))
 
-/** @type {<T, R>(ro: op.ReduceOperator<R, T>) => (first: R) => (input: Sequence<T>) => R} */
-const fold = ro => first => reduce(seqOp.exclusiveScan(ro)(first))
+/** @type {<T, R>(operator: op.ReduceOperator<R, T>) => (first: R) => (input: Sequence<T>) => R} */
+const fold = operator => first => reduce(seqOp.exclusiveScan(operator)(first))
 
 const entries = scan(seqOp.entries)
 
@@ -265,6 +266,20 @@ const zip = a => b => () => {
     return [[resultA[0], resultB[0]], zip(resultA[1])(resultB[1])]
 }
 
+/** @type {<T>(s: Sequence<T>) => Sequence<T>} */
+const reverse = s => {
+    /** @type {typeof s} */
+    let iResult = empty
+    let iSource = s
+    while (true) {
+        const result = next(iSource)
+        if (result === undefined) { return iResult }
+        const [first, tail] = result
+        iResult = sequence(first)(iResult)
+        iSource = tail
+    }
+}
+
 module.exports = {
     /** @readonly */
     next,
@@ -273,6 +288,8 @@ module.exports = {
     /** @readonly */
     empty,
     /** @readonly */
+    sequence,
+    /** @readonly */
     at,
     /** @readonly */
     concat,
@@ -326,4 +343,6 @@ module.exports = {
     includes,
     /** @readonly */
     zip,
+    /** @readonly */
+    reverse,
 }

package/sequence/operator/README.md

@@ -0,0 +1,41 @@
+# Operator
+
+## Sequence
+
+```ts
+type Sequence<T> = SubSequence<T, undefined>
+```
+
+## SubSequence
+
+```ts
+type SubSequence<T, C> = () => SubSequenceResult<T, C>
+type SubSequenceResult<T, C> = [T, SubSequence<T, C>] | [C]
+```
+
+## The Main FlatScan Operator
+
+```ts
+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] }        
+    }
+}
+```

package/sequence/test.js

@@ -1,12 +1,15 @@
 const seq = require('.')
+const { empty, next, list, flatMap, concat, exclusiveScan, find, every, some, first, drop, map, generate } = require('.')
 const { sum } = require('./operator')
 const array = require('./array')
+const json = require('../json')
+const { identity } = require('../function')
 
 /** @type {<T>(input: seq.Sequence<T>) => void} */
 const print = input => {
     let i = input
     while (true) {
-        const result = seq.next(i)
+        const result = next(i)
         if (result === undefined) { return }
         console.log(result[0])
         i = result[1]
@@ -14,47 +17,47 @@ const print = input => {
 }
 
 {
-    const big = seq.list(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 42, 60)
-    const list0 = seq.list(0, 1, 2, 3)
-    const list1 = seq.flatMap(x => seq.list(x, x * 2, x * 3))(list0)
-    const list2 = seq.concat(list0, list0)
-    const list3 = seq.exclusiveScan(sum)(list0)
-    const r = seq.find(x => x === 42)(big)
-    if (seq.every(x => x > 0)(big) !== true) { throw 'x'}
-    if (seq.every(x => x < 20)(big) !== false) { throw 'x' }
-    if (seq.some(x => x > 100)(big) !== false) { throw 'x' }
-    if (seq.some(x => x > 50)(big) !== true) { throw 'x' }
-    if (seq.first(seq.drop(16)(big)) !== 42) { throw 'drop'}
+    const big = list(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 42, 60)
+    const list0 = list(0, 1, 2, 3)
+    const list1 = flatMap(x => list(x, x * 2, x * 3))(list0)
+    const list2 = concat(list0, list0)
+    const list3 = exclusiveScan(sum)(list0)
+    const r = find(x => x === 42)(big)
+    if (every(x => x > 0)(big) !== true) { throw 'x' }
+    if (every(x => x < 20)(big) !== false) { throw 'x' }
+    if (some(x => x > 100)(big) !== false) { throw 'x' }
+    if (some(x => x > 50)(big) !== true) { throw 'x' }
+    if (first(drop(16)(big)) !== 42) { throw 'drop' }
     {
-        const a = seq.map(seq.generate)(seq.generate(100_000))
+        const a = map(generate)(generate(100_000))
         const ar = array.fromSequence(a)
-        // This operation use a lot of stack because `...` 
+        // This operation uses a lot of stack because `...` 
         // puts array items on a stack.
         // Use `array.sequence` instead
-        const x = seq.concat(...ar)
-        const r = seq.next(x)
+        const x = concat(...ar)
+        const r = next(x)
         // print(x)
     }
     {
-        const a = array.fromSequence(seq.generate(1_000_000))
-        let x = seq.concat(array.sequence(a), big)
-        const r = seq.next(x)
+        const a = array.fromSequence(generate(1_000_000))
+        let x = concat(array.sequence(a), big)
+        const r = next(x)
         // print(x)
     }
     {
         let x = big
         for (let i = 0; i < 1_000_000; ++i) {
-            x = seq.concat(seq.empty, x)
+            x = concat(empty, x)
         }
-        const r = seq.next(x)
+        const r = next(x)
         // print(x)
-    } 
+    }
     {
         let x = big
         for (let i = 0; i < 1_000_000; ++i) {
-            x = seq.concat(x, seq.list(i))
+            x = concat(x, list(i))
         }
-        const r = seq.next(x)
+        const r = next(x)
         // print(x)
     }
 }
@@ -63,3 +66,10 @@ const print = input => {
     const x = seq.join(':')(seq.list("1", "2", "3", "4", "5", "6"))
     if (x !== "1:2:3:4:5:6") { throw x }
 }
+
+{
+    const r = seq.reverse(seq.list(1, 2, 3, 4))
+    const s = array.fromSequence(r)
+    const j = json.stringify(identity)(s)
+    if (j !== '[4,3,2,1]') { throw j }
+}