functionalscript 0.0.315 → 0.0.319

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

@@ -5,6 +5,7 @@ name: Node.js CI
 
 on:
   push:
+  pull_request:
 
 jobs:
   build:

package/commonjs/README.md

@@ -3,7 +3,22 @@
 ```ts
 // package/index.js
 
+// A dictionary of packages.
+//
+// A package contains a dictionary of dependencies and a dictionary of files.
+//
+// `packageId` examples:
+//   - Node.js:
+//     - normalized: `./node_modules/functionalscript`
+//   - fs modules:
+//     - normalized: `github:functionalscript/functionalscript:bf4f3ed9ad1d3c19ee7bea3e76000dec77d01b4f`
+// - `localPackageId` examples:
+//   - `functionalscript`
+
 type PackageGet = (packageId: string) => Package | undefined
+
+// A local file id is
+
 type Package = {
     // returns a global package id.
     readonly dependency: (localPackageId: string) => string | undefined
@@ -13,21 +28,35 @@ type Package = {
 
 // module/index.js
 
+// A module map is a dictionary of modules.
+//
+// A module is a compiled and initialized source file.
+
+type ModuleGet = (moduleId: string) => ModuleState | undefined
+
 type ModuleMapInterface<M> = {
-    readonly at: (moduleId: string) => (moduleMap: M) => ModuleState | undefined
-    readonly insert: (moduleId: string) => (moduleState: ModuleState) => (moduleMap: M) => M
+    readonly get: (moduleMap: M) => ModuleGet
+    readonly insert: (moduleMap: M) => (moduleId: string) => (moduleState: ModuleState) => M
 }
 
-type ModuleState = readonly['ok', Module] | readonly['error', ModuleError] | readonly['building']
+type ModuleState = readonly['ok', Module] | readonly['error', ModuleError]
 
 type Module = {
+    // Exports is a result of module initialization.
     readonly exports: unknown
+    // A dictionary of required modules.
+    // For example, `require('functionalscript/types/list')` may produce the dictionary entry
+    // `['functionalscript/types/list', './node_modules/functionalscript/types/list/index.js']`
     readonly requireMap: object.Map<string>
 }
 
 type ModuleError = 'file not found' | 'compile error' | 'runtime error' | 'circular reference'
 
-type ModuleId = { 
+// A module id is a global module id. It contains a package id and file id. For example
+// - `./node_modules/functionalscript/types/list/index.js`
+// - `github:functionalscript/functionalscript:bf4f3ed9ad1d3c19ee7bea3e76000dec77d01b4f/types/list/index.js`
+
+type ModuleId = {
     readonly packageId: string,
     readonly path: readonly string[],
 }
@@ -38,7 +67,7 @@ const moduleIdToString: (moduleId: ModuleId) => string;
 
 type BuildConfig<M> = {
     readonly packageGet: PackageGet
-    readonly moduleMapInterface: ModuleMapInterface<M>     
+    readonly moduleMapInterface: ModuleMapInterface<M>
     readonly moduleId: ModuleId
     readonly moduleMap: M // mutable
 }

package/commonjs/build/index.js

@@ -25,98 +25,153 @@ const path = require('../path')
 const notFound = moduleMap => [['error', ['file not found']], moduleMap]
 
 /**
- * @type {(packageGet: package_.Get) =>
+ * @type {(compile: function_.Compile) =>
+ *  (packageGet: package_.Get) =>
  *  <M>(moduleMapInterface: module_.MapInterface<M>) =>
- *  (compile: function_.Compile) =>
  *  (moduleId: module_.Id) =>
- *  (moduleMapFirst: M) =>
+ *  (moduleMap: M) =>
  *  Result<M>
  * }
  */
-const getOrBuild = packageGet => moduleMapInterface => compile => moduleId => {
-
+const getOrBuild = compile => packageGet => moduleMapInterface =>  {
     /** @typedef {typeof moduleMapInterface extends module_.MapInterface<infer M> ? M : never} M */
-
-    const moduleIdStr = module_.idToString(moduleId)
-
-    /** @type {(e: module_.Error) => (moduleMap: M) => Result<M>} */
-    const error = e => moduleMap => {
-        /** @type {module_.State} */
-        const state = ['error', e]
-        return [state, moduleMapInterface.insert(moduleIdStr)(state)(moduleMap)]
-    }
-
-    /** @type {function_.Require<readonly[M, map.Map<string>]>} */
-    const require_ = pathStr => prior => {
-        const pathResult = path.parseAndFind(packageGet)(moduleId.packageId)(moduleIdStr)(pathStr)
-        if (pathResult === undefined) { return [['error', `file not found: '${pathStr}'`], prior] }
-        const mId = { packageId: pathResult.package, path: pathResult.file.split('/') }
-        const [state, newMap] = getOrBuild
-            (packageGet)
-            (moduleMapInterface)
-            (compile)
-            (mId)
-            (prior[0])
-        switch (state[0]) {
-            case 'ok': {
-                const newRequireMap = map.set(pathStr)(module_.idToString(mId))(prior[1])
-                return [
-                    ['ok', state[1].exports],
-                    [newMap, newRequireMap]
-                ]
-            }
-            case 'building': {
-                return todo()
-            }
-            // 'ok'
-            default: {
-                return todo()
-            }
-        }
+    /** @type {(moduleId: module_.Id) => function_.Require<[map.Map<string>, M]>} */
+    const req = moduleId => p => prior => {
+        const r = path.parseAndFind(packageGet)(moduleId)(p)
+        if (r === undefined) { return [['error', 'file not found'], prior] }
+        const requireMap = map.set(p)(module_.idToString(moduleId))(prior[0])
+        r
+        return todo()
     }
-
-    return moduleMapFirst => {
-        let moduleMap = moduleMapFirst
-
+    /**
+     * @type {(moduleId: module_.Id) =>
+     *  (moduleMapFirst: M) =>
+     *  Result<M>
+     * }
+     */
+    const f = moduleId => moduleMap => {
+        const moduleIdStr = module_.idToString(moduleId)
+        /** @type {(s: module_.State) => (m: M) => Result<M>} */
+        const set = s => m => [s, moduleMapInterface.insert(moduleIdStr)(s)(m)]
+        /** @type {(e: module_.Error) => (m: M) => Result<M>} */
+        const error = e => set(['error', e])
+        // check moduleMap
         {
             const m = moduleMapInterface.at(moduleIdStr)(moduleMap)
             if (m !== undefined) { return [m, moduleMap] }
         }
-
-        const p = packageGet(moduleId.packageId)
+        // check package
+        const p = packageGet(moduleId.package)
         if (p === undefined) { return notFound(moduleMap) }
-
-        const source = p.file(moduleId.path.join('/'))
-        if (source === undefined) { return notFound(moduleMap) }
-
-        const compileResult = compile(source)
-        if (compileResult[0] === 'error') { return error(['compilation error', compileResult[1]])(moduleMap) }
-
-        const moduleFunction = compileResult[1]
-
-        moduleMap = moduleMapInterface.insert(moduleIdStr)(['building'])(moduleMap)
-
-        const [[type, exportsOrError], [newModuleMap, requireMap]] = moduleFunction(require_)([moduleMap, map.empty])
-        moduleMap = newModuleMap
-
-        {
-            const m = moduleMapInterface.at(moduleIdStr)(moduleMap)
-            if (m === undefined ) { throw 'm === undefined' }
-            if (m[0] !== 'building') { return [m, moduleMap] }
-        }
-
-        /** @type {module_.State} */
-        const result = type === 'error' ?
-            ['error', ['runtime error', exportsOrError]] :
-            ['ok', {
-                exports: exportsOrError,
-                requireMap: object.fromMap(requireMap)
-            }]
-
-        return [result, moduleMapInterface.insert(moduleIdStr)(result)(moduleMap)]
+        // check file
+        const f = p.file(moduleId.path.join('/'))
+        if (f === undefined) { return notFound(moduleMap) }
+        // check compilation
+        const j = compile(f)
+        if (j[0] === 'error') { return error(['compilation error', j[1]])(moduleMap) }
+        // build
+        const [r, [requireMap, moduleMap2]] = j[1](req(moduleId))([undefined, moduleMap])
+        const x = r[0] === 'error' ?
+            error(['runtime error', r[1]]) :
+            set(['ok', { exports: r[1], requireMap: object.fromEntries(map.entries(requireMap)) }])
+        return x(moduleMap2)
     }
+    return f
 }
 
+// /**
+//  * @type {(packageGet: package_.Get) =>
+//  *  <M>(moduleMapInterface: module_.MapInterface<M>) =>
+//  *  (compile: function_.Compile) =>
+//  *  (moduleId: module_.Id) =>
+//  *  (moduleMapFirst: M) =>
+//  *  Result<M>
+//  * }
+//  */
+// const getOrBuild = packageGet => moduleMapInterface => compile => moduleId => {
+
+//     /** @typedef {typeof moduleMapInterface extends module_.MapInterface<infer M> ? M : never} M */
+
+//     const moduleIdStr = module_.idToString(moduleId)
+
+//     /** @type {(e: module_.Error) => (moduleMap: M) => Result<M>} */
+//     const error = e => moduleMap => {
+//         /** @type {module_.State} */
+//         const state = ['error', e]
+//         return [state, moduleMapInterface.insert(moduleIdStr)(state)(moduleMap)]
+//     }
+
+//     /** @type {function_.Require<readonly[M, map.Map<string>]>} */
+//     const require_ = pathStr => prior => {
+//         const pathResult = path.parseAndFind(packageGet)(moduleId.packageId)(moduleIdStr)(pathStr)
+//         if (pathResult === undefined) { return [['error', `file not found: '${pathStr}'`], prior] }
+//         const mId = { packageId: pathResult.package, path: pathResult.file.split('/') }
+//         const [state, newMap] = getOrBuild
+//             (packageGet)
+//             (moduleMapInterface)
+//             (compile)
+//             (mId)
+//             (prior[0])
+//         switch (state[0]) {
+//             case 'ok': {
+//                 const newRequireMap = map.set(pathStr)(module_.idToString(mId))(prior[1])
+//                 return [
+//                     ['ok', state[1].exports],
+//                     [newMap, newRequireMap]
+//                 ]
+//             }
+//             case 'building': {
+//                 return todo()
+//             }
+//             // 'ok'
+//             default: {
+//                 return todo()
+//             }
+//         }
+//     }
+
+//     return moduleMapFirst => {
+//         let moduleMap = moduleMapFirst
+
+//         {
+//             const m = moduleMapInterface.at(moduleIdStr)(moduleMap)
+//             if (m !== undefined) { return [m, moduleMap] }
+//         }
+
+//         const p = packageGet(moduleId.packageId)
+//         if (p === undefined) { return notFound(moduleMap) }
+
+//         const source = p.file(moduleId.path.join('/'))
+//         if (source === undefined) { return notFound(moduleMap) }
+
+//         const compileResult = compile(source)
+//         if (compileResult[0] === 'error') { return error(['compilation error', compileResult[1]])(moduleMap) }
+
+//         const moduleFunction = compileResult[1]
+
+//         moduleMap = moduleMapInterface.insert(moduleIdStr)(['building'])(moduleMap)
+
+//         const [[type, exportsOrError], [newModuleMap, requireMap]] = moduleFunction(require_)([moduleMap, map.empty])
+//         moduleMap = newModuleMap
+
+//         {
+//             const m = moduleMapInterface.at(moduleIdStr)(moduleMap)
+//             if (m === undefined ) { throw 'm === undefined' }
+//             if (m[0] !== 'building') { return [m, moduleMap] }
+//         }
+
+//         /** @type {module_.State} */
+//         const result = type === 'error' ?
+//             ['error', ['runtime error', exportsOrError]] :
+//             ['ok', {
+//                 exports: exportsOrError,
+//                 requireMap: object.fromMap(requireMap)
+//             }]
+
+//         return [result, moduleMapInterface.insert(moduleIdStr)(result)(moduleMap)]
+//     }
+// }
+
 module.exports = {
     /** @readonly */
     getOrBuild,

package/commonjs/module/index.js

@@ -11,8 +11,7 @@ const object = require('../../types/object')
 /**
  * @typedef {|
  *  readonly['ok', Module] |
- *  readonly['error', Error] |
- *  readonly['building']
+ *  readonly['error', Error]
  * } State
  */
 
@@ -34,13 +33,13 @@ const object = require('../../types/object')
 
 /**
  * @typedef {{
- *  readonly packageId: string
+ *  readonly package: string
  *  readonly path: readonly string[]
  * }} Id
  */
 
 /** @type {(id: Id) => string} */
-const idToString = ({ packageId, path }) => `${packageId}/${path.join('/')}`
+const idToString = id => `${id.package}/${id.path.join('/')}`
 
 module.exports = {
     /** @readonly */

package/commonjs/path/index.js

@@ -89,7 +89,7 @@ const mapDependency = d => ([external, internal]) => {
 
 /**
  * @typedef {{
- *  readonly packageId: string,
+ *  readonly package: string,
  *  readonly items: Items,
  *  readonly dir: boolean,
  * }} Path
@@ -105,7 +105,7 @@ const parseGlobal = d => dir => items => {
     const v = variants([undefined, items])
     const r = list.first(undefined)(list.filterMap(mapDependency(d))(v))
     if (r === undefined) { return undefined }
-    return { packageId: r[0], items: list.toArray(r[1]), dir }
+    return { package: r[0], items: list.toArray(r[1]), dir }
 }
 
 /**
@@ -119,37 +119,35 @@ const parse = packageId => dependencies => local => path => {
     const parsed = parseLocal(local)(path)
     if (parsed === undefined) { return undefined }
     const {external, dir, items } = parsed
-    if (!external) { return { packageId, items, dir } }
+    if (!external) { return { package: packageId, items, dir } }
     return parseGlobal(dependencies)(dir)(items)
 }
 
 /**
  * @typedef {{
- *  readonly package: string
- *  readonly file: string
+ *  readonly id: module_.Id
  *  readonly source: string
  * }| undefined} Result
  */
 
 /**
  * @type {(packageGet: package_.Get) =>
- *  (packageId: string) =>
- *  (local: string) =>
+ *  (moduleId: module_.Id) =>
  *  (path: string) =>
  *  Result
  * }
  */
-const parseAndFind = packageGet => packageId => local => path => {
-    const currentPack = packageGet(packageId)
+const parseAndFind = packageGet => moduleId => path => {
+    const currentPack = packageGet(moduleId.package)
     if (currentPack === undefined) { return undefined }
-    const p = parse(packageId)(currentPack.dependency)(local)(path)
+    const p = parse(moduleId.package)(currentPack.dependency)(moduleId.path.join('/'))(path)
     if (p === undefined) { return undefined }
-    const pack = packageGet(p.packageId)
+    const pack = packageGet(p.package)
     if (pack === undefined) { return undefined }
     /** @type {(file: string) => Result } */
     const tryFile = file => {
         const source = pack.file(file)
-        return source === undefined ? undefined : { package: p.packageId, file, source }
+        return source === undefined ? undefined : { id: { package: p.package, path: file.split('/') }, source }
     }
     const file = p.items.join('/')
     const indexJs = list.join('/')(list.concat(p.items)(['index.js']))

package/commonjs/path/test.js

@@ -59,20 +59,20 @@ const stringify = g => {
     if (_.parseGlobal(d => at(d)({ b: 'x' }))(false)(['d']) !== undefined) { throw 'error' }
     {
         const result = stringify(_.parseGlobal(d => at(d)({ b: 'x' }))(false)(['b']))
-        if (result !== '{"packageId":"x","items":[],"dir":false}') { throw result }
+        if (result !== '{"package":"x","items":[],"dir":false}') { throw result }
     }
     if (_.parseGlobal(d => at(d)({ 'b/r': 'x' }))(false)(['b']) !== undefined) { throw 'error' }
     {
         const result = stringify(_.parseGlobal(d => at(d)({ 'b/r': 'x' }))(false)(['b', 'r']))
-        if (result !== '{"packageId":"x","items":[],"dir":false}') { throw result }
+        if (result !== '{"package":"x","items":[],"dir":false}') { throw result }
     }
     {
         const result = stringify(_.parseGlobal(d => at(d)({ 'b/r': 'x' }))(false)(['b', 'r', 'd', 't']))
-        if (result !== '{"packageId":"x","items":["d","t"],"dir":false}') { throw result }
+        if (result !== '{"package":"x","items":["d","t"],"dir":false}') { throw result }
     }
     {
         const result = stringify(_.parseGlobal(d => at(d)({ 'b/r': 'x' }))(true)(['b', 'r', 'd', 't']))
-        if (result !== '{"packageId":"x","items":["d","t"],"dir":true}') { throw result }
+        if (result !== '{"package":"x","items":["d","t"],"dir":true}') { throw result }
     }
 }
 
@@ -84,8 +84,8 @@ const stringify = g => {
             file: path => at(path)({ 'a/c': 'return "a/c"' }),
         }
     }
-    const result = stringify(_.parseAndFind(p => at(p)(packages))('')('a/b')('../c'))
-    if (result !== '{"package":"","file":"a/c","source":"return \\"a/c\\""}') { throw result }
+    const result = stringify(_.parseAndFind(p => at(p)(packages))({ package: '', path: ['a', 'b']})('../c'))
+    if (result !== '{"id":{"package":"","path":["a","c"]},"source":"return \\"a/c\\""}') { throw result }
 }
 
 {
@@ -108,32 +108,34 @@ const stringify = g => {
         }
     }
     {
-        const result = stringify(_.parseAndFind(p => at(p)(packages))('')('a/b')('z/a/c'))
-        if (result !== '{"package":"node_modules/z","file":"a/c/index.js","source":"return \\"a/c\\""}') { throw result }
+        const result = stringify(_.parseAndFind(p => at(p)(packages))({ package: '', path: ['a', 'b']})('z/a/c'))
+        if (result !== '{"id":{"package":"node_modules/z","path":["a","c","index.js"]},"source":"return \\"a/c\\""}') {
+            throw result
+        }
     }
     {
-        const result = stringify(_.parseAndFind(p => at(p)(packages))('')('a/b')('../..'))
-        if (result !== '{"package":"","file":"index.js","source":"return \\"index.js\\""}') { throw result }
+        const result = stringify(_.parseAndFind(p => at(p)(packages))({ package: '', path: ['a', 'b']})('../..'))
+        if (result !== '{"id":{"package":"","path":["index.js"]},"source":"return \\"index.js\\""}') { throw result }
     }
     {
-        const result = stringify(_.parseAndFind(p => at(p)(packages))('')('')('./x'))
-        if (result !== '{"package":"","file":"x.js","source":"return \\"x.js\\""}') { throw result }
+        const result = stringify(_.parseAndFind(p => at(p)(packages))({ package: '', path: []})('./x'))
+        if (result !== '{"id":{"package":"","path":["x.js"]},"source":"return \\"x.js\\""}') { throw result }
     }
     {
-        const result = stringify(_.parseAndFind(p => at(p)(packages))('')('')('./x.js'))
-        if (result !== '{"package":"","file":"x.js","source":"return \\"x.js\\""}') { throw result }
+        const result = stringify(_.parseAndFind(p => at(p)(packages))({ package: '', path: []})('./x.js'))
+        if (result !== '{"id":{"package":"","path":["x.js"]},"source":"return \\"x.js\\""}') { throw result }
     }
     {
-        const result = stringify(_.parseAndFind(p => at(p)(packages))('')('')('./x/'))
-        if (result !== '{"package":"","file":"x/index.js","source":"return \\"x/index.js\\""}') { throw result }
+        const result = stringify(_.parseAndFind(p => at(p)(packages))({ package: '', path: []})('./x/'))
+        if (result !== '{"id":{"package":"","path":["x","index.js"]},"source":"return \\"x/index.js\\""}') { throw result }
     }
     {
-        const result = stringify(_.parseAndFind(p => at(p)(packages))('')('x/a')('../'))
-        if (result !== '{"package":"","file":"x/index.js","source":"return \\"x/index.js\\""}') { throw result }
+        const result = stringify(_.parseAndFind(p => at(p)(packages))({ package: '', path: ['x', 'a']})('../'))
+        if (result !== '{"id":{"package":"","path":["x","index.js"]},"source":"return \\"x/index.js\\""}') { throw result }
     }
     {
-        const result = stringify(_.parseAndFind(p => at(p)(packages))('')('x/a')('..'))
-        if (result !== '{"package":"","file":"x/index.js","source":"return \\"x/index.js\\""}') { throw result }
+        const result = stringify(_.parseAndFind(p => at(p)(packages))({ package: '', path: ['x', 'a']})('..'))
+        if (result !== '{"id":{"package":"","path":["x","index.js"]},"source":"return \\"x/index.js\\""}') { throw result }
     }
 }
 
@@ -156,12 +158,12 @@ const stringify = g => {
         }
     }
     {
-        const result = stringify(_.parseAndFind(p => at(p)(packages))('')('a/b')('z/a/c'))
-        if (result !== '{"package":"node_modules/z/a","file":"c.js","source":"return \\"c.js\\""}') { throw result }
+        const result = stringify(_.parseAndFind(p => at(p)(packages))({ package: '', path: ['a', 'b']})('z/a/c'))
+        if (result !== '{"id":{"package":"node_modules/z/a","path":["c.js"]},"source":"return \\"c.js\\""}') { throw result }
     }
     {
-        const result = stringify(_.parseAndFind(p => at(p)(packages))('')('a/b')('z/a/c/'))
-        if (result !== '{"package":"node_modules/z/a","file":"c/index.js","source":"return \\"c/index.js\\""}') { throw result }
+        const result = stringify(_.parseAndFind(p => at(p)(packages))({ package: '', path: ['a', 'b']})('z/a/c/'))
+        if (result !== '{"id":{"package":"node_modules/z/a","path":["c","index.js"]},"source":"return \\"c/index.js\\""}') { throw result }
     }
 }
 
@@ -184,6 +186,6 @@ const stringify = g => {
             }),
         }
     }
-    const result = stringify(_.parseAndFind(p => at(p)(packages))('')('a/b')('z/a/c'))
-    if (result !== '{"package":"node_modules/z/a/c","file":"index.js","source":"return \\"a/c\\""}') { throw result }
+    const result = stringify(_.parseAndFind(p => at(p)(packages))({package: '', path: ['a', 'b']})('z/a/c'))
+    if (result !== '{"id":{"package":"node_modules/z/a/c","path":["index.js"]},"source":"return \\"a/c\\""}') { throw result }
 }

package/package.json

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

package/types/function/index.js

@@ -5,7 +5,7 @@
  */
 
 /**
- * Postfix Compose function.
+ * A postfix compose function.
  *
  * @type {<I, X>(g: Func<I, X>) => <O>(f: Func<X, O>) => Func<I, O>}
  */
@@ -22,6 +22,6 @@ module.exports = {
     identity,
     /** @readonly */
     compose,
-    /** @reeadonly */
+    /** @readonly */
     flip,
-}
+}