functionalscript 0.0.493 → 0.0.495

package/.github/workflows/{node.js.yml → ci.yml}

@@ -1,7 +1,7 @@
 # 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
+name: CI
 
 on:
   push:
@@ -10,7 +10,7 @@ on:
   pull_request:
 
 jobs:
-  build:
+  node:
 
     runs-on: ubuntu-latest
 
@@ -29,3 +29,23 @@ jobs:
     - run: npm test
     - run: npm run version
     - run: npm pack
+
+  deno:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - uses: denoland/setup-deno@v1
+      with:
+        deno-version: v1.x
+    - run: deno run --quiet --allow-read --allow-env --allow-net --allow-hrtime ./dev/test.mjs
+
+  bun:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - run: curl https://bun.sh/install | bash
+    - run: /home/runner/.bun/bin/bun ./dev/test.mjs

package/.github/workflows/com.yml

@@ -10,7 +10,7 @@ on:
   pull_request:
 
 jobs:
-  build:
+  COM:
 
     strategy:
       matrix:

package/dev/module.mjs

@@ -78,9 +78,24 @@ 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
+
+/** @type {(v: string) => string|undefined} */
+export const env =
+    self.Deno ? self.Deno.env.get :
+    a => {
+        const r = Object.getOwnPropertyDescriptor(process.env, a)
+        return r === void 0 ? void 0 :
+            typeof r.get === 'function' ? r.get() :
+            r.value
+    }
+
 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,72 +37,102 @@ const { reset, fgGreen } = require('../../text/sgr/module.f.cjs')
  * @typedef {{
  *  readonly moduleMap: ModuleMap,
  *  readonly log: Log<T>,
- *  readonly performanceNow: PerformanceNow<T>,
+ *  readonly error: Log<T>,
+ *  readonly measure: Measure<T>,
  *  readonly state: T,
+ *  readonly tryCatch: <R>(f: () => R) => result.Result<R, unknown>,
+ *  readonly env: (n: string) => string|undefined
  * }} 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]} FullState
+ * @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, error, measure, tryCatch, env, state } = input
+    const isGitHub = env('GITHUB_ACTION') !== void 0
     /** @typedef {input extends Input<infer T> ? T : never} T */
-    /** @type {(i: string) => (v: unknown) => (fs: FullState<T>) => FullState<T>} */
-    const test = i => v => ([time, 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])
+    /** @type {(k: readonly[string, Module]) => (fs: FullState<T>) => FullState<T>} */
+    const f = ([k, v]) => {
+        /** @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) {
+                        const [[s, r], delta, state0] = measure(() => tryCatch(/** @type {() => unknown} */(v)))(state)
+                        state = state0
+                        if (s === 'error') {
+                            ts = addFail(delta)(ts)
+                            if (isGitHub) {
+                                // https://docs.github.com/en/actions/learn-github-actions/workflow-commands-for-github-actions
+                                // https://github.com/OndraM/ci-detector/blob/main/src/Ci/GitHubActions.php
+                                state = error(`::error file=${k},line=1,title=[3]['a']()::${r}`)(state)
+                            } else {
+                                state = error(`${i}() ${fgRed}error${reset}, ${delta} ms`)(state)
+                                state = error(`${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
                 }
-                break
-            }
-            case 'object': {
-                if (v !== null) {
-                    /** @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]
+                case 'object': {
+                    if (v !== null) {
+                        /** @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]
+                        }
+                        [ts, state] = fold
+                            (f)
+                            ([ts, state])
+                            (v instanceof Array ? list.entries(v) : Object.entries(v))
                     }
-                    [time, state] = fold
-                        (f)
-                        ([time, state])
-                        (v instanceof Array ? list.entries(v) : Object.entries(v))
+                    break
                 }
-                break
             }
+            return [ts, state]
         }
-        return [time, state]
-    }
-    const next = test('| ')
-    /** @type {(k: readonly[string, Module]) => (fs: FullState<T>) => FullState<T>} */
-    const f = ([k, v]) => ([time, state]) => {
-        if (isTest(k)) {
-            state = log(`testing ${k}`)(state);
-            [time, state] = next(v.exports)([time, state])
+        return ([ts, state]) => {
+            if (isTest(k)) {
+                state = log(`testing ${k}`)(state);
+                [ts, state] = test('| ')(v.exports)([ts, state])
+            }
+            return [ts, state]
         }
-        return [time, state]
     }
-    let time = 0;
-    [time, state] = fold(f)([time, state])(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,44 @@
-import { loadModuleMap } from './module.mjs'
+import { loadModuleMap, exit, env } from './module.mjs'
 
-/** @type {(s: string) => <T>(_: T) => T} */
-const log = s => state => {
-    console.log(s)
+/** @type {(f: (s: string) => void) => (s: string) => <T>(_: T) => T} */
+const anyLog = f => s => state => {
+    f(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 +46,15 @@ const main = async() => {
 
     /** @type {any} */
     const f = moduleMap['./dev/test/module.f.cjs'].exports
-    f({
+    const r = f({
         moduleMap,
-        log,
-        performanceNow,
+        log: anyLog(console.log),
+        error: anyLog(console.error),
+        measure,
+        tryCatch,
+        env,
     })
+    exit(r[0])
 }
 
 main()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.493",
+  "version": "0.0.495",
   "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),
 }

package/.github/workflows/bun.yml

@@ -1,17 +0,0 @@
-name: bun
-
-on:
-  push:
-    branches:
-    - master
-  pull_request:
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v2
-    - run: curl https://bun.sh/install | bash
-    - run: /home/runner/.bun/bin/bun ./dev/test.mjs

package/.github/workflows/deno.yml

@@ -1,19 +0,0 @@
-name: deno
-
-on:
-  push:
-    branches:
-    - master
-  pull_request:
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v2
-    - uses: denoland/setup-deno@v1
-      with:
-        deno-version: v1.x
-    - run: deno run --allow-read --allow-env --allow-net --allow-hrtime ./dev/test.mjs