functionalscript 0.12.5 → 0.12.7

package/io/module.f.d.ts

@@ -1,5 +1,5 @@
 import { type Effect } from '../types/effects/module.f.ts';
-import type { Headers, NodeOp } from '../types/effects/node/module.f.ts';
+import type { ExecResult, Headers, IoResult, NodeOp } from '../types/effects/node/module.f.ts';
 import { type Result } from '../types/result/module.f.ts';
 /**
  * Represents a directory entry (file or directory) in the filesystem
@@ -96,6 +96,9 @@ export type RequestListener = (req: IncomingMessage, res: ServerResponse) => Pro
 export type Http = {
     readonly createServer: (_: RequestListener) => Server;
 };
+export type ChildProcess = {
+    readonly exec: (command: string) => Promise<IoResult<ExecResult>>;
+};
 /**
  * Core IO operations interface providing access to system resources
  */
@@ -109,6 +112,7 @@ export type Io = {
     readonly tryCatch: TryCatch;
     readonly asyncTryCatch: <T>(f: () => Promise<T>) => Promise<Result<T, unknown>>;
     readonly http: Http;
+    readonly childProcess: ChildProcess;
 };
 /**
  * The environment variables.
@@ -124,4 +128,4 @@ export type Run = (f: App) => Promise<never>;
  */
 export declare const run: (io: Io) => Run;
 export type EffectToPromise = <T>(effect: Effect<NodeOp, T>) => Promise<T>;
-export declare const fromIo: ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile, rm } }, fetch, http: { createServer }, }: Io) => EffectToPromise;
+export declare const fromIo: ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile, rm } }, fetch, http: { createServer }, childProcess: { exec }, }: Io) => EffectToPromise;

package/io/module.f.js

@@ -35,7 +35,7 @@ const collect = async (v) => {
     }
     return result;
 };
-export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile, rm } }, fetch, http: { createServer }, }) => {
+export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile, rm } }, fetch, http: { createServer }, childProcess: { exec }, }) => {
     const result = asyncRun({
         all: async (effects) => await Promise.all(effects.map(result)),
         error: async (message) => error(message),
@@ -53,6 +53,7 @@ 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))),
         rm: path => tc(() => rm(path)),
+        exec,
         createServer: async (requestListener) => {
             const erl = requestListener;
             const nodeRl = async (req, res) => {

package/io/module.js

@@ -7,6 +7,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     return path;
 };
 import http from 'node:http';
+import { exec } from 'node:child_process';
 import { fromIo, run } from "./module.f.js";
 import fs from 'node:fs';
 import process from 'node:process';
@@ -41,6 +42,9 @@ export const io = {
         }
     },
     http,
+    childProcess: {
+        exec: command => new Promise(resolve => exec(command, (e, stdout, stderr) => resolve(e !== null ? error(e) : ok({ stdout, stderr })))),
+    },
 };
 export const legacyRun = run(io);
 export const ioRun = (io) => {

package/io/virtual/module.f.js

@@ -36,5 +36,8 @@ export const createVirtualIo = (files) => ({
     asyncTryCatch: async (f) => ['ok', await f()],
     http: {
         createServer: todo
-    }
+    },
+    childProcess: {
+        exec: todo,
+    },
 });

package/package.json

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

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

@@ -188,6 +188,16 @@ export declare const msb: BitOrder;
  * @returns The resulting vector based on the provided bit order.
  */
 export declare const u8ListToVec: ({ unpackConcat }: BitOrder) => (list: List<number>) => Vec;
+/**
+ * Chunks a bit vector into fixed-size pieces of `n` bits using the provided bit order.
+ * The last chunk may be smaller than `n` bits if the vector length is not a multiple of `n`.
+ *
+ * @param bitOrder The bit order for the conversion.
+ * @param n The chunk size in bits.
+ * @param v The vector to be chunked.
+ * @returns A thunk that produces a list of bit vectors, each representing one chunk.
+ */
+export declare const chunkList: ({ unpackSplit }: BitOrder) => (n: bigint) => (v: Vec) => Thunk<Vec>;
 /**
  * Converts a bit vector to a list of unsigned 8-bit integers based on the provided bit order.
  *
@@ -195,7 +205,7 @@ export declare const u8ListToVec: ({ unpackConcat }: BitOrder) => (list: List<nu
  * @param v The vector to be converted.
  * @returns A thunk that produces a list of unsigned 8-bit integers.
  */
-export declare const u8List: ({ unpackSplit }: BitOrder) => (v: Vec) => Thunk<number>;
+export declare const u8List: (bo: BitOrder) => (v: Vec) => Thunk<number>;
 /**
  * Concatenates a list of vectors using the provided bit order.
  */

package/types/bit_vec/module.f.js

@@ -21,9 +21,9 @@
  *
  * @module
  */
-import { bitLength, mask, max, min, xor } from "../bigint/module.f.js";
+import { bitLength, divUp, mask, max, min, xor } from "../bigint/module.f.js";
 import { flip } from "../function/module.f.js";
-import { fold, iterable } from "../list/module.f.js";
+import { fold, iterable, map } 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";
@@ -230,37 +230,54 @@ export const u8ListToVec = ({ unpackConcat }) => (list) => {
     return pack(result.reduce((p, c) => unpackConcat(c)(p), unpackEmpty));
 };
 /**
- * Converts a bit vector to a list of unsigned 8-bit integers based on the provided bit order.
+ * Chunks a bit vector into fixed-size pieces of `n` bits using the provided bit order.
+ * The last chunk may be smaller than `n` bits if the vector length is not a multiple of `n`.
  *
  * @param bitOrder The bit order for the conversion.
- * @param v The vector to be converted.
- * @returns A thunk that produces a list of unsigned 8-bit integers.
+ * @param n The chunk size in bits.
+ * @param v The vector to be chunked.
+ * @returns A thunk that produces a list of bit vectors, each representing one chunk.
  */
-export const u8List = ({ unpackSplit }) => (v) => {
-    if (v === empty) {
-        return () => null;
-    }
-    const f = (stack) => () => {
-        while (true) {
-            const [first, rest] = stack;
-            const { length, uint } = first;
-            if (length <= 8n) {
-                // the last unpack split is required to align data.
-                const v = length < 8n ? unpackSplit(8n)(first)[0] : uint;
-                return { first: Number(v), tail: rest !== undefined ? f(rest) : null };
-            }
-            // `length` is bigger than `8n` so `newLen` is `8n` or bigger.
-            const aLength = ((length + 7n) >> 4n) << 3n;
-            const bLength = length - aLength;
-            const [a, b] = unpackSplit(aLength)(first);
-            stack = [
-                { length: aLength, uint: a & mask(aLength) },
-                [{ length: bLength, uint: b & mask(bLength) }, rest],
-            ];
+export const chunkList = ({ unpackSplit }) => (n) => {
+    const divUpN2 = divUp(n << 1n);
+    return v => {
+        if (v === empty) {
+            return () => null;
         }
+        const f = (stack) => () => {
+            while (true) {
+                const [first, rest] = stack;
+                const { length } = first;
+                if (length <= n) {
+                    return { first: pack(first), tail: rest !== undefined ? f(rest) : null };
+                }
+                const aLength = divUpN2(length) * n;
+                const bLength = length - aLength;
+                const [a, b] = unpackSplit(aLength)(first);
+                stack = [
+                    { length: aLength, uint: a & mask(aLength) },
+                    [{ length: bLength, uint: b & mask(bLength) }, rest],
+                ];
+            }
+        };
+        return f([unpack(v), undefined]);
     };
-    return f([unpack(v), undefined]);
 };
+const vecToU8 = ({ unpackSplit }) => {
+    const unpackSplit8 = unpackSplit(8n);
+    return chunk => {
+        const u = unpack(chunk);
+        return Number(u.length < 8n ? unpackSplit8(u)[0] : u.uint);
+    };
+};
+/**
+ * Converts a bit vector to a list of unsigned 8-bit integers based on the provided bit order.
+ *
+ * @param bitOrder The bit order for the conversion.
+ * @param v The vector to be converted.
+ * @returns A thunk that produces a list of unsigned 8-bit integers.
+ */
+export const u8List = (bo) => (v) => map(vecToU8(bo))(chunkList(bo)(8n)(v));
 /**
  * Concatenates a list of vectors using the provided bit order.
  */

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

@@ -41,5 +41,12 @@ declare const _default: {
     msbCmp: () => void;
     u8ListToVec: () => () => void;
     u8ListUnaligned: () => void;
+    chunkList: {
+        empty: () => void;
+        lsb_aligned: () => void;
+        msb_aligned: () => void;
+        lsb_unaligned: () => void;
+        msb_unaligned: () => void;
+    };
 };
 export default _default;

package/types/bit_vec/test.f.js

@@ -1,6 +1,6 @@
 import { mask } from "../bigint/module.f.js";
 import { asBase, asNominal } from "../nominal/module.f.js";
-import { length, empty, uint, vec, lsb, msb, repeat, vec8, u8ListToVec, u8List } from "./module.f.js";
+import { length, empty, uint, vec, lsb, msb, repeat, vec8, u8ListToVec, u8List, chunkList } from "./module.f.js";
 import { repeat as listRepeat, toArray } from "../list/module.f.js";
 const unsafeVec = (a) => asNominal(a);
 // 0x8 = 0b1000 = 0 + 8
@@ -482,5 +482,73 @@ export default {
         if (a1 !== 0x80) {
             throw `a1: ${a1.toString(16)}`;
         }
-    }
+    },
+    chunkList: {
+        empty: () => {
+            const chunks = toArray(chunkList(lsb)(4n)(empty));
+            if (chunks.length !== 0) {
+                throw chunks.length;
+            }
+        },
+        // 8-bit vector 0xF5 = 0b1111_0101, aligned to 4-bit chunks
+        lsb_aligned: () => {
+            const chunks = toArray(chunkList(lsb)(4n)(vec(8n)(0xf5n)));
+            // LSB: low nibble first — bits 0-3 = 0101 = 5, bits 4-7 = 1111 = 15
+            if (chunks.length !== 2) {
+                throw chunks.length;
+            }
+            if (length(chunks[0]) !== 4n || uint(chunks[0]) !== 5n) {
+                throw chunks[0];
+            }
+            if (length(chunks[1]) !== 4n || uint(chunks[1]) !== 0xfn) {
+                throw chunks[1];
+            }
+        },
+        msb_aligned: () => {
+            const chunks = toArray(chunkList(msb)(4n)(vec(8n)(0xf5n)));
+            // MSB: high nibble first — bits 0-3 = 1111 = 15, bits 4-7 = 0101 = 5
+            if (chunks.length !== 2) {
+                throw chunks.length;
+            }
+            if (length(chunks[0]) !== 4n || uint(chunks[0]) !== 0xfn) {
+                throw chunks[0];
+            }
+            if (length(chunks[1]) !== 4n || uint(chunks[1]) !== 5n) {
+                throw chunks[1];
+            }
+        },
+        // 10-bit vector 0x1B5 = 0b01_1011_0101, unaligned to 4-bit chunks (last chunk is 2 bits)
+        lsb_unaligned: () => {
+            const chunks = toArray(chunkList(lsb)(4n)(vec(10n)(0x1b5n)));
+            // LSB: bits 0-3 = 0101 = 5, bits 4-7 = 1011 = 11, bits 8-9 = 01 = 1
+            if (chunks.length !== 3) {
+                throw chunks.length;
+            }
+            if (length(chunks[0]) !== 4n || uint(chunks[0]) !== 5n) {
+                throw chunks[0];
+            }
+            if (length(chunks[1]) !== 4n || uint(chunks[1]) !== 0xbn) {
+                throw chunks[1];
+            }
+            if (length(chunks[2]) !== 2n || uint(chunks[2]) !== 1n) {
+                throw chunks[2];
+            }
+        },
+        msb_unaligned: () => {
+            const chunks = toArray(chunkList(msb)(4n)(vec(10n)(0x1b5n)));
+            // MSB: bits 0-3 = 0110 = 6, bits 4-7 = 1101 = 13, bits 8-9 = 01 = 1
+            if (chunks.length !== 3) {
+                throw chunks.length;
+            }
+            if (length(chunks[0]) !== 4n || uint(chunks[0]) !== 6n) {
+                throw chunks[0];
+            }
+            if (length(chunks[1]) !== 4n || uint(chunks[1]) !== 0xdn) {
+                throw chunks[1];
+            }
+            if (length(chunks[2]) !== 2n || uint(chunks[2]) !== 1n) {
+                throw chunks[2];
+            }
+        },
+    },
 };

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

@@ -43,7 +43,13 @@ export type WriteFile = readonly ['writeFile', (_: WriteFileParam) => IoResult<v
 export declare const writeFile: RestFunc<WriteFile>;
 export type Rm = readonly ['rm', (_: string) => IoResult<void>];
 export declare const rm: Func<Rm>;
-export type Fs = Mkdir | ReadFile | Readdir | WriteFile | Rm;
+export type ExecResult = {
+    readonly stdout: string;
+    readonly stderr: string;
+};
+export type Exec = readonly ['exec', (_: string) => IoResult<ExecResult>];
+export declare const exec: Func<Exec>;
+export type Fs = Mkdir | ReadFile | Readdir | WriteFile | Rm | Exec;
 export type Error = ['error', (_: string) => void];
 export declare const error: Func<Error>;
 export type Log = ['log', (_: string) => void];

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

@@ -15,6 +15,7 @@ export const readFile = do_('readFile');
 export const readdir = doRest('readdir');
 export const writeFile = doRest('writeFile');
 export const rm = do_('rm');
+export const exec = do_('exec');
 export const error = do_('error');
 export const log = do_('log');
 export const createServer = do_('createServer');

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

@@ -131,6 +131,7 @@ const map = {
     readdir: (state, [path, { recursive }]) => readdir(path, recursive === true)(state, path),
     writeFile: (state, [path, payload]) => writeFile(payload)(state, path),
     rm: (state, path) => rm(state, path),
+    exec: todo,
     createServer: todo,
     listen: todo,
     forever: todo,