functionalscript 0.0.432 → 0.0.434

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

@@ -34,6 +34,17 @@ const { fold } = list
  * }} 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')
 
@@ -47,7 +58,7 @@ 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

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/fsm/module.f.cjs

@@ -15,7 +15,7 @@ const byteSet = require('../types/byte_set/module.f.cjs')
  */
 
 /** @type {(faId: string) => string} */
-const escape = faId => todo()
+const escape = faId => faId.replaceAll('\\', '\\\\').replaceAll('|', '\\|')
 
 /** @type {(grammar: Grammar) => Dfa} */
 const dfa = grammar => todo()

package/fsm/test.f.cjs

@@ -0,0 +1,14 @@
+const _ = require('./module.f.cjs')
+
+module.exports = {
+    escape: [
+        () => {
+            const result = _.escape('abc')
+            if (result !== 'abc') { throw result }
+        },
+        () => {
+            const result = _.escape('\\a|b|c\\')
+            if (result !== '\\\\a\\|b\\|c\\\\') { throw result }
+        }
+    ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.432",
+  "version": "0.0.434",
   "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} */

package/types/sorted_list/module.f.cjs

@@ -0,0 +1,38 @@
+const compare = require("../function/compare/module.f.cjs")
+const list = require("../list/module.f.cjs")
+const { next, toArray } = list
+
+/**
+ * @template T
+ * @typedef {list.List<T>} SortedList
+ */
+
+/**
+ * @template T
+ * @typedef {(a: T) => (b: T) => compare.Sign} Cmp
+ */
+
+/** @typedef {number} Byte */
+
+/**
+ * @template T
+ * @typedef {SortedList<[Byte, readonly string[]]>} RangeMap
+ */
+
+/** @type {<T>(cmp: Cmp<T>) => (a: SortedList<T>) => (b: SortedList<T>) => SortedList<T>} */
+const merge = cmp => a => b => () => {
+    const aResult = next(a)
+    if (aResult === undefined) { return b }
+    const bResult = next(b)
+    if (bResult === undefined) { return a }
+    switch (cmp(aResult.first)(bResult.first)) {
+        case -1: return { first: aResult.first, tail: merge(cmp)(aResult.tail)(b) }
+        case 0: return { first: aResult.first, tail: merge(cmp)(aResult.tail)(bResult.tail) }
+        case 1: return { first: bResult.first, tail: merge(cmp)(a)(bResult.tail) }
+    }
+}
+
+module.exports = {
+    /** @readonly */
+    merge
+}

package/types/sorted_list/test.f.cjs

@@ -0,0 +1,33 @@
+const _ = require('./module.f.cjs')
+const { unsafeCmp } = require('../function/compare/module.f.cjs')
+const json = require('../../json/module.f.cjs')
+const { sort } = require('../../types/object/module.f.cjs')
+const { toArray, countdown, length } = require('../list/module.f.cjs')
+const map = require('../map/module.f.cjs')
+const { flip } = require('../function/module.f.cjs')
+
+/** @type {(a: readonly json.Unknown[]) => string} */
+const stringify = a => json.stringify(sort)(a)
+
+/** @type {<T>(a: T) => (b: T) => map.Sign} */
+const reverseCmp = flip(unsafeCmp)
+
+module.exports = {
+    sortedMergre: [
+        () => {
+            const result = stringify(toArray(_.merge(unsafeCmp)([2, 3, 4])([1, 3, 5])))
+            if (result !== '[1,2,3,4,5]') { throw result }
+        },
+        () => {
+            const result = stringify(toArray(_.merge(unsafeCmp)([1, 2, 3])([])))
+            if (result !== '[1,2,3]') { throw result }
+        },
+        () => {
+            const n = 10_000
+            const list = countdown(n)
+            const result = _.merge(reverseCmp)(list)(list)
+            const len = length(result)
+            if (len != n) { throw result }
+        }
+    ]
+}