functionalscript 0.0.438 → 0.0.440

package/.github/workflows/{node-pack.yml → com.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 & pack
+name: COM Test
 
 on:
   push:
@@ -12,15 +12,17 @@ on:
 jobs:
   build:
 
-    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        os: ['ubuntu-latest', 'windows-latest', 'macos-12']
+
+    runs-on: ${{ matrix.os }}
 
     steps:
     - uses: actions/checkout@v2
-    - name: Use Node.js
+    - name: Use Node.js 19
       uses: actions/setup-node@v2
       with:
-        node-version: 18
+        node-version: 19
     - run: npm ci
-    - run: npm test
-    - run: npm run version
-    - run: npm pack
+    - run: node ./com/test/build.cjs

package/.github/workflows/node.js.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 install
+name: node CI
 
 on:
   push:
@@ -16,7 +16,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [16.x, 18.x]
+        node-version: [16.x, 18.x, 19.x]
         # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
 
     steps:
@@ -25,7 +25,7 @@ jobs:
       uses: actions/setup-node@v2
       with:
         node-version: ${{ matrix.node-version }}
-    - run: npm install
+    - run: npm ci
     - run: npm test
     - run: npm run version
     - run: npm pack

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

@@ -14,7 +14,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-node@v2
         with:
-          node-version: 18
+          node-version: 19
       - run: npm ci
       - run: npm test
 
@@ -27,7 +27,7 @@ jobs:
           fetch-depth: 0
       - uses: actions/setup-node@v2
         with:
-          node-version: 18
+          node-version: 19
           registry-url: https://registry.npmjs.org/
       - run: npm ci
       - run: npm run version

package/com/cpp/com.hpp

@@ -3,7 +3,7 @@
 #include <cstdint>
 #include <cstddef>
 
-#if defined(__aarch64__)
+#if defined(__aarch64__) || defined(__amd64__)
 #define COM_STDCALL
 #elif defined(__clang__)
 #define COM_STDCALL __attribute__((stdcall))

package/com/cpp/module.f.cjs

@@ -82,7 +82,7 @@ const cpp = name => lib => {
 
     const e = entries(lib)
 
-    return list.flat([
+    return flat([
         ['#pragma once', ''],
         namespace(name)(flat([flatMap(forward)(e), flatMap(def)(e)]))
     ])

package/com/test/build.cjs

@@ -1,37 +1,32 @@
-const fs = require('node:fs')
-const cp = require('node:child_process')
-const os = require('node:os');
-const cpp = require('../cpp/test.f.cjs').result
-const { string: { join }, list: { flat } } = require('../../types/module.f.cjs')
+const { writeFileSync } = require('node:fs')
+const { execSync } = require('node:child_process')
+const { platform } = require('node:process')
+const build = require('./build.f.cjs')
+const { cpp, cs, rust } = build
+const { join } = require('../../types/string/module.f.cjs')
+const { log, error } = console
+const { bold, reset } = require('../../text/sgr/module.f.cjs')
 
-const dirname = __dirname
-
-fs.writeFileSync(`${dirname}/cpp/_result.hpp`, cpp)
-try {
-    const flags = os.platform() === 'win32' ? [] : ['-std=c++11', '-lc++']
-    const line = join(' ')(flat([['clang'], flags, [dirname + '/cpp/main.cpp']]))
-    console.log(cp.execSync(line).toString())
-} catch (e) {
-    // @ts-ignore
-    console.error(e.output.toString())
+const nodeJs = {
+    dirname: __dirname,
+    platform,
 }
 
-const cs = require('../cs/test.f.cjs').result
-
-fs.writeFileSync(`${dirname}/cs/_result.cs`, cs)
-try {
-    console.log(cp.execSync(`dotnet build ${dirname}/cs/cs.csproj`).toString())
-} catch (e) {
-    // @ts-ignore
-    console.error(e.output.toString())
+/** @type {(f: build.Func) => void} */
+const run = f => {
+    const { file: { name, content }, line } = f(nodeJs)
+    log(`${bold}writing: ${name}${reset}`)
+    writeFileSync(name, content)
+    const cmd = join(' ')(line)
+    log(`${bold}running: ${cmd}${reset}`)
+    try {
+        log(execSync(cmd).toString())
+    } catch (e) {
+        // @ts-ignore
+        error(e.output.toString())
+    }
 }
 
-const rust = require("../rust/test.f.cjs").result();
-
-fs.writeFileSync(`${dirname}/rust/src/_result.rs`, rust);
-try {
-    console.log(cp.execSync("cargo build").toString());
-} catch (e) {
-    // @ts-ignore
-    console.error(e.output.toString());
-}
+run(cpp)
+run(cs)
+run(rust)

package/com/test/build.f.cjs

@@ -0,0 +1,93 @@
+const list = require('../../types/list/module.f.cjs')
+const { flat } = list
+
+const cppContent = require('../cpp/test.f.cjs').result
+const csContent = require('../cs/test.f.cjs').result
+const rustContent = require("../rust/test.f.cjs").result();
+
+/**
+ * @typedef {|
+ *  'aix' |
+ *  'android' |
+ *  'darwin' |
+ *  'freebsd' |
+ *  'haiku' |
+ *  'linux' |
+ *  'openbsd' |
+ *  'sunos' |
+ *  'win32' |
+ *  'cygwin' |
+ *  'netbsd'
+ * } Platform
+ */
+
+/**
+ * @typedef {{
+ *  readonly dirname: string
+ *  readonly platform: Platform
+ * }} NodeJs
+ */
+
+/**
+ * @typedef {{
+ *  readonly file: {
+ *      readonly name: string
+ *      readonly content: string
+ *  }
+ *  readonly line: list.List<string>
+ * }} Output
+ */
+
+/** @typedef {(nodejs: NodeJs) => Output} Func */
+
+/** @type {(platform: Platform) => readonly string[]} */
+const flags = platform => {
+    switch (platform) {
+        case 'win32':
+            return []
+        case 'linux':
+            return ['-lstdc++']
+        default:
+            return ['-std=c++11', '-lc++']
+    }
+}
+
+/** @type {Func} */
+const cpp = ({dirname, platform}) => ({
+    file: {
+        name: `${dirname}/cpp/_result.hpp`,
+        content: cppContent,
+    },
+    line: flat([
+        ['clang'],
+        flags(platform),
+        [`${dirname}/cpp/main.cpp`]]
+    ),
+})
+
+/** @type {Func} */
+const cs = ({dirname}) => ({
+    file: {
+        name: `${dirname}/cs/_result.cs`,
+        content: csContent,
+    },
+    line: ['dotnet', 'build', `${dirname}/cs/cs.csproj`],
+})
+
+/** @type {Func} */
+const rust = ({dirname}) => ({
+    file: {
+        name: `${dirname}/rust/src/_result.rs`,
+        content: rustContent,
+    },
+    line: ['cargo', 'build']
+})
+
+module.exports = {
+    /** @readonly */
+    cpp,
+    /** @readonly */
+    cs,
+    /** @readonly */
+    rust,
+}

package/com/test/rust/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "testrust"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+nanocom = { path = "../../rust/nanocom" }

package/com/test/rust/src/lib.rs

@@ -0,0 +1 @@
+mod _result;

package/dev/test/module.f.cjs

@@ -1,5 +1,6 @@
 const list = require('../../types/list/module.f.cjs')
 const { fold } = list
+const { reset, fgGreen } = require('../../text/sgr/module.f.cjs')
 
 /**
  * @typedef {{
@@ -34,17 +35,6 @@ 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')
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.438",
+  "version": "0.0.440",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "module.f.cjs",
   "scripts": {
@@ -29,7 +29,7 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@types/node": "^18.8.4",
+    "@types/node": "^18.11.2",
     "typescript": "^4.8.4"
   }
 }

package/text/sgr/module.f.cjs

@@ -0,0 +1,17 @@
+/**
+ * https://en.wikipedia.org/wiki/ANSI_escape_code#SGR
+ *
+ * @type {(c: number) => string}
+ */
+const sgr = c => `\x1b[${c.toString()}m`
+
+module.exports = {
+    /** @readonly */
+    sgr,
+    /** @readonly */
+    reset: sgr(0),
+    /** @readonly */
+    bold: sgr(1),
+    /** @readonly */
+    fgGreen: sgr(32),
+}

package/types/list/module.f.cjs

@@ -294,16 +294,18 @@ const zip = a => b => () => {
     return { first: [aResult.first, bResult.first], tail: zip(aResult.tail)(bResult.tail) }
 }
 
-/** @type {<T>(e: operator.Equal<T>) => (a: List<T>) => (b: List<T>) => List<boolean>} */
-const equalZip = e => a => b => () => {
-    const [aResult, bResult] = [next(a), next(b)]
-    return aResult === undefined || bResult === undefined
-        ? { first: aResult === bResult, tail: undefined }
-        : { first: e(aResult.first)(bResult.first), tail: equalZip(e)(aResult.tail)(bResult.tail) }
-}
-
 /** @type {<T>(e: operator.Equal<T>) => (a: List<T>) => (b: List<T>) => boolean} */
-const equal = e => a => b => every(equalZip(e)(a)(b))
+const equal = e => {
+    /** @typedef {typeof e extends operator.Equal<infer T> ? T : never} T */
+    /** @type {(a: List<T>) => (b: List<T>) => List<boolean>} */
+    const f = a => b => () => {
+        const [aResult, bResult] = [next(a), next(b)]
+        return aResult === undefined || bResult === undefined
+            ? { first: aResult === bResult, tail: undefined }
+            : { first: e(aResult.first)(bResult.first), tail: f(aResult.tail)(bResult.tail) }
+    }
+    return a => b => every(f(a)(b))
+}
 
 module.exports = {
     /** @readonly */

package/types/sorted_list/module.f.cjs

@@ -1,7 +1,8 @@
-const compare = require("../function/compare/module.f.cjs")
-const list = require("../list/module.f.cjs")
-const option = require("../option/module.f.cjs")
+const compare = require('../function/compare/module.f.cjs')
+const list = require('../list/module.f.cjs')
+const option = require('../option/module.f.cjs')
 const { next } = list
+const { identity } = require('../function/module.f.cjs')
 
 /**
  * @template T
@@ -13,55 +14,74 @@ const { next } = list
  * @typedef {(a: T) => (b: T) => compare.Sign} Cmp
  */
 
-/** @typedef {number} Byte */
-
 /**
  * @template T
- * @typedef {SortedList<[Byte, readonly string[]]>} RangeMap
+ * @typedef {SortedList<[T, number]>} RangeMap
  */
 
 /**
- * @template S
  * @template T
+ * @template S
  * @typedef {(state: S) => (a: T) => (b: T) => readonly[option.Option<T>, compare.Sign, S]} ReduceOp
  */
 
 /**
- * @template S
  * @template T
+ * @template S
  * @typedef {(state: S) => (tail: list.List<T>) => list.List<T>} TailReduce
  */
 
 /**
+ * @template T
  * @template S
+  * @typedef {{
+ *  readonly reduceOp: ReduceOp<T,S>
+ *  readonly tailReduce: TailReduce<T,S>
+  * }} MergeReduce
+ */
+
+/** @type {<T,S>(reduce: MergeReduce<T,S>) => (state: S) => (a: list.List<T>) => (b: list.List<T>) => list.List<T>} */
+const genericMerge = reduce => {
+    const { reduceOp, tailReduce } = reduce
+    /** @typedef {typeof reduce extends MergeReduce<infer T, infer S> ? [T, S] : never} TS */
+    /** @typedef {TS[0]} T */
+    /** @typedef {TS[1]} S */
+    /** @type {(state: S) => (a: list.List<T>) => (b: list.List<T>) => list.List<T>} */
+    const f = state => a => b => () => {
+        const aResult = next(a)
+        if (aResult === undefined) { return tailReduce(state)(b) }
+        const bResult = next(b)
+        if (bResult === undefined) { return tailReduce(state)(a) }
+        const [first, sign, stateNext] = reduceOp(state)(aResult.first)(bResult.first)
+        const aNext = sign === 1 ? a : aResult.tail
+        const bNext = sign === -1 ? b : bResult.tail
+        const tail = f(stateNext)(aNext)(bNext)
+        return first === undefined ? tail : { first, tail }
+    }
+    return f
+}
+
+/**
  * @template T
- * @typedef {(init: S) => (reduce: ReduceOp<S,T>) => (tailReduce: TailReduce<S, T>) => (a: list.List<T>) => (b: list.List<T>) => list.List<T>} GenericMerge
+ * @typedef {ReduceOp<T, undefined>} CmpReduceOp
  */
 
 /** @type {<T>(cmp: Cmp<T>) => (a: SortedList<T>) => (b: SortedList<T>) => SortedList<T>} */
-const merge = cmp => genericMerge(undefined)(cmpReduce(cmp))(mergeTail)
+const merge = cmp => {
+    /** @typedef {typeof cmp extends Cmp<infer T> ? T : never} T*/
+    /** @type {TailReduce<T, undefined>} */
+    const tailReduce = mergeTail
+    return genericMerge({ reduceOp: cmpReduce(cmp), tailReduce })(undefined)
+}
 
-/** @type {<S,T>(cmp: Cmp<T>) => ReduceOp<S, T>} */
-const cmpReduce = cmp => state => a => b => {
+/** @type {<T>(cmp: Cmp<T>) => CmpReduceOp<T>} */
+const cmpReduce = cmp => () => a => b => {
     const sign = cmp(a)(b)
-    return [sign === 1 ? b : a, sign, state]
+    return [sign === 1 ? b : a, sign, undefined]
 }
 
-/** @type {<S,T>(state: S) => (tail: list.List<T>) => list.List<T>} */
-const mergeTail = s => input => input
-
-/** @type {<S,T>(init: S) => (reduce: ReduceOp<S,T>) => (tailReduce: TailReduce<S, T>) => (a: list.List<T>) => (b: list.List<T>) => list.List<T>} */
-const genericMerge = init => reduce => tailReduce => a => b => () => {
-    const aResult = next(a)
-    if (aResult === undefined) { return tailReduce(init)(b) }
-    const bResult = next(b)
-    if (bResult === undefined) { return tailReduce(init)(a) }
-    const [result, sign, state] = reduce(init)(aResult.first)(bResult.first)
-    const aNext = sign === 1 ? a : aResult.tail
-    const bNext = sign === -1 ? b : bResult.tail
-    const mergeNext = genericMerge(state)(reduce)(tailReduce)(aNext)(bNext)
-    return result === undefined ? mergeNext : { first: result, tail: mergeNext }
-}
+/** @type {() => <T>(tail: list.List<T>) => list.List<T>} */
+const mergeTail = () => identity
 
 module.exports = {
     /** @readonly */

package/types/sorted_set/module.f.cjs

@@ -24,16 +24,15 @@ const union = cmp => a => b => toArray(merge(cmp)(a)(b))
 const intersect = cmp => a => b => toArray(intersectMerge(cmp)(a)(b))
 
 /** @type {<T>(cmp: Cmp<T>) => (a: sortedList.SortedList<T>) => (b: sortedList.SortedList<T>) => sortedList.SortedList<T>} */
-const intersectMerge = cmp => genericMerge(undefined)(intersectReduce(cmp))(intersectTail)
+const intersectMerge = cmp => genericMerge({ reduceOp: intersectReduce(cmp), tailReduce: intersectTail })(undefined)
 
-/** @type {<S,T>(cmp: Cmp<T>) => sortedList.ReduceOp<S, T>} */
+/** @type {<T,S>(cmp: Cmp<T>) => sortedList.ReduceOp<T,S>} */
 const intersectReduce = cmp => state => a => b => {
     const sign = cmp(a)(b)
     return [sign === 0 ? a : undefined, sign, state]
 }
 
-/** @type {<S,T>(state: S) => (tail: list.List<T>) => list.List<T>} */
-const intersectTail = s => input => undefined
+const intersectTail = () => () => undefined
 
 module.exports = {
     /** @readonly */