functionalscript 0.3.5 → 0.3.7

package/crypto/prime_field/module.f.d.ts

@@ -1,4 +1,4 @@
-import * as Operator from '../../types/function/operator/module.f.ts';
+import type * as Operator from '../../types/function/operator/module.f.ts';
 type Reduce = Operator.Reduce<bigint>;
 type Unary = Operator.Unary<bigint, bigint>;
 /**

package/crypto/prime_field/module.f.js

@@ -1,5 +1,4 @@
-import * as Operator from "../../types/function/operator/module.f.js";
-import { scalar_mul } from "../../types/bigint/module.f.js";
+import { repeat } from "../../types/monoid/module.f.js";
 /**
  * Creates a prime field with the specified prime modulus and associated operations.
  *
@@ -33,7 +32,7 @@ export const prime_field = p => {
     };
     const middle = p >> 1n;
     const pow2 = a => mul(a)(a);
-    const pow = scalar_mul({ 0: 1n, add: mul });
+    const pow = repeat({ identity: 1n, operation: mul });
     return {
         p,
         middle,

package/crypto/secp/module.f.d.ts

@@ -1,4 +1,4 @@
-import * as Operator from '../../types/function/operator/module.f.ts';
+import type * as Operator from '../../types/function/operator/module.f.ts';
 import { type PrimeField } from '../prime_field/module.f.ts';
 /**
  * A 2D point represented as a pair of `bigint` values `[x, y]`.

package/crypto/secp/module.f.js

@@ -1,6 +1,5 @@
-import * as Operator from "../../types/function/operator/module.f.js";
 import { prime_field, sqrt } from "../prime_field/module.f.js";
-import { scalar_mul } from "../../types/bigint/module.f.js";
+import { repeat } from "../../types/monoid/module.f.js";
 /**
  * Constructs an elliptic curve with the given initialization parameters.
  *
@@ -71,7 +70,7 @@ export const curve = ({ p, a: [a0, a1], n }) => {
             return [x, neg(y)];
         },
         add: addPoint,
-        mul: scalar_mul({ 0: null, add: addPoint })
+        mul: repeat({ identity: null, operation: addPoint })
     };
 };
 export const eq = a => b => {

package/html/module.f.d.ts

@@ -6,8 +6,8 @@ export type Element = Element1 | Element2;
 type Attributes = {
     readonly [k in string]: string;
 };
-type Node = Element | string;
-export declare const element: (element: Element) => List<string>;
+export type Node = Element | string;
+export declare const element: (e: Element) => List<string>;
 export declare const html: (_: Element) => List<string>;
 export declare const htmlToString: (_: Element) => string;
 export {};

package/html/module.f.js

@@ -1,6 +1,5 @@
 import { map, flatMap, flat, concat as listConcat } from "../types/list/module.f.js";
 import { concat as stringConcat } from "../types/string/module.f.js";
-import * as O from "../types/object/module.f.js";
 import { compose } from "../types/function/module.f.js";
 import * as utf16 from "../text/utf16/module.f.js";
 const { stringToList } = utf16;
@@ -27,11 +26,10 @@ const voidTagList = [
     'track',
     'wbr',
 ];
-const isVoid = tag => voidTagList.includes(tag);
 /**
  * https://stackoverflow.com/questions/7381974/which-characters-need-to-be-escaped-in-html
  */
-const escapeCharCode = code => {
+const escapeCharCode = (code) => {
     switch (code) {
         case 0x22: return '"';
         case 0x26: return '&';
@@ -41,18 +39,24 @@ const escapeCharCode = code => {
     }
 };
 const escape = compose(stringToList)(map(escapeCharCode));
-const node = n => typeof n === 'string' ? escape(n) : element(n);
+const node = (n) => typeof n === 'string' ? escape(n) : element(n);
 const nodes = flatMap(node);
 const attribute = ([name, value]) => flat([[' ', name, '="'], escape(value), ['"']]);
 const attributes = compose(entries)(flatMap(attribute));
-const open = t => a => flat([[`<`, t], attributes(a), [`>`]]);
-const element3 = t => ([a, n]) => {
-    const o = flat([[`<`, t], attributes(a), [`>`]]);
-    return isVoid(t) ? o : flat([o, nodes(n), ['</', t, '>']]);
+const parseElement = (e) => {
+    const [tag, item1, ...list] = e;
+    return item1 === undefined ?
+        [tag, {}, []] :
+        typeof item1 === 'object' && !(item1 instanceof Array) ?
+            [tag, item1, list] :
+            [tag, {}, [item1, ...list]];
 };
-export const element = e => {
-    const [t, a, ...n] = e;
-    return element3(t)(a === undefined ? [{}, []] : typeof a === 'object' && !(a instanceof Array) ? [a, n] : [{}, [a, ...n]]);
+export const element = (e) => {
+    const [tag, a, n] = parseElement(e);
+    const open = flat([[`<`, tag], attributes(a), [`>`]]);
+    return voidTagList.includes(tag) ?
+        open :
+        flat([open, nodes(n), ['</', tag, '>']]);
 };
 export const html = compose(element)(listConcat(['<!DOCTYPE html>']));
 export const htmlToString = compose(html)(stringConcat);

package/html/test.f.js

@@ -1,40 +1,40 @@
-import * as _ from "./module.f.js";
+import { htmlToString } from "./module.f.js";
 export default {
     empty: () => {
-        const r = _.htmlToString(['html']);
+        const r = htmlToString(['html']);
         if (r !== '<!DOCTYPE html><html></html>') {
             throw `empty: ${r}`;
         }
     },
     empty2: () => {
-        const r = _.htmlToString(['html']);
+        const r = htmlToString(['html']);
         if (r !== '<!DOCTYPE html><html></html>') {
             throw r;
         }
     },
     void: () => {
-        const r = _.htmlToString(['area']);
+        const r = htmlToString(['area']);
         if (r !== '<!DOCTYPE html><area>') {
             throw r;
         }
     },
     some: () => {
         const x = ['div', {}, '<div>&amp;</div>', ['a', { href: 'hello"' }]];
-        const s = _.htmlToString(x);
+        const s = htmlToString(x);
         if (s !== '<!DOCTYPE html><div>&lt;div&gt;&amp;amp;&lt;/div&gt;<a href="hello&quot;"></a></div>') {
             throw s;
         }
     },
     some2: () => {
         const x = ['div', '<div>&amp;</div>', ['a', { href: 'hello"' }]];
-        const s = _.htmlToString(x);
+        const s = htmlToString(x);
         if (s !== '<!DOCTYPE html><div>&lt;div&gt;&amp;amp;&lt;/div&gt;<a href="hello&quot;"></a></div>') {
             throw s;
         }
     },
     someVoid: () => {
         const x = ['div', ['br', { id: '5' }], '<div>&amp;</div>', ['a', { href: 'hello"' }]];
-        const s = _.htmlToString(x);
+        const s = htmlToString(x);
         if (s !== '<!DOCTYPE html><div><br id="5">&lt;div&gt;&amp;amp;&lt;/div&gt;<a href="hello&quot;"></a></div>') {
             throw s;
         }

package/js/tokenizer/module.f.d.ts

@@ -1,5 +1,5 @@
 import * as list from '../../types/list/module.f.ts';
-import * as bigfloatT from '../../types/bigfloat/module.f.ts';
+import type * as bigfloatT from '../../types/bigfloat/module.f.ts';
 export type StringToken = {
     readonly kind: 'string';
     readonly value: string;

package/js/tokenizer/module.f.js

@@ -7,7 +7,6 @@ const { at } = map;
 import * as _range from "../../types/range/module.f.js";
 const { one } = _range;
 const { empty, stateScan, flat, toArray, reduce: listReduce, scan } = list;
-import * as bigfloatT from "../../types/bigfloat/module.f.js";
 const { fromCharCode } = String;
 import * as ascii from "../../text/ascii/module.f.js";
 const { range } = ascii;

package/nanvm-lib/tests/test.f.d.ts

@@ -23,5 +23,33 @@ declare const _default: {
             object: () => void;
         };
     };
+    unary_plus: () => {
+        null: () => void;
+        undefined: () => void;
+        boolean: {
+            false: () => void;
+            true: () => void;
+        };
+        number: {
+            zero: () => void;
+            positive: () => void;
+            negative: () => void;
+        };
+        string: {
+            empty: () => void;
+            zero: () => void;
+            positive: () => void;
+            nan: () => void;
+        };
+        array: {
+            empty: () => void;
+            single_number: () => void;
+            single_string: () => void;
+            multiple: () => void;
+        };
+        object: {
+            empty: () => void;
+        };
+    };
 };
 export default _default;

package/nanvm-lib/tests/test.f.js

@@ -25,6 +25,7 @@ export default {
             },
             nullish: () => {
                 n(false)(undefined);
+                n(false)(null);
             }
         },
         number: {
@@ -80,5 +81,49 @@ export default {
                 n(o)({ '0': '0' });
             }
         }
+    },
+    unary_plus: () => {
+        const op = (n) => +n;
+        const nan = (n) => {
+            let result = op(n);
+            if (!Number.isNaN(result)) {
+                throw result;
+            }
+        };
+        return {
+            null: () => e(op(null))(0),
+            undefined: () => nan(undefined),
+            boolean: {
+                false: () => e(op(false))(0),
+                true: () => e(op(true))(1)
+            },
+            number: {
+                zero: () => e(op(0))(0),
+                positive: () => e(op(2.3))(2.3),
+                negative: () => e(op(-2.3))(-2.3)
+            },
+            string: {
+                empty: () => e(op(""))(0),
+                zero: () => e(op("0"))(0),
+                positive: () => e(op("2.3"))(2.3),
+                nan: () => nan("a")
+            },
+            // TODO: bigint - handle TypeError exception for bigint. The test below (that follows
+            // current Rust implementation) is incorrect.
+            // bigint: {
+            //     nan: () => u_p_nan(0n)
+            // }
+            array: {
+                empty: () => e(op([]))(0),
+                single_number: () => e(op([2.3]))(2.3),
+                single_string: () => e(op(["-2.3"]))(-2.3),
+                multiple: () => nan([null, null])
+            },
+            object: {
+                empty: () => nan({})
+                // TODO: test objects with valueOf, toString functions - when Rust logic is implemented
+            }
+            // TODO: test Function - when Rust logic is implemented
+        };
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "type": "module",
   "files": [
     "**/*.f.d.ts",

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

@@ -1,21 +1,24 @@
 export type Array1<T> = readonly [T];
-type Index1 = 0;
+export type Index1 = 0;
 export type Array2<T> = readonly [T, T];
-type Index2 = 0 | 1;
+export type Tuple2<T0, T1> = readonly [T0, T1];
+export type Index2 = 0 | 1;
 export type Array3<T> = readonly [T, T, T];
+export type Tuple3<T0, T1, T2> = readonly [T0, T1, T2];
 export type Index3 = 0 | 1 | 2;
 export type Array4<T> = readonly [T, T, T, T];
-type Index4 = 0 | 1 | 2 | 3;
+export type Index4 = 0 | 1 | 2 | 3;
 export type Array5<T> = readonly [T, T, T, T, T];
 export type Array8<T> = readonly [T, T, T, T, T, T, T, T];
 export type Array16<T> = readonly [T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T];
+export type Index16 = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15;
+export type Array1_5<T> = Array1<T> | Array2<T> | Array3<T> | Array4<T> | Array5<T>;
 export type Index5 = 0 | 1 | 2 | 3 | 4;
 export type KeyOf<T> = T extends Array1<infer _> ? Index1 : T extends Array2<infer _> ? Index2 : T extends Array3<infer _> ? Index3 : T extends Array4<infer _> ? Index4 : T extends Array5<infer _> ? Index5 : T extends readonly (infer _)[] ? number : never;
-export declare const at: (index: number) => <T>(a: readonly T[]) => T | null;
+export declare const at: (i: number) => <T>(a: readonly T[]) => T | null;
 export declare const first: <T>(_: readonly T[]) => T | null;
-export declare const last: <T>(_: readonly T[]) => T | null;
-export declare const tail: <T>(_: readonly T[]) => readonly T[] | null;
+export declare const last: <T>(a: readonly T[]) => T | null;
+export declare const tail: <T>(a: readonly T[]) => readonly T[] | null;
 export declare const splitFirst: <T>(a: readonly T[]) => readonly [T, readonly T[]] | null;
-export declare const head: <T>(_: readonly T[]) => readonly T[] | null;
-export declare const splitLast: <T>(_: readonly T[]) => readonly [readonly T[], T] | null;
-export {};
+export declare const head: <T>(a: readonly T[]) => readonly T[] | null;
+export declare const splitLast: <T>(a: readonly T[]) => readonly [readonly T[], T] | null;

package/types/array/module.f.js

@@ -1,20 +1,19 @@
-import * as option from "../nullable/module.f.js";
-const { map } = option;
-const uncheckTail = a => a.slice(1);
-const uncheckHead = a => a.slice(0, -1);
-export const at = i => a => {
+import { map } from "../nullable/module.f.js";
+const uncheckTail = (a) => a.slice(1);
+const uncheckHead = (a) => a.slice(0, -1);
+export const at = (i) => (a) => {
     const r = a[i];
-    return r === void 0 ? null : r;
+    return r === undefined ? null : r;
 };
 export const first = at(0);
-export const last = a => at(a.length - 1)(a);
-export const tail = a => a.length === 0 ? null : uncheckTail(a);
+export const last = (a) => at(a.length - 1)(a);
+export const tail = (a) => a.length === 0 ? null : uncheckTail(a);
 export const splitFirst = (a) => {
-    const split = first => [first, uncheckTail(a)];
+    const split = (first) => [first, uncheckTail(a)];
     return map(split)(first(a));
 };
-export const head = a => a.length === 0 ? null : uncheckHead(a);
-export const splitLast = a => {
+export const head = (a) => a.length === 0 ? null : uncheckHead(a);
+export const splitLast = (a) => {
     const lastA = last(a);
     if (lastA === null) {
         return null;

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

@@ -6,5 +6,6 @@ declare const _default: {
     head: (() => void)[];
     tail: (() => void)[];
     splitFirst: (() => void)[];
+    splitLast: (() => void)[];
 };
 export default _default;

package/types/array/test.f.js

@@ -1,7 +1,6 @@
-import * as _ from "./module.f.js";
+import { at, first, last, head, tail, splitFirst, splitLast } from "./module.f.js";
 import * as json from "../../json/module.f.js";
-import * as o from "../object/module.f.js";
-const { sort } = o;
+import { sort } from "../object/module.f.js";
 const stringify = json.stringify(sort);
 export default {
     stringify: () => {
@@ -12,13 +11,13 @@ export default {
     },
     at: [
         () => {
-            const result = _.at(2)([1, 20, 300]);
+            const result = at(2)([1, 20, 300]);
             if (result !== 300) {
                 throw result;
             }
         },
         () => {
-            const result = _.at(3)([1, 20, 300]);
+            const result = at(3)([1, 20, 300]);
             if (result !== null) {
                 throw result;
             }
@@ -26,13 +25,13 @@ export default {
     ],
     first: [
         () => {
-            const result = _.first([1, 20, 300]);
+            const result = first([1, 20, 300]);
             if (result !== 1) {
                 throw result;
             }
         },
         () => {
-            const result = _.first([]);
+            const result = first([]);
             if (result !== null) {
                 throw result;
             }
@@ -40,13 +39,13 @@ export default {
     ],
     last: [
         () => {
-            const result = _.last([1, 20, 300]);
+            const result = last([1, 20, 300]);
             if (result !== 300) {
                 throw result;
             }
         },
         () => {
-            const result = _.last([]);
+            const result = last([]);
             if (result !== null) {
                 throw result;
             }
@@ -54,7 +53,7 @@ export default {
     ],
     head: [
         () => {
-            const result = _.head([1, 20, 300]);
+            const result = head([1, 20, 300]);
             if (result === null) {
                 throw result;
             }
@@ -64,7 +63,7 @@ export default {
             }
         },
         () => {
-            const result = _.head([]);
+            const result = head([]);
             if (result !== null) {
                 throw result;
             }
@@ -72,14 +71,14 @@ export default {
     ],
     tail: [
         () => {
-            const result = _.tail([1, 20, 300]);
+            const result = tail([1, 20, 300]);
             const str = stringify(result);
             if (str !== '[20,300]') {
                 throw str;
             }
         },
         () => {
-            const result = _.tail([]);
+            const result = tail([]);
             if (result !== null) {
                 throw result;
             }
@@ -87,27 +86,29 @@ export default {
     ],
     splitFirst: [
         () => {
-            const result = _.splitFirst([1, 20, 300]);
+            const result = splitFirst([1, 20, 300]);
             const str = stringify(result);
             if (str !== '[1,[20,300]]') {
                 throw str;
             }
         },
         () => {
-            const result = _.splitFirst([]);
+            const result = splitFirst([]);
             if (result !== null) {
                 throw result;
             }
         },
+    ],
+    splitLast: [
         () => {
-            const result = _.splitLast([1, 20, 300]);
+            const result = splitLast([1, 20, 300]);
             const str = stringify(result);
             if (str !== '[[1,20],300]') {
                 throw str;
             }
         },
         () => {
-            const result = _.splitLast([]);
+            const result = splitLast([]);
             if (result !== null) {
                 throw result;
             }

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

@@ -1,3 +1,3 @@
 export type BigFloat = readonly [bigint, number];
-export declare const multiply: (b: BigFloat) => (mul: bigint) => BigFloat;
+export declare const multiply: ([m, e]: BigFloat) => (mul: bigint) => BigFloat;
 export declare const decToBin: (dec: BigFloat) => BigFloat;

package/types/bigfloat/module.f.js

@@ -1,8 +1,7 @@
-import * as bi from "../bigint/module.f.js";
-const { abs, sign } = bi;
+import { abs, sign } from "../bigint/module.f.js";
 const twoPow53 = 9007199254740992n;
 const twoPow54 = 18014398509481984n;
-const increaseMantissa = ([m, e]) => min => {
+const increaseMantissa = ([m, e]) => (min) => {
     if (m === 0n) {
         return [m, e];
     }
@@ -16,7 +15,7 @@ const increaseMantissa = ([m, e]) => min => {
         e--;
     }
 };
-const decreaseMantissa = ([m, e]) => max => {
+const decreaseMantissa = ([m, e]) => (max) => {
     if (m === 0n) {
         return [m, e];
     }
@@ -30,10 +29,10 @@ const decreaseMantissa = ([m, e]) => max => {
         e++;
     }
 };
-const pow = base => exp => base ** BigInt(exp);
+const pow = (base) => (exp) => base ** BigInt(exp);
 const pow5 = pow(5n);
-export const multiply = ([m, e]) => mul => [m * mul, e];
-const divide = ([m, e]) => div => [[m / div, e], m % div];
+export const multiply = ([m, e]) => (mul) => [m * mul, e];
+const divide = ([m, e]) => (div) => [[m / div, e], m % div];
 const round53 = ([[m, e], r]) => {
     const mabs = abs(m);
     const s = BigInt(sign(m));

package/types/bigfloat/test.f.js

@@ -1,5 +1,4 @@
-import * as _ from "./module.f.js";
-const { decToBin } = _;
+import { decToBin } from "./module.f.js";
 export default {
     decToBin: [
         () => {

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

@@ -1,16 +1,13 @@
 import * as compare from '../function/compare/module.f.ts';
-import * as Operator from '../function/operator/module.f.ts';
+import type * as Operator from '../function/operator/module.f.ts';
 import { type List } from '../list/module.f.ts';
-export declare const addition: (a: bigint) => (b: bigint) => bigint;
+type Unary = Operator.Unary<bigint, bigint>;
+type Reduce = Operator.Reduce<bigint>;
+export declare const addition: Reduce;
 export declare const sum: (input: List<bigint>) => bigint;
-export declare const abs: (a: bigint) => bigint;
+export declare const abs: Unary;
 export declare const sign: (a: bigint) => compare.Sign;
 export declare const serialize: (a: bigint) => string;
-type Additive<T> = {
-    readonly 0: T;
-    readonly add: Operator.Reduce<T>;
-};
-export declare const scalar_mul: <T>(a: Additive<T>) => (a: T) => (n: bigint) => T;
 /**
  * Calculates the base-2 logarithm (floor).
  *

package/types/bigint/module.f.js

@@ -1,5 +1,4 @@
 import * as compare from "../function/compare/module.f.js";
-import * as Operator from "../function/operator/module.f.js";
 const { unsafeCmp } = compare;
 import { reduce } from "../list/module.f.js";
 export const addition = a => b => a + b;
@@ -7,21 +6,6 @@ export const sum = reduce(addition)(0n);
 export const abs = a => a >= 0 ? a : -a;
 export const sign = a => unsafeCmp(a)(0n);
 export const serialize = a => `${a}n`;
-export const scalar_mul = ({ 0: _0, add }) => a => n => {
-    let ai = a;
-    let ni = n;
-    let result = _0;
-    while (true) {
-        if ((ni & 1n) === 1n) {
-            result = add(result)(ai);
-        }
-        ni >>= 1n;
-        if (ni === 0n) {
-            return result;
-        }
-        ai = add(ai)(ai);
-    }
-};
 /**
  * Calculates the base-2 logarithm (floor).
  *

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

@@ -0,0 +1,73 @@
+import type { Reduce } from "../function/operator/module.f.ts";
+/**
+ * Represents a monoid, an algebraic structure with a binary operation
+ * and an identity (neutral) element.
+ *
+ * A monoid satisfies the following properties:
+ * 1. **Associativity**: The operation must be associative.
+ *    For all `a`, `b`, and `c` in the set, `(a operation b) operation c = a operation (b operation c)`.
+ *    {@link https://en.wikipedia.org/wiki/Associative_property Learn more about associativity}.
+ * 2. **Identity Element**: There exists an element (called the identity) such that,
+ *    when combined with any other element under the operation, it leaves the other element unchanged.
+ *    {@link https://en.wikipedia.org/wiki/Identity_element Learn more about identity elements}.
+ *
+ * Learn more about monoids: {@link https://en.wikipedia.org/wiki/Monoid}.
+ *
+ * @template T The type of the elements in the monoid.
+ */
+export type Monoid<T> = {
+    /**
+     * The identity (neutral) element for the monoid.
+     * When combined with any value under the `operation`, it leaves the other value unchanged.
+     *
+     * Examples:
+     * - `0` for addition
+     * - `1` for multiplication
+     * - `""` for string concatenation
+     * - `[]` for array concatenation
+     *
+     * Learn more: {@link https://en.wikipedia.org/wiki/Identity_element}
+     */
+    readonly identity: T;
+    /**
+     * The associative binary operation of the monoid.
+     * Takes one value of type `T` and returns a function that takes another value of type `T`,
+     * producing a result of type `T`.
+     *
+     * Examples:
+     * - `(a, b) => a + b` for addition
+     * - `(a, b) => a * b` for multiplication
+     * - `(a, b) => a.concat(b)` for arrays or strings
+     *
+     * Learn more: {@link https://en.wikipedia.org/wiki/Binary_operation}
+     */
+    readonly operation: Reduce<T>;
+};
+/**
+ * Repeats a monoid operation `n` times on the given element `a`.
+ * This function efficiently performs the operation using exponentiation by squaring.
+ *
+ * @template T The type of the elements in the monoid.
+ * @param monoid The monoid structure, including the identity and binary operation.
+ * @returns A function that takes an element `a` and a repetition count `n`,
+ * and returns the result of applying the operation `n` times.
+ *
+ * @example
+ *
+ * ```ts
+ * const add: Monoid<number> = {
+ *     identity: 0,
+ *     operation: a => b => a + b,
+ * };
+ *
+ * const resultAdd = repeat(add)(2)(10n) // 20
+ *
+ * const concat: Monoid<string> = {
+ *     identity: '',
+ *     operation: a => b => a + b,
+ * };
+ *
+ * const resultConcat = repeat(concat)('ha')(3n) // 'hahaha'
+ * ```
+ */
+export declare const repeat: <T>({ identity, operation }: Monoid<T>) => (a: T) => (n: bigint) => T;

package/types/monoid/module.f.js

@@ -0,0 +1,42 @@
+/**
+ * Repeats a monoid operation `n` times on the given element `a`.
+ * This function efficiently performs the operation using exponentiation by squaring.
+ *
+ * @template T The type of the elements in the monoid.
+ * @param monoid The monoid structure, including the identity and binary operation.
+ * @returns A function that takes an element `a` and a repetition count `n`,
+ * and returns the result of applying the operation `n` times.
+ *
+ * @example
+ *
+ * ```ts
+ * const add: Monoid<number> = {
+ *     identity: 0,
+ *     operation: a => b => a + b,
+ * };
+ *
+ * const resultAdd = repeat(add)(2)(10n) // 20
+ *
+ * const concat: Monoid<string> = {
+ *     identity: '',
+ *     operation: a => b => a + b,
+ * };
+ *
+ * const resultConcat = repeat(concat)('ha')(3n) // 'hahaha'
+ * ```
+ */
+export const repeat = ({ identity, operation }) => (a) => (n) => {
+    let ai = a;
+    let ni = n;
+    let result = identity;
+    while (true) {
+        if ((ni & 1n) !== 0n) {
+            result = operation(result)(ai);
+        }
+        ni >>= 1n;
+        if (ni === 0n) {
+            return result;
+        }
+        ai = operation(ai)(ai);
+    }
+};

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

@@ -0,0 +1,5 @@
+declare const _default: {
+    numberAdd: () => void;
+    stringConcat: () => void;
+};
+export default _default;

package/types/monoid/test.f.js

@@ -0,0 +1,27 @@
+import { repeat } from "./module.f.js";
+export default {
+    numberAdd: () => {
+        const add = {
+            identity: 0,
+            operation: a => b => a + b,
+        };
+        const resultAdd = repeat(add)(2)(10n); // 20
+        if (resultAdd !== 20) {
+            throw resultAdd;
+        }
+        const id = repeat(add)(42)(0n);
+        if (id !== 0) {
+            throw id;
+        }
+    },
+    stringConcat: () => {
+        const concat = {
+            identity: '',
+            operation: a => b => a + b,
+        };
+        const resultConcat = repeat(concat)('ha')(3n); // 'hahaha'
+        if (resultConcat !== 'hahaha') {
+            throw resultConcat;
+        }
+    }
+};