functionalscript 0.3.6 → 0.3.8

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;
+        }
+    }
+};

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

@@ -1,5 +1,5 @@
-type NibbleSet = number;
-type Nibble = number;
+export type NibbleSet = number;
+export type Nibble = number;
 export declare const empty = 0;
 export declare const universe = 65535;
 export declare const has: (n: Nibble) => (s: NibbleSet) => boolean;
@@ -7,4 +7,3 @@ export declare const set: (n: Nibble) => (s: NibbleSet) => NibbleSet;
 export declare const complement: (n: NibbleSet) => NibbleSet;
 export declare const unset: (n: Nibble) => (s: NibbleSet) => NibbleSet;
 export declare const setRange: (r: readonly [number, number]) => (s: NibbleSet) => NibbleSet;
-export {};

package/types/nibble_set/test.f.js

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

package/types/number/test.f.js

@@ -1,5 +1,4 @@
-import * as _ from "./module.f.js";
-const { sum, min, max, cmp } = _;
+import { sum, min, max, cmp } from "./module.f.js";
 export default {
     sum: () => {
         const result = sum([2, 3, 4, 5]);

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

@@ -1,10 +1,10 @@
-import * as list from '../list/module.f.ts';
-import * as btMap from '../map/module.f.ts';
+import { type List } from '../list/module.f.ts';
+import { type Map as BtMap } from '../map/module.f.ts';
 export type Map<T> = {
     readonly [k in string]: T;
 };
 export type Entry<T> = readonly [string, T];
 export declare const at: (name: string) => <T>(object: Map<T>) => T | null;
-export declare const sort: <T>(e: list.List<Entry<T>>) => list.List<Entry<T>>;
-export declare const fromEntries: <T>(e: list.List<Entry<T>>) => Map<T>;
-export declare const fromMap: <T>(m: btMap.Map<T>) => Map<T>;
+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: BtMap<T>) => Map<T>;

package/types/object/module.f.js

@@ -1,7 +1,5 @@
-import * as list from "../list/module.f.js";
-const { iterable } = list;
-import * as btMap from "../map/module.f.js";
-const { entries: mapEntries, fromEntries: mapFromEntries } = btMap;
+import { iterable } from "../list/module.f.js";
+import { entries as mapEntries, fromEntries as mapFromEntries } from "../map/module.f.js";
 const { getOwnPropertyDescriptor, fromEntries: objectFromEntries } = Object;
 export const at = name => object => {
     const r = getOwnPropertyDescriptor(object, name);

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

@@ -1,8 +1,8 @@
-import * as sortedList from '../sorted_list/module.f.ts';
-import * as O from '../function/operator/module.f.ts';
-import * as Range from '../range/module.f.ts';
+import { type SortedList } from '../sorted_list/module.f.ts';
+import type * as O from '../function/operator/module.f.ts';
+import type * as Range from '../range/module.f.ts';
 export type Entry<T> = [T, number];
-export type RangeMap<T> = sortedList.SortedList<Entry<T>>;
+export type RangeMap<T> = SortedList<Entry<T>>;
 export type RangeMapArray<T> = readonly Entry<T>[];
 export type Operators<T> = {
     readonly union: O.Reduce<T>;

package/types/range_map/module.f.js

@@ -1,12 +1,6 @@
-import * as sortedList from "../sorted_list/module.f.js";
-const { genericMerge } = sortedList;
-import * as list from "../list/module.f.js";
-const { next } = list;
-import * as Option from "../nullable/module.f.js";
-import * as number from "../number/module.f.js";
-const { cmp } = number;
-import * as O from "../function/operator/module.f.js";
-import * as Range from "../range/module.f.js";
+import { genericMerge } from "../sorted_list/module.f.js";
+import { next } from "../list/module.f.js";
+import { cmp } from "../number/module.f.js";
 const reduceOp = union => equal => state => ([aItem, aMax]) => ([bItem, bMax]) => {
     const sign = cmp(aMax)(bMax);
     const min = sign === 1 ? bMax : aMax;

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

@@ -1,7 +1,6 @@
-type Ok<T> = readonly ['ok', T];
-type Error<E> = readonly ['error', E];
+export type Ok<T> = readonly ['ok', T];
+export type Error<E> = readonly ['error', E];
 export type Result<T, E> = Ok<T> | Error<E>;
 export declare const ok: <T>(value: T) => Ok<T>;
 export declare const error: <E>(e: E) => Error<E>;
 export declare const unwrap: <T, E>(r: Result<T, E>) => T;
-export {};

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

@@ -1,16 +1,16 @@
-import * as compare from '../function/compare/module.f.ts';
-import * as list from '../list/module.f.ts';
-import * as option from '../nullable/module.f.ts';
-export type SortedList<T> = list.List<T>;
+import type * as compare from '../function/compare/module.f.ts';
+import { type List } from '../list/module.f.ts';
+import type * as option from '../nullable/module.f.ts';
+export type SortedList<T> = List<T>;
 type SortedArray<T> = readonly T[];
 type Cmp<T> = (a: T) => (b: T) => compare.Sign;
 export type ReduceOp<T, S> = (state: S) => (a: T) => (b: T) => readonly [option.Nullable<T>, compare.Sign, S];
-export type TailReduce<T, S> = (state: S) => (tail: list.List<T>) => list.List<T>;
+export type TailReduce<T, S> = (state: S) => (tail: List<T>) => List<T>;
 type MergeReduce<T, S> = {
     readonly reduceOp: ReduceOp<T, S>;
     readonly tailReduce: TailReduce<T, S>;
 };
-export declare const genericMerge: <T, S>({ reduceOp, tailReduce }: MergeReduce<T, S>) => (state: S) => (a: list.List<T>) => (b: list.List<T>) => list.List<T>;
+export declare const genericMerge: <T, S>({ reduceOp, tailReduce }: MergeReduce<T, S>) => (state: S) => (a: List<T>) => (b: List<T>) => List<T>;
 export declare const merge: <T>(cmp: Cmp<T>) => (a: SortedList<T>) => (b: SortedList<T>) => SortedList<T>;
 export declare const find: <T>(cmp: Cmp<T>) => (value: T) => (array: SortedArray<T>) => T | null;
 export {};

package/types/sorted_list/module.f.js

@@ -1,9 +1,5 @@
-import * as compare from "../function/compare/module.f.js";
-import * as list from "../list/module.f.js";
-import * as option from "../nullable/module.f.js";
-const { next } = list;
-import * as f from "../function/module.f.js";
-const { identity } = f;
+import { next } from "../list/module.f.js";
+import { identity } from "../function/module.f.js";
 export const genericMerge = ({ reduceOp, tailReduce }) => {
     const f = state => a => b => () => {
         const aResult = next(a);

package/types/sorted_list/test.f.js

@@ -1,14 +1,9 @@
 import * as _ from "./module.f.js";
-import * as compare from "../function/compare/module.f.js";
-const { unsafeCmp } = compare;
+import { unsafeCmp } from "../function/compare/module.f.js";
 import * as json from "../../json/module.f.js";
-import * as object from "../object/module.f.js";
-const { sort } = object;
-import * as list from "../list/module.f.js";
-const { toArray, countdown, length } = list;
-import * as Map from "../map/module.f.js";
-import * as f from "../function/module.f.js";
-const { flip } = f;
+import { sort } from "../object/module.f.js";
+import { toArray, countdown, length } from "../list/module.f.js";
+import { flip } from "../function/module.f.js";
 const stringify = json.stringify(sort);
 const reverseCmp = flip(unsafeCmp);
 export default {

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

@@ -1,4 +1,4 @@
-import * as Compare from '../function/compare/module.f.ts';
+import type * as Compare from '../function/compare/module.f.ts';
 export type SortedSet<T> = readonly T[];
 type Cmp<T> = (a: T) => (b: T) => Compare.Sign;
 export declare const union: <T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>;

package/types/sorted_set/module.f.js

@@ -1,8 +1,5 @@
-import * as Compare from "../function/compare/module.f.js";
-import * as list from "../list/module.f.js";
-const { toArray } = list;
-import * as sortedList from "../sorted_list/module.f.js";
-const { merge, genericMerge, find } = sortedList;
+import { toArray } from "../list/module.f.js";
+import { merge, genericMerge, find } from "../sorted_list/module.f.js";
 export const union = cmp => a => b => toArray(merge(cmp)(a)(b));
 export const intersect = cmp => a => b => toArray(intersectMerge(cmp)(a)(b));
 const tailReduce = () => () => null;

package/types/sorted_set/test.f.js

@@ -1,14 +1,9 @@
 import * as _ from "./module.f.js";
-import * as compare from "../function/compare/module.f.js";
-const { unsafeCmp } = compare;
+import { unsafeCmp } from "../function/compare/module.f.js";
 import * as json from "../../json/module.f.js";
-import * as object from "../object/module.f.js";
-const { sort } = object;
-import * as list from "../list/module.f.js";
-const { toArray, countdown, length } = list;
-import * as Map from "../map/module.f.js";
-import * as f from "../function/module.f.js";
-const { flip } = f;
+import { sort } from "../object/module.f.js";
+import { toArray, countdown, length } from "../list/module.f.js";
+import { flip } from "../function/module.f.js";
 const stringify = a => json.stringify(sort)(a);
 const reverseCmp = flip(unsafeCmp);
 export default {

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

@@ -1,6 +1,6 @@
-import * as list from '../list/module.f.ts';
+import { type List } from '../list/module.f.ts';
 import * as compare from '../function/compare/module.f.ts';
-export declare const join: (_: string) => (input: list.List<string>) => string;
-export declare const concat: (input: list.List<string>) => string;
+export declare const join: (_: string) => (input: List<string>) => string;
+export declare const concat: (input: List<string>) => string;
 export declare const repeat: (n: string) => (v: number) => string;
 export declare const cmp: (a: string) => (b: string) => compare.Sign;

package/types/string/module.f.js

@@ -1,5 +1,4 @@
-import * as list from "../list/module.f.js";
-const { reduce: listReduce, repeat: listRepeat } = list;
+import { reduce as listReduce, repeat as listRepeat } from "../list/module.f.js";
 import { compose } from "../function/module.f.js";
 import * as compare from "../function/compare/module.f.js";
 const { unsafeCmp } = compare;

package/types/string/test.f.js

@@ -1,7 +1,5 @@
-import * as _ from "./module.f.js";
-const { join, concat, repeat, cmp } = _;
-import * as list from "../list/module.f.js";
-const { repeat: repeatList } = list;
+import { join, concat, repeat, cmp } from "./module.f.js";
+import { repeat as repeatList } from "../list/module.f.js";
 export default {
     join: {
         0: () => {

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

@@ -1,4 +1,4 @@
-import * as BtreeTypes from '../btree/types/module.f.ts';
+import type * as BtreeTypes from '../btree/types/module.f.ts';
 import { type List } from '../list/module.f.ts';
 export declare const values: (s: StringSet) => List<string>;
 export declare const empty: null;

package/types/string_set/module.f.js

@@ -1,16 +1,10 @@
-import * as BtreeTypes from "../btree/types/module.f.js";
 import * as btree from "../btree/module.f.js";
-import * as btf from "../btree/find/module.f.js";
-const { find, isFound } = btf;
-import * as btr from "../btree/remove/module.f.js";
-const { remove: btreeRemove } = btr;
-import * as bts from "../btree/set/module.f.js";
-const { set: btreeSet } = bts;
-import * as string from "../string/module.f.js";
-const { cmp } = string;
+import { find, isFound } from "../btree/find/module.f.js";
+import { remove as btreeRemove } from "../btree/remove/module.f.js";
+import { set as btreeSet } from "../btree/set/module.f.js";
+import { cmp } from "../string/module.f.js";
 import { fold } from "../list/module.f.js";
-import * as f from "../function/module.f.js";
-const { compose } = f;
+import { compose } from "../function/module.f.js";
 export const values = btree.values;
 export const empty = btree.empty;
 export const contains = value => {