functionalscript 0.11.5 → 0.11.7

package/io/module.f.js

@@ -53,14 +53,16 @@ export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readF
             .map(v => ({ name: v.name, parentPath: normalize(v.parentPath), isFile: v.isFile() }))),
         writeFile: ([path, data]) => tc(() => writeFile(path, fromVec(data))),
         createServer: async (requestListener) => {
+            const erl = requestListener;
             const nodeRl = async (req, res) => {
+                const reqBody = await collect(req);
                 const { method, url, headers } = req;
-                const { status, headers: outHeaders, body: outBody } = requestListener({
+                const { status, headers: outHeaders, body: outBody } = await result(erl({
                     method,
                     url,
                     headers,
-                    body: listToVec(await collect(req))
-                });
+                    body: listToVec(reqBody)
+                }));
                 res
                     .writeHead(status, outHeaders)
                     .end(fromVec(outBody));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.11.5",
+  "version": "0.11.7",
   "type": "module",
   "files": [
     "**/*.js",

package/types/bit_vec/module.f.d.ts

@@ -169,7 +169,7 @@ export declare const msb: BitOrder;
  * @param list The list of unsigned 8-bit integers to be converted.
  * @returns The resulting vector based on the provided bit order.
  */
-export declare const u8ListToVec: (bo: BitOrder) => (list: List<number>) => Vec;
+export declare const u8ListToVec: ({ concat }: BitOrder) => (list: List<number>) => Vec;
 /**
  * Converts a bit vector to a list of unsigned 8-bit integers based on the provided bit order.
  *

package/types/bit_vec/module.f.js

@@ -23,7 +23,7 @@
  */
 import { bitLength, mask, max, min, xor } from "../bigint/module.f.js";
 import { flip } from "../function/module.f.js";
-import { fold } from "../list/module.f.js";
+import { entries, fold, iterable } from "../list/module.f.js";
 import { asBase, asNominal } from "../nominal/module.f.js";
 import { repeat as mRepeat } from "../monoid/module.f.js";
 import { cmp } from "../function/compare/module.f.js";
@@ -169,7 +169,6 @@ export const msb = {
     concat: flip(lsb.concat),
     xor: op(msbNorm)(xor)
 };
-const appendU8 = ({ concat }) => (u8) => (a) => concat(a)(vec8(BigInt(u8)));
 /**
  * Converts a list of unsigned 8-bit integers to a bit vector using the provided bit order.
  *
@@ -177,7 +176,34 @@ const appendU8 = ({ concat }) => (u8) => (a) => concat(a)(vec8(BigInt(u8)));
  * @param list The list of unsigned 8-bit integers to be converted.
  * @returns The resulting vector based on the provided bit order.
  */
-export const u8ListToVec = (bo) => fold(appendU8(bo))(empty);
+export const u8ListToVec = ({ concat }) => (list) => {
+    // much faster than: `fold(appendU8(bo))(empty)(list)`
+    // where `appendU8` is defined as
+    // ```
+    // const appendU8 = ({ concat }: BitOrder) => (u8: number) => (a: Vec) =>
+    //    concat(a)(vec8(BigInt(u8)))
+    // ```
+    let result = [];
+    for (const b of iterable(list)) {
+        let v = vec8(BigInt(b));
+        let i = 0;
+        while (true) {
+            if (result.length <= i) {
+                result = [...result, v];
+                break;
+            }
+            const old = result[i];
+            if (old === empty) {
+                result = result.toSpliced(i, 1, v);
+                break;
+            }
+            result = result.toSpliced(i, 1, empty);
+            v = concat(old)(v);
+            i++;
+        }
+    }
+    return result.reduce((p, c) => concat(c)(p), empty);
+};
 /**
  * Converts a bit vector to a list of unsigned 8-bit integers based on the provided bit order.
  *

package/types/bit_vec/test.f.d.ts

@@ -38,5 +38,6 @@ declare const _default: {
     msbXor: () => void;
     repeat: () => void;
     msbCmp: () => void;
+    u8ListToVec: () => void;
 };
 export default _default;

package/types/bit_vec/test.f.js

@@ -1,6 +1,7 @@
 import { mask } from "../bigint/module.f.js";
 import { asBase, asNominal } from "../nominal/module.f.js";
-import { length, empty, uint, vec, lsb, msb, repeat, vec8, msbCmp } from "./module.f.js";
+import { length, empty, uint, vec, lsb, msb, repeat, vec8, msbCmp, u8ListToVec } from "./module.f.js";
+import { repeat as listRepeat } from "../list/module.f.js";
 const unsafeVec = (a) => asNominal(a);
 // 0x8 = 0b1000 = 0 + 8
 // 0x9 = 0b1001 = 1 + 8
@@ -442,5 +443,9 @@ export default {
         c(vec(4n)(0x5n))(vec(5n)(0x5n))(1); // 0b0101_ < 0b00101
         c(vec(5n)(0x5n))(vec(4n)(0x5n))(-1); // 0b00101 < 0b0101_
         c(vec(4n)(0x5n))(vec(5n)(0xan))(-1); // 0b0101_ < 0b01010
+    },
+    u8ListToVec: () => {
+        // 131_072 is too much for Bun
+        const x = u8ListToVec(msb)(listRepeat(0x12)(131_071));
     }
 };

package/types/effects/node/module.f.d.ts

@@ -62,9 +62,9 @@ export type ServerResponse = {
     readonly headers: Headers;
     readonly body: Vec;
 };
-export type RequestListener = (_: IncomingMessage) => ServerResponse;
-export type CreateServer = ['createServer', (_: RequestListener) => Server];
-export declare const createServer: Func<CreateServer>;
+export type RequestListener<O extends Operation> = (_: IncomingMessage) => Effect<O, ServerResponse>;
+export type CreateServer = ['createServer', (_: RequestListener<Operation>) => Server];
+export declare const createServer: <O extends Operation>(listener: RequestListener<O>) => Effect<O | CreateServer, Server>;
 export type Listen = ['listen', (_: readonly [Server, number]) => void];
 export declare const listen: RestFunc<Listen>;
 export type Http = CreateServer | Listen;

package/types/effects/node/module.f.js

@@ -1,4 +1,5 @@
 import { doRest, do_ } from "../module.f.js";
+const doAll = do_('all');
 /**
  * To run the operation `O` should be known by the runner/engine.
  * This is the reason why we merge `O` with `All` in the resulted `Effect`.
@@ -6,7 +7,7 @@ import { doRest, do_ } from "../module.f.js";
  * @param a
  * @returns
  */
-export const all = (...a) => do_('all')(a);
+export const all = (...a) => doAll(a);
 export const both = (a) => (b) => all(a, b);
 export const fetch = do_('fetch');
 export const mkdir = doRest('mkdir');

package/website/module.f.js

@@ -7,10 +7,13 @@ import { htmlToString } from "../html/module.f.js";
 import { writeFile } from "../types/effects/node/module.f.js";
 import { utf8 } from "../text/module.f.js";
 import { begin, pure } from "../types/effects/module.f.js";
-const html = ['body',
-    ['a', { href: 'https://github.com/functionalscript/functionalscript' }, 'GitHub Repository']
-];
+const html = utf8(htmlToString(['body',
+    ['a',
+        { href: 'https://github.com/functionalscript/functionalscript' },
+        'GitHub Repository'
+    ]
+]));
 const program = begin
-    .step(() => writeFile('index.html', utf8(htmlToString(html))))
+    .step(() => writeFile('index.html', html))
     .step(() => pure(0));
 export default () => program;