functionalscript 0.0.228 → 0.0.232

package/commonjs/index.js

@@ -0,0 +1,11 @@
+/** @typedef {(packageName: string) => PackageMap|Package|undefined} PackageMap */
+
+/** 
+ * @typedef {readonly[
+ *  string, 
+ *  PackageMap, 
+ *  (fileName: string) => string|undefined
+ * ]} Package 
+ */
+
+module.exports = {}

package/commonjs/path/index.js

@@ -0,0 +1,64 @@
+const seq = require("../../types/sequence")
+const option = require("../../types/option")
+const { compose } = require("../../types/function")
+
+/** @typedef {readonly string[]} Items */
+
+/** 
+ * @typedef {{
+ *  readonly external: boolean
+ *  readonly dir: boolean
+ *  readonly items: Items
+ * }} Path 
+ */
+
+/** @type {(path: string) => seq.Sequence<string>} */
+const split = path => path.split('/')
+
+/** @type {(s: undefined|seq.Sequence<string>) => (items: string) => undefined|seq.Sequence<string>} */
+const normItemsOp = prior => item => {
+    if (prior === undefined) { return undefined }
+    switch (item) {
+        case '': case '.': { return prior }
+        case '..': {
+            const result = seq.next(prior)
+            if (result === undefined) { return undefined }
+            return result.tail
+        }
+        default: {
+            return seq.sequence(item)(prior)
+        }
+    }
+}
+
+/** @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 {(path: string) => readonly[boolean, seq.Sequence<string>]} */
+    const fSeq = path => {
+        const pathSeq = split(path)
+        switch (seq.first(undefined)(pathSeq)) {
+            case '.': case '..': { return [false, seq.flat([split(local), pathSeq])] }
+            default: { return [true, pathSeq] }
+        }
+    }
+    /** @type {(path: string) => Path|undefined} */
+    const f = path => {
+        const [external, items] = fSeq(path)
+        const n = normItems(items)
+        if (n === undefined) { return undefined }
+        return {
+            external,
+            dir: path[path.length - 1] === '/',
+            items: seq.toArray(n)
+        }
+    }
+    return f
+}
+
+module.exports = {
+    /** @readonly */
+    parse,
+}

package/commonjs/path/test.js

@@ -0,0 +1,47 @@
+const _ = require('.')
+const json = require('../../json')
+const { identity, compose } = require('../../types/function')
+const seq = require('../../types/sequence')
+
+const stringify = json.stringify(identity)
+
+{
+    const result = _.parse('')('./a')
+    if (result === undefined) { throw result }
+    if (stringify(result) !== '{"external":false,"dir":false,"items":["a"]}') { throw result }
+}
+
+{
+    const result = _.parse('')('./a/')
+    if (result === undefined) { throw result }
+    if (stringify(result) !== '{"external":false,"dir":true,"items":["a"]}') { throw result }
+}
+
+{
+    const result = _.parse('')('..')
+    if (result !== undefined) { throw result }
+}
+
+{
+    const result = _.parse('a')('')
+    if (result === undefined) { throw result }
+    if (stringify(result) !== '{"external":true,"dir":false,"items":[]}') { throw result }
+}
+
+{
+    const result = _.parse('')('./a/b/.././c')
+    if (result === undefined) { throw result }
+    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 }
+    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 }
+    if (stringify(result) !== '{"external":true,"dir":false,"items":["a","c"]}') { throw result }
+}

package/commonjs/run/index.js

@@ -0,0 +1,17 @@
+const result = require('../../types/result')
+
+/** @typedef {<T>(req: Require<T>) => (prior: T) => ModuleResult<T>} Module*/
+
+/**
+ * @template T 
+ * @typedef {readonly[result.Result<unknown, unknown>, T]} ModuleResult 
+ */
+
+/**
+ * @template T 
+ * @typedef {(prior: T) => (path: string) => ModuleResult<T>} Require 
+ */
+
+/** @typedef {(source: string) => result.Result<Module, unknown>} Compile */
+
+module.exports = {}

package/io/commonjs/index.js

@@ -0,0 +1,34 @@
+const { ok, error } = require('../../types/result')
+const run = require('../../commonjs/run')
+
+/** @type {(f: Function) => run.Module} */
+const runModule = f => req => info => {
+    /** @type {(path: string) => unknown} */
+    const mutableRequire = path => {
+        const [result, newInfo] = req(info)(path)
+        info = newInfo
+        if (result[0] === 'error') { throw result[1] }
+        return result[1]
+    }
+    const mutableModule = { exports: {} }
+    try {
+        f(mutableModule, mutableRequire)
+    } catch (e) {
+        return [error(e), info]
+    }
+    return [ok(mutableModule.exports), info]
+}
+
+/** @type {run.Compile} */
+const compile = source => {
+    try {
+        return ok(runModule(Function('module', 'require', `"use strict";${source}`)))
+    } catch (e) {
+        return error(e)
+    }
+}
+
+module.exports = {
+    /** @readonly */
+    compile,
+}

package/io/commonjs/test.js

@@ -0,0 +1,72 @@
+const _ = require('.')
+const run = require('../../commonjs/run')
+
+// ok:
+{
+    const source = 'module.exports = "Hello world!"'
+    const m = _.compile(source)
+    if (m[0] !== 'ok') { throw m }
+    const [result] = m[1](() => { throw 0 })(undefined)
+    if (result[0] !== 'ok') { throw result }
+    if (result[1] !== 'Hello world!') { throw result }
+}
+
+// compilation error:
+{
+    const source = '+'
+    const m = _.compile(source)
+    if (m[0] !== 'error') { throw m }
+}
+
+// compilation error with "use strict;":
+{
+    const source = 'const x = 04'
+    const m = _.compile(source)
+    if (m[0] !== 'error') { throw m }
+}
+
+// runtime error:
+{
+    const source = 'a = 5'
+    const m = _.compile(source)
+    if (m[0] !== 'ok') { throw m }
+    const [result] = m[1](() => { throw 0 })(undefined)
+    if (result[0] !== 'error') { throw result }
+}
+
+//
+{
+    const depSource = 'module.exports = 137'
+    const d = _.compile(depSource)
+    if (d[0] !== 'ok') { throw d }
+
+    /** @type {run.Require<number>} */
+    const req = prior => path => {
+        if (path !== 'm') { throw path }
+        return d[1](req)(prior + 1)
+    }
+
+    let info = 0
+    {
+        const source = 'module.exports = require("m") + 42'
+        const m = _.compile(source)
+        if (m[0] !== 'ok') { throw m }
+
+        const [result, newInfo] = m[1](req)(info)
+        if (result[0] !== 'ok') { throw result }
+        if (result[1] !== 179) { throw result }
+        info = newInfo
+    }
+
+    {
+        const source = 'module.exports = require("x") + 42'
+        const m = _.compile(source)
+        if (m[0] !== 'ok') { throw m }
+
+        const [result, infox] = m[1](req)(info)
+        if (result[0] !== 'error') { throw result }
+        if (infox !== 1) { throw info }
+    }
+}
+
+module.exports = {}

package/json/index.js

@@ -1,22 +1,20 @@
-const seq = require('../sequence')
-const op = require('../sequence/operator')
-const object = require('../object')
-const array = require('../sequence/array')
-const { compose } = require('../function')
+const seq = require('../types/sequence')
+const object = require('../types/object')
+const array = require('../types/array')
 
 /** 
  * @typedef {{
- *  readonly [k in string]: Json
+ *  readonly [k in string]: Unknown
  * }} Object 
  */
 
-/** @typedef {readonly Json[]} Array */
+/** @typedef {readonly Unknown[]} Array */
 
-/** @typedef {Object|boolean|string|number|null|Array} Json */
+/** @typedef {Object|boolean|string|number|null|Array} Unknown */
 
-/** @type {(value: Json) => (path: seq.Sequence<string>) => (src: Json|undefined) => Json} */
-const addProperty = value => {
-    /** @type {(path: seq.Sequence<string>) => (src: Json|undefined) => Json} */
+/** @type {(value: Unknown) => (path: seq.Sequence<string>) => (src: Unknown|undefined) => Unknown} */
+const setProperty = value => {
+    /** @type {(path: seq.Sequence<string>) => (src: Unknown|undefined) => Unknown} */
     const f = path => src => {
         const result = seq.next(path)
         if (result === undefined) { return value }
@@ -45,11 +43,8 @@ const boolSerialize = value => value ? trueSerialize : falseSerialize
 const colon = [':']
 const comma = [',']
 
-/** @type {op.Scan<seq.Sequence<string>, seq.Sequence<string>>} */
-const commaValue = a => [seq.concat(comma, a), commaValue]
-
 /** @type {seq.FoldOperator<seq.Sequence<string>>} */
-const joinOp = a => b => seq.concat(a, comma, b)
+const joinOp = a => b => seq.flat([a, comma, b])
 
 /** @type {(input: seq.Sequence<seq.Sequence<string>>) => seq.Sequence<string>} */
 const join = seq.fold(joinOp)([])
@@ -58,26 +53,27 @@ const join = seq.fold(joinOp)([])
 const list = open => close => {
     const seqOpen = [open]
     const seqClose = [close]
-    return input => seq.concat(seqOpen, join(input), seqClose)
+    return input => seq.flat([seqOpen, join(input), seqClose])
 }
 
 const objectList = list('{')('}')
 
 const arrayList = list('[')(']')
 
-/** @typedef {object.Entry<Json>} Entry*/
+/** @typedef {object.Entry<Unknown>} Entry*/
 
 /** @typedef {(seq.Sequence<Entry>)} Entries */
 
 /** @typedef {(entries: Entries) => Entries} MapEntries */
 
-/** @type {(mapEntries: MapEntries) => (value: Json) => seq.Sequence<string>} */
+/** @type {(mapEntries: MapEntries) => (value: Unknown) => seq.Sequence<string>} */
 const serialize = sort => {
-    /** @type {(kv: readonly[string, Json]) => seq.Sequence<string>} */
-    const propertySerialize = ([k, v]) => seq.concat(
+    /** @type {(kv: readonly[string, Unknown]) => seq.Sequence<string>} */
+    const propertySerialize = ([k, v]) => seq.flat([
         stringSerialize(k),
         colon,
-        f(v))
+        f(v)
+    ])
     /** @type {(object: Object) => seq.Sequence<string>} */
     const objectSerialize = input => {
         const entries = Object.entries(input)
@@ -91,7 +87,7 @@ const serialize = sort => {
         const serializedEntries = seq.map(f)(input)
         return arrayList(serializedEntries)
     }
-    /** @type {(value: Json) => seq.Sequence < string >} */
+    /** @type {(value: Unknown) => seq.Sequence < string >} */
     const f = value => {
         switch (typeof value) {
             case 'boolean': { return boolSerialize(value) }
@@ -110,22 +106,22 @@ const serialize = sort => {
 /**
  * A version of `JSON.stringify` with an alphabeticly ordered `keys`.
  * 
- * The standard `JSON.stringify` rules determines by 
+ * The standard `JSON.stringify` rules determined by 
  * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
  *  
- * @type {(mapEntries: MapEntries) => (value: Json) => string}
+ * @type {(mapEntries: MapEntries) => (value: Unknown) => string}
  */
 const stringify = sort => value => {
     const _s = serialize(sort)(value)
     return seq.join('')(_s)
 }
 
-/** @type {(value: string) => Json} */
+/** @type {(value: string) => Unknown} */
 const parse = value => JSON.parse(value)
 
 module.exports = {
     /** @readonly */
-    addProperty,
+    setProperty,
     /** @readonly */
     stringify,
     /** @readonly */

package/json/test.js

@@ -1,40 +1,40 @@
 const json = require('.')
-const { sort } = require('../object')
-const { identity } = require('../function')
+const { sort } = require('../types/object')
+const { identity } = require('../types/function')
 
-if (json.addProperty("Hello")([])({}) !== "Hello") { throw 'error' }
+if (json.setProperty("Hello")([])({}) !== "Hello") { throw 'error' }
 
 {
-    const r = json.addProperty("Hello")(['a'])({})
+    const r = json.setProperty("Hello")(['a'])({})
     const x = json.stringify(sort)(r)
     if (x !== '{"a":"Hello"}') { throw x }
 }
 
 {
-    const x = json.stringify(identity)(json.addProperty("Hello")(['a'])({}))
+    const x = json.stringify(identity)(json.setProperty("Hello")(['a'])({}))
     if (x !== '{"a":"Hello"}') { throw x }
 }
 
 {
-    const x = json.stringify(sort)(json.addProperty("Hello")(['a'])({c:[],b:12}))
+    const x = json.stringify(sort)(json.setProperty("Hello")(['a'])({c:[],b:12}))
     if (x !== '{"a":"Hello","b":12,"c":[]}') { throw x }
 }
 
 {
-    const x = json.stringify(identity)(json.addProperty("Hello")(['a'])({ c: [], b: 12 }))
+    const x = json.stringify(identity)(json.setProperty("Hello")(['a'])({ c: [], b: 12 }))
     if (x !== '{"c":[],"b":12,"a":"Hello"}') { throw x }
 }
 
 {
     const _0 = { a: { y: [24] }, c: [], b: 12 }
-    const _1 = json.addProperty("Hello")(['a', 'x'])(_0)
+    const _1 = json.setProperty("Hello")(['a', 'x'])(_0)
     const _2 = json.stringify(sort)(_1)
     if (_2 !== '{"a":{"x":"Hello","y":[24]},"b":12,"c":[]}') { throw _2 }
 }
 
 {
     const _0 = { a: { y: [24] }, c: [], b: 12 }
-    const _1 = json.addProperty("Hello")(['a', 'x'])(_0)
+    const _1 = json.setProperty("Hello")(['a', 'x'])(_0)
     const _2 = json.stringify(identity)(_1)
     if (_2 !== '{"a":{"y":[24],"x":"Hello"},"c":[],"b":12}') { throw _2 }
 }

package/package.json

@@ -1,25 +1,25 @@
 {
-   "name": "functionalscript",
-   "version": "0.0.228",
-   "description": "FunctionalScript is a functional subset of JavaScript",
-   "main": "index.js",
-   "scripts": {
-      "tsc": "tsc",
-      "test": "tsc && npm run test-only",
-      "test-only": "node --trace-uncaught ./test"
-   },
-   "repository": {
-      "type": "git",
-      "url": "git+https://github.com/functionalscript/functionalscript.git"
-   },
-   "author": "Natfoam",
-   "license": "Apache-2.0",
-   "bugs": {
-      "url": "https://github.com/functionalscript/functionalscript/issues"
-   },
-   "homepage": "https://github.com/functionalscript/functionalscript#readme",
-   "devDependencies": {
-      "@types/node": "^16.11.11",
-      "typescript": "^4.5.2"
-   }
+  "name": "functionalscript",
+  "version": "0.0.232",
+  "description": "FunctionalScript is a functional subset of JavaScript",
+  "main": "index.js",
+  "scripts": {
+    "tsc": "tsc",
+    "test": "tsc && npm run test-only",
+    "test-only": "node --trace-uncaught ./test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/functionalscript/functionalscript.git"
+  },
+  "author": "Natfoam",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/functionalscript/functionalscript/issues"
+  },
+  "homepage": "https://github.com/functionalscript/functionalscript#readme",
+  "devDependencies": {
+    "@types/node": "^16.11.11",
+    "typescript": "^4.5.2"
+  }
 }

package/test.js

@@ -1,12 +1,10 @@
 const i = require('./')
 
-require('./sequence/test')
-require('./btree/test')
-require('./sequence/iterable/test')
-require('./sequence/asyncIterable/test')
-require('./module-manager/test')
+require('./types/sequence/test')
+require('./types/btree/test')
 require('./json/test')
-require('./object/test')
+require('./types/object/test')
+require('./io/commonjs/test')
 
 /** @type {() => never} */
 const assert = () => { throw 'assert' }

package/{sequence → types}/array/index.js

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

package/{btree → types/btree}/index.js

@@ -1,4 +1,4 @@
-const cmp = require('../cmp')
+const cmp = require('../function/compare')
 const { index3, index5 } = cmp
 const seq = require('../sequence')
 
@@ -9,7 +9,7 @@ const seq = require('../sequence')
 
 /**
  * @template T
- * @typedef {cmp.Cmp<T>} Cmp
+ * @typedef {cmp.Compare<T>} Cmp
  */
 
 /**
@@ -311,20 +311,20 @@ const values = node => () => {
         switch (node.length) {
             case 1: case 2: { return node }
             case 3: { 
-                return seq.concat(
+                return seq.flat([
                     values(node[0]), 
                     [node[1]], 
                     values(node[2])
-                )
+                ])
             }
             default: {
-                return seq.concat(
+                return seq.flat([
                     values(node[0]),
                     [node[1]],
                     values(node[2]),
                     [node[3]],
                     values(node[4])
-                )
+                ])
             }
         }
     }

package/{btree → types/btree}/test.js

@@ -1,6 +1,6 @@
 const btree = require('.')
 const { setVisitor, values } = btree
-const { cmp } = require('../cmp') 
+const { cmp } = require('../function/compare') 
 const list = require('../sequence')
 
 /** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string>} */

package/{cmp → types/function/compare}/index.js

@@ -1,22 +1,22 @@
-/** @typedef {import('../sequence/array').Index3} Index3 */
-/** @typedef {import('../sequence/array').Index5} Index5 */
+/** @typedef {import('../../array').Index3} Index3 */
+/** @typedef {import('../../array').Index5} Index5 */
 
 /**
  * @template T
- * @typedef {import('../sequence/array').Array2<T>} Array2 
+ * @typedef {import('../../array').Array2<T>} Array2 
  */
 
 /** @typedef {-1|0|1} Sign */
 
 /**
  * @template T
- * @typedef {(_: T) => Sign} Cmp
+ * @typedef {(_: T) => Sign} Compare
  */
 
-/** @type {<T>(cmp: Cmp<T>) => (value: T) => Index3} */
+/** @type {<T>(cmp: Compare<T>) => (value: T) => Index3} */
 const index3 = cmp => value => /** @type {Index3} */ (cmp(value) + 1)
 
-/** @type {<T>(cmp: Cmp<T>) => (v2: Array2<T>) => Index5} */
+/** @type {<T>(cmp: Compare<T>) => (v2: Array2<T>) => Index5} */
 const index5 = cmp => ([v0, v1]) => {
     const _0 = cmp(v0)
     return /** @type {Index5} */ (_0 <= 0 ? _0 + 1 : cmp(v1) + 3)

package/{function → types/function}/operator/index.js

@@ -26,9 +26,20 @@ const addition = a => b => a + b
 /** @type {(value: boolean) => boolean} */
 const logicalNot = v => !v
 
+/**
+ * @template T 
+ * @typedef {(a: T) => (b: T) => boolean} EqualOperator 
+ */
+
 /** @type {<T>(a: T) => (b: T) => boolean} */
 const strictEqual = a => b => a === b
 
+/** @type {ReduceOperator<number, number>} */
+const min = a => b => a < b ? a : b
+
+/** @type {ReduceOperator<number, number>} */
+const max = a => b => a > b ? a : b
+
 module.exports = {
     /** @readonly */
     join,
@@ -38,4 +49,8 @@ module.exports = {
     strictEqual,
     /** @readonly */
     logicalNot,
+    /** @readonly */
+    min,
+    /** @readonly */
+    max,
 }

package/{map → types/map}/index.js

@@ -1,9 +1,9 @@
 const option = require("../option")
 const { getVisitor, setVisitor, values } = require("../btree")
-const { cmp } = require("../cmp")
+const { cmp } = require("../function/compare")
 const seq = require("../sequence")
 
-/** @typedef {import("../cmp").Sign} Sign */
+/** @typedef {import("../function/compare").Sign} Sign */
 
 /**
  * @template T 
@@ -17,7 +17,7 @@ const seq = require("../sequence")
 
 /**
  * @template T
- * @typedef {import("../cmp").Cmp<T>} Cmp
+ * @typedef {import("../function/compare").Compare<T>} Cmp
  */
 
 /**

package/{object → types/object}/index.js

@@ -1,4 +1,3 @@
-const array = require('../sequence/array')
 const seq = require('../sequence')
 const map = require('../map')
 
@@ -25,4 +24,4 @@ module.exports = {
     at,
     /** @readonly */
     sort,
-}
+}