functionalscript 0.0.420 → 0.0.423

package/.github/workflows/bun.yml

@@ -12,4 +12,4 @@ jobs:
     steps:
     - uses: actions/checkout@v2
     - run: curl https://bun.sh/install | bash
-    - run: /home/runner/.bun/bin/bun ./test.f.cjs
+    - run: /home/runner/.bun/bin/bun ./test.mjs

package/.github/workflows/deno.yml

@@ -14,4 +14,4 @@ jobs:
     - uses: denoland/setup-deno@v1
       with:
         deno-version: v1.x
-    - run: deno run --allow-read ./deno-test
+    - run: deno run --allow-read --allow-env --allow-net ./test.mjs

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "functionalscript",
-  "version": "0.0.420",
+  "version": "0.0.423",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "module.f.cjs",
   "scripts": {
     "tsc": "tsc",
     "test": "tsc && npm run test-only",
     "version": "node ./nodejs/version/main.cjs",
-    "test-only": "node --trace-uncaught ./test.f.cjs"
+    "test-only": "node --trace-uncaught ./test.mjs"
   },
   "repository": {
     "type": "git",

package/{deno-test → test.mjs}

@@ -1,78 +1,86 @@
-const {
-    /** @type {(path: string | URL) => AsyncIterable<DirEntry>} */
-    readDir,
-    /** @type {(path: string | URL) => Promise<string>} */
-    readTextFile,
-} = Deno
+/**
+ * @typedef {{
+ *  readonly withFileTypes: true
+ * }} Options
+ */
 
 /**
  * @typedef {{
- *  readonly isDirectory: boolean
- *  readonly isFile: boolean
- *  readonly isSymlink: boolean
  *  readonly name: string
- * }} DirEntry
+ *  readonly isDirectory: () => boolean
+ * }} Dirent
  */
 
-/** @typedef {{ exports?: unknown }} Module */
-
-/** @typedef {(name: string) => unknown} Require */
-
 /**
  * @typedef {{
- *  [k in string]: Function
- * }} FunctionMap
+ *  readonly readdir: (path: string, options: Options) => Promise<readonly Dirent[]>
+ *  readonly readFile: (path: string, options: 'utf8') => Promise<Buffer>
+ * }} FsPromises
  */
 
-/** @type {(path: string) => Promise<FunctionMap>} */
-const dir = async p => {
+/** @type {FsPromises} */
+const { readdir, readFile } = await import(globalThis.Deno ? 'https://deno.land/std/node/fs/promises.ts' : 'node:fs/promises')
+
+const load = async() => {
     /** @type {FunctionMap} */
     const map = {}
     /** @type {(path: string) => Promise<void>} */
     const f = async p => {
-        for await (const i of readDir(p)) {
+        for (const i of await readdir(p, { withFileTypes: true })) {
             const { name } = i
             if (!name.startsWith('.')) {
                 const file = `${p}/${name}`
-                if (i.isDirectory) {
+                if (i.isDirectory()) {
                     if (!['node_modules', 'target'].includes(name)) {
                         await f(file)
                     }
                 } else if (name.endsWith('.f.cjs')) {
-                    // console.log(name)
-                    const source = await readTextFile(file)
+                    console.log(`loading ${file}`)
+                    const source = await readFile(file, 'utf8')
                     map[file] = Function('module', 'require', `"use strict";${source}`)
                 }
             }
         }
     }
-    await f(p)
+    await f('.')
     return map
 }
 
+const map = await load()
+
+/** @typedef {{ exports?: unknown }} Module */
+
+/** @typedef {(name: string) => unknown} Require */
+
+/**
+ * @typedef {{
+ *  [k in string]: Function
+ * }} FunctionMap
+ */
+
 /**
  * @typedef {{
  *  [k in string]: unknown
  * }} ModuleMap
  */
 
-const run = async () => {
-    const m = await dir('.')
+const build = async () => {
     /** @type {ModuleMap} */
     const d = {}
-    /** @type {(base: readonly string[]) => (k: string) => unknown} */
-    const req = p => k => {
+    /** @type {(base: readonly string[]) => (i: string) => (k: string) => unknown} */
+    const req = p => i => k => {
         const relativePath = k.split('/')
-        const bPath = relativePath.filter(v => !['..', '.'].includes(v))
         const dif = relativePath.filter(v => v === '..').length
-        const path = [p.slice(0, p.length - dif), bPath.slice(0, bPath.length)].flat()
+        const path = [p.slice(0, p.length - dif), relativePath.filter(v => !['..', '.'].includes(v))]
+            .flat()
         const pathStr = path.join('/')
         const newBase = path.slice(0, path.length - 1)
         const result = d[pathStr]
         if (result === undefined) {
             /** @type {Module} */
             const me = {}
-            m[pathStr](me, req(newBase))
+            console.log(`${i}building ${pathStr}`)
+            map[pathStr](me, req(newBase)(`${i}| `))
             const newResult = me.exports
             d[pathStr] = newResult
             return newResult
@@ -80,10 +88,11 @@ const run = async () => {
             return result
         }
     }
-    const r = req(['.'])
-    for (const k of Object.keys(m)) {
+    const r = req(['.'])('')
+    for (const k of Object.keys(map)) {
         r(k)
     }
+    return d
 }
 
-run()
+const modules = await build()

package/text/utf16/module.f.cjs

@@ -1,9 +1,8 @@
 const list = require('../../types/list/module.f.cjs')
 const operator = require('../../types/function/operator/module.f.cjs')
-const array = require('../../types/array/module.f.cjs')
 const { contains } = require('../../types/range/module.f.cjs')
-const { compose } = require('../../types/function/module.f.cjs')
-const { map, flat, stateScan, concat, reduce, flatMap } = list
+const { fn } = require('../../types/function/module.f.cjs')
+const { map, flat, stateScan, reduce, flatMap } = list
 
 /** @typedef {u16|undefined} WordOrEof */
 
@@ -13,48 +12,57 @@ const { map, flat, stateScan, concat, reduce, flatMap } = list
 
 /** @typedef {number} i32 */
 
-/** @type {(a:number) => boolean} */
-const isBmpCodePoint = a => a >= 0x0000 && a <= 0xd7ff || a >= 0xe000 && a <= 0xffff
+const lowBmp = contains([0x0000, 0xd7ff])
+const highBmp = contains([0xe000, 0xffff])
 
+/** @type {(codePoint: i32) => boolean} */
+const isBmpCodePoint = codePoint => lowBmp(codePoint) || highBmp(codePoint)
+
+/** @type {(codePoint: i32) => boolean} */
 const isHighSurrogate = contains([0xd800, 0xdbff])
 
-/** @type {(a:number) => boolean} */
+/** @type {(codePoint: i32) => boolean} */
 const isLowSurrogate = contains([0xdc00, 0xdfff])
 
 const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000
 
-/** @type {(input:i32) => list.List<u16>} */
-const codePointToUtf16 = input =>
-{
-    if (isBmpCodePoint(input)) { return [input] }
-    if (input >= 0x010000 && input <= 0x10ffff) {
-        const high = ((input - 0x10000) >> 10) + 0xd800
-        const low = ((input - 0x10000) & 0b0011_1111_1111) + 0xdc00
+/** @type {(a: i32) => boolean} */
+const isSupplementaryPlane = contains([0x01_0000, 0x10_ffff])
+
+/** @type {(input: i32) => list.List<u16>} */
+const codePointToUtf16 = codePoint => {
+    if (isBmpCodePoint(codePoint)) { return [codePoint] }
+    if (isSupplementaryPlane(codePoint)) {
+        const n = codePoint - 0x1_0000
+        const high = (n >> 10) + 0xd800
+        const low = (n & 0b0011_1111_1111) + 0xdc00
         return [high, low]
     }
-    return [input & 0xffff]
+    return [codePoint & 0xffff]
 }
 
 const fromCodePointList = flatMap(codePointToUtf16)
 
+const u16 = contains([0x0000, 0xFFFF])
+
 /** @type {operator.StateScan<u16, Utf16State, list.List<i32>>} */
-const utf16ByteToCodePointOp = state => byte => {
-    if (byte < 0x00 || byte > 0xffff) {
+const utf16ByteToCodePointOp = state => word => {
+    if (!u16(word)) {
         return [[0xffffffff], state]
     }
     if (state === undefined) {
-        if (isBmpCodePoint(byte)) { return [[byte], undefined] }
-        if (isHighSurrogate(byte)) { return [[], byte] }
-        return [[byte | errorMask], undefined]
+        if (isBmpCodePoint(word)) { return [[word], undefined] }
+        if (isHighSurrogate(word)) { return [[], word] }
+        return [[word | errorMask], undefined]
     }
-    if (isLowSurrogate(byte)) {
+    if (isLowSurrogate(word)) {
         const high = state - 0xd800
-        const low = byte - 0xdc00
+        const low = word - 0xdc00
         return [[(high << 10) + low + 0x10000], undefined]
     }
-    if (isBmpCodePoint(byte)) { return [[state | errorMask, byte], undefined] }
-    if (isHighSurrogate(byte)) { return [[state | errorMask], byte] }
-    return [[state | errorMask, byte | errorMask], undefined]
+    if (isBmpCodePoint(word)) { return [[state | errorMask, word], undefined] }
+    if (isHighSurrogate(word)) { return [[state | errorMask], word] }
+    return [[state | errorMask, word | errorMask], undefined]
 }
 
 /** @type {(state: Utf16State) => readonly[list.List<i32>, Utf16State]} */
@@ -63,8 +71,11 @@ const utf16EofToCodePointOp = state => [state === undefined ? undefined : [state
 /** @type {operator.StateScan<WordOrEof, Utf16State, list.List<i32>>} */
 const utf16ByteOrEofToCodePointOp = state => input => input === undefined ? utf16EofToCodePointOp(state) : utf16ByteToCodePointOp(state)(input)
 
+/** @type {list.List<WordOrEof>} */
+const eofList = [undefined]
+
 /** @type {(input: list.List<u16>) => list.List<i32>} */
-const toCodePointList = input => flat(stateScan(utf16ByteOrEofToCodePointOp)(undefined)(concat(/** @type {list.List<WordOrEof>} */(input))([undefined])))
+const toCodePointList = input => flat(stateScan(utf16ByteOrEofToCodePointOp)(undefined)(flat([input, eofList])))
 
 /** @type {(s: string) => list.List<u16>} */
 const stringToList = s => {
@@ -76,7 +87,10 @@ const stringToList = s => {
     return at(0)
 }
 
-const listToString = compose(map(String.fromCharCode))(reduce(operator.concat)(''))
+/** @type {(input: list.List<u16>) => string} */
+const listToString = fn(map(String.fromCharCode))
+    .then(reduce(operator.concat)(''))
+    .result
 
 module.exports = {
     /** @readonly */

package/text/utf8/module.f.cjs

@@ -1,7 +1,7 @@
 const list = require('../../types/list/module.f.cjs')
 const operator = require('../../types/function/operator/module.f.cjs')
 const array = require('../../types/array/module.f.cjs')
-const { flatMap } = list
+const { flatMap, flat, stateScan } = list
 
 /** @typedef {u8|undefined} ByteOrEof */
 
@@ -16,8 +16,7 @@ const { flatMap } = list
 const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000
 
 /** @type {(input:number) => list.List<u8>} */
-const codePointToUtf8 = input =>
-{
+const codePointToUtf8 = input => {
     if (input >= 0x0000 && input <= 0x007f) { return [input & 0b01111_1111] }
     if (input >= 0x0080 && input <= 0x07ff) { return [input >> 6 | 0b1100_0000, input & 0b0011_1111 | 0b1000_0000] }
     if (input >= 0x0800 && input <= 0xffff) { return [input >> 12 | 0b1110_0000, input >> 6 & 0b0011_1111 | 0b1000_0000, input & 0b0011_1111 | 0b1000_0000] }
@@ -35,9 +34,9 @@ const fromCodePointList = flatMap(codePointToUtf8)
 
 /** @type {(state: Utf8NonEmptyState) => i32}*/
 const utf8StateToError = state => {
-    switch(state.length) {
+    switch (state.length) {
         case 1:
-             return state[0] | errorMask
+            return state[0] | errorMask
         case 2:
             if (state[0] < 0b1111_0000) return (((state[0] & 0b0000_1111) << 6) + (state[1] & 0b0011_1111) + 0b0000_0100_0000_0000) | errorMask
             return (((state[0] & 0b0000_0111) << 6) + (state[1] & 0b0011_1111) + 0b0000_0010_0000_0000) | errorMask
@@ -57,7 +56,7 @@ const utf8ByteToCodePointOp = state => byte => {
         return [[byte | errorMask], undefined]
     }
     if (byte >= 0b1000_0000 && byte < 0b1100_0000) {
-        switch(state.length) {
+        switch (state.length) {
             case 1:
                 if (state[0] < 0b1110_0000) { return [[((state[0] & 0b0001_1111) << 6) + (byte & 0b0011_1111)], undefined] }
                 if (state[0] < 0b1111_1000) { return [[], [state[0], byte]] }
@@ -85,8 +84,11 @@ const utf8EofToCodePointOp = state => {
 /** @type {operator.StateScan<ByteOrEof, Utf8State, list.List<i32>>} */
 const utf8ByteOrEofToCodePointOp = state => input => input === undefined ? utf8EofToCodePointOp(state) : utf8ByteToCodePointOp(state)(input)
 
+/** @type {list.List<ByteOrEof>} */
+const eofList = [undefined]
+
 /** @type {(input: list.List<u8>) => list.List<i32>} */
-const toCodePointList = input => list.flat(list.stateScan(utf8ByteOrEofToCodePointOp)(undefined)(list.concat(/** @type {list.List<ByteOrEof>} */(input))([undefined])))
+const toCodePointList = input => flat(stateScan(utf8ByteOrEofToCodePointOp)(undefined)(flat([input, eofList])))
 
 module.exports = {
     /** @readonly */

package/tsconfig.json

@@ -97,5 +97,5 @@
     // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
     "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
   },
-  "exclude": ["target"]
+  "exclude": ["target", "test.mjs"]
 }