functionalscript 0.0.431 → 0.0.433

package/dev/module.mjs

@@ -0,0 +1,155 @@
+/**
+ * @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
+
+export const loadModuleMap = 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()
+}

package/dev/test/module.f.cjs

@@ -1,3 +1,6 @@
+const list = require('../../types/list/module.f.cjs')
+const { fold } = list
+
 /**
  * @typedef {{
  *  readonly[k in string]?: Module
@@ -31,6 +34,20 @@
  * }} Input
  */
 
+/**
+ * https://en.wikipedia.org/wiki/ANSI_escape_code#SGR
+ *
+ * @type {(c: number) => string}
+ */
+const sgr = c => `\x1b[${c.toString()}m`
+
+const reset = sgr(0)
+
+const fgGreen = sgr(32)
+
+/** @type {(s: string) => boolean} */
+const isTest = s => s.endsWith('test.f.cjs')
+
 /** @type {<T>(input: Input<T>) => T} */
 const main = ({moduleMap, log, state}) => {
     /** @typedef {log extends Log<infer T> ? T : never} T */
@@ -41,21 +58,23 @@ const main = ({moduleMap, log, state}) => {
             case 'function': {
                 if (v.length === 0) {
                     const r = v()
-                    state = log(`${i}() passed`)(state)
+                    state = log(`${i}() ${fgGreen}ok${reset}`)(state)
                     state = next(r)(state)
                 }
                 break
             }
             case 'object': {
+                /** @type {(k: readonly[string|number, unknown]) => (state: T) => T} */
+                const f = ([k, v]) => state => {
+                    state = log(`${i}${k}:`)(state)
+                    state = next(v)(state)
+                    return state
+                }
+                const foldF = fold(f)(state)
                 if (v instanceof Array) {
-                    for (const v2 of v) {
-                        state = next(v2)(state)
-                    }
+                    state = foldF(list.entries(v))
                 } else if (v !== null) {
-                    for (const [k, v2] of Object.entries(v)) {
-                        state = log(`${i}${k}:`)(state)
-                        state = next(v2)(state)
-                    }
+                    state = foldF(Object.entries(v))
                 }
                 break
             }
@@ -63,13 +82,15 @@ const main = ({moduleMap, log, state}) => {
         return state
     }
     const next = test('| ')
-    for (const [k, v] of Object.entries(moduleMap)) {
-        if (k.endsWith('test.f.cjs')) {
+    /** @type {(k: readonly[string, Module]) => (state: T) => T} */
+    const f = ([k, v]) => state => {
+        if (isTest(k)) {
             state = log(`testing ${k}`)(state)
             state = next(v.exports)(state)
         }
+        return state
     }
-    return state
+    return fold(f)(state)(Object.entries(moduleMap))
 }
 
 module.exports = main

package/{test.f.cjs → dev/test.f.cjs}

@@ -1,5 +1,3 @@
-const i = require('./module.f.cjs')
-
 /** @type {() => never} */
 const assert = () => { throw 'assert' }
 

package/dev/test.mjs

@@ -1,162 +1,8 @@
-/**
- * @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()
-}
+import { loadModuleMap } from './module.mjs'
 
 // test runner.
 const main = async() => {
-    const moduleMap = await boot()
+    const moduleMap = await loadModuleMap()
 
     /** @type {(s: string) => (_: undefined) => undefined} */
     const log = s => state => {

package/module.f.cjs

@@ -1,14 +1,22 @@
 module.exports = {
+    /** @readonly */
+    com: require('./com/module.f.cjs'),
     /** @readonly */
     commonjs: require('./commonjs/module.f.cjs'),
     /** @readonly */
     dev: require('./dev/module.f.cjs'),
     /** @readonly */
+    fsm: require('./fsm/module.f.cjs'),
+    /** @readonly */
     html: require('./html/module.f.cjs'),
     /** @readonly */
     json: require('./json/module.f.cjs'),
     /** @readonly */
+    nodejs: require('./nodejs/module.f.cjs'),
+    /** @readonly */
     sha2: require('./sha2/module.f.cjs'),
     /** @readonly */
+    text: require('./text/module.f.cjs'),
+    /** @readonly */
     types: require('./types/module.f.cjs'),
 }

package/nodejs/module.f.cjs

@@ -0,0 +1,4 @@
+module.exports = {
+    /** @readonly */
+    version: require('./version/module.f.cjs')
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.431",
+  "version": "0.0.433",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "module.f.cjs",
   "scripts": {

package/types/function/operator/module.f.cjs

@@ -7,7 +7,7 @@
 
 /**
  * @template I,O
- * @typedef {Binary<I, O, O>} FoldT
+ * @typedef {Binary<I, O, O>} Fold
  */
 
 /** @type {(separator: string) => Reduce<string>} */
@@ -49,7 +49,7 @@ const stateScanToScan = op => prior => i => {
     return [o, stateScanToScan(op)(s)]
 }
 
-/** @type {<I, O>(fold: FoldT<I, O>) => (prior: O) => Scan<I, O>} */
+/** @type {<I, O>(fold: Fold<I, O>) => (prior: O) => Scan<I, O>} */
 const foldToScan = fold => prior => i => {
     const result = fold(i)(prior)
     return [result, foldToScan(fold)(result)]
@@ -57,7 +57,7 @@ const foldToScan = fold => prior => i => {
 
 /**
  * @template T
- * @typedef {FoldT<T, T>} Reduce
+ * @typedef {Fold<T, T>} Reduce
  */
 
 /** @type {<T>(fold: Reduce<T>) => Scan<T, T>} */

package/types/list/module.f.cjs

@@ -250,10 +250,10 @@ const scan = op => apply(scanStep(op))
 /** @type {<I, S, O>(op: operator.StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>} */
 const stateScan = op => init => scan(stateScanToScan(op)(init))
 
-/** @type {<I,O>(op: operator.FoldT<I, O>) => (init: O) => (input: List<I>) => Thunk<O>} */
+/** @type {<I,O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => Thunk<O>} */
 const foldScan = op => init => scan(foldToScan(op)(init))
 
-/** @type {<I,O>(op: operator.FoldT<I, O>) => (init: O) => (input: List<I>) => O} */
+/** @type {<I,O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => O} */
 const fold = op => init => input => last(init)(foldScan(op)(init)(input))
 
 /** @type {<T>(op: operator.Reduce<T>) => <D>(def: D) => (input: List<T>) => D|T} */