functionalscript 0.0.234 → 0.0.238

package/.github/workflows/npm-publish.yml

@@ -30,7 +30,7 @@ jobs:
           node-version: 14
           registry-url: https://registry.npmjs.org/
       - run: npm ci
-      - run: node ./version
+      - run: node ./io/nodejs/version
       - run: npm publish
         env:
           NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/commonjs/module/index.js

@@ -0,0 +1,22 @@
+const map = require('../../types/map')
+const object = require('../../types/object')
+const run = require('../run')
+const seq = require('../../types/sequence')
+
+/**
+ * @typedef {{
+ *  readonly map: object.Map<string>
+ *  readonly run: run.Module
+ * }} Module
+ */
+
+/** 
+ * @typedef {{
+ *  readonly map: map.Map<Module>
+ *  readonly order: seq.Sequence<string>
+ * }} Cache 
+ */
+
+/** @typedef {(path: string) => string|undefined} ReadFile */
+
+module.exports = {}

package/commonjs/package/dependencies/index.js

@@ -1,71 +1,23 @@
 const json = require('../../../json')
-const { isObject } = json
 const seq = require('../../../types/sequence')
-const { split } = require('../../path')
-const map = require('../../../types/map')
 
-/** @typedef {(directoryName: string) => undefined|string|Directory} Directory */
+/** @typedef {readonly[string, string]} DependencyJson */
 
-const empty = () => undefined
+/** @typedef {{readonly[k in string]: string}} DependencyMapJson */
 
-/** 
- * @typedef {{
- *  readonly get: (dir: string) => Item|undefined
- *  readonly set: (dir: string) => (item: Item) => Map
- * }} Map
- */
+/** @typedef {DependencyMapJson|undefined} DependenciesJson */
 
-/** @typedef {Map|string} Item */
+/** @type {(entry: json.Entry) => boolean} */
+const isDependencyJson = ([, v]) => typeof v === 'string'
 
-/** @typedef {readonly[string, Map]} Pair */
-
-/** @type {(prior: seq.Sequence<Pair>) => (dir: string) => seq.Sequence<Pair>} */
-const get = prior => dir => {
-    const result = seq.next(prior)
-    if (result === undefined) { throw 'panic' }
-    const { first: [,m] } = result
-    const child = m.get(dir)
-    const childMap = child === undefined || typeof child === 'string' ? map.empty : child
-    /** @type {Pair} */
-    const pair = [dir, childMap]
-    return seq.sequence(pair)(prior)
-}
-
-/** @typedef {readonly[string, Item]} Result */
-
-/** @type {(a: Result) => (b: Pair) => Result} */
-const set = ([aDir, item]) => ([bDir, bMap]) => [bDir, bMap.set(aDir)(item)]
-
-/** @type {(prior: Map) => (entry: json.Entry) => Map} */
-const addDirectory = prior => ([directory, id]) => {
-    if (typeof id !== 'string') { return prior }
-    const path = split(directory)
-    const rev = seq.reduce(get)([['', prior]])(path)
-    const result = seq.next(rev)
-    if (result === undefined) { throw 'panic' }
-    const { first: [dir], tail } = result
-    const [, m] = seq.reduce(set)([dir, id])(tail)
-    if (typeof m === 'string') { return prior }
-    return m
-}
-
-/** @type {(m: Map) => Directory} */
-const func = m => dir => {
-    const r = m.get(dir)
-    if (typeof r !== 'object') { return r }
-    return func(r)
-}
-
-/** @type {(packageJson: json.Unknown) => Directory} */
-const getDirectory = packageJson => {
-    if (!isObject(packageJson)) { return empty }
-    const dep = packageJson['dependencies']
-    if (dep === undefined || !isObject(dep)) { return empty }
-    const result = seq.reduce(addDirectory)(map.empty)(Object.entries(dep))
-    return func(result)
+/** @type {(j: json.Unknown|undefined) => j is DependenciesJson} */
+const isDependenciesJson = j => {
+    if (j === undefined) { return true }
+    if (!json.isObject(j)) { return false }
+    return seq.every(seq.map(isDependencyJson)(Object.entries(j)))
 }
 
 module.exports = {
     /** @readonly */
-    getDirectory,
-}
+    isDependenciesJson,
+}

package/commonjs/package/dependencies/test.js

@@ -1,33 +1,12 @@
 const _ = require('.')
+const json = require('../../../json')
+const { sort } = require('../../../types/object')
+const seq = require('../../../types/sequence')
 
 {
-    const packageJson = { dependencies: {} }
-    const dir = _.getDirectory(packageJson)
-    const r = dir('x')
-    if (r !== undefined) { throw r }
+    if (!_.isDependenciesJson(undefined)) { throw 'error' }
+    if (_.isDependenciesJson(null)) { throw 'error' }
+    if (!_.isDependenciesJson({})) { throw 'error' }
+    if (!_.isDependenciesJson({'a':'b'})) { throw 'error' }
+    if (_.isDependenciesJson({ 'a': 12 })) { throw 'error' }
 }
-
-{
-    const packageJson = { dependencies: { 'x': 'e' } }
-    const dir = _.getDirectory(packageJson)
-    const r = dir('x')
-    if (r !== 'e') { throw r }
-}
-
-{
-    const packageJson = { 
-        dependencies: { 
-            'x/a': 'xa',
-            'x/b': 'xb'
-        } 
-    }
-    const dir = _.getDirectory(packageJson)
-    const x = dir('x')
-    if (typeof x !== 'function') { throw x }
-    const xa = x('a')
-    if (xa !== 'xa') { throw xa }
-    const xb = x('b')
-    if (xb !== 'xb') { throw xb }
-    const xc = x('c')
-    if (xc !== undefined) { throw xc }
-}

package/commonjs/package/index.js

@@ -1,37 +1,30 @@
 const json = require('../../json')
-const seq = require('../../types/sequence')
+const dep = require('./dependencies')
+const object = require('../../types/object')
+const run = require('../run')
 
 /** 
  * @typedef {{
+ *  readonly name: string
  *  readonly version: string
- *  readonly dependencies?: Dependencies
- * }} Package 
+ *  readonly dependencies?: dep.DependenciesJson
+ * }} PackageJson 
  */
 
-/** @type {(j: json.Unknown) => j is Package} */
-const isPackage = j => {
+/** @type {(j: json.Unknown) => j is PackageJson} */
+const isPackageJson = j => {
     if (!json.isObject(j)) { return false }
+    if (typeof j.name !== 'string') { return false }
     if (typeof j.version !== 'string') { return false }
-    if (j.dependencies !== undefined && !isDependencies(j.dependencies)) { return false }
+    if (!dep.isDependenciesJson(j.dependencies)) { return false }
     return true
 }
 
-/**
- * @typedef {{
- *  readonly [k in string]: string
- * }} Dependencies
- */
-
-/** @type {(entry: json.Entry) => boolean} */
-const isDependency = ([,v]) => typeof v === 'string'
+/** @typedef {object.Map<string>} Files */
 
-/** @type {(j: json.Unknown) => j is Dependencies} */
-const isDependencies = j => {
-    if (!json.isObject(j)) { return false }
-    return seq.every(seq.map(isDependency)(Object.entries(j)))
-}
+/** @typedef {object.Map<dep.DependencyJson>} PackageMap */
 
 module.exports = {
     /** @readonly */
-    isPackage,
-}
+    isPackageJson,
+}

package/commonjs/package/test.js

@@ -1,14 +1,16 @@
 const _ = require('.')
 
+require('./dependencies/test')
+
 {
-    if (_.isPackage(null)) { throw 'error' }
-    if (_.isPackage({})) { throw 'error' }
-    if (_.isPackage({version:12})) { throw 'error' }
-    if (!_.isPackage({version:"12"})) { throw 'error' }
-    if (_.isPackage({version:"",dependencies:[]})) { throw 'error' }
-    if (!_.isPackage({ version: "", dependencies: {} })) { throw 'error' }
-    if (_.isPackage({ version: "", dependencies: { x: 12} })) { throw 'error' }
-    if (!_.isPackage({ version: "", dependencies: { x: "12" } })) { throw 'error' }
+    if (_.isPackageJson(null)) { throw 'error' }
+    if (_.isPackageJson({})) { throw 'error' }
+    if (_.isPackageJson({name:'x',version:12})) { throw 'error' }
+    if (!_.isPackageJson({name:'x',version:"12"})) { throw 'error' }
+    if (_.isPackageJson({version:"",dependencies:[]})) { throw 'error' }
+    if (!_.isPackageJson({name:'a', version: "", dependencies: {} })) { throw 'error' }
+    if (_.isPackageJson({name:'b', version: "", dependencies: { x: 12} })) { throw 'error' }
+    if (!_.isPackageJson({name:'c', version: "", dependencies: { x: "12" } })) { throw 'error' }
 }
 
-module.exports = {}
+module.exports = {}

package/commonjs/path/index.js

@@ -1,6 +1,9 @@
 const seq = require("../../types/sequence")
 const option = require("../../types/option")
 const { compose } = require("../../types/function")
+const dep = require("../package/dependencies")
+const { at } = require("../../types/object")
+const pack = require("../package")
 
 /** @typedef {readonly string[]} Items */
 
@@ -9,7 +12,7 @@ const { compose } = require("../../types/function")
  *  readonly external: boolean
  *  readonly dir: boolean
  *  readonly items: Items
- * }} Path 
+ * }} LocalPath 
  */
 
 /** @type {(path: string) => readonly string[]} */
@@ -34,8 +37,8 @@ const normItemsOp = prior => item => {
 /** @type {(items: seq.Sequence<string>) => seq.Sequence<string>|undefined} */
 const normItems = compose(seq.reduce(normItemsOp)([]))(option.map(seq.reverse))
 
-/** @type {(local: string) => (path: string) => Path|undefined} */
-const parse = local => {
+/** @type {(local: string) => (path: string) => LocalPath|undefined} */
+const parseLocal = local => {
     /** @type {(path: string) => readonly[boolean, seq.Sequence<string>]} */
     const fSeq = path => {
         const pathSeq = split(path)
@@ -44,7 +47,7 @@ const parse = local => {
             default: { return [true, pathSeq] }
         }
     }
-    /** @type {(path: string) => Path|undefined} */
+    /** @type {(path: string) => LocalPath|undefined} */
     const f = path => {
         const [external, items] = fSeq(path)
         const n = normItems(items)
@@ -58,9 +61,56 @@ const parse = local => {
     return f
 }
 
+/** @typedef {readonly[string, seq.Sequence<string>]} IdPath */
+
+/** @type {(prior: readonly[string|undefined, seq.Sequence<string>]) => seq.Thunk<IdPath>} */
+const variants = prior => () => {
+    const [a, b] = prior
+    const r = seq.next(b)
+    if (r === undefined) { return undefined }
+    const { first, tail } = r
+    /** @type {IdPath} */
+    const n = [a === undefined ? first : `${a}/${first}`, tail]
+    return { first: n, tail: variants(n) }
+}
+
+/** @type {(d: dep.DependencyMapJson) => (p: IdPath) => IdPath|undefined} */
+const mapDependency = d => ([external, internal]) => {
+    const id = at(external)(d)
+    return id === undefined ? undefined : [id, internal]
+}
+
+/**
+ * @typedef {{
+ *  readonly name: string,
+ *  readonly items: Items,
+ *  readonly dir: boolean,
+ * }} Path
+ */
+
+/** @type {(d: dep.DependenciesJson) => (dir: boolean) => (items: seq.Sequence<string>) => Path|undefined} */
+const parseGlobal = d => dir => items => {
+    if (d === undefined) { return undefined }
+    const v = variants([undefined, items])
+    const r = seq.first(undefined)(seq.filterMap(mapDependency(d))(v))
+    if (r === undefined) { return undefined }
+    return { name: r[0], items: seq.toArray(r[1]), dir }
+}
+
+/** @type {(name: string) => (dependencies: dep.DependenciesJson) => (local: string) => (path: string) => Path|undefined } */
+const parse = name => dependencies => local => path => {
+    const parsed = parseLocal(local)(path)
+    if (parsed === undefined) { return undefined }
+    const {external, dir, items} = parsed
+    if (!external) { return { name, items, dir } }
+    return parseGlobal(dependencies)(dir)(items)
+}
+
 module.exports = {
     /** @readonly */
-    split,
+    parseLocal,
+    /** @readonly */
+    parseGlobal,
     /** @readonly */
     parse,
 }

package/commonjs/path/test.js

@@ -1,47 +1,64 @@
 const _ = require('.')
 const json = require('../../json')
-const { identity, compose } = require('../../types/function')
-const seq = require('../../types/sequence')
+const { identity } = require('../../types/function')
 
-const stringify = json.stringify(identity)
+/** @type {(g: json.Unknown|undefined) => string} */
+const stringify = g => {
+    if (g === undefined) { throw g }
+    return json.stringify(identity)(g)
+}
 
 {
-    const result = _.parse('')('./a')
-    if (result === undefined) { throw result }
+    const p = { name: '', version: '' }
+    const result = _.parseLocal('')('./a')
     if (stringify(result) !== '{"external":false,"dir":false,"items":["a"]}') { throw result }
 }
 
 {
-    const result = _.parse('')('./a/')
-    if (result === undefined) { throw result }
+    const result = _.parseLocal('')('./a/')
     if (stringify(result) !== '{"external":false,"dir":true,"items":["a"]}') { throw result }
 }
 
 {
-    const result = _.parse('')('..')
+    const result = _.parseLocal('')('..')
     if (result !== undefined) { throw result }
 }
 
 {
-    const result = _.parse('a')('')
-    if (result === undefined) { throw result }
+    const result = _.parseLocal('a')('')
     if (stringify(result) !== '{"external":true,"dir":false,"items":[]}') { throw result }
 }
 
 {
-    const result = _.parse('')('./a/b/.././c')
-    if (result === undefined) { throw result }
+    const result = _.parseLocal('')('./a/b/.././c')
     if (stringify(result) !== '{"external":false,"dir":false,"items":["a","c"]}') { throw result }
 }
 
 {
-    const result = _.parse('x/r')('./a/b/.././c')
-    if (result === undefined) { throw result }
+    const result = _.parseLocal('x/r')('./a/b/.././c')
     if (stringify(result) !== '{"external":false,"dir":false,"items":["x","r","a","c"]}') { throw result }
 }
 
 {
-    const result = _.parse('a')('a/b/.././c')
-    if (result === undefined) { throw result }
+    const result = _.parseLocal('a')('a/b/.././c')
     if (stringify(result) !== '{"external":true,"dir":false,"items":["a","c"]}') { throw result }
 }
+
+{
+    if (_.parseGlobal(undefined)(false)(['a', 'b']) !== undefined) { throw 'error' }
+    if (_.parseGlobal({})(false)(['b']) !== undefined) { throw 'error' }
+    if (_.parseGlobal({ b: 'x' })(false)(['d']) !== undefined) { throw 'error' }
+    {
+        const result = stringify(_.parseGlobal({ b: 'x' })(false)(['b']))
+        if (result !== '["x",""]') { throw result }
+    }
+    if (_.parseGlobal({ 'b/r': 'x' })(false)(['b']) !== undefined) { throw 'error' }
+    {
+        const result = stringify(_.parseGlobal({ 'b/r': 'x' })(false)(['b', 'r']))
+        if (result !== '["x",""]') { throw result }
+    }
+    {
+        const result = stringify(_.parseGlobal({ 'b/r': 'x' })(false)(['b', 'r', 'd', 't']))
+        if (result !== '["x","d/t"]') { throw result }
+    }
+}

package/io/commonjs/index.js

@@ -3,11 +3,11 @@ const { unwrap } = require('../../types/result')
 const run = require('../../commonjs/run')
 
 /** @type {(f: Function) => run.Module} */
-const createModule = f => req => mutableInfo => {
+const build = f => immutableRequire => mutableData => {
     /** @type {(path: string) => unknown} */
     const mutableRequire = path => {
-        const [result, info] = req(mutableInfo)(path)
-        mutableInfo = info
+        const [result, data] = immutableRequire(mutableData)(path)
+        mutableData = data
         return unwrap(result)
     }
     const result = tryCatch(() => {
@@ -15,12 +15,12 @@ const createModule = f => req => mutableInfo => {
         f(mutableModule, mutableRequire)
         return mutableModule.exports
     })
-    return [result, mutableInfo]
+    return [result, mutableData]
 }
 
 /** @type {run.Compile} */
 const compile = source => 
-    tryCatch(() => createModule(Function('module', 'require', `"use strict";${source}`)))
+    tryCatch(() => build(Function('module', 'require', `"use strict";${source}`)))
 
 module.exports = {
     /** @readonly */

package/{version.js → io/nodejs/version/index.js}

@@ -1,7 +1,7 @@
 const cp = require('child_process')
 const fs = require('fs')
-const json = require('./json')
-const { isPackage } = require('./commonjs/package')
+const json = require('../../../json')
+const { isPackageJson } = require('../../../commonjs/package')
 
 const b =cp.execSync('git log --oneline')
 
@@ -13,7 +13,7 @@ console.log(`version: ${v}`)
 
 const package_json = json.parse(fs.readFileSync('package.json').toString())
 
-if (!isPackage(package_json)) { throw 'error' }
+if (!isPackageJson(package_json)) { throw 'error' }
 
 const x = { ...package_json, version: v }
 

package/package.json

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