functionalscript 0.0.317 → 0.0.321

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

@@ -5,11 +5,12 @@ const { todo } = require('../../dev')
 const map = require('../../types/map')
 const object = require('../../types/object')
 const path = require('../path')
+const stringSet = require('../../types/stringSet')
 
 /**
  * @template M
  * @typedef {{
- *  readonly pagkageGet: package_.Get
+ *  readonly packageGet: package_.Get
  *  readonly moduleMapInterface: module_.MapInterface<M>
  *  readonly moduleId: module_.Id
  *  readonly moduleMap: M
@@ -25,96 +26,66 @@ 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 {(buildSet: stringSet.StringSet) => (moduleId: module_.Id) => (source: string) => (moduleMap: M) => Result<M>} */
+    const build = buildSet => moduleId => {
+        const moduleIdStr = module_.idToString(moduleId)
+        const buildSet1 = stringSet.set(moduleIdStr)(buildSet)
+        const dir = module_.dir(moduleId)
+        /** @type {function_.Require<readonly[map.Map<string>, M]>} */
+        const require_ = p => ([requireMap, m]) => {
+            /** @type {(e: unknown) => function_.Result<readonly[map.Map<string>, M]>} */
+            const error = e => [['error', 'file not found'], [requireMap, m]]
+            if (dir === undefined) { return error('file not found') }
+            const r = path.parseAndFind(packageGet)(dir)(p)
+            if (r === undefined) { return error('file not found') }
+            const rIdStr = module_.idToString(r.id)
+            if (stringSet.contains(rIdStr)(buildSet1)) { return error('circular reference') }
+            const [state, m1] = build(buildSet1)(r.id)(r.source)(m)
+            return [state[0] === 'error' ? state : ['ok', state[1].exports], [map.set(p)(rIdStr)(requireMap), m1]]
+        }
+        return source => moduleMap => {
+            /** @type {(s: module_.State) => (m: M) => Result<M>} */
+            const set = s => m => [s, moduleMapInterface.set(moduleIdStr)(s)(m)]
+            /** @type {(e: module_.Error) => (m: M) => Result<M>} */
+            const error = e => set(['error', e])
+            // check compilation
+            const j = compile(source)
+            if (j[0] === 'error') { return error(['compilation error', j[1]])(moduleMap) }
+            // build
+            const [r, [requireMap, moduleMap2]] = j[1](require_)([undefined, moduleMap])
+            const x = r[0] === 'error' ?
+                error(['runtime error', r[1]]) :
+                set(['ok', { exports: r[1], requireMap: object.fromMap(requireMap) }])
+            return x(moduleMap2)
         }
     }
-
-    return moduleMapFirst => {
-        let moduleMap = moduleMapFirst
-
+    /** @type {(moduleId: module_.Id) => (moduleMap: M) => Result<M>} */
+    const f = moduleId => moduleMap => {
+        const moduleIdStr = module_.idToString(moduleId)
+        // 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) }
-
+        // check file
         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)]
+        return (source === undefined ? notFound : build(undefined)(moduleId)(source))(moduleMap)
     }
+    return f
 }
 
 module.exports = {

package/commonjs/build/test.js

@@ -0,0 +1,77 @@
+const _ = require('.')
+const map = require('../../types/map')
+const module_ = require('../module')
+const function_ = require('../module/function')
+const result = require('../../types/result')
+const package_ = require('../package')
+
+/** @type {{ readonly [k in string]?: result.Result<function_.Function_, unknown> }} */
+const compileMap = {
+    ':index.js': [
+        'ok',
+        require_ => m0 => {
+            const [r1, m1] = require_('./b')(m0);
+            if (r1[0] === 'error') { throw r1 }
+            const [r2, m2] = require_('./a/')(m1);
+            if (r2[0] === 'error') { throw r2 }
+            const [r3, m3] = require_('x/r')(m2);
+            if (r3[0] === 'error') { throw r3 }
+            return [['ok', ':index.js'], m3]
+        }],
+    ':b.js': [
+        'ok',
+        () => m0 => [['ok', ':b.js'], m0]],
+    ':a/index.js': [
+        'ok',
+        () => m0 => [['ok', ':a/index.js'], m0]],
+    'x:r.js': [
+        'ok',
+        () => m0 => [['ok', 'x:r.js'], m0]],
+}
+
+/** @type {function_.Compile} */
+const compile = source => compileMap[source] ?? ['error', 'invalid source']
+
+/** @type {{ readonly [k in string]?: { readonly dependencies: { readonly [k in string]?: string }, files:{ readonly [k in string]?: string } }}} */
+const packageMap = {
+    '': {
+        dependencies: {
+            'x': 'x'
+        },
+        files: {
+            'index.js': ':index.js',
+            'b.js': ':b.js',
+            'a/index.js': ':a/index.js',
+        }
+    },
+    'x': {
+        dependencies: {},
+        files: {
+            'r.js': 'x:r.js'
+        }
+    },
+}
+
+/** @type {package_.Get} */
+const packageGet = packageId => {
+    const p = packageMap[packageId]
+    if (p === undefined) { return undefined }
+    return {
+        dependency: dependency => p.dependencies[dependency],
+        file: file => p.files[file]
+    }
+}
+
+const getOrBuild = _.getOrBuild
+    (compile)
+    (packageGet)
+    (/** @type {module_.MapInterface<map.Map<module_.State>>} */(map))
+
+{
+    const [r] = getOrBuild({ package: '', path: ['index.js'] })(undefined)
+    if (JSON.stringify(r) !==
+        '["ok",{"exports":":index.js","requireMap":{"./a/":"/a/index.js","./b":"/b.js","x/r":"x/r.js"}}]'
+    ) {
+        throw r
+    }
+}

package/commonjs/module/index.js

@@ -4,15 +4,14 @@ const object = require('../../types/object')
  * @template M
  * @typedef {{
  *  readonly at: (moduleId: string) => (moduleMap: M) => State | undefined
- *  readonly insert: (moduleId: string) => (moduleState: State) => (moduleMap: M) => M
+ *  readonly set: (moduleId: string) => (moduleState: State) => (moduleMap: M) => M
  * }} MapInterface
  */
 
 /**
  * @typedef {|
  *  readonly['ok', Module] |
- *  readonly['error', Error] |
- *  readonly['building']
+ *  readonly['error', Error]
  * } State
  */
 
@@ -34,15 +33,27 @@ const object = require('../../types/object')
 
 /**
  * @typedef {{
- *  readonly packageId: string
+ *  readonly package: string
  *  readonly path: readonly string[]
  * }} Id
  */
 
+/** @type {(id: Id) => Id | undefined} */
+const dir = id => {
+    const len = id.path.length
+    if (len < 1) { return undefined }
+    return {
+        package: id.package,
+        path: id.path.slice(0, len - 1)
+    }
+}
+
 /** @type {(id: Id) => string} */
-const idToString = ({ packageId, path }) => `${packageId}/${path.join('/')}`
+const idToString = id => `${id.package}/${id.path.join('/')}`
 
 module.exports = {
+    /** @readonly */
+    dir,
     /** @readonly */
     idToString,
 }

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.317",
+  "version": "0.0.321",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "index.js",
   "scripts": {

package/test.js

@@ -12,6 +12,7 @@ require('./commonjs/package/test')
 require('./commonjs/path/test')
 require('./types/function/compare/test')
 require('./types/stringSet/test')
+require('./commonjs/build/test')
 
 /** @type {() => never} */
 const assert = () => { throw 'assert' }