functionalscript 0.0.428 → 0.0.431

package/.github/workflows/bun.yml

@@ -1,7 +1,9 @@
-name: Bun CI
+name: bun
 
 on:
   push:
+    branches:
+    - master
   pull_request:
 
 jobs:
@@ -12,4 +14,4 @@ jobs:
     steps:
     - uses: actions/checkout@v2
     - run: curl https://bun.sh/install | bash
-    - run: /home/runner/.bun/bin/bun ./test.mjs
+    - run: /home/runner/.bun/bin/bun ./dev/test.mjs

package/.github/workflows/deno.yml

@@ -1,7 +1,9 @@
-name: Deno CI
+name: deno
 
 on:
   push:
+    branches:
+    - master
   pull_request:
 
 jobs:
@@ -14,4 +16,4 @@ jobs:
     - uses: denoland/setup-deno@v1
       with:
         deno-version: v1.x
-    - run: deno run --allow-read --allow-env --allow-net ./test.mjs
+    - run: deno run --allow-read --allow-env --allow-net ./dev/test.mjs

package/.github/workflows/node-pack.yml

@@ -0,0 +1,26 @@
+# This workflow will do a clean install of node dependencies, cache/restore them, build the source code and run tests across different versions of node
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
+
+name: node ci & pack
+
+on:
+  push:
+    branches:
+    - master
+  pull_request:
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js
+      uses: actions/setup-node@v2
+      with:
+        node-version: 18
+    - run: npm ci
+    - run: npm test
+    - run: npm run version
+    - run: npm pack

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

@@ -1,10 +1,12 @@
 # This workflow will do a clean install of node dependencies, cache/restore them, build the source code and run tests across different versions of node
 # For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
 
-name: Node.js CI
+name: node install
 
 on:
   push:
+    branches:
+    - master
   pull_request:
 
 jobs:

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

@@ -1,7 +1,7 @@
 # This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
 # For more information see: https://help.github.com/actions/language-and-framework-guides/publishing-nodejs-packages
 
-name: Node.js Package
+name: node publish
 
 on:
   push:
@@ -14,7 +14,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-node@v2
         with:
-          node-version: 16
+          node-version: 18
       - run: npm ci
       - run: npm test
 
@@ -27,7 +27,7 @@ jobs:
           fetch-depth: 0
       - uses: actions/setup-node@v2
         with:
-          node-version: 16
+          node-version: 18
           registry-url: https://registry.npmjs.org/
       - run: npm ci
       - run: npm run version

package/commonjs/build/module.f.cjs

@@ -8,7 +8,7 @@ const object = require('../../types/object/module.f.cjs')
 const { fromMap } = object
 const path = require('../path/module.f.cjs')
 const { parseAndFind } = path
-const stringSet = require('../../types/stringset/module.f.cjs')
+const stringSet = require('../../types/string_set/module.f.cjs')
 const { set: setSet, contains: setContains } = stringSet
 
 /**

package/dev/test/module.f.cjs

@@ -1,19 +1,75 @@
-const { todo } = require('../module.f.cjs')
-const list = require('../../types/list/module.f.cjs')
-const function_ = require('../../commonjs/module/function/module.f.cjs')
-const package_ = require('../../commonjs/package/module.f.cjs')
+/**
+ * @typedef {{
+ *  readonly[k in string]?: Module
+ * }} DependencyMap
+ */
+
+/**
+ * @typedef {{
+ *  readonly dependencyMap: DependencyMap
+ *  readonly exports?: unknown
+ * }} Module
+ */
+
+/**
+ * @typedef {{
+ *  readonly[k in string]: Module
+ * }} ModuleMap
+ */
+
+/**
+ * @template T
+ * @typedef {(v: string) => (state: T) => T} Log
+ */
 
 /**
- * @type {(c: function_.Compile) =>
- *  (files: string) =>
- *  (packageGet: package_.Get) =>
- *  never}
+ * @template T
+ * @typedef {{
+ *  readonly moduleMap: ModuleMap,
+ *  readonly log: Log<T>,
+ *  readonly state: T,
+ * }} Input
  */
-const test = compile => files => packageGet => {
-    return todo()
+
+/** @type {<T>(input: Input<T>) => T} */
+const main = ({moduleMap, log, state}) => {
+    /** @typedef {log extends Log<infer T> ? T : never} T */
+    /** @type {(i: string) => (v: unknown) => (state: T) => T} */
+    const test = i => v => state => {
+        const next = test(`${i}| `)
+        switch (typeof v) {
+            case 'function': {
+                if (v.length === 0) {
+                    const r = v()
+                    state = log(`${i}() passed`)(state)
+                    state = next(r)(state)
+                }
+                break
+            }
+            case 'object': {
+                if (v instanceof Array) {
+                    for (const v2 of v) {
+                        state = next(v2)(state)
+                    }
+                } else if (v !== null) {
+                    for (const [k, v2] of Object.entries(v)) {
+                        state = log(`${i}${k}:`)(state)
+                        state = next(v2)(state)
+                    }
+                }
+                break
+            }
+        }
+        return state
+    }
+    const next = test('| ')
+    for (const [k, v] of Object.entries(moduleMap)) {
+        if (k.endsWith('test.f.cjs')) {
+            state = log(`testing ${k}`)(state)
+            state = next(v.exports)(state)
+        }
+    }
+    return state
 }
 
-module.exports = {
-    /** @readonly */
-    test,
-}
+module.exports = main

package/dev/test.mjs

@@ -0,0 +1,175 @@
+/**
+ * @typedef {{
+ *  readonly withFileTypes: true
+ * }} Options
+ */
+
+/**
+ * @typedef {{
+ *  readonly name: string
+ *  readonly isDirectory: () => boolean
+ * }} Dirent
+ */
+
+/**
+ * @typedef {{
+ *  readonly readdir: (path: string, options: Options) => Promise<readonly Dirent[]>
+ *  readonly readFile: (path: string, options: 'utf8') => Promise<string>
+ * }} FsPromises
+ */
+
+/**
+ * @typedef {{
+ *  [k in string]?: MutableModule
+ * }} MutableDependencyMap
+ */
+
+/**
+ * @typedef {{
+ *  dependencyMap: MutableDependencyMap
+ *  exports?: unknown
+ * }} MutableModule
+ */
+
+/**
+ * @typedef {{
+ *  readonly dependencyMap: DependencyMap
+ *  readonly exports?: unknown
+ * }} Module
+ */
+
+/**
+ * @typedef {{
+ *   readonly[k in string]?: Module
+ * }} DependencyMap
+ */
+
+/** @typedef {(name: string) => unknown} Require */
+
+/**
+ * @typedef {{
+ *  readonly[k in string]: Function
+ * }} FunctionMap
+ */
+
+/**
+ * @template T
+ * @typedef {readonly[string, T]} Entry
+ */
+
+/** @type {(a: Entry<Function>, b: Entry<Function>) => number} */
+const cmp = ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
+
+/**
+ * @typedef {{
+ *  [k in string]: MutableModule
+ * }} MutableModuleMap
+ */
+
+/**
+ * @typedef {{
+ *  readonly[k in string]: Module
+ * }} ModuleMap
+ */
+
+/** @type {(v: readonly string[]) => (dif: number) => readonly string[]} */
+const remove_tail = v => dif => v.slice(0, v.length - dif)
+
+/** @type {any} */
+const self = globalThis
+
+const boot = async() => {
+    /** @type {FsPromises} */
+    const { readdir, readFile } = await import(self.Deno ? 'https://deno.land/std/node/fs/promises.ts' : 'node:fs/promises')
+
+    /** @type {() => Promise<FunctionMap>} */
+    const load = async () => {
+        /** @type {(readonly[string, Function])[]} */
+        const map = []
+        /** @type {(path: string) => Promise<void>} */
+        const f = async p => {
+            for (const i of await readdir(p, { withFileTypes: true })) {
+                const { name } = i
+                if (!name.startsWith('.')) {
+                    const file = `${p}/${name}`
+                    if (i.isDirectory()) {
+                        await f(file)
+                    } else if (name.endsWith('.f.cjs')) {
+                        const source = await readFile(file, 'utf8')
+                        map.push([file, Function('module', 'require', `"use strict";${source}`)])
+                    }
+                }
+            }
+        }
+        await f('.')
+        map.sort(cmp)
+        return Object.fromEntries(map)
+    }
+
+    const map = await load()
+
+    /** @type {() => ModuleMap} */
+    const build = () => {
+        /** @type {MutableModuleMap} */
+        const d = {}
+        /** @type {(base: readonly string[]) => (k: string) => readonly[string, MutableModule]} */
+        const getModule = base => k => {
+            const relativePath = k.split('/')
+            const dif = relativePath.filter(v => v === '..').length
+            const path = [remove_tail(base)(dif), relativePath.filter(v => !['..', '.'].includes(v))]
+                .flat()
+            const pathStr = path.join('/')
+            {
+                const module = d[pathStr]
+                if (module !== undefined) {
+                    return [pathStr, module]
+                }
+            }
+            {
+                /** @type {MutableDependencyMap} */
+                const dependencyMap = {}
+                /** @type {MutableModule} */
+                const module = { dependencyMap }
+                const get = getModule(remove_tail(path)(1))
+                /** @type {(s: string) => unknown} */
+                const newReq = s => {
+                    const [p, result] = get(s)
+                    dependencyMap[p] = result
+                    return result.exports
+                }
+                map[pathStr](module, newReq)
+                d[pathStr] = module
+                return [pathStr, module]
+            }
+        }
+        {
+            const get = getModule(['.'])
+            for (const k of Object.keys(map)) {
+                get(k)
+            }
+        }
+        return d
+    }
+
+    return build()
+}
+
+// test runner.
+const main = async() => {
+    const moduleMap = await boot()
+
+    /** @type {(s: string) => (_: undefined) => undefined} */
+    const log = s => state => {
+        console.log(s)
+        return state
+    }
+
+    /** @type {any} */
+    const f = moduleMap['./dev/test/module.f.cjs'].exports
+    f({
+        moduleMap,
+        log,
+    })
+}
+
+main()

package/fsm/README.md

@@ -0,0 +1,4 @@
+# FSM
+
+This module is about a [finite-state machine](https://en.wikipedia.org/wiki/Finite-state_machine). It's not about
+[Flying Spaghetti Monster](https://en.wikipedia.org/wiki/Flying_Spaghetti_Monster).

package/fsm/module.f.cjs

@@ -0,0 +1,28 @@
+const { todo } = require('../dev/module.f.cjs')
+const list = require('../types/list/module.f.cjs')
+const byteSet = require('../types/byte_set/module.f.cjs')
+
+/** @typedef {readonly[string, byteSet.ByteSet, string]} Rule */
+
+/** @typedef {list.List<Rule>} Grammar */
+
+/** @typedef {readonly string[]} ByteMap */
+
+/**
+ * @typedef {{
+ *  readonly[state in string]: ByteMap
+ * }} Dfa
+ */
+
+/** @type {(faId: string) => string} */
+const escape = faId => todo()
+
+/** @type {(grammar: Grammar) => Dfa} */
+const dfa = grammar => todo()
+
+module.exports = {
+    /** @readonly */
+    escape,
+    /** @readonly */
+    dfa,
+}

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "functionalscript",
-  "version": "0.0.428",
+  "version": "0.0.431",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "module.f.cjs",
   "scripts": {
     "tsc": "tsc",
     "test": "tsc && npm run test-only",
     "version": "node ./nodejs/version/main.cjs",
-    "test-only": "node --trace-uncaught ./test.mjs"
+    "test-only": "node --trace-uncaught ./dev/test.mjs"
   },
   "repository": {
     "type": "git",
@@ -29,7 +29,7 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@types/node": "^18.7.16",
+    "@types/node": "^18.7.18",
     "typescript": "^4.8.3"
   }
 }

package/tsconfig.json

@@ -97,5 +97,5 @@
     // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
     "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
   },
-  "exclude": ["target", "test.mjs"]
+  "exclude": ["target"]
 }

package/types/byte_set/module.f.cjs

@@ -0,0 +1,57 @@
+const { fn } = require('../function/module.f.cjs')
+
+/** @typedef {bigint} ByteSet */
+/** @typedef {number} Byte */
+
+/** @type {(n: Byte) => (s: ByteSet) => boolean} */
+const has = n => s => ((s >> BigInt(n)) & 1n) === 1n
+
+// create a set
+
+const empty = 0n
+
+/** @type {(n: Byte) => ByteSet} */
+const one = n => 1n << BigInt(n)
+
+/** @type {(r: readonly[Byte, Byte]) => ByteSet} */
+const range = ([b, e]) => one(e - b + 1) - 1n << BigInt(b)
+
+// set operations
+
+/** @type {(a: ByteSet) => (b: ByteSet) => ByteSet} */
+const union = a => b => a | b
+
+/** @type {(a: ByteSet) => (b: ByteSet) => ByteSet} */
+const intersect = a => b => a & b
+
+/** @type {(a: ByteSet) => (b: ByteSet) => ByteSet} */
+const difference = a => b => intersect(a)(complement(b))
+
+/** @type {(n: ByteSet) => ByteSet} */
+const complement = n => ~n
+
+// additional operations
+
+const set = fn(one).then(union).result
+
+const setRange = fn(range).then(union).result
+
+/** @type {(n: Byte) => (s: ByteSet) => ByteSet} */
+const unset = n => s => difference(s)(one(n))
+
+module.exports = {
+    /** @readonly */
+    empty,
+    /** @readonly */
+    has,
+    /** @readonly */
+    set,
+    /** @readonly */
+    unset,
+    /** @readonly */
+    union,
+    /** @readonly */
+    setRange,
+    /** @readonly */
+    range,
+}

package/types/module.f.cjs

@@ -10,13 +10,15 @@ module.exports = {
     /** @readonly */
     map: require('./map/module.f.cjs'),
     /** @readonly */
+    nibbleSet: require('./nibble_set/module.f.cjs'),
+    /** @readonly */
     object: require('./object/module.f.cjs'),
     /** @readonly */
     range: require('./range/module.f.cjs'),
     /** @readonly */
     result: require('./result/module.f.cjs'),
     /** @readonly */
-    stringset: require('./stringset/module.f.cjs'),
+    stringSet: require('./string_set/module.f.cjs'),
     /** @readonly */
     bigint: require('./bigint/module.f.cjs'),
     /** @readonly */

package/test.mjs

@@ -1,174 +0,0 @@
-/**
- * @typedef {{
- *  readonly withFileTypes: true
- * }} Options
- */
-
-/**
- * @typedef {{
- *  readonly name: string
- *  readonly isDirectory: () => boolean
- * }} Dirent
- */
-
-/**
- * @typedef {{
- *  readonly readdir: (path: string, options: Options) => Promise<readonly Dirent[]>
- *  readonly readFile: (path: string, options: 'utf8') => Promise<Buffer>
- * }} FsPromises
- */
-
-/** @type {FsPromises} */
-const { readdir, readFile } = await import(globalThis.Deno ? 'https://deno.land/std/node/fs/promises.ts' : 'node:fs/promises')
-
-/**
- * @typedef {{
- *  [k: in string]?: Module
- * }} Dependencies
- */
-
-/**
- * @typedef {{
- *  dependencies: Dependencies
- *  exports?: unknown
- * }} Module
- */
-
-/** @typedef {(name: string) => unknown} Require */
-
-/**
- * @typedef {{
- *  readonly[k in string]: Function
- * }} FunctionMap
- */
-
-/**
- * @template T
- * @typedef {readonly[string, T]} Entry
- */
-
-/** @type {(a: Entry<Function>, b: Entry<Function>) => number} */
-const cmp = ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
-
-/** @type {() => Promise<FunctionMap>} */
-const load = async () => {
-    /** @type {(readonly[string, Function])[]} */
-    const map = []
-    /** @type {(path: string) => Promise<void>} */
-    const f = async p => {
-        for (const i of await readdir(p, { withFileTypes: true })) {
-            const { name } = i
-            if (!name.startsWith('.')) {
-                const file = `${p}/${name}`
-                if (i.isDirectory()) {
-                    if (!['node_modules', 'target'].includes(name)) {
-                        await f(file)
-                    }
-                } else if (name.endsWith('.f.cjs')) {
-                    // console.log(`loading ${file}`)
-                    const source = await readFile(file, 'utf8')
-                    map.push([file, Function('module', 'require', `"use strict";${source}`)])
-                }
-            }
-        }
-    }
-    await f('.')
-    map.sort(cmp)
-    return Object.fromEntries(map)
-}
-
-const map = await load()
-
-/**
- * @typedef {{
- *  [k in string]: Module
- * }} ModuleMap
- */
-
-const build = async () => {
-    /** @type {ModuleMap} */
-    const d = {}
-    /** @type {(base: readonly string[]) => (i: string) => (k: string) => readonly[string, Module]} */
-    const req = base => i => k => {
-        const relativePath = k.split('/')
-        const dif = relativePath.filter(v => v === '..').length
-        const path = [base.slice(0, base.length - dif), relativePath.filter(v => !['..', '.'].includes(v))]
-            .flat()
-        const pathStr = path.join('/')
-        const newBase = path.slice(0, path.length - 1)
-        {
-            const module = d[pathStr]
-            if (module !== undefined) {
-                return [pathStr, module]
-            }
-        }
-        {
-            /** @type {Module} */
-            const module = {
-                dependencies: {}
-            }
-            // console.log(`${i}building ${pathStr}`)
-            const getModule = req(newBase)(`${i}| `)
-            const newReq = s => {
-                const [p, result] = getModule(s)
-                module.dependencies[p] = result
-                return result.exports
-            }
-            map[pathStr](module, newReq)
-            d[pathStr] = module
-            return [pathStr, module]
-        }
-    }
-    const r = req(['.'])('')
-    for (const k of Object.keys(map)) {
-        r(k)
-    }
-    return d
-}
-
-const modules = await build()
-
-// graph
-
-/*
-for (const [k, v] of Object.entries(modules)) {
-    console.log(`: ${k}`)
-    console.log(Object.keys(v.dependencies))
-}
-*/
-
-// test runner.
-
-/** @type {(i: string) => (v: unknown) => void} */
-const test = i => v => {
-    switch (typeof v) {
-        case 'function': {
-            if (v.length === 0) {
-                const r = v()
-                console.log(`${i}() passed`)
-                test(`${i}| `)(r)
-            }
-            return;
-        }
-        case 'object': {
-            if (v instanceof Array) {
-                for (const v2 of v) {
-                    test(`${i}| `)(v2)
-                }
-            } else {
-                for (const [k, v2] of Object.entries(v)) {
-                    console.log(`${i}${k}:`)
-                    test(`${i}| `)(v2)
-                }
-            }
-            return;
-        }
-    }
-}
-
-for (const [k, v] of Object.entries(modules)) {
-    if (k.endsWith('test.f.cjs')) {
-        console.log(`testing ${k}`)
-        test('| ')(v.exports)
-    }
-}

package/types/byteSet/module.f.cjs

@@ -1,30 +0,0 @@
-/** @typedef {bigint} byteSet */
-/** @typedef {number} byte */
-
-/** @type {(n: byte) => (s: byteSet) => boolean} */
-const has = n => s => ((s >> BigInt(n)) & 1n) === 1n
-
-/** @type {(n: byte) => (s: byteSet) => byteSet} */
-const set = n => s => s | (1n << BigInt(n))
-
-/** @type {(n: byte) => (s: byteSet) => byteSet} */
-const unset = n => s => s & ~(1n << BigInt(n))
-
-/** @type {(r: readonly[number, number]) => (s: byteSet) => byteSet} */
- const setRange = ([b, e]) => s => s | ((1n << BigInt(e - b + 1)) - 1n << BigInt(b))
-
-// how to define FA???
-// const stateA = [init, set] ????
-
-module.exports = {
-    /** @readonly */
-    empty: 0n,
-    /** @readonly */
-    has,
-    /** @readonly */
-    set,
-    /** @readonly */
-    unset,
-    /** @readonly */
-    setRange
-}