functionalscript 0.43.1 → 0.44.0

package/fjs/types/object/proof.f.mjs

@@ -0,0 +1,26 @@
+import { at } from './module.f.mjs'
+/** @import { OptionalMap, RequiredMap, StringMap } from './types.ts' */
+import { assertEq } from '../../asserts/module.f.mjs'
+/** @import { Assert } from '../../asserts/types.ts' */
+/** @import { Equal } from '../ts/types.ts' */
+
+/** @typedef {Assert<Equal<StringMap<bigint>, { readonly [k in string]?: bigint }>>} _StringMapIsOptional */
+
+/** @typedef {Assert<Equal<OptionalMap<'a'|'b', bigint>, { readonly a?: bigint; readonly b?: bigint }>>} _OptionalIsPartial */
+
+/** @typedef {Assert<Equal<RequiredMap<'a'|'b', bigint>, { readonly a: bigint; readonly b: bigint }>>} _RequiredIsRequired */
+
+/** @typedef {Assert<Equal<RequiredMap<string, bigint>, never>>} _RequiredOverAnyStringIsNever */
+
+export const proof = {
+    ctor: () => {
+        const a = {}
+        const value = at('constructor')(a)
+        assertEq(value, null)
+    },
+    property: () => {
+        const a = { constructor: 42 }
+        const value = at('constructor')(a)
+        assertEq(value, 42)
+    }
+}

package/fjs/types/object/types.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Types for plain-object helpers: the `OptionalMap`/`RequiredMap`/`StringMap`
+ * record shapes and `Entry<T>`, and the `OneKey`/`SingleProperty`/`NotUnion`
+ * utility types.
+ *
+ * @module
+ */
+/** A record over the keys of `K`, each value possibly missing at runtime. */
+export type OptionalMap<K extends string, T> = {
+    readonly [k in K]?: T;
+};
+/**
+ * A record over the keys of `K`, each value required.
+ *
+ * `K` has to be a finite union of string literals: `RequiredMap<string, T>` is
+ * `never`, because no object can carry every string as a key. Use `StringMap<T>`
+ * for an open key set — its values are optional, which is what such a key set
+ * means at runtime.
+ *
+ * There is no known way to ask TypeScript whether `K` is finite, so the guard
+ * approximates it with `string extends K`, which holds exactly when `K` is
+ * `string`. Other infinite key sets are not caught: a template literal such as
+ * `x-${string}` yields a template index signature instead of `never`, and its
+ * reads are typed `T` while the runtime value is `undefined`. Keep `K` a union
+ * of string literals.
+ */
+export type RequiredMap<K extends string, T> = string extends K ? never : {
+    readonly [k in K]: T;
+};
+/** A record with an open key set. Every value can be missing at runtime. */
+export type StringMap<T> = OptionalMap<string, T>;
+export type Entry<T> = readonly [string, T];
+/**
+ * A set of objects with a single key.
+ *
+ * See also
+ * 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]: (RequiredMap<P, V> & OptionalMap<Exclude<K, P>, never>) extends infer O ? {
+        [Q in keyof O]: O[Q];
+    } : never;
+}[K];
+/**
+ * https://stackoverflow.com/questions/61112584/typing-a-single-record-entry
+ */
+export type NotUnion<T, U = T> = T extends unknown ? [
+    U
+] extends [T] ? T : never : never;
+export type SingleProperty<T extends StringMap<never>> = keyof T extends NotUnion<keyof T> ? T : never;

package/fjs/types/object/types.js

@@ -0,0 +1,8 @@
+/**
+ * Types for plain-object helpers: the `OptionalMap`/`RequiredMap`/`StringMap`
+ * record shapes and `Entry<T>`, and the `OneKey`/`SingleProperty`/`NotUnion`
+ * utility types.
+ *
+ * @module
+ */
+export {};

package/fjs/types/ordered_map/module.f.d.mts

@@ -0,0 +1,21 @@
+/**
+ * Ordered map operations with deterministic key traversal.
+ *
+ * @module
+ */
+import type { List } from '../list/types.ts';
+import type { Reduce } from '../function/operator/types.ts';
+import type { Entry, OrderedMap } from './types.ts';
+/** @type {(name: string) => <T>(map: OrderedMap<T>) => T | null} */
+export declare const at: (name: string) => <T>(map: OrderedMap<T>) => T | null;
+/** @type {<T>(reduce: Reduce<T>) => (name: string) => (value: T) => (map: OrderedMap<T>) => OrderedMap<T>} */
+export declare const setReduce: <T>(reduce: Reduce<T>) => (name: string) => (value: T) => (map: OrderedMap<T>) => OrderedMap<T>;
+/** @type {(name: string) => <T>(value: T) => (map: OrderedMap<T>) => OrderedMap<T>} */
+export declare const setReplace: (name: string) => <T>(value: T) => (map: OrderedMap<T>) => OrderedMap<T>;
+/** @type {<T>(map: OrderedMap<T>) => List<Entry<T>>} */
+export declare const entries: <T>(map: OrderedMap<T>) => List<Entry<T>>;
+/** @type {<T>(entries: List<Entry<T>>) => OrderedMap<T>} */
+export declare const fromEntries: <T>(entries: List<Entry<T>>) => OrderedMap<T>;
+/** @type {(name: string) => <T>(map: OrderedMap<T>) => OrderedMap<T>} */
+export declare const remove: (name: string) => <T>(map: OrderedMap<T>) => OrderedMap<T>;
+export declare const empty: null;

package/fjs/types/ordered_map/module.f.mjs

@@ -0,0 +1,54 @@
+/**
+ * Ordered map operations with deterministic key traversal.
+ *
+ * @module
+ */
+
+import { value, find } from '../btree/find/module.f.mjs'
+import { set } from '../btree/set/module.f.mjs'
+import { remove as btreeRemove } from '../btree/remove/module.f.mjs'
+import { values } from '../btree/module.f.mjs'
+/** @import { Sign } from '../function/compare/types.ts' */
+import { cmp } from '../string/module.f.mjs'
+/** @import { List } from '../list/types.ts' */
+import { fold } from '../list/module.f.mjs'
+/** @import { Reduce } from '../function/operator/types.ts' */
+/** @import { Entry, OrderedMap } from './types.ts' */
+
+/** @type {(a: string) => <T>(b: Entry<T>) => Sign} */
+const keyCmp = a => ([b]) => cmp(a)(b)
+
+/** @type {(name: string) => <T>(map: OrderedMap<T>) => T | null} */
+export const at = name => map => {
+    if (map === null) { return null }
+    const result = value(find(keyCmp(name))(map).first)
+    return result === null ? null : result[1]
+}
+
+/** @type {<T>(reduce: Reduce<T>) => (entry: Entry<T>) => (map: OrderedMap<T>) => OrderedMap<T>} */
+const setReduceEntry = reduce => entry =>
+    set(keyCmp(entry[0]))(old => old === null ? entry : [old[0], reduce(old[1])(entry[1])])
+
+/** @type {<T>(reduce: Reduce<T>) => (name: string) => (value: T) => (map: OrderedMap<T>) => OrderedMap<T>} */
+export const setReduce =
+    reduce => name => value => setReduceEntry(reduce)([name, value])
+
+/** @type {<T>(a: T) => (b: T) => T} */
+const replace = () => b => b
+
+/** @type {(name: string) => <T>(value: T) => (map: OrderedMap<T>) => OrderedMap<T>} */
+export const setReplace =
+    name => value => setReduceEntry(replace)([name, value])
+
+/** @type {<T>(map: OrderedMap<T>) => List<Entry<T>>} */
+export const entries = values
+
+/** @type {<T>(entries: List<Entry<T>>) => OrderedMap<T>} */
+export const fromEntries =
+    fold(setReduceEntry(replace))(null)
+
+/** @type {(name: string) => <T>(map: OrderedMap<T>) => OrderedMap<T>} */
+export const remove =
+    name => btreeRemove(keyCmp(name))
+
+export const empty = null

package/fjs/types/ordered_map/proof.f.mjs

@@ -0,0 +1,88 @@
+import { at, setReplace, setReduce, empty, entries, remove, fromEntries } from './module.f.mjs'
+/** @import { OrderedMap } from './types.ts' */
+import { toArray } from '../list/module.f.mjs'
+import { assertEq } from '../../asserts/module.f.mjs'
+
+export const proof = {
+    main: [
+        () => {
+            let m = setReplace('a')(1)(null)
+
+            assertEq(at('a')(m), 1)
+            assertEq(at('b')(m), null)
+
+            m = setReplace('b')(2)(m)
+
+            assertEq(at('a')(m), 1)
+            assertEq(at('b')(m), 2)
+            assertEq(at('c')(m), null)
+
+            m = setReplace('z')(3)(m)
+
+            assertEq(at('a')(m), 1)
+            assertEq(at('b')(m), 2)
+            assertEq(at('z')(m), 3)
+            assertEq(at('')(m), null)
+
+            m = setReplace('')(4)(m)
+
+            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)
+
+            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)
+            assertEq(at('Hello world!')(m), null)
+
+            m = setReduce((/** @type {number} */a) => (/** @type {number} */b) => a + b)('a')(43)(m)
+            assertEq(at('a')(m), 44)
+        },
+        () => {
+            let m = setReplace('x')(12)(null)
+            m = setReplace('y')(44)(m)
+            assertEq(at('x')(m), 12)
+            assertEq(at('y')(m), 44)
+            assertEq(at('a')(m), null)
+            const e = toArray(entries(m))
+            assertEq(e.length, 2)
+        },
+    ],
+    fromEntries: () => {
+        /** @type {readonly (readonly [string, number])[]} */
+        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(/** @type {const} */([['x', 10], ['x', 20]]))
+        assertEq(at('x')(m2), 20)
+    },
+    stress: () => {
+        /** @type {OrderedMap<number>} */
+        let m = empty
+        for (let i = 0; i < 100_000; ++i) {
+            m = setReplace((i * i).toString())(i)(m)
+            /*
+            console.log()
+            console.log(`# ${i}`)
+            console.log()
+            for (const e of m.struct()) {
+                console.log(e)
+            }
+            */
+        }
+    }
+}

package/fjs/types/ordered_map/types.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Types for the ordered map data structure.
+ *
+ * @module
+ */
+import type { Tree } from '../btree/types/types.ts';
+export type Entry<T> = readonly [string, T];
+export type OrderedMap<T> = Tree<Entry<T>>;

package/fjs/types/ordered_map/types.js

@@ -0,0 +1,6 @@
+/**
+ * Types for the ordered map data structure.
+ *
+ * @module
+ */
+export {};

package/fjs/types/patricia_trie/module.f.d.mts

@@ -0,0 +1,19 @@
+/**
+ * Streaming Patricia trie for building content-addressed binary trees from sorted leaf sequences.
+ *
+ * @module
+ */
+import type { Create, PatriciaTrie } from './types.ts';
+/** @import { Candidate, Create, PatriciaTrie } from './types.ts' */
+/**
+ * Creates a Patricia trie whose node merging is delegated to `create`.
+ *
+ * @type {<S, T>(create: Create<S, T>) => PatriciaTrie<S, T>}
+ */
+export declare const patriciaTrie: <S, T>(create: Create<S, T>) => PatriciaTrie<S, T>;
+/**
+ * Constructs the initial state from a storage value.
+ *
+ * @type {<S>(storage: S) => readonly [S, readonly []]}
+ */
+export declare const emptyState: <S>(storage: S) => readonly [S, readonly []];

package/fjs/types/patricia_trie/module.f.mjs

@@ -0,0 +1,43 @@
+/**
+ * Streaming Patricia trie for building content-addressed binary trees from sorted leaf sequences.
+ *
+ * @module
+ */
+
+/** @import { Candidate, Create, PatriciaTrie } from './types.ts' */
+
+/**
+ * Creates a Patricia trie whose node merging is delegated to `create`.
+ *
+ * @type {<S, T>(create: Create<S, T>) => PatriciaTrie<S, T>}
+ */
+export const patriciaTrie = create => ({
+    push: (c, [storage, stack]) => {
+        const [u] = c
+        while (stack.length >= 2) {
+            const [rLeaf, rHash] = stack[stack.length - 1]
+            const [lLeaf, lHash] = stack[stack.length - 2]
+            if ((lLeaf ^ rLeaf) >= (rLeaf ^ u)) { break }
+            const [h, newS] = create(lHash, rHash, storage)
+            storage = newS
+            stack = [...stack.slice(0, -2), [rLeaf, h]]
+        }
+        return [storage, [...stack, c]]
+    },
+    end: ([storage, stack]) => {
+        if (stack.length === 0) { return [undefined, storage] }
+        let h = stack[stack.length - 1][1]
+        for (let i = stack.length - 2; i >= 0; i--) {
+            const lHash = stack[i][1];
+            [h, storage] = create(lHash, h, storage)
+        }
+        return [h, storage]
+    }
+})
+
+/**
+ * Constructs the initial state from a storage value.
+ *
+ * @type {<S>(storage: S) => readonly [S, readonly []]}
+ */
+export const emptyState = storage => [storage, []]

package/fjs/types/patricia_trie/proof.f.d.mts

@@ -0,0 +1,14 @@
+export type _NodeList = readonly [bigint, bigint, bigint][];
+declare const empty: () => void;
+declare const singleLeaf: () => void;
+declare const twoLeaves: () => void;
+declare const descending: () => void;
+declare const ascending: () => void;
+export declare const proof: {
+    empty: typeof empty;
+    singleLeaf: typeof singleLeaf;
+    twoLeaves: typeof twoLeaves;
+    descending: typeof descending;
+    ascending: typeof ascending;
+};
+export {};

package/fjs/types/patricia_trie/proof.f.mjs

@@ -0,0 +1,148 @@
+import { assert, assertEq } from '../../asserts/module.f.mjs'
+import { emptyState, patriciaTrie } from './module.f.mjs'
+/** @import { State } from './types.ts' */
+
+/** @typedef {readonly [bigint, bigint, bigint][]} _NodeList */
+
+/** @type {(a: bigint, b: bigint) => bigint} */
+const combine = (a, b) => a * 1_000n + b
+
+/** @type {(a: bigint, b: bigint, s: _NodeList) => readonly [bigint, _NodeList]} */
+const create = (a, b, s) => {
+    const h = combine(a, b)
+    return [h, [...s, [a, b, h]]]
+}
+
+const { push, end } = patriciaTrie(create)
+
+/** @type {(state: State<_NodeList, bigint>) => readonly bigint[]} */
+const leaves = ([, candidates]) => candidates.map(([leaf]) => leaf)
+
+/** @type {(inputs: readonly bigint[], expectedLeaves: readonly (readonly bigint[])[], expectedNodeCounts: readonly number[]) => void} */
+const runExample = (inputs, expectedLeaves, expectedNodeCounts) => {
+    /** @type {State<_NodeList, bigint>} */
+    let state = emptyState([])
+    for (let i = 0; i < inputs.length; i++) {
+        const x = inputs[i]
+        const prevCount = state[0].length
+        state = push([x, x], state)
+
+        const actual = leaves(state)
+        assertEq(actual.length, expectedLeaves[i].length)
+        for (let j = 0; j < actual.length; j++) {
+            assertEq(actual[j], expectedLeaves[i][j])
+        }
+
+        const newNodes = state[0].slice(prevCount)
+        assertEq(newNodes.length, expectedNodeCounts[i])
+        for (const [l, r, h] of newNodes) { assertEq(h, combine(l, r)) }
+    }
+    const prevCount = state[0].length
+    const [root, finalStorage] = end(state)
+    const finalNodes = finalStorage.slice(prevCount)
+    assertEq(finalNodes.length, expectedLeaves[expectedLeaves.length - 1].length - 1)
+    assert(root !== undefined)
+    for (const [l, r, h] of finalNodes) { assertEq(h, combine(l, r)) }
+}
+
+const empty = () => {
+    const [root, storage] = end(emptyState([]))
+    assertEq(storage.length, 0)
+    assertEq(root, undefined)
+}
+
+const singleLeaf = () => {
+    const state = push([42n, 42n], emptyState([]))
+    assertEq(state[0].length, 0)
+    assertEq(leaves(state).length, 1)
+    assertEq(leaves(state)[0], 42n)
+
+    const [root, finalStorage] = end(state)
+    assertEq(finalStorage.length, 0)
+    assertEq(root, 42n)
+}
+
+const twoLeaves = () => {
+    const s1 = push([7n, 7n], emptyState([]))
+    const prevCount = s1[0].length
+    const s2 = push([3n, 3n], s1)
+    assertEq(s2[0].slice(prevCount).length, 0)
+    assertEq(leaves(s2).length, 2)
+
+    const prevCount2 = s2[0].length
+    const [root, finalStorage] = end(s2)
+    const finalNodes = finalStorage.slice(prevCount2)
+    assertEq(finalNodes.length, 1)
+    assertEq(finalNodes[0][0], 7n)
+    assertEq(finalNodes[0][1], 3n)
+    assertEq(finalNodes[0][2], combine(7n, 3n))
+    assertEq(root, combine(7n, 3n))
+}
+
+// example.md — descending
+// merges happen at: step 2 (1), 3 (1), 4 (1), 7 (2), 8 (2), A (1), C (2), F (1)
+const descending = () => runExample(
+    [
+        0b11111001n, 0b11110010n, 0b11100011n, 0b11001000n,
+        0b10110011n, 0b10100110n, 0b10100011n, 0b10011111n,
+        0b01110111n, 0b01101110n, 0b01011001n, 0b01001001n,
+        0b00100111n, 0b00010111n, 0b00010000n, 0b00001110n,
+    ],
+    [
+        [0b11111001n],
+        [0b11111001n, 0b11110010n],
+        [0b11110010n, 0b11100011n],
+        [0b11100011n, 0b11001000n],
+        [0b11001000n, 0b10110011n],
+        [0b11001000n, 0b10110011n, 0b10100110n],
+        [0b11001000n, 0b10110011n, 0b10100110n, 0b10100011n],
+        [0b11001000n, 0b10100011n, 0b10011111n],
+        [0b10011111n, 0b01110111n],
+        [0b10011111n, 0b01110111n, 0b01101110n],
+        [0b10011111n, 0b01101110n, 0b01011001n],
+        [0b10011111n, 0b01101110n, 0b01011001n, 0b01001001n],
+        [0b10011111n, 0b01001001n, 0b00100111n],
+        [0b10011111n, 0b01001001n, 0b00100111n, 0b00010111n],
+        [0b10011111n, 0b01001001n, 0b00100111n, 0b00010111n, 0b00010000n],
+        [0b10011111n, 0b01001001n, 0b00100111n, 0b00010000n, 0b00001110n],
+    ],
+    [0, 0, 1, 1, 1, 0, 0, 2, 2, 0, 1, 0, 2, 0, 0, 1],
+)
+
+// example.md — ascending (same values, reversed)
+// merges happen at: step 3 (2), 4 (1), 6 (1), 8 (3), B (1), C (2)
+const ascending = () => runExample(
+    [
+        0b00001110n, 0b00010000n, 0b00010111n, 0b00100111n,
+        0b01001001n, 0b01011001n, 0b01101110n, 0b01110111n,
+        0b10011111n, 0b10100011n, 0b10100110n, 0b10110011n,
+        0b11001000n, 0b11100011n, 0b11110010n, 0b11111001n,
+    ],
+    [
+        [0b00001110n],
+        [0b00001110n, 0b00010000n],
+        [0b00001110n, 0b00010000n, 0b00010111n],
+        [0b00010111n, 0b00100111n],
+        [0b00100111n, 0b01001001n],
+        [0b00100111n, 0b01001001n, 0b01011001n],
+        [0b00100111n, 0b01011001n, 0b01101110n],
+        [0b00100111n, 0b01011001n, 0b01101110n, 0b01110111n],
+        [0b01110111n, 0b10011111n],
+        [0b01110111n, 0b10011111n, 0b10100011n],
+        [0b01110111n, 0b10011111n, 0b10100011n, 0b10100110n],
+        [0b01110111n, 0b10011111n, 0b10100110n, 0b10110011n],
+        [0b01110111n, 0b10110011n, 0b11001000n],
+        [0b01110111n, 0b10110011n, 0b11001000n, 0b11100011n],
+        [0b01110111n, 0b10110011n, 0b11001000n, 0b11100011n, 0b11110010n],
+        [0b01110111n, 0b10110011n, 0b11001000n, 0b11100011n, 0b11110010n, 0b11111001n],
+    ],
+    [0, 0, 0, 2, 1, 0, 1, 0, 3, 0, 0, 1, 2, 0, 0, 0],
+)
+
+export const proof = {
+    empty,
+    singleLeaf,
+    twoLeaves,
+    descending,
+    ascending
+}

package/fjs/types/patricia_trie/types.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Types for the streaming Patricia trie.
+ *
+ * @module
+ */
+/**
+ * Merges two child identities into a parent. Values first, storage last in both
+ * params and return.
+ */
+export type Create<S, T> = (a: T, b: T, storage: S) => readonly [T, S];
+/**
+ * A leaf entry: `[sortKey, identity]`. The sort key is used only for XOR
+ * comparisons.
+ */
+export type Candidate<T> = readonly [bigint, T];
+export type InternalState<T> = readonly Candidate<T>[];
+/**
+ * Streaming state: `[storage, right-spine stack]`.
+ */
+export type State<S, T> = readonly [S, InternalState<T>];
+/**
+ * @property push
+ *
+ * Add one leaf. Merges any tightly-coupled stack candidates before pushing.
+ *
+ * @property end
+ *
+ * Drain the stack right-to-left, returning the root identity and final storage.
+ * Returns `undefined` as the root if no leaves were pushed.
+ */
+export type PatriciaTrie<S, T> = {
+    readonly push: (c: Candidate<T>, state: State<S, T>) => State<S, T>;
+    readonly end: (state: State<S, T>) => readonly [T | undefined, S];
+};

package/fjs/types/patricia_trie/types.js

@@ -0,0 +1,6 @@
+/**
+ * Types for the streaming Patricia trie.
+ *
+ * @module
+ */
+export {};

package/fjs/types/prime_field/module.f.d.mts

@@ -0,0 +1,42 @@
+/**
+ * Prime field arithmetic over `bigint`: `prime_field(p)` builds a `PrimeField`
+ * with negation, addition, subtraction, multiplication, division via modular
+ * inverse, and exponentiation; `sqrt` returns a square-root function when
+ * `p % 4 === 3`.
+ *
+ * @module
+ */
+import type { Unary } from '../bigint/types.ts';
+import type { PrimeField } from './types.ts';
+/** @import { PrimeField } from './types.ts' */
+/**
+ * Creates a prime field with the specified prime modulus and associated operations.
+ *
+ * @param {bigint} p A prime number to define the field.
+ * @returns {PrimeField} The prime field object.
+ */
+export declare const prime_field: (p: bigint) => PrimeField;
+/**
+ * Computes the square root of a number in a prime field.
+ *
+ * @throws If the prime modulus `p` does not satisfy `p % 4 == 3`.
+ *
+ * @param {PrimeField} field
+ * @returns {(a: bigint) => bigint | null}
+ *
+ * @example
+ *
+ * ```js
+ * const field = prime_field(7n);
+ * const root = sqrt(field)(4n);
+ * if (root !== 2n) { throw root }
+ * ```
+ */
+export declare const sqrt: ({ p, pow, pow2 }: PrimeField) => (a: bigint) => bigint | null;
+/**
+ * Modular square root mod `p` (`p ≡ 3 (mod 4)`); uses {@link PrimeField.neg} when `x` is not a residue.
+ *
+ * @param {PrimeField} field
+ * @returns {Unary}
+ */
+export declare const modSqrt: (field: PrimeField) => Unary;