functionalscript 0.0.238 → 0.0.242

package/.github/workflows/node.js.yml

@@ -5,9 +5,7 @@ name: Node.js CI
 
 on:
   push:
-    branches: [ main ]
   pull_request:
-    branches: [ main ]
 
 jobs:
   build:

package/commonjs/README.md

@@ -0,0 +1,55 @@
+# Common.js
+
+```ts
+// package/index.js
+
+type PackageGet = (packageId: string) => Package | undefined
+type Package = {
+    // returns a global package id.
+    readonly dependency: (localPackageId: string) => string | undefined
+    // returns source of the file.
+    readonly file: (localFileId: string) => string | undefined
+}
+
+// module/index.js
+
+type ModuleMapInterface<M> = {
+    readonly at: (moduleId: string) => (moduleMap: M) => ModuleState | undefined
+    readonly insert: (moduleId: string) => (moduleState: ModuleState) => (moduleMap: M) => M
+}
+
+type ModuleState = readonly['ok', Module] | readonly['error', ModuleError] | readonly['building']
+
+type Module = {
+    readonly exports: unknown
+    readonly requireMap: object.Map<string>
+}
+
+type ModuleError = 'file not found' | 'compile error' | 'runtime error' | 'circular reference'
+
+type ModuleId = { 
+    readonly packageId: string,
+    readonly path: readonly string[],
+}
+
+const moduleIdToString: (moduleId: ModuleId) => string;
+
+// build/index.js
+
+type BuildConfig<M> = {
+    readonly packageGet: PackageGet
+    readonly moduleMapInterface: ModuleMapInterface<M>     
+    readonly moduleId: ModuleId
+    readonly moduleMap: M // mutable
+}
+
+type BuildState<M> = {
+    readonly packageGet: PackageGet
+    readonly moduleMapInterface: ModuleMapInterface<M>
+    readonly moduleId: ModuleId
+    readonly moduleMap: M // mutable
+    readonly ModuleRequireMap: map.Map<string> // mutable
+}
+
+const getOrBuild: <M>(buildConfig: BuildConfig<M>) => readonly[ModuleState, M];
+```

package/commonjs/module/index.js

@@ -1,22 +1,35 @@
-const map = require('../../types/map')
 const object = require('../../types/object')
-const run = require('../run')
-const seq = require('../../types/sequence')
 
 /**
+ * @template M
  * @typedef {{
- *  readonly map: object.Map<string>
- *  readonly run: run.Module
- * }} Module
+ *  readonly at: (moduleId: string) => (moduleMap: M) => ModuleState | undefined
+ *  readonly insert: (moduleId: string) => (moduleState: ModuleState) => (moduleMap: M) => M
+ * }} ModuleMapInterface
  */
 
 /** 
+ * @typedef {|
+ *  readonly['ok', Module] | 
+ *  readonly['error', ModuleError] | 
+ *  readonly['building']
+ * } ModuleState 
+ */
+
+/**
  * @typedef {{
- *  readonly map: map.Map<Module>
- *  readonly order: seq.Sequence<string>
- * }} Cache 
+ *  readonly exports: unknown
+ *  readonly requireMap: object.Map<string>
+ * }} Module
  */
 
-/** @typedef {(path: string) => string|undefined} ReadFile */
+/** 
+ * @typedef {|
+ *  'file not found' | 
+ *  'compile error' | 
+ *  'runtime error' | 
+ *  'circular reference'
+ * } ModuleError
+ */
 
 module.exports = {}

package/commonjs/package/dependencies/index.js

@@ -1,5 +1,5 @@
 const json = require('../../../json')
-const seq = require('../../../types/sequence')
+const seq = require('../../../types/list')
 
 /** @typedef {readonly[string, string]} DependencyJson */
 

package/commonjs/package/dependencies/test.js

@@ -1,7 +1,4 @@
 const _ = require('.')
-const json = require('../../../json')
-const { sort } = require('../../../types/object')
-const seq = require('../../../types/sequence')
 
 {
     if (!_.isDependenciesJson(undefined)) { throw 'error' }

package/commonjs/package/index.js

@@ -20,9 +20,14 @@ const isPackageJson = j => {
     return true
 }
 
-/** @typedef {object.Map<string>} Files */
+/**
+ * @typedef {{
+ *  readonly dependency: (localPackageId: string) => string | undefined
+ *  readonly file: (localFileId: string) => string | undefined
+ * }} Package
+ */
 
-/** @typedef {object.Map<dep.DependencyJson>} PackageMap */
+/** @typedef {(packageId: string) => Package | undefined} PackageGet */
 
 module.exports = {
     /** @readonly */

package/commonjs/path/index.js

@@ -1,9 +1,9 @@
-const seq = require("../../types/sequence")
+const seq = require("../../types/list")
 const option = require("../../types/option")
 const { compose } = require("../../types/function")
 const dep = require("../package/dependencies")
 const { at } = require("../../types/object")
-const pack = require("../package")
+// const pack = require("../package")
 
 /** @typedef {readonly string[]} Items */
 
@@ -18,7 +18,7 @@ const pack = require("../package")
 /** @type {(path: string) => readonly string[]} */
 const split = path => path.split('/')
 
-/** @type {(s: undefined|seq.Sequence<string>) => (items: string) => undefined|seq.Sequence<string>} */
+/** @type {(s: undefined|seq.List<string>) => (items: string) => undefined|seq.List<string>} */
 const normItemsOp = prior => item => {
     if (prior === undefined) { return undefined }
     switch (item) {
@@ -29,17 +29,17 @@ const normItemsOp = prior => item => {
             return result.tail
         }
         default: {
-            return seq.sequence(item)(prior)
+            return seq.nonEmpty(item)(prior)
         }
     }
 }
 
-/** @type {(items: seq.Sequence<string>) => seq.Sequence<string>|undefined} */
+/** @type {(items: seq.List<string>) => seq.List<string>|undefined} */
 const normItems = compose(seq.reduce(normItemsOp)([]))(option.map(seq.reverse))
 
 /** @type {(local: string) => (path: string) => LocalPath|undefined} */
 const parseLocal = local => {
-    /** @type {(path: string) => readonly[boolean, seq.Sequence<string>]} */
+    /** @type {(path: string) => readonly[boolean, seq.List<string>]} */
     const fSeq = path => {
         const pathSeq = split(path)
         switch (seq.first(undefined)(pathSeq)) {
@@ -61,9 +61,9 @@ const parseLocal = local => {
     return f
 }
 
-/** @typedef {readonly[string, seq.Sequence<string>]} IdPath */
+/** @typedef {readonly[string, seq.List<string>]} IdPath */
 
-/** @type {(prior: readonly[string|undefined, seq.Sequence<string>]) => seq.Thunk<IdPath>} */
+/** @type {(prior: readonly[string|undefined, seq.List<string>]) => seq.Thunk<IdPath>} */
 const variants = prior => () => {
     const [a, b] = prior
     const r = seq.next(b)
@@ -88,7 +88,7 @@ const mapDependency = d => ([external, internal]) => {
  * }} Path
  */
 
-/** @type {(d: dep.DependenciesJson) => (dir: boolean) => (items: seq.Sequence<string>) => Path|undefined} */
+/** @type {(d: dep.DependenciesJson) => (dir: boolean) => (items: seq.List<string>) => Path|undefined} */
 const parseGlobal = d => dir => items => {
     if (d === undefined) { return undefined }
     const v = variants([undefined, items])

package/commonjs/run/index.js

@@ -9,7 +9,7 @@ const result = require('../../types/result')
 
 /**
  * @template T 
- * @typedef {(prior: T) => (path: string) => ModuleResult<T>} Require 
+ * @typedef {(path: string) => (prior: T) => ModuleResult<T>} Require
  */
 
 /** @typedef {(source: string) => result.Result<Module, unknown>} Compile */

package/io/commonjs/index.js

@@ -6,7 +6,7 @@ const run = require('../../commonjs/run')
 const build = f => immutableRequire => mutableData => {
     /** @type {(path: string) => unknown} */
     const mutableRequire = path => {
-        const [result, data] = immutableRequire(mutableData)(path)
+        const [result, data] = immutableRequire(path)(mutableData)
         mutableData = data
         return unwrap(result)
     }

package/io/commonjs/test.js

@@ -41,7 +41,7 @@ const run = require('../../commonjs/run')
     if (d[0] !== 'ok') { throw d }
 
     /** @type {run.Require<number>} */
-    const req = prior => path => {
+    const req = path => prior => {
         if (path !== 'm') { throw path }
         return d[1](req)(prior + 1)
     }

package/io/nodejs/version/index.js

@@ -1,7 +1,6 @@
 const cp = require('child_process')
 const fs = require('fs')
-const json = require('../../../json')
-const { isPackageJson } = require('../../../commonjs/package')
+const package_json = require('../../../package.json')
 
 const b =cp.execSync('git log --oneline')
 
@@ -11,10 +10,6 @@ const v = `0.0.${r}`
 
 console.log(`version: ${v}`)
 
-const package_json = json.parse(fs.readFileSync('package.json').toString())
-
-if (!isPackageJson(package_json)) { throw 'error' }
-
 const x = { ...package_json, version: v }
 
 fs.writeFileSync('package.json', JSON.stringify(x, null, 2))

package/json/index.js

@@ -1,7 +1,7 @@
-const seq = require('../types/sequence')
+const seq = require('../types/list')
 const object = require('../types/object')
 const array = require('../types/array')
-const { todo } = require('../dev')
+const op = require('../types/function/operator')
 
 /** 
  * @typedef {{
@@ -13,9 +13,9 @@ const { todo } = require('../dev')
 
 /** @typedef {Object|boolean|string|number|null|Array} Unknown */
 
-/** @type {(value: Unknown) => (path: seq.Sequence<string>) => (src: Unknown|undefined) => Unknown} */
+/** @type {(value: Unknown) => (path: seq.List<string>) => (src: Unknown|undefined) => Unknown} */
 const setProperty = value => {
-    /** @type {(path: seq.Sequence<string>) => (src: Unknown|undefined) => Unknown} */
+    /** @type {(path: seq.List<string>) => (src: Unknown|undefined) => Unknown} */
     const f = path => src => {
         const result = seq.next(path)
         if (result === undefined) { return value }
@@ -26,10 +26,10 @@ const setProperty = value => {
     return f
 }
 
-/** @type {(_: string) => seq.Sequence<string>} */
+/** @type {(_: string) => seq.List<string>} */
 const stringSerialize = input => [JSON.stringify(input)]
 
-/** @type {(_: number) => seq.Sequence<string>} */
+/** @type {(_: number) => seq.List<string>} */
 const numberSerialize = input => [JSON.stringify(input)]
 
 const nullSerialize = ['null']
@@ -38,19 +38,19 @@ const trueSerialize = ['true']
 
 const falseSerialize = ['false']
 
-/** @type {(_: boolean) => seq.Sequence<string>} */
+/** @type {(_: boolean) => seq.List<string>} */
 const boolSerialize = value => value ? trueSerialize : falseSerialize
 
 const colon = [':']
 const comma = [',']
 
-/** @type {seq.FoldOperator<seq.Sequence<string>>} */
+/** @type {op.Fold<seq.List<string>>} */
 const joinOp = a => b => seq.flat([a, comma, b])
 
-/** @type {(input: seq.Sequence<seq.Sequence<string>>) => seq.Sequence<string>} */
+/** @type {(input: seq.List<seq.List<string>>) => seq.List<string>} */
 const join = seq.fold(joinOp)([])
 
-/** @type {(open: string) => (close: string) => (input: seq.Sequence<seq.Sequence<string>>) => seq.Sequence<string>} */
+/** @type {(open: string) => (close: string) => (input: seq.List<seq.List<string>>) => seq.List<string>} */
 const list = open => close => {
     const seqOpen = [open]
     const seqClose = [close]
@@ -63,19 +63,19 @@ const arrayList = list('[')(']')
 
 /** @typedef {object.Entry<Unknown>} Entry*/
 
-/** @typedef {(seq.Sequence<Entry>)} Entries */
+/** @typedef {(seq.List<Entry>)} Entries */
 
 /** @typedef {(entries: Entries) => Entries} MapEntries */
 
-/** @type {(mapEntries: MapEntries) => (value: Unknown) => seq.Sequence<string>} */
+/** @type {(mapEntries: MapEntries) => (value: Unknown) => seq.List<string>} */
 const serialize = sort => {
-    /** @type {(kv: readonly[string, Unknown]) => seq.Sequence<string>} */
+    /** @type {(kv: readonly[string, Unknown]) => seq.List<string>} */
     const propertySerialize = ([k, v]) => seq.flat([
         stringSerialize(k),
         colon,
         f(v)
     ])
-    /** @type {(object: Object) => seq.Sequence<string>} */
+    /** @type {(object: Object) => seq.List<string>} */
     const objectSerialize = input => {
         const entries = Object.entries(input)
         const sortedEntries = sort(entries)
@@ -83,12 +83,12 @@ const serialize = sort => {
         const serializedEntries = seq.map(propertySerialize)(sortedEntries)
         return objectList(serializedEntries)
     }
-    /** @type {(input: Array) => seq.Sequence<string>} */
+    /** @type {(input: Array) => seq.List<string>} */
     const arraySerialize = input => {
         const serializedEntries = seq.map(f)(input)
         return arrayList(serializedEntries)
     }
-    /** @type {(value: Unknown) => seq.Sequence < string >} */
+    /** @type {(value: Unknown) => seq.List < string >} */
     const f = value => {
         switch (typeof value) {
             case 'boolean': { return boolSerialize(value) }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.238",
+  "version": "0.0.242",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "index.js",
   "scripts": {
@@ -14,12 +14,19 @@
   },
   "author": "Natfoam",
   "license": "Apache-2.0",
+  "keywords": [
+    "lambda",
+    "functional-programming",
+    "closure",
+    "pure-functional",
+    "typescript"
+  ],
   "bugs": {
     "url": "https://github.com/functionalscript/functionalscript/issues"
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@types/node": "^16.11.11",
+    "@types/node": "^16.11.12",
     "typescript": "^4.5.2"
   }
 }

package/test.js

@@ -1,6 +1,6 @@
 const i = require('./')
 
-require('./types/sequence/test')
+require('./types/list/test')
 require('./types/btree/test')
 require('./json/test')
 require('./types/object/test')

package/tsconfig.json

@@ -33,7 +33,7 @@
     // "typeRoots": [],                                  /* Specify multiple folders that act like `./node_modules/@types`. */
     // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
     // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
-    // "resolveJsonModule": true,                        /* Enable importing .json files */
+    "resolveJsonModule": true,                        /* Enable importing .json files */
     // "noResolve": true,                                /* Disallow `import`s, `require`s or `<reference>`s from expanding the number of files TypeScript should add to a project. */
 
     /* JavaScript Support */

package/types/array/index.js

@@ -1,5 +1,5 @@
 const option = require('../option')
-const seq = require('../sequence')
+const seq = require('../list')
 
 /**
  * @template T

package/types/btree/index.js

@@ -1,6 +1,6 @@
 const cmp = require('../function/compare')
 const { index3, index5 } = cmp
-const seq = require('../sequence')
+const seq = require('../list')
 
 /**
  * @template T
@@ -129,41 +129,39 @@ const seq = require('../sequence')
 const split = ([n0, v1, n2, v3, n4, v5, n6]) => [[n0, v1, n2], v3, [n4, v5, n6]]
 
 /** 
- * @type {<T>(overflow: (o: Branch3<T>) => Result<T>) => 
+ * @type {<T>(extend: (o: Branch3<T>) => Result<T>) => 
  *  (replace: (r: Node<T>) => Node<T>) => 
  *  (result: Result<T>) => 
  *  Result<T>} 
  */
-const merge = overflow => replace => result => {
+const merge = extend => replace => result => {
     switch (result[0]) {
         case 'done': { return result }
         case 'replace': { return ['replace', replace(result[1])] }
-        default: { return overflow(result[1]) }
+        default: { return extend(result[1]) }
     }
 }
 
-/** 
- * @type {<T>(overflow: (o: Branch3<T>) => Branch5<T>) => 
- *  (replace: (r: Node<T>) => Branch3<T>) => 
- *  (result: Result<T>) => 
- *  Result<T>} 
- */
-const merge2 = overflow => merge(o => ['replace', overflow(o)])
-
-/** 
- * @type {<T>(overflow: (o: Branch3<T>) => Branch7<T>) => 
- *  (replace: (r: Node<T>) => Branch5<T>) => 
- *  (result: Result<T>) => 
- *  Result<T>} 
- */
-const merge3 = overflow => merge(o => ['overflow', split(overflow(o))])
-
 /** @type {(visitor: Visitor) => <T>(cmp: Cmp<T>) => (init: Lazy<T>) => (node: Node<T>) => Result<T>} */
 const visit = ({ found, notFound }) => cmp => {
     const i3 = index3(cmp)
     const i5 = index5(cmp)
+    /** @typedef {typeof cmp extends Cmp<infer T> ? T : never} T */
+    /** 
+     * @type {(extend: (o: Branch3<T>) => Branch5<T>) => 
+     *  (replace: (r: Node<T>) => Branch3<T>) => 
+     *  (result: Result<T>) => 
+     *  Result<T>} 
+     */
+    const merge2 = extend => merge(o => ['replace', extend(o)])
+    /** 
+     * @type {(extend: (o: Branch3<T>) => Branch7<T>) => 
+     *  (replace: (r: Node<T>) => Branch5<T>) => 
+     *  (result: Result<T>) => 
+     *  Result<T>}
+     */
+    const merge3 = extend => merge(o => ['overflow', split(extend(o))])
     return init => {
-        /** @typedef {typeof cmp extends Cmp<infer T> ? T : never} T*/
         /** @type {(node: Node<T>) => Result<T>} */
         const f = node => {
             switch (node.length) {
@@ -188,14 +186,14 @@ const visit = ({ found, notFound }) => cmp => {
                     switch (i3(v1)) {
                         case 0: {
                             return merge2
-                                (o => [...o, v1, n2])
+                                (e => [...e, v1, n2])
                                 (r => [r, v1, n2])
                                 (f(n0))
                         }
                         case 1: { return found.branch3(init)(node) }
                         default: {
                             return merge2
-                                (o => [n0, v1, ...o])
+                                (e => [n0, v1, ...e])
                                 (r => [n0, v1, r])
                                 (f(n2))
                         }
@@ -305,7 +303,7 @@ const replaceVisitor = {
     notFound: notFoundGet,
 }
 
-/** @type {<T>(node: Node<T>) => seq.Sequence<T>} */
+/** @type {<T>(node: Node<T>) => seq.List<T>} */
 const values = node => () => {
     const f = () => {
         switch (node.length) {
@@ -339,7 +337,7 @@ module.exports = {
      * @type { <T>(cmp: Cmp<T>) => (node: Node<T>) => T|undefined }
      */
     getVisitor: cmp => node => {
-        const result = visit(getVisitor)(cmp)(() => { throw '' })(node)
+        const result = visit(getVisitor)(cmp)(() => { throw 'getVisitor' })(node)
         if (result[0] === 'done') { return result[1] }
         return undefined
     },

package/types/btree/test.js

@@ -1,7 +1,7 @@
 const btree = require('.')
 const { setVisitor, values } = btree
 const { cmp } = require('../function/compare') 
-const list = require('../sequence')
+const list = require('../list')
 
 /** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string>} */
 const set = node => value => {
@@ -22,7 +22,7 @@ const test = () => {
     _map = set(_map)('f')
     //
     {
-        /** @type {import('../sequence').Result<string>} */
+        /** @type {list.Result<string>} */
         let _item = list.next(values(_map))
         while (_item !== undefined) {
             _item = list.next(_item.tail)

package/types/function/operator/index.js

@@ -2,44 +2,76 @@
  * @template A
  * @template B
  * @template R
- * @typedef {(a: A) => (b: B) => R} BinaryOperator
+ * @typedef {(a: A) => (b: B) => R} Binary
  */
 
 /**
- * @template R
- * @template T
- * @typedef {BinaryOperator<R, T, R>} ReduceOperator
+ * @template I,O
+ * @typedef {Binary<O, I, O>} Reduce
  */
 
-/** @type {(separator: string) => ReduceOperator<string, string>} */
+/** @type {(separator: string) => Fold<string>} */
 const join = separator => prior => value => `${prior}${separator}${value}`
 
-/** @type {(sum: number) => (value: number) => number} */
+/** @type {Fold<number>} */
 const addition = a => b => a + b
 
 /**
  * @template T
  * @template R
- * @typedef {(value: T) => R} UnaryOperator
+ * @typedef {(value: T) => R} Unary
  */
 
-/** @type {(value: boolean) => boolean} */
+/** @type {Unary<boolean, boolean>} */
 const logicalNot = v => !v
 
 /**
  * @template T 
- * @typedef {(a: T) => (b: T) => boolean} EqualOperator 
+ * @typedef {Binary<T, T, boolean>} Equal 
  */
 
 /** @type {<T>(a: T) => (b: T) => boolean} */
 const strictEqual = a => b => a === b
 
-/** @type {ReduceOperator<number, number>} */
+/** @type {Fold<number>} */
 const min = a => b => a < b ? a : b
 
-/** @type {ReduceOperator<number, number>} */
+/** @type {Fold<number>} */
 const max = a => b => a > b ? a : b
 
+/**
+ * @template I,O
+ * @typedef {(input: I) => readonly[O, Scan<I,O>]} Scan
+ */
+
+/**
+ * @template I,S,O
+ * @typedef {(prior: S) => (input: I) => readonly[O, S]} StateScan
+ */
+
+/** @type {<I, S, O>(op: StateScan<I, S, O>) => (prior: S) => Scan<I, O>} */
+const stateScanToScan = op => prior => i => {
+    const [o, s] = op(prior)(i)
+    return [o, stateScanToScan(op)(s)]
+}
+
+/** @type {<I, O>(reduce: Reduce<I, O>) => (prior: O) => Scan<I, O>} */
+const reduceToScan = reduce => prior => i => {
+    const result = reduce(prior)(i)
+    return [result, reduceToScan(reduce)(result)]
+}
+
+/**
+ * @template T
+ * @typedef {Reduce<T, T>} Fold
+ */
+
+/** @type {<T>(fold: Fold<T>) => Scan<T, T>} */
+const foldToScan = op => init => [init, reduceToScan(op)(init)]
+
+/** @type {(a: number) => () => number} */
+const counter = a => () => a + 1
+
 module.exports = {
     /** @readonly */
     join,
@@ -53,4 +85,12 @@ module.exports = {
     min,
     /** @readonly */
     max,
+    /** @readonly */
+    stateScanToScan,
+    /** @readonly */
+    reduceToScan,
+    /** @readonly */
+    foldToScan,
+    /** @readonly */
+    counter,
 }