functionalscript 0.0.421 → 0.0.422

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 ./denotest.mjs
+    - run: deno run --allow-read --allow-env ./denotest.mjs

package/denotest.mjs

@@ -1,7 +1,13 @@
+// import * as fs from "https://deno.land/std/node/fs.ts"
+
+/**
+ * @type {{
+ *  readonly readDir: (path: string | URL) => AsyncIterable<DirEntry>,
+ *  readonly readTextFile: (path: string | URL) => Promise<string>,
+ * }}
+ */
 const {
-    /** @type {(path: string | URL) => AsyncIterable<DirEntry>} */
     readDir,
-    /** @type {(path: string | URL) => Promise<string>} */
     readTextFile,
 } = Deno
 
@@ -39,7 +45,7 @@ const dir = async p => {
                         await f(file)
                     }
                 } else if (name.endsWith('.f.cjs')) {
-                    // console.log(name)
+                    console.log(`loading ${file}`)
                     const source = await readTextFile(file)
                     map[file] = Function('module', 'require', `"use strict";${source}`)
                 }
@@ -60,19 +66,20 @@ const run = async () => {
     const m = await dir('.')
     /** @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}`)
+            m[pathStr](me, req(newBase)(`${i}| `))
             const newResult = me.exports
             d[pathStr] = newResult
             return newResult
@@ -80,7 +87,7 @@ const run = async () => {
             return result
         }
     }
-    const r = req(['.'])
+    const r = req(['.'])('')
     for (const k of Object.keys(m)) {
         r(k)
     }

package/package.json

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

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 */