functionalscript 0.8.1 → 0.9.1

package/types/btree/set/module.f.js

@@ -30,7 +30,20 @@ const reduceOp = ([i, x]) => a => {
 };
 const reduceBranch = fold(reduceOp);
 const nodeSet = (c) => (g) => (node) => {
+    // export type Result<T> = {
+    //    readonly first: First<T>,
+    //    readonly tail: Path<T>
+    //}
     const { first, tail } = find(c)(node);
+    // export type Index2 = 0 | 1
+    // export type Index3 = Index2 | 2 // 0 | 1 | 2
+    // export type Index4 = Index3 | 3 // 0 | 1 | 2 | 3
+    // export type Index5 = Index4 | 4 // 0 | 1 | 2 | 3 | 4
+    // type FirstLeaf1<T> = readonly[Index3, Leaf1<T>]
+    // type FirstBranch3<T> = readonly[1, Branch3<T>]
+    // type FirstLeaf2<T> = readonly[Index5, Leaf2<T>]
+    // type FirstBranch5<T> = readonly[1|3, Branch5<T>]
+    // export type First<T> = FirstLeaf1<T> | FirstBranch3<T> | FirstLeaf2<T> | FirstBranch5<T>
     const [i, x] = first;
     const f = () => {
         switch (i) {
@@ -66,6 +79,8 @@ const nodeSet = (c) => (g) => (node) => {
             case 2: {
                 // insert
                 const value = g(null);
+                // TODO: remove after TSGO fix the regression.
+                const _xl = x.length;
                 switch (x.length) {
                     case 1: {
                         return [[x[0], value]];
@@ -74,9 +89,13 @@ const nodeSet = (c) => (g) => (node) => {
                         return [[x[0]], value, [x[1]]];
                     }
                 }
+                // TODO: remove after TSGO fix the regression.
+                throw 'unreachable';
             }
             case 3: {
                 // replace
+                // TODO: remove after TSGO fix the regression.
+                const _xl = x.length;
                 switch (x.length) {
                     case 2: {
                         return [[x[0], g(x[1])]];
@@ -85,6 +104,8 @@ const nodeSet = (c) => (g) => (node) => {
                         return [[x[0], x[1], x[2], g(x[3]), x[4]]];
                     }
                 }
+                // TODO: remove after TSGO fix the regression.
+                throw 'unreachable';
             }
             case 4: {
                 // insert

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

@@ -0,0 +1,6 @@
+import { type Vec } from "../bit_vec/module.f.ts";
+import type { Nullable } from "../nullable/module.f.ts";
+export declare const vec5xToCBase32: (v: Vec) => string;
+export declare const vecToCBase32: (v: Vec) => string;
+export declare const cBase32ToVec5x: (s: string) => Nullable<Vec>;
+export declare const cBase32ToVec: (s: string) => Nullable<Vec>;

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/{crypto → types}/prime_field/module.f.d.ts

@@ -1,4 +1,4 @@
-import type { Unary, Reduce } from '../../types/bigint/module.f.ts';
+import type { Unary, Reduce } from '../bigint/module.f.ts';
 /**
  * A type representing a prime field and its associated operations.
  */

package/{crypto → types}/prime_field/module.f.js

@@ -1,4 +1,4 @@
-import { repeat } from "../../types/monoid/module.f.js";
+import { repeat } from "../monoid/module.f.js";
 /**
  * Creates a prime field with the specified prime modulus and associated operations.
  *

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/crypto/rfc6979/module.f.d.ts

@@ -1,15 +0,0 @@
-import { type Vec } from '../../types/bit_vec/module.f.ts';
-import type { Curve } from '../secp/module.f.ts';
-import { type Sha2 } from '../sha2/module.f.ts';
-export type All = {
-    readonly q: bigint;
-    readonly qlen: bigint;
-    readonly bits2int: (b: Vec) => bigint;
-    readonly int2octets: (x: bigint) => Vec;
-    readonly bits2octets: (b: Vec) => Vec;
-};
-export declare const all: (q: bigint) => All;
-export declare const fromCurve: (c: Curve) => All;
-export declare const concat: (...x: readonly Vec[]) => Vec;
-export declare const computeK: ({ q, bits2int, qlen, int2octets, bits2octets }: All) => (hf: Sha2) => (x: bigint) => (m: Vec) => bigint;
-export declare const sign: (a: All) => (hf: Sha2) => (x: bigint) => (m: Vec) => bigint;

package/crypto/rfc6979/module.f.js

@@ -1,98 +0,0 @@
-import { todo } from "../../dev/module.f.js";
-import { bitLength, divUp, roundUp } from "../../types/bigint/module.f.js";
-import { empty, length, listToVec, msb, repeat, unpack, vec, vec8 } from "../../types/bit_vec/module.f.js";
-import { hmac } from "../hmac/module.f.js";
-import { computeSync } from "../sha2/module.f.js";
-// qlen to rlen
-const roundUp8 = roundUp(8n);
-const divUp8 = divUp(8n);
-export const all = (q) => {
-    const qlen = bitLength(q);
-    const bits2int = (b) => {
-        const { length, uint } = unpack(b);
-        const diff = length - qlen;
-        return diff > 0n ? uint >> diff : uint;
-    };
-    const int2octets = vec(roundUp8(qlen));
-    return {
-        q,
-        qlen,
-        bits2int,
-        int2octets,
-        // since z2 < 2*q, we can use simple mod with `z1 < q ? z1 : z1 - q`
-        bits2octets: b => int2octets(bits2int(b) % q),
-    };
-};
-export const fromCurve = (c) => all(c.nf.p);
-const v0 = vec8(0x01n);
-const k0 = vec8(0x00n);
-const ltov = listToVec(msb);
-export const concat = (...x) => ltov(x);
-export const computeK = ({ q, bits2int, qlen, int2octets, bits2octets }) => (hf) => (x) => (m) => {
-    const hmacf = hmac(hf);
-    // a. Process m through the hash function H, yielding:
-    //      h1 = H(m)
-    //   (h1 is a sequence of hlen bits).
-    const h1 = computeSync(hf)([m]);
-    // b. Set:
-    //      V = 0x01 0x01 0x01 ... 0x01
-    //    such that the length of V, in bits, is equal to 8*ceil(hlen/8).
-    //    For instance, on an octet-based system, if H is SHA-256, then V
-    //    is set to a sequence of 32 octets of value 1.  Note that in this
-    //    step and all subsequent steps, we use the same H function as the
-    //    one used in step 'a' to process the input message; this choice
-    //    will be discussed in more detail in Section 3.6.
-    const rep = repeat(divUp8(hf.hashLength));
-    let v = rep(v0);
-    // c. Set:
-    //      K = 0x00 0x00 0x00 ... 0x00
-    //    such that the length of K, in bits, is equal to 8*ceil(hlen/8).
-    let k = rep(k0);
-    // d. Set:
-    //      K = HMAC_K(V || 0x00 || int2octets(x) || bits2octets(h1))
-    //    where '||' denotes concatenation.
-    const xh1 = concat(int2octets(x), bits2octets(h1));
-    k = hmacf(k)(concat(v, k0, xh1));
-    // e. Set:
-    //      V = HMAC_K(V)
-    v = hmacf(k)(v);
-    // f. Set:
-    //      K = HMAC_K(V || 0x01 || int2octets(x) || bits2octets(h1))
-    k = hmacf(k)(concat(v, v0, xh1));
-    // g. Set:
-    //      V = HMAC_K(V)
-    v = hmacf(k)(v);
-    // h. Apply the following algorithm until a proper value is for `k`:
-    while (true) {
-        // h. Apply the following algorithm until a proper value is for `k`:
-        //    1. Set `T` to the empty sequence, so `tlen = 0`.
-        let t = empty;
-        //    2. while `tlen < qlen` do:
-        //       - `V = HMAC_K(V)`
-        //       - `T = T || V`
-        // Possible optimizations:
-        // - precompute number of iterations
-        // - `qlen` can't be 0, so we can avoid the first check and
-        //   first concatenation.
-        while (length(t) < qlen) {
-            v = hmacf(k)(v);
-            t = concat(t, v);
-        }
-        //    3. Compute `k = bits2int(T)`. If `k` is not in `[1, q-1]` or `kG = 0` then
-        //       - `K = HMAC_K(V || 0x00)`
-        //       - `V = HMAC_K(V)`
-        //       and loop (try to generate a new `T`, and so on). Return to step `1`.
-        const result = bits2int(t);
-        if (0n < result && result < q) {
-            return result;
-        }
-        k = hmacf(k)(concat(v, k0));
-        v = hmacf(k)(v);
-    }
-};
-export const sign = (a) => (hf) => (x) => (m) => {
-    const hm = computeSync(hf)([m]);
-    const h = a.bits2int(hm) % a.q;
-    ///
-    return todo();
-};

package/crypto/rfc6979/test.f.d.ts

@@ -1,10 +0,0 @@
-declare const _default: {
-    bits2int: () => void;
-    int2octets: () => void;
-    bit2octets: () => void;
-    k: () => void;
-    computeK: () => void;
-    investigate: () => void;
-    a2: () => void;
-};
-export default _default;