@fncts/base 0.0.39 → 0.0.41

package/data/Eq/api.d.ts

@@ -1,11 +1,98 @@
 import { Eq } from "@fncts/base/data/Eq/definition";
+import type { Literal } from "@fncts/typelevel/Any";
 /**
- * @tsplus pipeable fncts.Eq contramap
+ * @tsplus static fncts.EqOps never
+ * @tsplus implicit
  * @tsplus location "@fncts/base/data/Eq/api"
  */
-export declare function contramap<A, B>(f: (b: B) => A): (self: Eq<A>) => Eq<B>;
+export declare const never: Eq<never>;
+/**
+ * @tsplus static fncts.EqOps strict
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Eq/api"
+ */
+export declare const strict: Eq<any>;
+/**
+ * @tsplus static fncts.EqOps string
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Eq/api"
+ */
+export declare const string: Eq<string>;
+/**
+ * @tsplus static fncts.EqOps number
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Eq/api"
+ */
+export declare const number: Eq<number>;
+/**
+ * @tsplus static fncts.EqOps boolean
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Eq/api"
+ */
+export declare const boolean: Eq<boolean>;
+/**
+ * @tsplus static fncts.EqOps symbol
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Eq/api"
+ */
+export declare const symbol: Eq<symbol>;
+/**
+ * @tsplus getter fncts.Eq nullable
+ * @tsplus location "@fncts/base/data/Eq/api"
+ */
+export declare function nullable<A>(self: Eq<A>): Eq<A | null>;
+/**
+ * @tsplus getter fncts.Eq undefinable
+ * @tsplus location "@fncts/base/data/Eq/api"
+ */
+export declare function undefinable<A>(self: Eq<A>): Eq<A | undefined>;
+/**
+ * @tsplus static fncts.EqOps union
+ * @tsplus location "@fncts/base/data/Eq/api"
+ */
+export declare function union<A extends ReadonlyArray<any>>(eqs: {
+    [K in keyof A]: Eq<A[K]>;
+}): Eq<A[number]>;
+/**
+ * @tsplus static fncts.EqOps tuple
+ * @tsplus location "@fncts/base/data/Eq/api"
+ */
+export declare function tuple<A extends ReadonlyArray<any>>(eqs: {
+    [K in keyof A]: Eq<A[K]>;
+}): Eq<A>;
+/**
+ * @tsplus static fncts.EqOps record
+ * @tsplus location "@fncts/base/data/Eq/api"
+ */
+export declare function record<K extends PropertyKey, V>(_key: Eq<K>, value: Eq<V>): Eq<Record<K, V>>;
+/**
+ * @tsplus pipeable fncts.Eq intersection
+ * @tsplus location "@fncts/base/data/Eq/api"
+ */
+export declare function intersection<B>(that: Eq<B>): <A>(self: Eq<A>) => Eq<A & B>;
+/**
+ * @tsplus static fncts.EqOps literal
+ * @tsplus location "@fncts/base/data/Eq/api"
+ */
+export declare function literal<A extends Literal | null>(_: A): Eq<A>;
+/**
+ * @tsplus static fncts.EqOps struct
+ * @tsplus location "@fncts/base/data/Eq/api"
+ */
+export declare function struct<Required extends Record<PropertyKey, any>, Optional extends Record<PropertyKey, any>>(requiredFields: {
+    [K in keyof Required]: Eq<Required[K]>;
+}, optionalFields?: {
+    [K in keyof Optional]: Eq<Optional[K]>;
+}): Eq<Required & {
+    [K in keyof Optional]?: Optional[K];
+}>;
 /**
  * @tsplus static fncts.EqOps all
  * @tsplus location "@fncts/base/data/Eq/api"
  */
 export declare function all<A>(collection: Iterable<Eq<A>>): Eq<ReadonlyArray<A>>;
+/**
+ * @tsplus pipeable fncts.Eq contramap
+ * @tsplus location "@fncts/base/data/Eq/api"
+ */
+export declare function contramap<A, B>(f: (b: B) => A): (self: Eq<A>) => Eq<B>;

package/data/Eq/derivations.d.ts

@@ -22,3 +22,10 @@ export declare function deriveStruct<A extends Record<string, any>>(...[required
         }
     ])
 ] : never): Eq<A>;
+/**
+ * @tsplus derive fncts.Eq<|> 30
+ * @tsplus location "@fncts/base/data/Eq/derivations"
+ */
+export declare function deriveUnion<A extends ReadonlyArray<unknown>>(...members: {
+    [K in keyof A]: Eq<A[K]>;
+}): Eq<A[number]>;

package/data/Exit/api.d.ts

@@ -1,57 +1,49 @@
 import { Exit } from "@fncts/base/data/Exit/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
-import { Cause } from "@fncts/base/data/Cause/definition";
 /**
  * @tsplus pipeable fncts.Exit ap
  * @tsplus location "@fncts/base/data/Exit/api"
  */
 export declare function ap<E, A>(that: Exit<E, A>): <G, B>(self: Exit<G, (a: A) => B>) => Exit<E | G, B>;
 /**
- * @tsplus pipeable fncts.Exit zipLeft
+ * @tsplus pipeable fncts.Exit bimap
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipLeft<G, B>(that: Exit<G, B>): <E, A>(self: Exit<E, A>) => Exit<E | G, A>;
+export declare function bimap<E1, A, E2, B>(f: (e: E1) => E2, g: (a: A) => B): (self: Exit<E1, A>) => Exit<E2, B>;
 /**
- * @tsplus pipeable fncts.Exit zipRight
+ * @tsplus getter fncts.Exit causeOrNull
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipRight<G, B>(that: Exit<G, B>): <E, A>(self: Exit<E, A>) => Exit<E | G, B>;
+export declare function causeOrNull<E, A>(self: Exit<E, A>): Cause<E> | null;
 /**
- * @tsplus pipeable fncts.Exit zipLeftConcurrent
+ * @tsplus static fncts.ExitOps collectAll
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipLeftConcurrent<G, B>(that: Exit<G, B>): <E, A>(self: Exit<E, A>) => Exit<E | G, A>;
+export declare function collectAll<E, A>(exits: Conc<Exit<E, A>>): Maybe<Exit<E, Conc<A>>>;
 /**
- * @tsplus pipeable fncts.Exit zipRightConcurrent
+ * @tsplus getter fncts.Conc collectAllConcurrent
+ * @tsplus static fncts.ExitOps collectAllConcurrent
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipRightConcurrent<G, B>(that: Exit<G, B>): <E, A>(self: Exit<E, A>) => Exit<E | G, B>;
+export declare function collectAllConcurrent<E, A>(exits: Conc<Exit<E, A>>): Maybe<Exit<E, Conc<A>>>;
 /**
  * @tsplus pipeable fncts.Exit flatMap
  * @tsplus location "@fncts/base/data/Exit/api"
  */
 export declare function flatMap<A, G, B>(f: (a: A) => Exit<G, B>): <E>(ma: Exit<E, A>) => Exit<E | G, B>;
 /**
- * @tsplus pipeable fncts.Exit bimap
- * @tsplus location "@fncts/base/data/Exit/api"
- */
-export declare function bimap<E1, A, E2, B>(f: (e: E1) => E2, g: (a: A) => B): (self: Exit<E1, A>) => Exit<E2, B>;
-/**
- * @tsplus static fncts.ExitOps collectAll
- * @tsplus location "@fncts/base/data/Exit/api"
- */
-export declare function collectAll<E, A>(exits: Conc<Exit<E, A>>): Maybe<Exit<E, Conc<A>>>;
-/**
- * @tsplus static fncts.ExitOps collectAllConcurrent
+ * @tsplus getter fncts.Exit flatten
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function collectAllConcurrent<E, A>(exits: Conc<Exit<E, A>>): Maybe<Exit<E, Conc<A>>>;
+export declare function flatten<E, G, A>(mma: Exit<E, Exit<G, A>>): Exit<E | G, A>;
 /**
- * @tsplus getter fncts.Exit flatten
+ * Returns the Exit's Success value if it exists, or throws the pretty-printed Cause if it doesn't
+ * @tsplus getter fncts.Exit getOrThrow
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function flatten<E, G, A>(mma: Exit<E, Exit<G, A>>): Exit<E | G, A>;
+export declare function getOrThrow<E, A>(self: Exit<E, A>): A;
 /**
  * @tsplus pipeable fncts.Exit map
  * @tsplus location "@fncts/base/data/Exit/api"
@@ -73,39 +65,53 @@ export declare function mapErrorCause<E1, E2>(f: (e: Cause<E1>) => Cause<E2>): <
  */
 export declare function match<E, A, B, C>(onFailure: (e: Cause<E>) => B, onSuccess: (a: A) => C): (exit: Exit<E, A>) => B | C;
 /**
- * @tsplus pipeable fncts.Exit zipWith
+ * Returns the Exit's Success value if it exists
+ * @tsplus getter fncts.Exit value
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipWith<A, EB, B, C>(fb: Exit<EB, B>, f: (a: A, b: B) => C): <EA>(fa: Exit<EA, A>) => Exit<EA | EB, C>;
+export declare function value<E, A>(self: Exit<E, A>): A | undefined;
 /**
  * @tsplus pipeable fncts.Exit zip
  * @tsplus location "@fncts/base/data/Exit/api"
  */
 export declare function zip<EB, B>(that: Exit<EB, B>): <EA, A>(self: Exit<EA, A>) => Exit<EA | EB, readonly [A, B]>;
 /**
- * @tsplus pipeable fncts.Exit zipWithConcurrent
+ * @tsplus pipeable fncts.Exit zipConcurrent
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipWithConcurrent<A, EB, B, C>(fb: Exit<EB, B>, f: (a: A, b: B) => C): <EA>(fa: Exit<EA, A>) => Exit<EA | EB, C>;
+export declare function zipConcurrent<EB, B>(that: Exit<EB, B>): <EA, A>(self: Exit<EA, A>) => Exit<EA | EB, readonly [A, B]>;
 /**
- * @tsplus pipeable fncts.Exit zipConcurrent
+ * @tsplus pipeable fncts.Exit zipLeft
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipConcurrent<EB, B>(that: Exit<EB, B>): <EA, A>(self: Exit<EA, A>) => Exit<EA | EB, readonly [A, B]>;
+export declare function zipLeft<G, B>(that: Exit<G, B>): <E, A>(self: Exit<E, A>) => Exit<E | G, A>;
 /**
- * @tsplus pipeable fncts.Exit zipWithCause
+ * @tsplus pipeable fncts.Exit zipLeftConcurrent
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipWithCause<E, A, G, B, C>(fb: Exit<G, B>, f: (a: A, b: B) => C, g: (ea: Cause<E>, eb: Cause<G>) => Cause<E | G>): (fa: Exit<E, A>) => Exit<E | G, C>;
+export declare function zipLeftConcurrent<G, B>(that: Exit<G, B>): <E, A>(self: Exit<E, A>) => Exit<E | G, A>;
 /**
- * Returns the Exit's Success value if it exists
- * @tsplus getter fncts.Exit value
+ * @tsplus pipeable fncts.Exit zipRight
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function value<E, A>(self: Exit<E, A>): A | undefined;
+export declare function zipRight<G, B>(that: Exit<G, B>): <E, A>(self: Exit<E, A>) => Exit<E | G, B>;
 /**
- * Returns the Exit's Success value if it exists, or throws the pretty-printed Cause if it doesn't
- * @tsplus getter fncts.Exit getOrThrow
+ * @tsplus pipeable fncts.Exit zipRightConcurrent
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function getOrThrow<E, A>(self: Exit<E, A>): A;
+export declare function zipRightConcurrent<G, B>(that: Exit<G, B>): <E, A>(self: Exit<E, A>) => Exit<E | G, B>;
+/**
+ * @tsplus pipeable fncts.Exit zipWith
+ * @tsplus location "@fncts/base/data/Exit/api"
+ */
+export declare function zipWith<A, EB, B, C>(fb: Exit<EB, B>, f: (a: A, b: B) => C): <EA>(fa: Exit<EA, A>) => Exit<EA | EB, C>;
+/**
+ * @tsplus pipeable fncts.Exit zipWithCause
+ * @tsplus location "@fncts/base/data/Exit/api"
+ */
+export declare function zipWithCause<E, A, G, B, C>(fb: Exit<G, B>, f: (a: A, b: B) => C, g: (ea: Cause<E>, eb: Cause<G>) => Cause<E | G>): (fa: Exit<E, A>) => Exit<E | G, C>;
+/**
+ * @tsplus pipeable fncts.Exit zipWithConcurrent
+ * @tsplus location "@fncts/base/data/Exit/api"
+ */
+export declare function zipWithConcurrent<A, EB, B, C>(fb: Exit<EB, B>, f: (a: A, b: B) => C): <EA>(fa: Exit<EA, A>) => Exit<EA | EB, C>;

package/data/Guard/api.d.ts

@@ -1,7 +1,6 @@
 import { Refinement } from "@fncts/base/data/Refinement/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
-import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
-import { ImmutableNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
+import { ReadonlyNonEmptyArray } from "@fncts/base/collection/immutable/ReadonlyNonEmptyArray/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 import type { Brand, Validation } from "@fncts/base/data/Branded";
 import type { Check } from "@fncts/typelevel";
@@ -181,25 +180,25 @@ export declare function deriveDictionary<A extends Record<string, any>>(...[valu
  */
 export declare function record<A>(codomain: Guard<A>): Guard<Record<string, A>>;
 /**
- * @tsplus derive fncts.Guard[fncts.ImmutableArray]<_> 10
+ * @tsplus derive fncts.Guard[fncts.ReadonlyArray]<_> 10
  * @tsplus location "@fncts/base/data/Guard/api"
  */
-export declare function deriveImmutableArray<A extends ImmutableArray<any>>(...[element]: [A] extends [ImmutableArray<infer A>] ? [element: Guard<A>] : never): Guard<A>;
+export declare function deriveImmutableArray<A extends ReadonlyArray<any>>(...[element]: [A] extends [ReadonlyArray<infer A>] ? [element: Guard<A>] : never): Guard<A>;
 /**
  * @tsplus static fncts.GuardOps immutableArray
  * @tsplus location "@fncts/base/data/Guard/api"
  */
-export declare function immutableArray<A>(base: Guard<A>): Guard<ImmutableArray<A>>;
+export declare function immutableArray<A>(base: Guard<A>): Guard<ReadonlyArray<A>>;
 /**
- * @tsplus derive fncts.Guard[fncts.ImmutableNonEmptyArray]<_> 10
+ * @tsplus derive fncts.Guard[fncts.ReadonlyNonEmptyArray]<_> 10
  * @tsplus location "@fncts/base/data/Guard/api"
  */
-export declare function deriveImmutableNonEmptyArray<A extends ImmutableNonEmptyArray<any>>(...[elem]: [A] extends [ImmutableNonEmptyArray<infer _A>] ? [elem: Guard<_A>] : never): Guard<A>;
+export declare function deriveImmutableNonEmptyArray<A extends ReadonlyNonEmptyArray<any>>(...[elem]: [A] extends [ReadonlyNonEmptyArray<infer _A>] ? [elem: Guard<_A>] : never): Guard<A>;
 /**
  * @tsplus static fncts.GuardOps immutableNonEmptyArray
  * @tsplus location "@fncts/base/data/Guard/api"
  */
-export declare function immutableNonEmptyArray<A>(base: Guard<A>): Guard<ImmutableNonEmptyArray<A>>;
+export declare function immutableNonEmptyArray<A>(base: Guard<A>): Guard<ReadonlyNonEmptyArray<A>>;
 /**
  * @tsplus derive fncts.Guard[fncts.Conc]<_> 10
  * @tsplus location "@fncts/base/data/Guard/api"

package/data/Maybe/api.d.ts

@@ -1,8 +1,8 @@
 import { Maybe, Nothing } from "@fncts/base/data/Maybe/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { Refinement } from "@fncts/base/data/Refinement/definition";
-import { Either } from "@fncts/base/data/Either/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
+import { Either } from "@fncts/base/data/Either/definition";
 import { Zipped } from "@fncts/base/data/Zipped";
 import type { Eq, Monoid } from "@fncts/base/typeclass";
 import type { Nullable } from "@fncts/base/types";
@@ -11,28 +11,16 @@ import type { Nullable } from "@fncts/base/types";
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
 export declare function ap<A>(fa: Maybe<A>): <B>(self: Maybe<(a: A) => B>) => Maybe<B>;
-/**
- * Applies `f` to the value contained in `Maybe` if it is `Just` and returns the result,
- * otherwise returns `Nothing`.
- * @tsplus pipeable fncts.Maybe flatMap
- * @tsplus location "@fncts/base/data/Maybe/api"
- */
-export declare function flatMap<A, B>(f: (a: A) => Maybe<B>): (self: Maybe<A>) => Maybe<B>;
 /**
  * @tsplus pipeable fncts.Maybe elem
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
 export declare function elem<A>(elem: A, /** @tsplus auto */ E: Eq<A>): (self: Maybe<A>) => boolean;
-/**
- * @tsplus pipeable fncts.Maybe some
- * @tsplus location "@fncts/base/data/Maybe/api"
- */
-export declare function some<A>(p: Predicate<A>): (self: Maybe<A>) => boolean;
 /**
  * @tsplus pipeable fncts.Maybe filter
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function filter<A>(p: Predicate<A>): <B>(self: Maybe<A>) => Maybe<A>;
+export declare function filter<A>(p: Predicate<A>): (self: Maybe<A>) => Maybe<A>;
 export declare function filter<A, B extends A>(p: Refinement<A, B>): (self: Maybe<A>) => Maybe<B>;
 /**
  * @tsplus pipeable fncts.Maybe filter
@@ -40,42 +28,43 @@ export declare function filter<A, B extends A>(p: Refinement<A, B>): (self: Mayb
  */
 export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): (self: Maybe<A>) => Maybe<B>;
 /**
- * @tsplus getter fncts.Maybe flatten
- * @tsplus location "@fncts/base/data/Maybe/api"
- */
-export declare function flatten<A>(self: Maybe<Maybe<A>>): Maybe<A>;
-/**
- * @tsplus pipeable fncts.Maybe partition
+ * Applies `f` to the value contained in `Maybe` if it is `Just` and returns the result,
+ * otherwise returns `Nothing`.
+ * @tsplus pipeable fncts.Maybe flatMap
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function partition<A>(p: Predicate<A>): (self: Maybe<A>) => readonly [Maybe<A>, Maybe<A>];
-export declare function partition<A, B extends A>(p: Refinement<A, B>): (self: Maybe<A>) => readonly [Maybe<A>, Maybe<B>];
+export declare function flatMap<A, B>(f: (a: A) => Maybe<B>): (self: Maybe<A>) => Maybe<B>;
 /**
- * @tsplus pipeable fncts.Maybe partitionMap
+ * @tsplus getter fncts.Maybe flatten
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function partitionMap<A, B, C>(f: (a: A) => Either<B, C>): (self: Maybe<A>) => readonly [Maybe<B>, Maybe<C>];
+export declare function flatten<A>(self: Maybe<Maybe<A>>): Maybe<A>;
 /**
  * @tsplus pipeable fncts.Maybe foldLeft
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
 export declare function foldLeft<A, B>(b: B, f: (b: B, a: A) => B): (self: Maybe<A>) => B;
 /**
- * @tsplus pipeable fncts.Maybe foldRight
+ * @tsplus pipeable fncts.Maybe foldMap
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function foldRight<A, B>(b: B, f: (a: A, b: B) => B): (self: Maybe<A>) => B;
+export declare function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: Monoid<M>): (self: Maybe<A>) => M;
 /**
- * @tsplus pipeable fncts.Maybe foldMap
+ * @tsplus pipeable fncts.Maybe foldRight
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: Monoid<M>): (self: Maybe<A>) => M;
+export declare function foldRight<A, B>(b: B, f: (a: A, b: B) => B): (self: Maybe<A>) => B;
 /**
  * Extracts the value from `Maybe` if it exists, or returns the result of `orElse`.
  * @tsplus pipeable fncts.Maybe getOrElse
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
 export declare function getOrElse<B>(orElse: Lazy<B>): <A>(self: Maybe<A>) => A | B;
+/**
+ * @tsplus getter fncts.Maybe getOrThrow
+ * @tsplus location "@fncts/base/data/Maybe/api"
+ */
+export declare function getOrThrow<A>(self: Maybe<A>): A;
 /**
  * Applies `f` to the value contained in `Maybe` if it is `Just`, otherwise returns `Nothing`.
  * @tsplus pipeable fncts.Maybe map
@@ -83,7 +72,7 @@ export declare function getOrElse<B>(orElse: Lazy<B>): <A>(self: Maybe<A>) => A
  */
 export declare function map<A, B>(f: (a: A) => B): (self: Maybe<A>) => Maybe<B>;
 /**
- * `chain` + `fromNullable`
+ * `flatMap(fromNullable)`
  * @tsplus pipeable fncts.Maybe mapNullable
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
@@ -93,6 +82,22 @@ export declare function mapNullable<A, B>(f: (a: A) => Nullable<B>): (self: Mayb
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
 export declare function orElse<B>(fb: Lazy<Maybe<B>>): <A>(self: Maybe<A>) => Maybe<A | B>;
+/**
+ * @tsplus pipeable fncts.Maybe partition
+ * @tsplus location "@fncts/base/data/Maybe/api"
+ */
+export declare function partition<A>(p: Predicate<A>): (self: Maybe<A>) => readonly [Maybe<A>, Maybe<A>];
+export declare function partition<A, B extends A>(p: Refinement<A, B>): (self: Maybe<A>) => readonly [Maybe<A>, Maybe<B>];
+/**
+ * @tsplus pipeable fncts.Maybe partitionMap
+ * @tsplus location "@fncts/base/data/Maybe/api"
+ */
+export declare function partitionMap<A, B, C>(f: (a: A) => Either<B, C>): (self: Maybe<A>) => readonly [Maybe<B>, Maybe<C>];
+/**
+ * @tsplus pipeable fncts.Maybe some
+ * @tsplus location "@fncts/base/data/Maybe/api"
+ */
+export declare function some<A>(p: Predicate<A>): (self: Maybe<A>) => boolean;
 /**
  * Extracts the value from `Maybe` if it is `Just`, otherwise returns `undefined`
  * @tsplus getter fncts.Maybe value
@@ -100,12 +105,12 @@ export declare function orElse<B>(fb: Lazy<Maybe<B>>): <A>(self: Maybe<A>) => Ma
  */
 export declare function toUndefined<A>(self: Maybe<A>): A | undefined;
 /**
- * @tsplus pipeable fncts.Maybe zipWith
+ * @tsplus pipeable fncts.Maybe zip
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function zipWith<A, B, C>(fb: Maybe<B>, f: (a: A, b: B) => C): (self: Maybe<A>) => Maybe<C>;
+export declare function zip<B>(that: Maybe<B>): <A>(self: Maybe<A>) => Maybe<Zipped.Make<A, B>>;
 /**
- * @tsplus pipeable fncts.Maybe zip
+ * @tsplus pipeable fncts.Maybe zipWith
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function zip<B>(that: Maybe<B>): <A>(self: Maybe<A>) => Maybe<Zipped.Make<A, B>>;
+export declare function zipWith<A, B, C>(fb: Maybe<B>, f: (a: A, b: B) => C): (self: Maybe<A>) => Maybe<C>;

package/data/Maybe/constructors.d.ts

@@ -2,18 +2,6 @@ import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { Refinement } from "@fncts/base/data/Refinement/definition";
 import type { Nullable } from "@fncts/base/types";
-/**
- * @tsplus static fncts.MaybeOps just
- * @tsplus static fncts.JustOps __call
- * @tsplus location "@fncts/base/data/Maybe/constructors"
- */
-export declare function just<A>(a: A, __tsplusTrace?: string): Maybe<A>;
-/**
- * @tsplus static fncts.MaybeOps nothing
- * @tsplus static fncts.NothingOps __call
- * @tsplus location "@fncts/base/data/Maybe/constructors"
- */
-export declare function nothing<A = never>(__tsplusTrace?: string): Maybe<A>;
 /**
  * @tsplus static fncts.MaybeOps fromNullable
  * @tsplus location "@fncts/base/data/Maybe/constructors"
@@ -31,17 +19,29 @@ export declare function fromNullableK<P extends ReadonlyArray<unknown>, A>(f: (.
 export declare function fromPredicate<A>(a: A, p: Predicate<A>): Maybe<A>;
 export declare function fromPredicate<A, B extends A>(a: A, p: Refinement<A, B>): Maybe<A>;
 /**
- * @tsplus static fncts.MaybeOps tryCatch
+ * @tsplus static fncts.MaybeOps just
+ * @tsplus static fncts.JustOps __call
  * @tsplus location "@fncts/base/data/Maybe/constructors"
  */
-export declare function tryCatch<A>(thunk: () => A): Maybe<A>;
+export declare function just<A>(a: A, __tsplusTrace?: string): Maybe<A>;
 /**
- * @tsplus static fncts.MaybeOps tryCatchK
+ * @tsplus static fncts.MaybeOps nothing
+ * @tsplus static fncts.NothingOps __call
  * @tsplus location "@fncts/base/data/Maybe/constructors"
  */
-export declare function tryCatchK<P extends ReadonlyArray<unknown>, A>(f: (...params: P) => A): (...params: P) => Maybe<A>;
+export declare function nothing<A = never>(__tsplusTrace?: string): Maybe<A>;
 /**
  * @tsplus static fncts.MaybeOps partial
  * @tsplus location "@fncts/base/data/Maybe/constructors"
  */
 export declare function partial<P extends ReadonlyArray<unknown>, A>(f: (miss: () => never) => (...params: P) => A): (...params: P) => Maybe<A>;
+/**
+ * @tsplus static fncts.MaybeOps tryCatch
+ * @tsplus location "@fncts/base/data/Maybe/constructors"
+ */
+export declare function tryCatch<A>(thunk: () => A): Maybe<A>;
+/**
+ * @tsplus static fncts.MaybeOps tryCatchK
+ * @tsplus location "@fncts/base/data/Maybe/constructors"
+ */
+export declare function tryCatchK<P extends ReadonlyArray<unknown>, A>(f: (...params: P) => A): (...params: P) => Maybe<A>;

package/data/Showable/util.d.ts

@@ -19,7 +19,7 @@ export declare const OBJECT_TYPE = 0;
 export declare const ARRAY_TYPE = 1;
 export declare const ARRAY_EXTRAS_TYPE = 2;
 export declare const PROTO_TYPE = 3;
-export declare function hex(arrayBuffer: ArrayBuffer): string;
+export declare function hex(arrayBuffer: ArrayBuffer | Uint8Array<ArrayBuffer>): string;
 export declare function pluralize(n: number): string;
 export declare function getKeys(value: object, showHidden?: boolean): Array<PropertyKey>;
 export declare function getStringWidth(input: string, removeControlChars?: boolean): number;

package/data/These/api.d.ts

@@ -3,67 +3,67 @@ import { Predicate } from "@fncts/base/data/Predicate/definition";
 import type { Both, Left, Right } from "@fncts/base/data/These/definition";
 import type * as P from "@fncts/base/typeclass";
 /**
- * @tsplus fluent fncts.These isLeft
+ * @tsplus pipeable fncts.These ap
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function isLeft<E, A>(self: These<E, A>): self is Left<E>;
+export declare function ap<E, A>(that: These<E, A>, /** @tsplus auto */ S: P.Semigroup<E>): <B>(self: These<E, (a: A) => B>) => These<E, B>;
 /**
- * @tsplus fluent fncts.These isRight
+ * @tsplus pipeable fncts.These bimap
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function isRight<E, A>(self: These<E, A>): self is Right<A>;
+export declare function bimap<E, A, E1, B>(f: (e: E) => E1, g: (a: A) => B): (self: These<E, A>) => These<E1, B>;
 /**
- * @tsplus fluent fncts.These isBoth
+ * @tsplus pipeable fncts.These catchAll
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function isBoth<E, A>(self: These<E, A>): self is Both<E, A>;
+export declare function catchAll<E, B>(f: (e: E) => These<E, B>): <A>(self: These<E, A>) => These<E, A | B>;
 /**
- * @tsplus pipeable fncts.These map
+ * @tsplus getter fncts.These condemn
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function map<A, B>(f: (a: A) => B): <E>(self: These<E, A>) => These<E, B>;
+export declare function condemn<E, A>(self: These<E, A>): These<E, A>;
 /**
- * @tsplus pipeable fncts.These mapLeft
+ * @tsplus pipeable fncts.These condemnWhen
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function mapLeft<E, E1>(f: (e: E) => E1): <A>(self: These<E, A>) => These<E1, A>;
+export declare function condemnWhen<E>(p: Predicate<E>): <A>(self: These<E, A>) => These<E, A>;
 /**
- * @tsplus pipeable fncts.These bimap
+ * @tsplus pipeable fncts.These flatMap
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function bimap<E, A, E1, B>(f: (e: E) => E1, g: (a: A) => B): (self: These<E, A>) => These<E1, B>;
+export declare function flatMap<E, A, B>(f: (a: A) => These<E, B>, /** @tsplus auto */ S: P.Semigroup<E>): (self: These<E, A>) => These<E, B>;
 /**
- * @tsplus pipeable fncts.These zipWith
+ * @tsplus fluent fncts.These isBoth
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function zipWith<E, A, B, C>(that: These<E, B>, f: (a: A, b: B) => C, /** @tsplus auto */ S: P.Semigroup<E>): (self: These<E, A>) => These<E, C>;
+export declare function isBoth<E, A>(self: These<E, A>): self is Both<E, A>;
 /**
- * @tsplus pipeable fncts.These zip
+ * @tsplus fluent fncts.These isLeft
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function zip<E, B>(that: These<E, B>, /** @tsplus auto */ S: P.Semigroup<E>): <A>(self: These<E, A>) => These<E, readonly [A, B]>;
+export declare function isLeft<E, A>(self: These<E, A>): self is Left<E>;
 /**
- * @tsplus pipeable fncts.These ap
+ * @tsplus fluent fncts.These isRight
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function ap<E, A>(that: These<E, A>, /** @tsplus auto */ S: P.Semigroup<E>): <B>(self: These<E, (a: A) => B>) => These<E, B>;
+export declare function isRight<E, A>(self: These<E, A>): self is Right<A>;
 /**
- * @tsplus pipeable fncts.These flatMap
+ * @tsplus pipeable fncts.These map
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function flatMap<E, A, B>(f: (a: A) => These<E, B>, /** @tsplus auto */ S: P.Semigroup<E>): (self: These<E, A>) => These<E, B>;
+export declare function map<A, B>(f: (a: A) => B): <E>(self: These<E, A>) => These<E, B>;
 /**
- * @tsplus pipeable fncts.These catchAll
+ * @tsplus pipeable fncts.These mapLeft
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function catchAll<E, B>(f: (e: E) => These<E, B>): <A>(self: These<E, A>) => These<E, A | B>;
+export declare function mapLeft<E, E1>(f: (e: E) => E1): <A>(self: These<E, A>) => These<E1, A>;
 /**
- * @tsplus getter fncts.These condemn
+ * @tsplus pipeable fncts.These zip
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function condemn<E, A>(self: These<E, A>): These<E, A>;
+export declare function zip<E, B>(that: These<E, B>, /** @tsplus auto */ S: P.Semigroup<E>): <A>(self: These<E, A>) => These<E, readonly [A, B]>;
 /**
- * @tsplus pipeable fncts.These condemnWhen
+ * @tsplus pipeable fncts.These zipWith
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function condemnWhen<E>(p: Predicate<E>): <A>(self: These<E, A>) => These<E, A>;
+export declare function zipWith<E, A, B, C>(that: These<E, B>, f: (a: A, b: B) => C, /** @tsplus auto */ S: P.Semigroup<E>): (self: These<E, A>) => These<E, C>;

package/data.d.ts

@@ -36,6 +36,7 @@ export type {} from "./data/Environment.js";
 export type {} from "./data/Either.js";
 export type {} from "./data/Duration.js";
 export type {} from "./data/DatumEither.js";
+export type {} from "./data/Datum.js";
 export type {} from "./data/Date.js";
 export type {} from "./data/Data.js";
 export type {} from "./data/Const.js";