functionalscript 0.0.492 → 0.0.494

package/dev/module.mjs

@@ -78,9 +78,14 @@ const remove_tail = v => dif => v.slice(0, v.length - dif)
 /** @type {any} */
 const self = globalThis
 
+/** @type {() => Promise<FsPromises>} */
+export const fs = () => import(self.Deno ? 'https://deno.land/std/node/fs/promises.ts' : 'node:fs/promises')
+
+/** @type {(code: number) => never} */
+export const exit = self.Deno ? self.Deno.exit : process.exit
+
 export const loadModuleMap = async () => {
-    /** @type {FsPromises} */
-    const { readdir, readFile } = await import(self.Deno ? 'https://deno.land/std/node/fs/promises.ts' : 'node:fs/promises')
+    const { readdir, readFile } = await fs();
 
     /** @type {() => Promise<FunctionMap>} */
     const load = async () => {

package/dev/test/module.f.cjs

@@ -1,6 +1,7 @@
 const list = require('../../types/list/module.f.cjs')
 const { fold } = list
-const { reset, fgGreen } = require('../../text/sgr/module.f.cjs')
+const { reset, fgGreen, fgRed, bold } = require('../../text/sgr/module.f.cjs')
+const result = require('../../types/result/module.f.cjs')
 
 /**
  * @typedef {{
@@ -28,7 +29,7 @@ const { reset, fgGreen } = require('../../text/sgr/module.f.cjs')
 
 /**
  * @template T
- * @typedef {(state: T) => readonly[number, T]} PerformanceNow
+ * @typedef {<R>(f: () => R) => (state: T) => readonly[R, number, T]} Measure
  */
 
 /**
@@ -36,74 +37,92 @@ const { reset, fgGreen } = require('../../text/sgr/module.f.cjs')
  * @typedef {{
  *  readonly moduleMap: ModuleMap,
  *  readonly log: Log<T>,
- *  readonly performanceNow: PerformanceNow<T>,
+ *  readonly measure: Measure<T>,
  *  readonly state: T,
+ *  readonly tryCatch: <R>(f: () => R) => result.Result<R, unknown>
  * }} Input
  */
 
 /** @type {(s: string) => boolean} */
 const isTest = s => s.endsWith('test.f.cjs')
 
+/**
+ * @typedef {{
+ *  readonly time: number,
+ *  readonly pass: number,
+ *  readonly fail: number,
+ * }} TestState
+ */
+
+/** @type {(time: number) => (testState: TestState) => TestState} */
+const addPass = delta => ts => ({ ...ts, time: ts.time + delta, pass: ts.pass + 1 })
+
+/** @type {(time: number) => (testState: TestState) => TestState} */
+const addFail = delta => ts => ({ ...ts, time: ts.time + delta, fail: ts.fail + 1 })
+
 /**
  * @template T
- * @typedef {readonly[number, T]} State
+ * @typedef {readonly[TestState, T]} FullState
  */
 
-/** @type {<T>(input: Input<T>) => T} */
+/** @type {<T>(input: Input<T>) => readonly[number, T]} */
 const main = input => {
-    let { moduleMap, log, performanceNow, state } = input
+    let { moduleMap, log, measure, tryCatch, state } = input
     /** @typedef {input extends Input<infer T> ? T : never} T */
-    /** @type {(i: string) => (v: unknown) => (state: State<T>) => State<T>} */
-    const test = i => v => ([time, state]) => {
+    /** @type {(i: string) => (v: unknown) => (fs: FullState<T>) => FullState<T>} */
+    const test = i => v => ([ts, state]) => {
         const next = test(`${i}| `)
         switch (typeof v) {
             case 'function': {
                 if (v.length === 0) {
-                    let b = 0;
-                    [b, state] = performanceNow(state)
-                    const r = v()
-                    let e = 0;
-                    [e, state] = performanceNow(state)
-                    const delta = e - b
-                    time += delta
-                    state = log(`${i}() ${fgGreen}ok${reset}, ${delta} ms`)(state);
-                    [time, state] = next(r)([time, state])
+                    const [[s, r], delta, state0] = measure(() => tryCatch(/** @type {() => unknown} */(v)))(state)
+                    state = state0
+                    if (s === 'error') {
+                        ts = addFail(delta)(ts)
+                        state = log(`${i}() ${fgRed}error${reset}, ${delta} ms`)(state)
+                        state = log(`${fgRed}${r}${reset}`)(state)
+                    } else {
+                        ts = addPass(delta)(ts)
+                        state = log(`${i}() ${fgGreen}ok${reset}, ${delta} ms`)(state)
+                    }
+                    [ts, state] = next(r)([ts, state])
                 }
                 break
             }
             case 'object': {
                 if (v !== null) {
-                    /** @type {(k: readonly[string|number, unknown]) => (state: State<T>) => State<T>} */
+                    /** @type {(k: readonly[string|number, unknown]) => (fs: FullState<T>) => FullState<T>} */
                     const f = ([k, v]) => ([time, state]) => {
                         state = log(`${i}${k}:`)(state);
                         [time, state] = next(v)([time, state])
                         return [time, state]
                     }
-                    [time, state] = fold
+                    [ts, state] = fold
                         (f)
-                        ([time, state])
+                        ([ts, state])
                         (v instanceof Array ? list.entries(v) : Object.entries(v))
                 }
                 break
             }
         }
-        return [time, state]
+        return [ts, state]
     }
     const next = test('| ')
-    /** @type {(k: readonly[string, Module]) => (fs: State<T>) => State<T>} */
-    const f = ([k, v]) => ([time, state]) => {
+    /** @type {(k: readonly[string, Module]) => (fs: FullState<T>) => FullState<T>} */
+    const f = ([k, v]) => ([ts, state]) => {
         if (isTest(k)) {
             state = log(`testing ${k}`)(state);
-            [time, state] = next(v.exports)([time, state])
+            [ts, state] = next(v.exports)([ts, state])
         }
-        return [time, state]
+        return [ts, state]
     }
-    /** @type {State<T>} */
-    const init = [0, state]
-    let time = 0;
-    [time, state] = fold(f)(init)(Object.entries(moduleMap))
-    state = log(`total ${time} ms`)(state);
-    return state
+    /** @type {TestState} */
+    let ts = { time: 0, pass: 0, fail: 0 };
+    [ts, state] = fold(f)([ts, state])(Object.entries(moduleMap))
+    const fgFail = ts.fail === 0 ? fgGreen : fgRed
+    state = log(`${bold}Number of tests: pass: ${fgGreen}${ts.pass}${reset}${bold}, fail: ${fgFail}${ts.fail}${reset}${bold}, total: ${ts.pass + ts.fail}${reset}`)(state)
+    state = log(`${bold}Time: ${ts.time} ms${reset}`)(state);
+    return [ts.fail !== 0 ? 1 : 0, state]
 }
 
-module.exports = main
+module.exports = main

package/dev/test.mjs

@@ -1,13 +1,46 @@
-import { loadModuleMap } from './module.mjs'
+import { loadModuleMap, exit } from './module.mjs'
+
+const consoleLog = console.log
 
 /** @type {(s: string) => <T>(_: T) => T} */
 const log = s => state => {
-    console.log(s)
+    consoleLog(s)
     return state
 }
 
-/** @type {<T>(_: T) => readonly[number, T]} */
-const performanceNow = state => [performance.now(), state]
+/**
+ * @template T
+ * @typedef {readonly['ok', T]} Ok
+ */
+
+/**
+ * @template E
+ * @typedef {readonly['error', E]} Error
+ */
+
+/**
+ * @template T
+ * @template E
+ * @typedef {Ok<T>|Error<E>} Result
+ */
+
+/** @type {<T>(f: () => T) => Result<T, unknown>} */
+const tryCatch = f => {
+    // Side effect: `try catch` is not allowed in FunctionalScript.
+    try {
+        return ['ok', f()]
+    } catch (e) {
+        return ['error', e]
+    }
+}
+
+/** @type {<R>(f: () => R) => <T>(state: T) => readonly[R, number, T]} Measure} */
+const measure = f => state => {
+    const b = performance.now()
+    const r = f()
+    const e = performance.now()
+    return [r, e - b, state]
+}
 
 // test runner.
 const main = async() => {
@@ -15,11 +48,13 @@ const main = async() => {
 
     /** @type {any} */
     const f = moduleMap['./dev/test/module.f.cjs'].exports
-    f({
+    const r = f({
         moduleMap,
         log,
-        performanceNow,
+        measure,
+        tryCatch,
     })
+    exit(r[0])
 }
 
 main()

package/package.json

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

package/text/sgr/module.f.cjs

@@ -13,5 +13,7 @@ module.exports = {
     /** @readonly */
     bold: sgr(1),
     /** @readonly */
+    fgRed: sgr(31),
+    /** @readonly */
     fgGreen: sgr(32),
 }