functionalscript 0.8.2 → 0.9.1

package/types/cbase32/module.f.js

@@ -0,0 +1,71 @@
+import { msb, lsb, length, vec, empty } from "../bit_vec/module.f.js";
+//                         0123456789abcdef
+const m = '0123456789abcdefghjkmnpqrstvwxyz';
+const { popFront, concat } = msb;
+const popBack1 = lsb.popFront(1n);
+const popFront5 = popFront(5n);
+export const vec5xToCBase32 = (v) => {
+    let result = '';
+    while (true) {
+        const len = length(v);
+        if (len === 0n) {
+            break;
+        }
+        const [r, rest] = popFront5(v);
+        result += m[Number(r)];
+        v = rest;
+    }
+    return result;
+};
+export const vecToCBase32 = (v) => {
+    const len = length(v);
+    const extraLen = 5n - len % 5n;
+    const last = 1n << (extraLen - 1n);
+    const padded = concat(v)(vec(extraLen)(last));
+    return vec5xToCBase32(padded);
+};
+const vec5 = vec(5n);
+const normalizeChar = (c) => {
+    const lower = c.toLowerCase();
+    switch (lower) {
+        case 'i': {
+            return '1';
+        }
+        case 'l': {
+            return '1';
+        }
+        case 'o': {
+            return '0';
+        }
+        default: {
+            return lower;
+        }
+    }
+};
+const toCrockfordIndex = (c) => m.indexOf(normalizeChar(c));
+export const cBase32ToVec5x = (s) => {
+    let result = empty;
+    for (const c of s) {
+        const index = toCrockfordIndex(c);
+        if (index < 0) {
+            return null;
+        }
+        const v = vec5(BigInt(index));
+        result = concat(result)(v);
+    }
+    return result;
+};
+export const cBase32ToVec = (s) => {
+    let v = cBase32ToVec5x(s);
+    if (v === null || v === empty) {
+        return null;
+    }
+    // TODO: replace with a function that computes trailing zeros.
+    while (true) {
+        const [last, v0] = popBack1(v);
+        v = v0;
+        if (last === 1n) {
+            return v;
+        }
+    }
+};

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

@@ -0,0 +1,7 @@
+declare const _default: {
+    roundtrip5x: () => void;
+    roundtrip: () => void;
+    unalignedBits: () => void;
+    caseInsensitive: () => void;
+};
+export default _default;

package/types/cbase32/test.f.js

@@ -0,0 +1,74 @@
+import { empty, vec } from "../bit_vec/module.f.js";
+import { cBase32ToVec, cBase32ToVec5x, vec5xToCBase32, vecToCBase32 } from "./module.f.js";
+const check5x = (s, v) => {
+    const sr = vec5xToCBase32(v);
+    if (sr !== s) {
+        throw [sr, s];
+    }
+    const vr = cBase32ToVec5x(s);
+    if (vr !== v) {
+        throw [vr, v];
+    }
+    //
+    check(`${s}g`, v);
+};
+const check = (s, v) => {
+    const sr = vecToCBase32(v);
+    if (sr !== s) {
+        throw [sr, s];
+    }
+    const vr = cBase32ToVec(s);
+    if (vr !== v) {
+        throw [vr, v];
+    }
+};
+export default {
+    roundtrip5x: () => {
+        check5x("", empty);
+        check5x("0", vec(5n)(0n));
+        check5x("1", vec(5n)(1n));
+        check5x("7", vec(5n)(7n));
+        check5x("a", vec(5n)(10n));
+        check5x("b", vec(5n)(11n));
+        check5x("f", vec(5n)(15n));
+        check5x("gh", vec(10n)(529n));
+        check5x("jk", vec(10n)(595n));
+        check5x("mnpq", vec(20n)(677591n));
+        check5x("rstvwxyz", vec(40n)(852378941407n));
+    },
+    roundtrip: () => {
+        check("g", empty);
+        check("8", vec(1n)(0n));
+        check("r", vec(1n)(1n));
+        check("4", vec(2n)(0n));
+        check("c", vec(2n)(1n));
+        check("2", vec(3n)(0n));
+        check("1", vec(4n)(0n));
+        check("2g", vec(5n)(2n));
+        check("01", vec(9n)(0n));
+    },
+    unalignedBits: () => {
+        const v = vec(1n)(1n);
+        const cr = vec5xToCBase32(v);
+        if (cr !== "g") {
+            throw ['g', cr];
+        }
+    },
+    caseInsensitive: () => {
+        if (cBase32ToVec5x("A") !== cBase32ToVec5x("a")) {
+            throw 'case-insensitive expected';
+        }
+        if (cBase32ToVec5x("I") !== cBase32ToVec5x("1")) {
+            throw 'i maps to 1';
+        }
+        if (cBase32ToVec5x("l") !== cBase32ToVec5x("1")) {
+            throw 'l maps to 1';
+        }
+        if (cBase32ToVec5x("o") !== cBase32ToVec5x("0")) {
+            throw 'o maps to 0';
+        }
+        if (cBase32ToVec5x("u") !== null) {
+            throw 'should error on invalid character';
+        }
+    }
+};

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

@@ -12,6 +12,7 @@ type Concat<T> = {
     readonly head: List<T>;
     readonly tail: List<T>;
 };
+export declare const fromArrayLike: <T>(array: ArrayLike<T>) => Result<T>;
 export declare const concat: <T>(head: List<T>) => (tail: List<T>) => List<T>;
 export declare const next: <T>(head: List<T>) => Result<T>;
 export declare const iterable: <T>(list: List<T>) => Iterable<T>;

package/types/list/module.f.js

@@ -1,6 +1,6 @@
 import { identity, fn, compose } from "../function/module.f.js";
 import { addition, logicalNot, strictEqual, stateScanToScan, foldToScan, reduceToScan, } from "../function/operator/module.f.js";
-const fromArray = (array) => {
+export const fromArrayLike = (array) => {
     const at = (i) => i < array.length ? { first: array[i], tail: () => at(i + 1) } : null;
     return at(0);
 };
@@ -16,7 +16,7 @@ export const next = (head) => {
     while (true) {
         head = trampoline(head);
         if (head instanceof Array) {
-            head = fromArray(head);
+            head = fromArrayLike(head);
         }
         else if (head !== null && 'head' in head) {
             [head, tail] = [head.head, concat(head.tail)(tail)];

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

@@ -1,3 +1,5 @@
+import type { Option } from '../option/module.f.ts';
 export type Nullable<T> = T | null;
 export declare const map: <T, R>(f: (value: T) => R) => (value: Nullable<T>) => Nullable<R>;
 export declare const match: <T, R>(f: (_: T) => R) => (none: () => R) => (_: Nullable<T>) => Nullable<R>;
+export declare const toOption: <T>(value: Nullable<T>) => Option<T>;

package/types/nullable/module.f.js

@@ -1,2 +1,3 @@
 export const map = f => value => value === null ? null : f(value);
 export const match = f => none => value => value === null ? none() : f(value);
+export const toOption = (value) => value === null ? [] : [value];

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

@@ -1,2 +1,2 @@
-declare const _default: () => void;
+declare const _default: (() => void)[];
 export default _default;

package/types/nullable/test.f.js

@@ -1,12 +1,24 @@
-import { map } from "./module.f.js";
-export default () => {
-    const optionSq = map((v) => v * v);
-    const sq3 = optionSq(3);
-    if (sq3 !== 9) {
-        throw sq3;
+import { map, toOption } from "./module.f.js";
+export default [
+    () => {
+        const optionSq = map((v) => v * v);
+        const sq3 = optionSq(3);
+        if (sq3 !== 9) {
+            throw sq3;
+        }
+        const sqNull = optionSq(null);
+        if (sqNull !== null) {
+            throw sqNull;
+        }
+    },
+    () => {
+        const opt1 = toOption(5);
+        if (opt1.length !== 1 || opt1[0] !== 5) {
+            throw opt1;
+        }
+        const opt2 = toOption(null);
+        if (opt2.length !== 0) {
+            throw opt2;
+        }
     }
-    const sqNull = optionSq(null);
-    if (sqNull !== null) {
-        throw sqNull;
-    }
-};
+];

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

@@ -0,0 +1,9 @@
+/**
+ * Optional tuple-based value representation.
+ *
+ * @module
+ */
+/**
+ * Represents an optional value as an empty tuple or a tuple with one value.
+ */
+export type Option<T> = readonly [T] | readonly [];

package/types/option/module.f.js

@@ -0,0 +1,6 @@
+/**
+ * Optional tuple-based value representation.
+ *
+ * @module
+ */
+export {};

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

@@ -0,0 +1,11 @@
+import { type Vec } from "../bit_vec/module.f.ts";
+/**
+ * Converts a Uint8Array into an MSB-first bit vector.
+ */
+export declare const toVec: (input: Uint8Array) => Vec;
+/**
+ * Converts an MSB-first bit vector into a Uint8Array.
+ */
+export declare const fromVec: (input: Vec) => Uint8Array;
+export declare const decodeUtf8: (input: Uint8Array) => string;
+export declare const encodeUtf8: (input: string) => Uint8Array;

package/types/uint8array/module.f.js

@@ -0,0 +1,21 @@
+/**
+ * Conversions between Uint8Array values and bit vectors.
+ *
+ * @module
+ */
+import { utf8, utf8ToString } from "../../text/module.f.js";
+import { msb, u8List, u8ListToVec } from "../bit_vec/module.f.js";
+import { compose } from "../function/module.f.js";
+import { fromArrayLike, iterable } from "../list/module.f.js";
+const u8ListToVecMsb = u8ListToVec(msb);
+const u8ListMsb = u8List(msb);
+/**
+ * Converts a Uint8Array into an MSB-first bit vector.
+ */
+export const toVec = (input) => u8ListToVecMsb(fromArrayLike(input));
+/**
+ * Converts an MSB-first bit vector into a Uint8Array.
+ */
+export const fromVec = (input) => Uint8Array.from(iterable(u8ListMsb(input)));
+export const decodeUtf8 = compose(toVec)(utf8ToString);
+export const encodeUtf8 = compose(utf8)(fromVec);

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

@@ -0,0 +1,12 @@
+declare const _default: {
+    empty: () => void;
+    roundTrip: () => void;
+    unalignedLength: () => void;
+    encodeUtf8Empty: () => void;
+    encodeUtf8Ascii: () => void;
+    encodeUtf8Multibyte: () => void;
+    decodeUtf8Ascii: () => void;
+    decodeUtf8Multibyte: () => void;
+    utf8RoundTrip: () => void;
+};
+export default _default;

package/types/uint8array/test.f.js

@@ -0,0 +1,58 @@
+import { vec } from "../bit_vec/module.f.js";
+import { toVec, fromVec, decodeUtf8, encodeUtf8 } from "./module.f.js";
+import { strictEqual } from "../function/operator/module.f.js";
+import { equal, fromArrayLike } from "../list/module.f.js";
+const assertEq = (a, b) => {
+    if (a !== b) {
+        throw [a, b];
+    }
+};
+const assertArrayEq = (a, b) => {
+    if (!equal(strictEqual)(fromArrayLike(a))(fromArrayLike(b))) {
+        throw [a, b];
+    }
+};
+export default {
+    empty: () => {
+        const input = new Uint8Array();
+        const vec = toVec(input);
+        const output = fromVec(vec);
+        assertArrayEq(output, input);
+    },
+    roundTrip: () => {
+        const input = Uint8Array.from([0, 1, 2, 3, 255]);
+        const vec = toVec(input);
+        const output = fromVec(vec);
+        assertArrayEq(output, input);
+    },
+    unalignedLength: () => {
+        const input = vec(4n)(0xfn);
+        const output = fromVec(input);
+        assertArrayEq(output, Uint8Array.from([0xF0]));
+    },
+    encodeUtf8Empty: () => {
+        const output = encodeUtf8('');
+        assertArrayEq(output, new Uint8Array());
+    },
+    encodeUtf8Ascii: () => {
+        const output = encodeUtf8('Hi!');
+        assertArrayEq(output, Uint8Array.from([72, 105, 33]));
+    },
+    encodeUtf8Multibyte: () => {
+        const output = encodeUtf8('✓');
+        assertArrayEq(output, Uint8Array.from([0xE2, 0x9C, 0x93]));
+    },
+    decodeUtf8Ascii: () => {
+        const output = decodeUtf8(Uint8Array.from([102, 115]));
+        assertEq(output, 'fs');
+    },
+    decodeUtf8Multibyte: () => {
+        const output = decodeUtf8(Uint8Array.from([0xE2, 0x9C, 0x93]));
+        assertEq(output, '✓');
+    },
+    utf8RoundTrip: () => {
+        const input = 'FunctionalScript 🐝';
+        const output = decodeUtf8(encodeUtf8(input));
+        assertEq(output, input);
+    }
+};

package/fsc/module.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/fsc/module.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-import node from "../io/module.js";
-import { compile } from "../djs/module.f.js";
-await node(compile);