functionalscript 0.0.176 → 0.0.182

package/README.md

@@ -10,6 +10,9 @@ Try FunctionalScript [here](https://functionalscript.com/).
 
 Create a new FunctionalScript repository on GitHub [here](https://github.com/functionalscript/template/generate).
 
+One of the main challenges is how to make a pure functional language when ES6 TCO is not supported by Chrome and Firefox.
+A workaround for this problem is to use `let` for renaming objects.
+
 ## JSON
 
 ```js

package/btree/index.js

@@ -358,7 +358,7 @@ const valuesList = node => () => {
             }
         }
     }
-    return f()()
+    return list.next(f())
 }
 
 module.exports = {

package/btree/test.js

@@ -1,6 +1,7 @@
 const btree = require('.')
 const { setVisitor, valuesList } = btree
 const { cmp } = require('../cmp') 
+const list = require('../sequence/list')
 
 /** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string>} */
 const set = node => value => {
@@ -21,11 +22,11 @@ const test = () => {
     //
     {
         /** @type {import('../sequence/list').Result<string>} */
-        let result = valuesList(node)()
+        let result = list.next(valuesList(node))
         while (result !== undefined) {
             const t = result[0]
             console.log(t)
-            result = result[1]()
+            result = list.next(result[1])
         }
     }
 }

package/package.json

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

package/sequence/README.md

@@ -12,7 +12,7 @@ Sequence types:
 See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array
 
 - `length: Sequence<infer T> => number`
-- `at: number => Sequence<infer T> = T`
+- `at: number => Sequence<infer T> = T|undefined`
 - `concat: Sequence<infer T> => Sequence<T> => Sequence<T>`
 - `entries: Sequence<infer T> => Sequence<[number, T]>`
 - `every: (infer T => boolean) => Sequence<T> => boolean`
@@ -24,7 +24,6 @@ See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Obj
 - `includes: infer T => Sequence<T> => boolean`
 - `indexOf: infer T => Sequence<T> => number`
 - `join: string => Sequence<string> => string`
-- `keys: Sequence<T> => Sequence<string>`
 - `lastIndexOf: infer T => Sequence<T> => number`
 - `map: (infer T => infer R) => Sequence<T> => Sequence<R>`
 - `reduce: ...Scan<T, R> => Sequence<T> => R`
@@ -38,6 +37,7 @@ See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Obj
 
 ### Priority 3.
 
+- `keys: Sequence<T> => Sequence<string>`
 - `values: Sequence<infer T> => Sequence<T>`
 
 ## Prohibited Array Operations

package/sequence/array/index.js

@@ -30,6 +30,13 @@ const option = require('../../option')
  * @typedef {readonly [T, T, T]} Array3
  */
 
+/**
+ * @template T0
+ * @template T1
+ * @template T2
+ * @typedef {readonly [T0, T1, T2]} Tuple3
+ */
+
 /** @typedef {0|1|2} Index3 */
 
 /**

package/sequence/index.js

@@ -56,7 +56,10 @@ const join = separator => ['', value => [value, scan(op.join(separator))(value)]
 
 const sum = inclusiveScan(op.addition)(0)
 
-const length = inclusiveScan(a => () => a + 1)(0)
+/** @type {(a: number) => () => number} */
+const counter = a => () => a + 1
+
+const length = inclusiveScan(counter)(0)
 
 /**
  * @template T

package/sequence/list/index.js

@@ -6,7 +6,25 @@ const { todo } = require('../../dev')
 
 /**
  * @template T
- * @typedef {() => Result<T>} List
+ * @typedef {() => Result<T>} ListFunc
+ */
+
+/**
+ * @template T
+ * @typedef {readonly [List<T>, List<T>]} Concat
+ */
+
+/**
+ * Please note that the list 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 a stack overflow if a list
+ * contains a lot of concateneted lists. Use `next` function to extract 
+ * a list. 
+ *
+ * @template T
+ * @typedef { ListFunc<T> | Concat<T>} List
  */
 
 /**
@@ -21,46 +39,59 @@ const { todo } = require('../../dev')
 
 const empty = () => undefined
 
+/** @type {<F, T>(a: readonly[F, List<T>]) => (b: List<T>) => readonly[F, List<T>]} */
+const norm = ([a0, a1]) => b => [a0, [a1, b]]
+
+/** @type {<T>(list: List<T>) => Result<T>} */
+const next = list => {
+    let i = list
+    while (true) {
+        if (typeof i === 'function') { return i() }
+        const [a, b] = i
+        if (typeof a === 'function') { 
+            const result = a()
+            if (result !== undefined) { 
+                return norm(result)(b)
+            }
+            i = b
+        } else {
+            i = norm(a)(b)
+        }
+    }
+}
+
 /**
  * @template T
  * @template R
  * @typedef {(list: List<T>) => List<R>} ListMap
  */
 
-/** @type {<T>(first: T) => ListMap<T, T>} */
-const list = first => tail => () => [first, tail]
-
 /** @type {<T>(first: T) => List<T>} */
-const one = first => list(first)(empty)
+const one = first => () => [first, empty]
 
 /** @type {<T>(array: array.Array<T>) => List<T>} */
 const fromArray = a => {
     /** @typedef {typeof a extends array.Array<infer T> ? T : never} T */
     /** @type {(index: number) => List<T>} */
-    const at = index => {
-        /** @type {(value: readonly [T]) => Result<T>} */
-        const result = ([value]) => list(value)(at(index + 1))()
-        return () => option.map(result)(array.at(index)(a))
+    const at = index => () => {
+        const result = array.at(index)(a)
+        if (result === undefined) { return undefined }
+        return [result[0], at(index + 1)]
     }
     return at(0)
 }
 
 /** @type {<T>(list0: List<T>) => ListMap<T, T>} */
-const concat = a => b => () => {
-    /** @typedef {typeof a extends List<infer T> ? T : never} T */
-    /** @type {(firstAntTail: FirstAndTail<T>) => Result<T>} */
-    const defined = ([first, tail]) => [first, concat(tail)(b)]
-    return option.match(defined)(b)(a())
-}
+const concat = a => b => [a, b]
 
 /** @type {<T, R>(f: (value: T) => List<R>) => ListMap<T, R>} */
 const flatMap = f => input => () => {
     let i = input
     while (true) { 
-        const result = i()
+        const result = next(i)
         if (result === undefined) { return undefined }
         const [first, tail] = result
-        const firstResult = f(first)() 
+        const firstResult = next(f(first)) 
         if (firstResult !== undefined) {
             const [firstFirst, firstTail] = firstResult
             return [firstFirst, concat(firstTail)(flatMap(f)(tail))]
@@ -80,33 +111,35 @@ const filter = f => flatMap(i => f(i) ? one(i) : empty)
 
 /** @type {<T, R>(s: base.Scan<T, R>) => ListMap<T, R>} */
 const scan = s => input => () => {
-    /** @typedef {typeof s extends base.Scan<infer T, infer R> ? [T, R] : never} TR */
-    /** @typedef {TR[0]} T */
-    /** @typedef {TR[1]} R */
-    /** @type {(firstAndTail: FirstAndTail<T>) => Result<R>} */
-    const defined = ([first, tail]) => {
-        const [newFirst, newS] = s(first)
-        return [newFirst, scan(newS)(tail)]
+    const result = next(input)
+    if (result === undefined) {
+        return result
     }
-    return option.map(defined)(input())
+    const [first, tail] = result
+    const [newFirst, newS] = s(first)
+    return [newFirst, scan(newS)(tail)]
 }
 
 /** @type {<T, R>(s: base.InclusiveScan<T, R>) => ListMap<T, R>} */
-const inclusiveScan = ([first, s]) => input => list(first)(scan(s)(input))
+const inclusiveScan = ([first, s]) => input => () => [first, scan(s)(input)]
 
 /** @type {<T>(def: T) => (input: List<T>) => T} */
 const last = def => input => {
-    let i = input()
     let r = def
-    while (i !== undefined) {
-        r = i[0]
-        i = i[1]()
+    let i = input    
+    while (true) {
+        const result = next(i)
+        if (result === undefined) {
+            return r
+        }
+        r = result[0]
+        i = result[1]
     }
     return r
 }
 
 /** @type {<T, R>(s: base.InclusiveScan<T, R>) => (input: List<T>) => R} */
-const reduce = s => input => last(s[0])(inclusiveScan(s)(input))
+const reduce = ([first, s]) => input => last(first)(scan(s)(input))
 
 const entries = scan(base.entries)
 
@@ -116,12 +149,18 @@ const length = reduce(base.length)
 
 const join = pipe(base.join)(reduce)
 
+/** @type {<T>(f: (value: T) => boolean) => ListMap<T, T>} */
+const takeWhile = f => input => () => {
+    const result = next(input)
+    if (result === undefined || !f(result[0])) { return undefined }
+    return result
+}
+
 /** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => T|undefined} */
 const find = f => input => {
-    /** @typedef {typeof f extends (value: infer T) => boolean ? T : never} T */
-    /** @type {(result: FirstAndTail<T>) => T} */
-    const defined = ([first]) => first
-    return option.map(defined)(filter(f)(input)())
+    const result = next(filter(f)(input))
+    if (result === undefined) { return undefined }
+    return result[0]
 }
 
 /**
@@ -130,17 +169,19 @@ const find = f => input => {
  */
 const iterable = list => ({
     *[Symbol.iterator]() {
-        let result = list()
-        while (result !== undefined) {
+        let i = list
+        while (true) {
+            const result = next(i)
+            if (result === undefined) { return }
             yield result[0]
-            result = result[1]()
+            i = result[1]
         }
     }
 })
 
 module.exports = {
     /** @readonly */
-    list,
+    next,
     /** @readonly */
     one,
     /** @readonly */
@@ -177,4 +218,6 @@ module.exports = {
     length,
     /** @readonly */
     find,
+    /** @readonly */
+    takeWhile,
 }

package/sequence/list/test.js

@@ -3,23 +3,36 @@ const { sum } = require('..')
 
 /** @type {<T>(l: list.List<T>) => void} */
 const print = a => {
-    let i = a()
-    while (i !== undefined) {
-        console.log(i[0])
-        i = i[1]()
+    let i = a
+    while (true) {
+        const result = list.next(i)
+        if (result === undefined) { return }
+        console.log(result[0])
+        i = result[1]
     }
 }
 
 {
     const big = list.fromArray([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 42, 60])
-    // print(big)
-    /*
     const list0 = list.fromArray([0, 1, 2, 3])
     const list1 = list.flatMap(x => list.fromArray([x, x * 2, x * 3]))(list0)
     const list2 = list.concat(list0)(list0)
     const list3 = list.inclusiveScan(sum)(list0)
-    print(list3)
-    */
     const r = list.find(x => x === 42)(big)
-    console.log(r)
+    {
+        let x = big
+        for (let i = 0; i < 1_000_000; ++i) {
+            x = list.concat(list.empty)(x)
+        }
+        const r = list.next(x)
+        print(x)
+    } 
+    {
+        let x = big
+        for (let i = 0; i < 1_000_000; ++i) {
+            x = list.concat(x)(list.one(i))
+        }
+        const r = list.next(x)
+        // print(x)
+    }
 }