functionalscript 0.0.239 → 0.0.240

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/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.239",
+  "version": "0.0.240",
   "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/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/btree/index.js

@@ -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))
                         }
@@ -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/map/index.js

@@ -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] }
@@ -58,12 +58,12 @@ const insert = name => value => map =>  {
 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>} */
 const fromEntries = entries => {
     /** @typedef {typeof entries extends seq.Sequence<Entry<infer T>> ? T : never} T */    
-    return seq.reduce(insertOp)(/** @type {Map<T>} */(undefined))(entries)
+    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('../sequence')
 
 {
-    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}`)