functionalscript 0.0.239 → 0.0.243

package/types/{sequence → list}/test.js

@@ -1,11 +1,16 @@
 const _ = require('.')
 const json = require('../../json')
 const { sort } = require('../object')
-const { addition, strictEqual } = require('../function/operator')
+const { addition, strictEqual, foldToScan } = require('../function/operator')
 
-/** @type {(sequence: _.Sequence<json.Unknown>) => string} */
+/** @type {(sequence: _.List<json.Unknown>) => string} */
 const stringify = sequence => json.stringify(sort)(_.toArray(sequence))
 
+{
+    const x = stringify(_.toArray(_.take(10)(_.cycle([1, 2, 3]))))
+    if (x !== '[1,2,3,1,2,3,1,2,3,1]') { throw x }
+}
+
 {
     const s = stringify([1, 2, 3])
     if (s !== '[1,2,3]') { throw s }
@@ -84,7 +89,7 @@ const stringify = sequence => json.stringify(sort)(_.toArray(sequence))
 }
 
 {
-    const op = _.scanState(addition)
+    const op = foldToScan(addition)
     const result = stringify(_.scan(op)([2, 3, 4, 5]))
     if (result !== '[2,5,9,14]') { throw result }
 }
@@ -130,7 +135,7 @@ const stringify = sequence => json.stringify(sort)(_.toArray(sequence))
 }
 
 {
-    const result = stringify(_.reverse([1,2,3,4,5]))
+    const result = stringify(_.reverse([1, 2, 3, 4, 5]))
     if (result !== '[5,4,3,2,1]') { throw result }
 }
 
@@ -146,7 +151,7 @@ const stringify = sequence => json.stringify(sort)(_.toArray(sequence))
 
 {
     const result = _.some(_.map(x => x > 5)([0, 1, 7]))
-    if (!result) { throw result}
+    if (!result) { throw result }
 }
 
 {
@@ -176,7 +181,7 @@ const stringify = sequence => json.stringify(sort)(_.toArray(sequence))
 
 {
     const result = _.equal(strictEqual)([1])([2, 3])
-    if (result) { throw result}
+    if (result) { throw result }
 }
 
 {
@@ -214,8 +219,8 @@ const stringify = sequence => json.stringify(sort)(_.toArray(sequence))
 const stress = () => {
 
     {
-        // 100_000_000 is too much
-        const n = 50_000_000
+        // 200_000_000 is too much
+        const n = 100_000_000
         const result = _.toArray(_.countdown(n))
         if (result.length !== n) { throw result.length }
         const len = _.length(_.filter(x => x > n)(result))
@@ -225,26 +230,30 @@ const stress = () => {
     console.log('first')
 
     {
-        // 200_000_000 is too much
-        const n = 100_000_000
+        // 100_000_000 is too much
+        const n = 50_000_000
         const result = _.toArray(_.countdown(n))
         if (result.length !== n) { throw result.length }
         const first = _.first(undefined)(result)
         if (first !== n - 1) { throw first }
     }
 
+    console.log('concat back')
+
     {
-        /** @type {_.Sequence<number>} */
+        /** @type {_.List<number>} */
         let sequence = []
-        // 10_000_000 is too much
-        for (let i = 0; i < 5_000_000; ++i) {
+        // 20_000_000 is too much
+        for (let i = 0; i < 10_000_000; ++i) {
             sequence = _.concat(sequence)([i])
         }
         const r = _.toArray(sequence)
     }
 
+    console.log('flat to Array')
+
     {
-        /** @type {_.Sequence<number>} */
+        /** @type {_.List<number>} */
         let sequence = []
         // 4_000_000 is too much
         for (let i = 0; i < 2_000_000; ++i) {
@@ -253,18 +262,22 @@ const stress = () => {
         const r = _.toArray(sequence)
     }
 
+    console.log('flat next')
+
     {
-        /** @type {_.Sequence<number>} */
+        /** @type {_.List<number>} */
         let sequence = []
         // 5_000_000 is too much
-        for (let i = 0; i < 2_000_000; ++i) {
+        for (let i = 0; i < 4_000_000; ++i) {
             sequence = _.flat([sequence, [i]])
         }
         const a = _.next(sequence)
     }
 
+    console.log('concat front')
+
     {
-        /** @type {_.Sequence<number>} */
+        /** @type {_.List<number>} */
         let sequence = []
         // 20_000_000 is too much
         for (let i = 0; i < 10_000_000; ++i) {
@@ -274,7 +287,7 @@ const stress = () => {
     }
 
     {
-        /** @type {_.Sequence<number>} */
+        /** @type {_.List<number>} */
         let sequence = []
         // 10_000_000 is too much
         for (let i = 0; i < 5_000_000; ++i) {
@@ -306,7 +319,7 @@ const stress = () => {
     }
 }
 
-// stress()
+stress()
 
 module.exports = {
 

package/types/map/index.js

@@ -3,7 +3,7 @@ const btree = require('../btree')
 const { getVisitor, setVisitor, values } = require("../btree")
 const compare = require("../function/compare")
 const { cmp } = require("../function/compare")
-const seq = require("../sequence")
+const seq = require("../list")
 
 /** @typedef {compare.Sign} Sign */
 
@@ -43,7 +43,7 @@ const at = name => map => {
 }
 
 /** @type {(name: string) => <T>(value: T) => (map: Map<T>) => Map<T>} */
-const insert = name => value => map =>  {
+const set = name => value => map =>  {
     /** @type {Entry<typeof value>} */
     const entry = [name, value]
     if (map === undefined) { return [entry] }
@@ -54,16 +54,16 @@ const insert = name => value => map =>  {
     }
 }
 
-/** @type {<T>(map: Map<T>) => seq.Sequence<Entry<T>>} */
+/** @type {<T>(map: Map<T>) => seq.List<Entry<T>>} */
 const entries = map => map === undefined ? [] : values(map)
 
 /** @type {<T>(map: Map<T>) => (entry: Entry<T>) => Map<T>} */
-const insertOp = map => ([name, value]) => insert(name)(value)(map)
+const setOp = map => ([name, value]) => set(name)(value)(map)
 
-/** @type {<T>(entries: seq.Sequence<Entry<T>>) => Map<T>} */
+/** @type {<T>(entries: seq.List<Entry<T>>) => Map<T>} */
 const fromEntries = entries => {
-    /** @typedef {typeof entries extends seq.Sequence<Entry<infer T>> ? T : never} T */    
-    return seq.reduce(insertOp)(/** @type {Map<T>} */(undefined))(entries)
+    /** @typedef {typeof entries extends seq.List<Entry<infer T>> ? T : never} T */    
+    return seq.reduce(setOp)(/** @type {Map<T>} */(undefined))(entries)
 }
 
 module.exports = {
@@ -72,8 +72,8 @@ module.exports = {
     /** @readonly */
     at,
     /** @readonly */
-    insert,
-    /** @readonlg */
+    set,
+    /** @readonly */
     entries,
     /** @readonly */
     fromEntries,

package/types/map/test.js

@@ -1,26 +1,26 @@
-const { at, insert, empty, entries } = require('.')
-const list = require('../sequence')
+const { at, set, empty, entries } = require('.')
+const seq = require('../list')
 
 {
-    let m = insert('a')(1)(undefined)
+    let m = set('a')(1)(undefined)
 
     if (at('a')(m) !== 1) { throw 'error' }
     if (at('b')(m) !== undefined) { throw 'error' }
 
-    m = insert('b')(2)(m)
+    m = set('b')(2)(m)
 
     if (at('a')(m) !== 1) { throw 'error' }
     if (at('b')(m) !== 2) { throw 'error' }
     if (at('c')(m) !== undefined) { throw 'error' }
 
-    m = insert('z')(3)(m)
+    m = set('z')(3)(m)
 
     if (at('a')(m) !== 1) { throw 'error' }
     if (at('b')(m) !== 2) { throw 'error' }
     if (at('z')(m) !== 3) { throw 'error' }
     if (at('')(m) !== undefined) { throw 'error' }
 
-    m = insert('')(4)(m)
+    m = set('')(4)(m)
 
     if (at('a')(m) !== 1) { throw 'error' }
     if (at('b')(m) !== 2) { throw 'error' }
@@ -28,7 +28,7 @@ const list = require('../sequence')
     if (at('')(m) !== 4) { throw 'error' }
     if (at('Hello world!')(m) !== undefined) { throw 'error' }
 
-    m = insert('Hello world!')(42)(m)
+    m = set('Hello world!')(42)(m)
 
     if (at('a')(m) !== 1) { throw 'error' }
     if (at('b')(m) !== 2) { throw 'error' }
@@ -41,12 +41,12 @@ const list = require('../sequence')
 }
 
 {
-    let m = insert('x')(12)(undefined)
-    m = insert('y')(44)(m)
+    let m = set('x')(12)(undefined)
+    m = set('y')(44)(m)
     if (at('x')(m) !== 12) { throw 'error' }
     if (at('y')(m) !== 44) { throw 'error' }
     if (at('a')(m) !== undefined) { throw 'error' }
-    const e = list.toArray(entries(m))
+    const e = seq.toArray(entries(m))
     if (e.length !== 2) { throw 'error' }
 }
 
@@ -54,7 +54,7 @@ const list = require('../sequence')
     /** @type {import('.').Map<number>} */
     let m = empty
     for (let i = 0; i < 100_000; ++i) {
-        m = insert((i * i).toString())(i)(m)
+        m = set((i * i).toString())(i)(m)
         /*
         console.log()
         console.log(`# ${i}`)

package/types/object/index.js

@@ -1,6 +1,5 @@
-const seq = require('../sequence')
+const seq = require('../list')
 const map = require('../map')
-const { compose } = require('../function')
 
 /**
  * @template T
@@ -17,7 +16,7 @@ const { compose } = require('../function')
 /** @type {(name: string) => <T>(object: Map<T>) => T|undefined} */
 const at = name => object => Object.getOwnPropertyDescriptor(object, name)?.value
 
-/** @type {<T>(entries: seq.Sequence<Entry<T>>) => seq.Sequence<Entry<T>>} */
+/** @type {<T>(entries: seq.List<Entry<T>>) => seq.List<Entry<T>>} */
 const sort = entries => map.entries(map.fromEntries(entries))
 
 module.exports = {

package/types/sequence/README.md

@@ -1,68 +0,0 @@
-# Sequences
-
-Sequence types:
-
-- Sequence
-- Array
-- Iterable
-- AsyncIterable
-
-# Sequence Types
-
-```ts
-type Sequence<T> = 
-    readonly T[] |
-    Thunk<T> |
-
-type Thunk<T> = () => Node<T>
-
-type Node<T> =
-    undefined |
-    { readonly first: T, readonly tail: Sequence<T> } |
-    readonly[Sequence<T>, Sequence<T>]
-```
-
-## Functions
-
-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|undefined`
-- `concat: Sequence<infer T> => Sequence<T> => Sequence<T>`
-- `entries: Sequence<infer T> => Sequence<[number, T]>`
-- `every: (infer T => boolean) => Sequence<T> => boolean`
-- `filter: (infer T => boolean) => Sequence<T> => Sequence<T>`
-- `find: (infer T => boolean) => Sequence<T> => T`
-- `findIndex: (infer T => boolean) => Sequence<T> => number`
-- `flat: Sequence<Sequence<T>> => Sequence<T>`
-- `flatMap: (infer T => Sequence<infer R>) => Sequence<T> => Sequence<R>`
-- `includes: infer T => Sequence<T> => boolean`
-- `indexOf: infer T => Sequence<T> => number`
-- `join: string => Sequence<string> => string`
-- `lastIndexOf: infer T => Sequence<T> => number`
-- `map: (infer T => infer R) => Sequence<T> => Sequence<R>`
-- `reduce: ...Scan<T, R> => Sequence<T> => R`
-- `some: (infer T => boolean) => Sequence<T> => boolean`
-
-### Priority 2.
-
-- `slice: number => number => Sequence<T> => Sequence<T>`
-- `reduceRight: ...Scan<T, R> => Sequence<T> => R`
-- `toLocalString: Locales => Sequence<T> => string`
-
-### Priority 3.
-
-- `keys: Sequence<T> => Sequence<string>`
-- `values: Sequence<infer T> => Sequence<T>`
-
-## Prohibited Array Operations
-
-- `copyWithin`
-- `fill`
-- `pop`
-- `push`
-- `reverse`
-- `shift`
-- `sort`
-- `splice`
-- `unshift`