functionalscript 0.1.594 → 0.1.597

package/types/range_map/module.f.mjs

@@ -1,4 +1,4 @@
-import sortedList, * as SL from '../sorted_list/module.f.mjs'
+import sortedList, * as SortedList from '../sorted_list/module.f.mjs'
 const { genericMerge } = sortedList
 import list from '../list/module.f.mjs'
 const { next } = list
@@ -6,7 +6,7 @@ import * as Option from '../nullable/module.f.mjs'
 import number from '../number/module.f.mjs'
 const { cmp } = number
 import * as O from '../function/operator/module.f.mjs'
-import _range, * as Range from '../range/module.f.mjs'
+import * as Range from '../range/module.f.mjs'
 
 /**
  * @template T
@@ -15,7 +15,7 @@ import _range, * as Range from '../range/module.f.mjs'
 
 /**
  * @template T
- * @typedef {SL.SortedList<Entry<T>>} RangeMap
+ * @typedef {SortedList.SortedList<Entry<T>>} RangeMap
  */
 
 /**
@@ -41,7 +41,7 @@ import _range, * as Range from '../range/module.f.mjs'
  * @typedef {O.Reduce<RangeMap<T>>} RangeMerge
  */
 
-/** @type {<T>(union: O.Reduce<T>) => (equal: O.Equal<T>) => SL.ReduceOp<Entry<T>, RangeState<T>>} */
+/** @type {<T>(union: O.Reduce<T>) => (equal: O.Equal<T>) => SortedList.ReduceOp<Entry<T>, RangeState<T>>} */
 const reduceOp = union => equal => state => ([aItem, aMax]) => ([bItem, bMax]) => {
     const sign = cmp(aMax)(bMax)
     const min = sign === 1 ? bMax : aMax
@@ -50,7 +50,7 @@ const reduceOp = union => equal => state => ([aItem, aMax]) => ([bItem, bMax]) =
     return [newState, sign, [u, min]]
 }
 
-/** @type {<T>(equal: O.Equal<T>) => SL.TailReduce<Entry<T>, RangeState<T>>} */
+/** @type {<T>(equal: O.Equal<T>) => SortedList.TailReduce<Entry<T>, RangeState<T>>} */
 const tailReduce = equal => state => tail => {
     if (state === null) { return tail }
     const tailResult = next(tail)

package/types/range_map/test.f.d.mts

@@ -0,0 +1,6 @@
+declare namespace _default {
+    let merge: (() => void)[];
+    function get(): (() => void)[];
+    function fromRange(): (() => void)[];
+}
+export default _default;

package/types/range_map/test.f.mjs

@@ -1,14 +1,14 @@
 import _, * as T from './module.f.mjs'
 import compare from '../function/compare/module.f.mjs'
 const { unsafeCmp } = compare
-import json, * as jsonT from '../../json/module.f.mjs'
+import json, * as Json from '../../json/module.f.mjs'
 import object from '../object/module.f.mjs'
 const { sort } = object
 import sortedSet, * as SortedSet from '../sorted_set/module.f.mjs'
 import list from '../list/module.f.mjs'
 import operator from '../function/operator/module.f.mjs'
 
-/** @type {(a: readonly jsonT.Unknown[]) => string} */
+/** @type {(a: readonly Json.Unknown[]) => string} */
 const stringify = json.stringify(sort)
 
 /** @type {T.Operators<SortedSet.SortedSet<string>>} */

package/types/result/module.d.mts

@@ -0,0 +1,7 @@
+declare namespace _default {
+    export { tryCatch };
+}
+export default _default;
+/** @type {<T>(f: () => T) => Result.Result<T, unknown>} */
+declare const tryCatch: <T>(f: () => T) => Result.Result<T, unknown>;
+import * as Result from './module.f.mjs';

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

@@ -0,0 +1,28 @@
+declare namespace _default {
+    export { ok };
+    export { error };
+    export { unwrap };
+}
+export default _default;
+export type Ok<T> = readonly ["ok", T];
+export type Error<E> = readonly ["error", E];
+export type Result<T, E> = Ok<T> | Error<E>;
+/**
+ * @template T
+ * @typedef {readonly['ok', T]} Ok
+ */
+/**
+ * @template E
+ * @typedef {readonly['error', E]} Error
+ */
+/**
+ * @template T
+ * @template E
+ * @typedef {Ok<T>|Error<E>} Result
+ */
+/** @type {<T>(value: T) => Ok<T>} */
+declare const ok: <T>(value: T) => Ok<T>;
+/** @type {<E>(e: E) => Error<E>} */
+declare const error: <E>(e: E) => Error<E>;
+/** @type {<T, E>(r: Result<T, E>) => T} */
+declare const unwrap: <T, E>(r: Result<T, E>) => T;

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

@@ -0,0 +1,59 @@
+declare namespace _default {
+    export { merge };
+    export { genericMerge };
+    export { find };
+}
+export default _default;
+export type SortedList<T> = List.List<T>;
+export type SortedArray<T> = readonly T[];
+export 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 MergeReduce<T, S> = {
+    readonly reduceOp: ReduceOp<T, S>;
+    readonly tailReduce: TailReduce<T, S>;
+};
+export type CmpReduceOp<T> = ReduceOp<T, null>;
+/**
+ * @template T
+ * @typedef {ReduceOp<T, null>} CmpReduceOp
+ */
+/** @type {<T>(cmp: Cmp<T>) => (a: SortedList<T>) => (b: SortedList<T>) => SortedList<T>} */
+declare const merge: <T>(cmp: Cmp<T>) => (a: SortedList<T>) => (b: SortedList<T>) => SortedList<T>;
+/**
+ * @template T
+ * @typedef {List.List<T>} SortedList
+ */
+/**
+ * @template T
+ * @typedef {readonly T[]} SortedArray
+ */
+/**
+ * @template T
+ * @typedef {(a: T) => (b: T) => compare.Sign} Cmp
+ */
+/**
+ * @template T
+ * @template S
+ * @typedef {(state: S) => (a: T) => (b: T) => readonly[option.Nullable<T>, compare.Sign, S]} ReduceOp
+ */
+/**
+ * @template T
+ * @template S
+ * @typedef {(state: S) => (tail: List.List<T>) => List.List<T>} TailReduce
+ */
+/**
+ * @template T
+ * @template S
+  * @typedef {{
+ *  readonly reduceOp: ReduceOp<T,S>
+ *  readonly tailReduce: TailReduce<T,S>
+  * }} MergeReduce
+ */
+/** @type {<T,S>(reduce: MergeReduce<T,S>) => (state: S) => (a: List.List<T>) => (b: List.List<T>) => List.List<T>} */
+declare const genericMerge: <T, S>(reduce: MergeReduce<T, S>) => (state: S) => (a: List.List<T>) => (b: List.List<T>) => List.List<T>;
+/** @type {<T>(cmp: Cmp<T>) => (value: T) => (array: SortedArray<T>) =>  T|null} */
+declare const find: <T>(cmp: Cmp<T>) => (value: T) => (array: SortedArray<T>) => T | null;
+import * as List from '../list/module.f.mjs';
+import * as compare from '../function/compare/module.f.mjs';
+import * as option from '../nullable/module.f.mjs';

package/types/sorted_list/test.f.d.mts

@@ -0,0 +1,5 @@
+declare namespace _default {
+    let sortedMergre: (() => void)[];
+    let find: (() => void)[];
+}
+export default _default;

package/types/sorted_list/test.f.mjs

@@ -6,12 +6,12 @@ import object from '../object/module.f.mjs'
 const { sort } = object
 import list from '../list/module.f.mjs'
 const { toArray, countdown, length } = list
-import map, * as Map from '../map/module.f.mjs'
+import * as Map from '../map/module.f.mjs'
 import f from '../function/module.f.mjs'
 const { flip } = f
 
 /** @type {(a: readonly Json.Unknown[]) => string} */
-const stringify = a => json.stringify(sort)(a)
+const stringify = json.stringify(sort)
 
 /** @type {<T>(a: T) => (b: T) => Map.Sign} */
 const reverseCmp = flip(unsafeCmp)

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

@@ -0,0 +1,25 @@
+declare namespace _default {
+    export { union };
+    export { intersect };
+    export { has };
+}
+export default _default;
+export type SortedSet<T> = readonly T[];
+export type Cmp<T> = (a: T) => (b: T) => Compare.Sign;
+export type Byte = number;
+/**
+ * @template T
+ * @typedef {readonly T[]} SortedSet
+ */
+/**
+ * @template T
+ * @typedef {(a: T) => (b: T) => Compare.Sign} Cmp
+ */
+/** @typedef {number} Byte */
+/** @type {<T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>} */
+declare const union: <T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>;
+/** @type {<T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>} */
+declare const intersect: <T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>;
+/** @type {<T>(cmp: Cmp<T>) => (value: T) => (set: SortedSet<T>) => boolean} */
+declare const has: <T>(cmp: Cmp<T>) => (value: T) => (set: SortedSet<T>) => boolean;
+import * as Compare from '../function/compare/module.f.mjs';

package/types/sorted_set/test.f.d.mts

@@ -0,0 +1,6 @@
+declare namespace _default {
+    let union: (() => void)[];
+    let intersect: (() => void)[];
+    let has: (() => void)[];
+}
+export default _default;

package/types/sorted_set/test.f.mjs

@@ -6,7 +6,7 @@ import object from '../object/module.f.mjs'
 const { sort } = object
 import list from '../list/module.f.mjs'
 const { toArray, countdown, length } = list
-import map, * as Map from '../map/module.f.mjs'
+import * as Map from '../map/module.f.mjs'
 import f from '../function/module.f.mjs'
 const { flip } = f
 

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

@@ -0,0 +1,15 @@
+declare namespace _default {
+    export { join };
+    export { concat };
+    export { repeat };
+    export { cmp };
+}
+export default _default;
+declare const join: import("../function/module.f.mjs").Func<string, (input: List.List<string>) => string>;
+declare const concat: (input: List.List<string>) => string;
+/** @type {(n: string) => (v: number) => string} */
+declare const repeat: (n: string) => (v: number) => string;
+/** @type {(a: string) => (b: string) => Compare.Sign} */
+declare const cmp: (a: string) => (b: string) => Compare.Sign;
+import * as List from '../list/module.f.mjs';
+import * as Compare from '../function/compare/module.f.mjs';

package/types/string/test.f.d.mts

@@ -0,0 +1,15 @@
+declare namespace _default {
+    let join: {
+        0: () => void;
+        1: () => void;
+        3: () => void;
+    };
+    function concat(): void;
+    let repeatList: {
+        0: () => void;
+        5: () => void;
+    };
+    function repeat(): void;
+    function cmp(): void;
+}
+export default _default;

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

@@ -0,0 +1,21 @@
+declare namespace _default {
+    export { empty };
+    export { contains };
+    export { set };
+    export { values };
+    export { fromValues };
+    export { remove };
+}
+export default _default;
+export type StringSet = BtreeTypes.Tree<string>;
+declare const empty: null;
+/** @typedef {BtreeTypes.Tree<string>} StringSet */
+/** @type {(value: string) => (set: StringSet) => boolean} */
+declare const contains: (value: string) => (set: StringSet) => boolean;
+/** @type {(value: string) => (s: StringSet) => StringSet} */
+declare const set: (value: string) => (s: StringSet) => StringSet;
+declare const values: <T>(tree: BtreeTypes.Tree<T>) => import("../list/module.f.mjs").List<T>;
+declare const fromValues: (input: import("../list/module.f.mjs").List<string>) => StringSet;
+/** @type {(value: string) => (s: StringSet) => StringSet} */
+declare const remove: (value: string) => (s: StringSet) => StringSet;
+import * as BtreeTypes from '../btree/types/module.f.mjs';

package/types/string_set/test.f.d.mts

@@ -0,0 +1,5 @@
+declare namespace _default {
+    function contains(): void;
+    function remove(): void;
+}
+export default _default;