functionalscript 0.30.0 → 0.31.0

package/fs/types/list/module.f.js

@@ -56,10 +56,7 @@ export const toArray = (list) => {
 };
 const apply = (f) => (input) => () => {
     const n = next(input);
-    if (n === null) {
-        return null;
-    }
-    return f(n);
+    return n === null ? null : f(n);
 };
 const flatStep = ({ first, tail }) => concat(first)(flat(tail));
 export const flat = apply(flatStep);

package/fs/types/list/proof.f.d.ts

@@ -1,6 +1,6 @@
 export declare const proof: {
     stringifyTest: () => void;
-    cycle: () => void;
+    cycle: (() => void)[];
     countdown: () => void;
     flat: () => void;
     concat: () => void;

package/fs/types/list/proof.f.js

@@ -9,12 +9,20 @@ const stringifyTest = () => {
         throw s;
     }
 };
-const cycleTest = () => {
-    const x = str(toArray(take(10)(cycle([1, 2, 3]))));
-    if (x !== '[1,2,3,1,2,3,1,2,3,1]') {
-        throw x;
-    }
-};
+const cycleTest = [
+    () => {
+        const x = str(toArray(take(10)(cycle([1, 2, 3]))));
+        if (x !== '[1,2,3,1,2,3,1,2,3,1]') {
+            throw x;
+        }
+    },
+    () => {
+        const x = str(toArray(cycle([])));
+        if (x !== '[]') {
+            throw x;
+        }
+    },
+];
 const countdownTest = () => {
     const result = str(countdown(10));
     if (result !== '[9,8,7,6,5,4,3,2,1,0]') {

package/fs/types/map/proof.f.d.ts

@@ -1,4 +1,5 @@
 export declare const proof: {
     set: () => void;
     delete: () => void;
+    deleteOneOfMany: () => void;
 };

package/fs/types/map/proof.f.js

@@ -1,4 +1,5 @@
 import { mapSet, mapDelete } from "./module.f.js";
+import { assertEq } from "../../asserts/module.f.js";
 export const proof = {
     set: () => {
         const map = mapSet(new Map(), 'a', 'b');
@@ -17,5 +18,13 @@ export const proof = {
         if (map.size !== 0) {
             throw 'error';
         }
-    }
+    },
+    deleteOneOfMany: () => {
+        const m0 = mapSet(new Map(), 'a', 1);
+        const m1 = mapSet(m0, 'b', 2);
+        const result = mapDelete(m1, 'a');
+        assertEq(result.get('b'), 2);
+        assertEq(result.get('a'), undefined);
+        assertEq(result.size, 1);
+    },
 };

package/fs/types/nibble_set/module.f.d.ts

@@ -1,9 +1,22 @@
 /**
  * Nibble-set operations for compact 4-bit membership tracking.
  *
+ * A set of nibbles (values `0..15`) stored as a 16-bit mask in a plain
+ * `number`. It implements the same bitmask-as-set algebra as
+ * {@link ../byte_set/module.f.ts | `byte_set`}, which tracks all 256 byte
+ * values in a `bigint`.
+ *
+ * **Prefer `byte_set`.** Its 256-value universe covers the common cases and
+ * it is the set type used across the codebase. Use `nibble_set` only when
+ * the set has to be serialized into JSON: a `NibbleSet` is a `number`, which
+ * round-trips through `JSON.stringify`/`JSON.parse` as-is, while a
+ * `ByteSet` is a `bigint`, which `JSON.stringify` cannot serialize.
+ *
  * @module
  */
+/** A set of nibbles as a 16-bit mask. JSON-serializable. */
 export type NibbleSet = number;
+/** A 4-bit value, `0..15`. */
 export type Nibble = number;
 export declare const empty = 0;
 export declare const universe = 65535;

package/fs/types/nibble_set/module.f.js

@@ -1,3 +1,19 @@
+/**
+ * Nibble-set operations for compact 4-bit membership tracking.
+ *
+ * A set of nibbles (values `0..15`) stored as a 16-bit mask in a plain
+ * `number`. It implements the same bitmask-as-set algebra as
+ * {@link ../byte_set/module.f.ts | `byte_set`}, which tracks all 256 byte
+ * values in a `bigint`.
+ *
+ * **Prefer `byte_set`.** Its 256-value universe covers the common cases and
+ * it is the set type used across the codebase. Use `nibble_set` only when
+ * the set has to be serialized into JSON: a `NibbleSet` is a `number`, which
+ * round-trips through `JSON.stringify`/`JSON.parse` as-is, while a
+ * `ByteSet` is a `bigint`, which `JSON.stringify` cannot serialize.
+ *
+ * @module
+ */
 export const empty = 0;
 export const universe = 0xFFFF;
 const one = n => 1 << n;

package/fs/types/object/module.f.d.ts

@@ -1,10 +1,9 @@
 import { type List } from '../list/module.f.ts';
+import { type Nullable } from '../nullable/module.f.ts';
 import { type OrderedMap } from '../ordered_map/module.f.ts';
-export type Map<T> = {
-    readonly [k in string]: T;
-};
+export type Map<T> = StringMap<string, T>;
 export type Entry<T> = readonly [string, T];
-export declare const at: (name: string) => <T>(object: Map<T>) => T | null;
+export declare const at: (name: string) => <T>(object: Map<T>) => Nullable<Exclude<T, undefined>>;
 export declare const sort: <T>(e: List<Entry<T>>) => List<Entry<T>>;
 export declare const fromEntries: <T>(e: List<Entry<T>>) => Map<T>;
 export declare const fromMap: <T>(m: OrderedMap<T>) => Map<T>;
@@ -15,7 +14,7 @@ export declare const fromMap: <T>(m: OrderedMap<T>) => Map<T>;
  * https://stackoverflow.com/questions/57571664/typescript-type-for-an-object-with-only-one-key-no-union-type-allowed-as-a-key
  */
 export type OneKey<K extends string, V> = {
-    [P in K]: (ReadonlyRecord<P, V> & Partial<ReadonlyRecord<Exclude<K, P>, never>>) extends infer O ? {
+    [P in K]: (StringMap<P, V> & Partial<StringMap<Exclude<K, P>, never>>) extends infer O ? {
         [Q in keyof O]: O[Q];
     } : never;
 }[K];
@@ -25,8 +24,13 @@ export type OneKey<K extends string, V> = {
 export type NotUnion<T, U = T> = T extends unknown ? [
     U
 ] extends [T] ? T : never : never;
-export type SingleProperty<T extends ReadonlyRecord<string, never>> = keyof T extends NotUnion<keyof T> ? T : never;
+export type SingleProperty<T extends StringMap<string, never>> = keyof T extends NotUnion<keyof T> ? T : never;
 export declare const isObject: (value: unknown) => value is { readonly [k in string]: unknown; };
-export type ReadonlyRecord<S extends string, T> = {
-    readonly [K in S]: T;
+/** Returns only the defined (non-undefined) values of a partial record. */
+export declare const definedValues: <T>(map: StringMap<string, Exclude<T, undefined>>) => readonly Exclude<T, undefined>[];
+export type StringMap<K extends string, T> = string extends K ? {
+    readonly [k in string]?: T;
+} : {
+    readonly [k in K]: T;
 };
+export declare const definedEntries: <T>(cmd: StringMap<string, Exclude<T, undefined>>) => readonly (readonly [string, Exclude<T, undefined>])[];

package/fs/types/object/module.f.js

@@ -7,11 +7,18 @@
  */
 import { isArray } from "../array/module.f.js";
 import { iterable } from "../list/module.f.js";
-import { fromUndefined, map } from "../nullable/module.f.js";
+import { fromUndefined } from "../nullable/module.f.js";
 import { entries as mapEntries, fromEntries as mapFromEntries } from "../ordered_map/module.f.js";
 const { getOwnPropertyDescriptor, fromEntries: objectFromEntries } = Object;
-export const at = name => object => map((d) => d.value)(fromUndefined(getOwnPropertyDescriptor(object, name)));
+export const at = name => object => {
+    const d = getOwnPropertyDescriptor(object, name);
+    return d === undefined ? null : fromUndefined(d.value);
+};
 export const sort = e => mapEntries(mapFromEntries(e));
 export const fromEntries = e => objectFromEntries(iterable(e));
 export const fromMap = m => fromEntries(mapEntries(m));
 export const isObject = (value) => typeof value === 'object' && !isArray(value) && value !== null;
+const { values, entries } = Object;
+/** Returns only the defined (non-undefined) values of a partial record. */
+export const definedValues = (map) => values(map).filter(v => v !== undefined);
+export const definedEntries = (cmd) => entries(cmd).flatMap(([a, b]) => b === undefined ? [] : [[a, b]]);

package/fs/types/object/proof.f.d.ts

@@ -1,4 +1,18 @@
+import type { StringMap } from './module.f.ts';
+type E<A, B> = A extends B ? B extends A ? true : false : false;
+type _InfiniteIsOptional = E<StringMap<string, bigint>, {
+    readonly [k in string]?: bigint;
+}>;
+type _FiniteIsRequired = E<StringMap<'a' | 'b', bigint>, {
+    readonly a: bigint;
+    readonly b: bigint;
+}>;
 export declare const proof: {
+    stringMap: {
+        infiniteIsOptional: _InfiniteIsOptional;
+        finiteIsRequired: _FiniteIsRequired;
+    };
     ctor: () => void;
     property: () => void;
 };
+export {};

package/fs/types/object/proof.f.js

@@ -1,5 +1,9 @@
 import { at } from "./module.f.js";
 export const proof = {
+    stringMap: {
+        infiniteIsOptional: true,
+        finiteIsRequired: true,
+    },
     ctor: () => {
         const a = {};
         const value = at('constructor')(a);

package/fs/types/ordered_map/proof.f.d.ts

@@ -1,4 +1,5 @@
 export declare const proof: {
     main: (() => void)[];
+    fromEntries: () => void;
     stress: () => void;
 };

package/fs/types/ordered_map/proof.f.js

@@ -1,101 +1,61 @@
-import { at, setReplace, setReduce, empty, entries, remove } from "./module.f.js";
+import { at, setReplace, setReduce, empty, entries, remove, fromEntries } from "./module.f.js";
 import { toArray } from "../list/module.f.js";
+import { assertEq } from "../../asserts/module.f.js";
 export const proof = {
     main: [
         () => {
             let m = setReplace('a')(1)(null);
-            if (at('a')(m) !== 1) {
-                throw 'error';
-            }
-            if (at('b')(m) !== null) {
-                throw 'error';
-            }
+            assertEq(at('a')(m), 1);
+            assertEq(at('b')(m), null);
             m = setReplace('b')(2)(m);
-            if (at('a')(m) !== 1) {
-                throw 'error';
-            }
-            if (at('b')(m) !== 2) {
-                throw 'error';
-            }
-            if (at('c')(m) !== null) {
-                throw 'error';
-            }
+            assertEq(at('a')(m), 1);
+            assertEq(at('b')(m), 2);
+            assertEq(at('c')(m), null);
             m = setReplace('z')(3)(m);
-            if (at('a')(m) !== 1) {
-                throw 'error';
-            }
-            if (at('b')(m) !== 2) {
-                throw 'error';
-            }
-            if (at('z')(m) !== 3) {
-                throw 'error';
-            }
-            if (at('')(m) !== null) {
-                throw 'error';
-            }
+            assertEq(at('a')(m), 1);
+            assertEq(at('b')(m), 2);
+            assertEq(at('z')(m), 3);
+            assertEq(at('')(m), null);
             m = setReplace('')(4)(m);
-            if (at('a')(m) !== 1) {
-                throw 'error';
-            }
-            if (at('b')(m) !== 2) {
-                throw 'error';
-            }
-            if (at('z')(m) !== 3) {
-                throw 'error';
-            }
-            if (at('')(m) !== 4) {
-                throw 'error';
-            }
-            if (at('Hello world!')(m) !== null) {
-                throw 'error';
-            }
+            assertEq(at('a')(m), 1);
+            assertEq(at('b')(m), 2);
+            assertEq(at('z')(m), 3);
+            assertEq(at('')(m), 4);
+            assertEq(at('Hello world!')(m), null);
             m = setReplace('Hello world!')(42)(m);
-            if (at('a')(m) !== 1) {
-                throw 'error';
-            }
-            if (at('b')(m) !== 2) {
-                throw 'error';
-            }
-            if (at('z')(m) !== 3) {
-                throw 'error';
-            }
-            if (at('')(m) !== 4) {
-                throw 'error';
-            }
-            if (at('Hello world!')(m) !== 42) {
-                throw 'error';
-            }
-            if (at('x')(m) !== null) {
-                throw 'error';
-            }
+            assertEq(at('a')(m), 1);
+            assertEq(at('b')(m), 2);
+            assertEq(at('z')(m), 3);
+            assertEq(at('')(m), 4);
+            assertEq(at('Hello world!')(m), 42);
+            assertEq(at('x')(m), null);
             // console.log(Array.from(m.entries()))
             m = remove('Hello world!')(m);
-            if (at('Hello world!')(m) !== null) {
-                throw m;
-            }
+            assertEq(at('Hello world!')(m), null);
             m = setReduce((a) => (b) => a + b)('a')(43)(m);
-            if (at('a')(m) !== 44) {
-                throw 'error';
-            }
+            assertEq(at('a')(m), 44);
         },
         () => {
             let m = setReplace('x')(12)(null);
             m = setReplace('y')(44)(m);
-            if (at('x')(m) !== 12) {
-                throw 'error';
-            }
-            if (at('y')(m) !== 44) {
-                throw 'error';
-            }
-            if (at('a')(m) !== null) {
-                throw 'error';
-            }
+            assertEq(at('x')(m), 12);
+            assertEq(at('y')(m), 44);
+            assertEq(at('a')(m), null);
             const e = toArray(entries(m));
-            if (e.length !== 2) {
-                throw 'error';
-            }
+            assertEq(e.length, 2);
         },
     ],
+    fromEntries: () => {
+        const list = [['a', 1], ['b', 2], ['c', 3]];
+        const m = fromEntries(list);
+        assertEq(at('a')(m), 1);
+        assertEq(at('b')(m), 2);
+        assertEq(at('c')(m), 3);
+        assertEq(at('d')(m), null);
+        // duplicate key: last one wins
+        const m2 = fromEntries([['x', 10], ['x', 20]]);
+        assertEq(at('x')(m2), 20);
+    },
     stress: () => {
         let m = empty;
         for (let i = 0; i < 100_000; ++i) {

package/fs/types/phantom/module.f.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Phantom type — attaches a compile-time type annotation `T` to `S` with zero
+ * runtime representation, analogous to Rust's `PhantomData<T>`.
+ *
+ * The phantom field uses a unique symbol key so it is excluded from string index
+ * signatures (`{ readonly [K in string]: ... }`), making `Phantom<S, T>` valid
+ * for any `S` regardless of its index signature constraints.
+ *
+ * @module
+ */
+declare const phantomKey: unique symbol;
+export type { phantomKey };
+/**
+ * Intersects `S` with a phantom field carrying type `T`.
+ *
+ * The field is optional (`?`) so it never needs to be present at runtime.
+ * Use `phantomKey` to read the phantom type back out via a conditional type:
+ * `S extends Phantom<unknown, infer T> ? T : never`.
+ */
+export type Phantom<S, T> = S & {
+    readonly [phantomKey]?: T;
+};

package/fs/types/phantom/module.f.js

@@ -0,0 +1,11 @@
+/**
+ * Phantom type — attaches a compile-time type annotation `T` to `S` with zero
+ * runtime representation, analogous to Rust's `PhantomData<T>`.
+ *
+ * The phantom field uses a unique symbol key so it is excluded from string index
+ * signatures (`{ readonly [K in string]: ... }`), making `Phantom<S, T>` valid
+ * for any `S` regardless of its index signature constraints.
+ *
+ * @module
+ */
+export {};

package/fs/types/prime_field/proof.f.d.ts

@@ -1,4 +1,8 @@
 export declare const proof: {
+    throw: {
+        reciprocal_zero: () => bigint;
+        sqrt_bad_prime: () => (a: bigint) => bigint | null;
+    };
     prime_field_test: () => {
         neg: () => void;
         sub: () => void;
@@ -11,5 +15,8 @@ export declare const proof: {
         reduce: () => void;
         quadRes: () => void;
         modSqrt: () => void;
+        div: () => void;
+        pow3: () => void;
+        abs: () => void;
     };
 };

package/fs/types/prime_field/proof.f.js

@@ -1,121 +1,69 @@
 import { modSqrt, prime_field, sqrt } from "./module.f.js";
+import { assert, assertEq } from "../../asserts/module.f.js";
 export const proof = {
+    throw: {
+        reciprocal_zero: () => prime_field(7n).reciprocal(0n),
+        sqrt_bad_prime: () => sqrt(prime_field(5n)),
+    },
     prime_field_test: () => {
         const p = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn;
         const f = prime_field(p);
         const sqrt_f = sqrt(f);
         return {
             neg: () => {
-                if (f.neg(0n) !== 0n) {
-                    throw '-0';
-                }
-                if (f.neg(1n) !== p - 1n) {
-                    throw '-1';
-                }
+                assertEq(f.neg(0n), 0n);
+                assertEq(f.neg(1n), p - 1n);
             },
             sub: () => {
-                if (f.sub(10n)(4n) !== 6n) {
-                    throw '10 - 4';
-                }
-                if (f.sub(11n)(14n) !== p - 3n) {
-                    throw '11 - 14';
-                }
+                assertEq(f.sub(10n)(4n), 6n);
+                assertEq(f.sub(11n)(14n), p - 3n);
             },
             add: () => {
-                if (f.add(13n)(24n) !== 37n) {
-                    throw '13 + 24';
-                }
-                if (f.add(77n)(f.neg(12n)) !== 65n) {
-                    throw '77 + (-12)';
-                }
+                assertEq(f.add(13n)(24n), 37n);
+                assertEq(f.add(77n)(f.neg(12n)), 65n);
             },
             mul: () => {
-                if (f.mul(100n)(0n) !== 0n) {
-                    throw '100 * 0';
-                }
-                if (f.mul(101n)(205n) !== 20705n) {
-                    throw '101 * 205';
-                }
-                if (f.mul(304n)(f.neg(1n)) !== f.neg(304n)) {
-                    throw '304 * -1';
-                }
-                if (f.mul(f.neg(507n))(609n) !== f.neg(308763n)) {
-                    throw '-507 * 609';
-                }
-                if (f.mul(f.neg(713n))(f.neg(825n)) !== 588225n) {
-                    throw '-713 * -825';
-                }
+                assertEq(f.mul(100n)(0n), 0n);
+                assertEq(f.mul(101n)(205n), 20705n);
+                assertEq(f.mul(304n)(f.neg(1n)), f.neg(304n));
+                assertEq(f.mul(f.neg(507n))(609n), f.neg(308763n));
+                assertEq(f.mul(f.neg(713n))(f.neg(825n)), 588225n);
             },
             reciprocal: () => {
                 let i = 1n;
                 while (i < 10000n) {
-                    const x = f.reciprocal(i);
-                    if (f.mul(x)(i) !== 1n) {
-                        throw i;
-                    }
+                    assertEq(f.mul(f.reciprocal(i))(i), 1n);
                     ++i;
                 }
             },
             pow: () => {
                 const test = a => {
-                    if (f.pow(0n)(a) !== 1n) {
-                        throw '**0';
-                    }
-                    if (f.pow(1n)(a) !== a) {
-                        throw '**1';
-                    }
+                    assertEq(f.pow(0n)(a), 1n);
+                    assertEq(f.pow(1n)(a), a);
                     // https://en.wikipedia.org/wiki/Fermat%27s_little_theorem
                     // a^(p-1) % p = 1
-                    if (f.abs(f.pow(f.middle)(a)) !== 1n) {
-                        throw '**middle';
-                    }
-                    if (f.pow(f.sub(f.max)(1n))(a) !== f.reciprocal(a)) {
-                        throw '**(max-1)';
-                    }
-                    if (f.pow(f.max)(a) !== 1n) {
-                        throw '**max';
-                    }
+                    assertEq(f.abs(f.pow(f.middle)(a)), 1n);
+                    assertEq(f.pow(f.sub(f.max)(1n))(a), f.reciprocal(a));
+                    assertEq(f.pow(f.max)(a), 1n);
                 };
                 // 0
-                if (f.pow(0n)(0n) !== 1n) {
-                    throw '0**0';
-                }
-                if (f.pow(f.max)(0n) !== 0n) {
-                    throw '0**max';
-                }
+                assertEq(f.pow(0n)(0n), 1n);
+                assertEq(f.pow(f.max)(0n), 0n);
                 // 1
                 test(1n);
                 // 2
                 test(2n);
-                if (f.pow(2n)(2n) !== 4n) {
-                    throw '2**2';
-                }
-                if (f.pow(3n)(2n) !== 8n) {
-                    throw '2**3';
-                }
-                if (f.pow(128n)(2n) !== 1n << 128n) {
-                    throw '2**128';
-                }
+                assertEq(f.pow(2n)(2n), 4n);
+                assertEq(f.pow(3n)(2n), 8n);
+                assertEq(f.pow(128n)(2n), 1n << 128n);
                 // 3
                 test(3n);
-                if (f.pow(2n)(3n) !== 9n) {
-                    throw '3**2';
-                }
-                if (f.pow(3n)(3n) !== 27n) {
-                    throw '3**3';
-                }
-                if (f.pow(100n)(3n) !== 3n ** 100n) {
-                    throw '3**100';
-                }
-                if (f.pow(110n)(3n) !== 3n ** 110n) {
-                    throw '3**110';
-                }
-                if (f.pow(120n)(3n) !== 3n ** 120n) {
-                    throw '3**120';
-                }
-                if (f.pow(121n)(3n) !== 3n ** 121n) {
-                    throw '3**121';
-                }
+                assertEq(f.pow(2n)(3n), 9n);
+                assertEq(f.pow(3n)(3n), 27n);
+                assertEq(f.pow(100n)(3n), 3n ** 100n);
+                assertEq(f.pow(110n)(3n), 3n ** 110n);
+                assertEq(f.pow(120n)(3n), 3n ** 120n);
+                assertEq(f.pow(121n)(3n), 3n ** 121n);
                 //
                 test(f.middle);
                 test(f.max - 1n);
@@ -123,18 +71,13 @@ export const proof = {
             },
             sqrtExample: () => {
                 const field = prime_field(7n);
-                const root = sqrt(field)(4n);
-                if (root !== 2n) {
-                    throw root;
-                }
+                assertEq(sqrt(field)(4n), 2n);
             },
             sqrt: () => {
                 const test = a => {
                     const a2 = f.mul(a)(a);
                     const s = sqrt_f(a2);
-                    if (s !== null && f.abs(s) !== f.abs(a)) {
-                        throw 'sqrt';
-                    }
+                    assert(s === null || f.abs(s) === f.abs(a), 'sqrt');
                 };
                 let i = 1n;
                 while (i < 1000n) {
@@ -145,42 +88,40 @@ export const proof = {
                 test(f.max);
             },
             reduce: () => {
-                if (f.reduce(13n) !== 13n) {
-                    throw f.reduce(13n);
-                }
-                if (f.reduce(-1n) !== p - 1n) {
-                    throw [f.reduce(-1n), p - 1n];
-                }
+                assertEq(f.reduce(13n), 13n);
+                assertEq(f.reduce(-1n), p - 1n);
             },
             quadRes: () => {
-                if (!f.quadRes(0n)) {
-                    throw 0n;
-                }
-                if (!f.quadRes(1n)) {
-                    throw 1n;
-                }
-                if (!f.quadRes(p)) {
-                    throw p;
-                }
-                if (f.quadRes(3n)) {
-                    throw 3n;
-                }
+                assert(f.quadRes(0n), 0n);
+                assert(f.quadRes(1n), 1n);
+                assert(f.quadRes(p), p);
+                assert(!f.quadRes(3n), 3n);
                 const f2 = prime_field(2n);
-                if (!f2.quadRes(0n)) {
-                    throw '0 mod 2';
-                }
-                if (!f2.quadRes(1n)) {
-                    throw '1 mod 2';
-                }
+                assert(f2.quadRes(0n), '0 mod 2');
+                assert(f2.quadRes(1n), '1 mod 2');
             },
             modSqrt: () => {
                 const root = modSqrt(f);
-                if (root(4n) !== 2n) {
-                    throw root(4n);
-                }
-                if (f.pow2(root(2n)) !== 2n) {
-                    throw root(2n);
-                }
+                assertEq(root(4n), 2n);
+                assertEq(f.pow2(root(2n)), 2n);
+            },
+            div: () => {
+                assertEq(f.div(6n)(2n), 3n);
+                assertEq(f.div(0n)(5n), 0n);
+                assertEq(f.div(1n)(1n), 1n);
+            },
+            pow3: () => {
+                assertEq(f.pow3(0n), 0n);
+                assertEq(f.pow3(1n), 1n);
+                assertEq(f.pow3(2n), 8n);
+                assertEq(f.pow3(3n), 27n);
+                assertEq(f.pow3(10n), 1000n);
+            },
+            abs: () => {
+                assertEq(f.abs(0n), 0n);
+                assertEq(f.abs(1n), 1n);
+                assertEq(f.abs(f.neg(1n)), 1n);
+                assertEq(f.abs(f.middle), f.middle);
             },
         };
     }