@fncts/base 0.0.35 → 0.0.37

package/_src/optics/Setter.ts

@@ -1,4 +1,3 @@
-/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Setter/*.ts }
 export * from "./Setter/definition.js";
 // codegen:end

package/_src/optics/Traversal.ts

@@ -1,4 +1,3 @@
-/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Traversal/*.ts }
 export * from "./Traversal/definition.js";
 // codegen:end

package/_src/typeclass/builtin.ts

@@ -1,4 +1,3 @@
-/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./builtin/*.ts }
 export * from "./builtin/Symbol.js";
 // codegen:end

package/_src/util/PCGRandom.ts

@@ -1,4 +1,3 @@
-/* eslint-disable no-param-reassign */
 /*
  * Copyright 2014 Thom Chiovoloni, released under the MIT license.
  *

package/_src/util/predicates.ts

@@ -86,6 +86,15 @@ export function isPlain(value: unknown): value is object {
   return isObject(value) && value.constructor === Object;
 }
 
+/**
+ * @tsplus pipeable global hasProperty
+ */
+export function hasProperty<P extends PropertyKey>(property: P) {
+  return (self: unknown): self is { [K in P]: unknown } => {
+    return isObject(self) && property in self;
+  };
+}
+
 export function isInstanceOf<C extends Constructor<A>, A>(type: C): (value: unknown) => value is A {
   return (value): value is A => value instanceof type;
 }

package/_src/util/rand/distribution/UniformBigIntDistribution.ts

@@ -12,7 +12,7 @@ function uniformBigIntInternal(from: bigint, diff: bigint, rng: RandomGenerator)
     ++NumIterations;
   }
   const MaxAcceptedRandom = FinalNumValues - (FinalNumValues % diff);
-  // eslint-disable-next-line no-constant-condition
+
   while (true) {
     // Aggregate mutiple calls to next() into a single random value
     let value = BigInt(0);

package/_src/util/rand/distribution/internals/ArrayInt.ts

@@ -111,7 +111,7 @@ export function substractArrayIntToNew(arrayIntA: ArrayInt, arrayIntB: ArrayInt)
 export function trimArrayIntInplace(arrayInt: ArrayInt) {
   const data       = arrayInt.data;
   let firstNonZero = 0;
-  // eslint-disable-next-line no-empty
+
   for (; firstNonZero !== data.length && data[firstNonZero] === 0; ++firstNonZero) {}
   if (firstNonZero === data.length) {
     // only zeros

package/_src/util/rand/distribution/internals/UniformArrayIntDistributionInternal.ts

@@ -18,7 +18,7 @@ export function uniformArrayIntDistributionInternal(
 ): ArrayInt["data"] {
   const rangeLength = rangeSize.length;
   // We iterate until we find a valid value for arrayInt
-  // eslint-disable-next-line no-constant-condition
+
   while (true) {
     // We compute a new value for arrayInt
     for (let index = 0; index !== rangeLength; ++index) {

package/_src/util/rand/distribution/internals/UniformIntDistributionInternal.ts

@@ -9,7 +9,7 @@ export function uniformIntDistributionInternal(rangeSize: number, rng: RandomGen
   // Range provided by the RandomGenerator is large enough
   if (rangeSize <= NumValues) {
     const MaxAllowed = NumValues - (NumValues % rangeSize);
-    // eslint-disable-next-line no-constant-condition
+
     while (true) {
       const out    = rng.next();
       const deltaV = out - MinRng;
@@ -27,7 +27,7 @@ export function uniformIntDistributionInternal(rangeSize: number, rng: RandomGen
     ++NumIterations;
   }
   const MaxAcceptedRandom = rangeSize * Math.floor((1 * FinalNumValues) / rangeSize);
-  // eslint-disable-next-line no-constant-condition
+
   while (true) {
     // Aggregate mutiple calls to next() into a single random value
     let value = 0;

package/collection/Iterable/api/traverseConc.d.ts

@@ -5,7 +5,7 @@ import type * as P from "@fncts/base/typeclass";
  * @tsplus getter fncts.Iterable traverseToConcWithIndex
  * @tsplus location "@fncts/base/collection/Iterable/api/traverseConc"
  */
-export declare function _traverseToConcWithIndex<A>(ta: Iterable<A>): <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (i: number, a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, B>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, import("../../immutable/Conc").Conc<B>>;
+export declare function _traverseToConcWithIndex<A>(ta: Iterable<A>): <G extends HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (i: number, a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, B>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, Conc<B>>;
 /**
  * @tsplus getter fncts.Iterable traverseToConc
  * @tsplus location "@fncts/base/collection/Iterable/api/traverseConc"

package/collection/Iterable/api.d.ts

@@ -4,7 +4,6 @@ import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Eval } from "@fncts/base/control/Eval/definition";
 import { Either } from "@fncts/base/data/Either/definition";
 import type * as P from "@fncts/base/typeclass";
-import { Iterable } from "@fncts/base/collection/Iterable/definition";
 /**
  * @tsplus pipeable fncts.Iterable ap
  * @tsplus location "@fncts/base/collection/Iterable/api"
@@ -20,6 +19,11 @@ export declare function append<B>(b: B): <A>(self: Iterable<A>) => Iterable<A |
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
 export declare function toIterable<A>(self: Iterable<A>): Iterable<A>;
+/**
+ * @tsplus getter fncts.Iterable toArray
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function toArray<A>(self: Iterable<A>): Array<A>;
 /**
  * @tsplus pipeable fncts.Iterable flatMap
  * @tsplus location "@fncts/base/collection/Iterable/api"

package/collection/compat/Array/api.d.ts

@@ -1,6 +1,11 @@
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { ReadonlyNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
 import type { Eq } from "@fncts/base/typeclass";
+/**
+ * @tsplus static fncts.ArrayOps fromValue
+ * @tsplus location "@fncts/base/collection/compat/Array/api"
+ */
+export declare function fromValue<A>(value: A): A extends Array<any> ? A : A extends ReadonlyArray<any> ? A : ReadonlyArray<A>;
 /**
  * @tsplus getter fncts.Array elem
  * @tsplus getter fncts.ReadonlyArray elem
@@ -49,3 +54,9 @@ export declare function foldLeftWithIndex<A, B>(b: B, f: (i: number, b: B, a: A)
  * @tsplus location "@fncts/base/collection/compat/Array/api"
  */
 export declare function updateAt<A>(i: number, a: A): (self: ReadonlyArray<A>) => ReadonlyArray<A>;
+/**
+ * @tsplus pipeable fncts.Array groupBy
+ * @tsplus pipeable fncts.ReadonlyArray groupBy
+ * @tsplus location "@fncts/base/collection/compat/Array/api"
+ */
+export declare function groupBy<A, K extends PropertyKey>(f: (a: A) => K): (self: ReadonlyArray<A>) => Record<K, ReadonlyArray<A>>;

package/collection/compat/Map/definition.d.ts

@@ -0,0 +1,8 @@
+declare global {
+    /**
+     * @tsplus type fncts.Map
+     */
+    interface Map<K, V> {
+    }
+}
+export {};

package/collection/compat/Map.d.ts

@@ -0,0 +1 @@
+export * from "./Map/definition.js";

package/collection/compat/Set/definition.d.ts

@@ -0,0 +1,8 @@
+declare global {
+    /**
+     * @tsplus type fncts.Set
+     */
+    interface Set<T> {
+    }
+}
+export {};

package/collection/compat/Set.d.ts

@@ -0,0 +1 @@
+export * from "./Set/definition.js";

package/collection/compat.d.ts

@@ -1 +1,3 @@
+export type {} from "./compat/Set.js";
+export type {} from "./compat/Map.js";
 export type {} from "./compat/Array.js";

package/collection/immutable/ImmutableArray/api.d.ts

@@ -31,7 +31,7 @@ export declare function alt<B>(that: Lazy<ImmutableArray<B>>): <A>(self: Immutab
  * @tsplus pipeable fncts.ImmutableArray ap
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function ap<A>(fa: ImmutableArray<A>): <B>(self: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<(a: A) => B>) => ImmutableArray<B>;
+export declare function ap<A>(fa: ImmutableArray<A>): <B>(self: ImmutableArray<(a: A) => B>) => ImmutableArray<B>;
 /**
  * @tsplus pipeable fncts.ImmutableArray append
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
@@ -153,7 +153,7 @@ export declare function everyWithIndex<A>(p: PredicateWithIndex<number, A>): (se
  * @tsplus pipeable fncts.ImmutableArray some
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function some<A>(p: Predicate<A>): (self: ImmutableArray<A>) => self is import("../ImmutableNonEmptyArray").ImmutableNonEmptyArray<A>;
+export declare function some<A>(p: Predicate<A>): (self: ImmutableArray<A>) => self is ImmutableNonEmptyArray<A>;
 /**
  * @tsplus pipeable fncts.ImmutableArray filter
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
@@ -570,22 +570,22 @@ export declare function updateAt<A>(i: number, a: A): (as: ImmutableArray<A>) =>
  * @tsplus getter fncts.ImmutableArray wiltWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function _wiltWithIndex<A>(self: ImmutableArray<A>): <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B, B2>(f: (i: number, a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, import("@fncts/base/data/Either").Either<B, B2>>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, readonly [import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B>, import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B2>]>;
+export declare function _wiltWithIndex<A>(self: ImmutableArray<A>): <G extends HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B, B2>(f: (i: number, a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, Either<B, B2>>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, readonly [ImmutableArray<B>, ImmutableArray<B2>]>;
 /**
  * @tsplus getter fncts.ImmutableArray wilt
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function _wilt<A>(self: ImmutableArray<A>): <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B, B2>(f: (a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, import("@fncts/base/data/Either").Either<B, B2>>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, readonly [import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B>, import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B2>]>;
+export declare function _wilt<A>(self: ImmutableArray<A>): <G extends HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B, B2>(f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, Either<B, B2>>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, readonly [ImmutableArray<B>, ImmutableArray<B2>]>;
 /**
  * @tsplus getter fncts.ImmutableArray witherWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function _witherWithIndex<A>(self: ImmutableArray<A>): <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (i: number, a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, import("../../../data/Maybe").Maybe<B>>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B>>;
+export declare function _witherWithIndex<A>(self: ImmutableArray<A>): <G extends HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (i: number, a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, Maybe<B>>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, ImmutableArray<B>>;
 /**
  * @tsplus getter fncts.ImmutableArray wither
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function _wither<A>(self: ImmutableArray<A>): <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, import("../../../data/Maybe").Maybe<B>>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B>>;
+export declare function _wither<A>(self: ImmutableArray<A>): <G extends HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, Maybe<B>>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, ImmutableArray<B>>;
 export declare const wiltWithIndex: P.WitherableWithIndex<ImmutableArrayF>["wiltWithIndex"];
 export declare const wilt: P.WitherableWithIndex<ImmutableArrayF>["wilt"];
 export declare const witherWithIndex: P.WitherableWithIndex<ImmutableArrayF>["witherWithIndex"];

package/collection/immutable/Vector/api.d.ts

@@ -577,7 +577,7 @@ export declare function _traverseWithIndex<A>(self: Vector<A>): <G extends HKT,
  * @tsplus getter fncts.Vector traverse
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function _traverse<A>(self: Vector<A>): <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, B>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, import("@fncts/base/collection/immutable/Vector/definition").Vector<B>>;
+export declare function _traverse<A>(self: Vector<A>): <G extends HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, B>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, Vector<B>>;
 export declare const traverseWithIndex: P.TraversableWithIndex<VectorF>["traverseWithIndex"];
 export declare const traverse: Traversable<VectorF>["traverse"];
 /**

package/control/Eval/api.d.ts

@@ -35,7 +35,7 @@ export declare function zip<B>(fb: Eval<B>): <A>(self: Eval<A>) => Eval<Zipped.M
  * @tsplus pipeable fncts.control.Eval ap
  * @tsplus location "@fncts/base/control/Eval/api"
  */
-export declare function ap<A>(fa: Eval<A>): <B>(self: import("@fncts/base/control/Eval/definition").Eval<(a: A) => B>) => Eval<B>;
+export declare function ap<A>(fa: Eval<A>): <B>(self: Eval<(a: A) => B>) => Eval<B>;
 /**
  * @tsplus static fncts.control.EvalOps sequenceT
  * @tsplus location "@fncts/base/control/Eval/api"

package/control/Pure/api.d.ts

@@ -16,7 +16,7 @@ export declare function absolve<W, S1, S2, R, E, E1, A>(fa: Pure<W, S1, S2, R, E
  * @tsplus pipeable fncts.control.Pure ap
  * @tsplus location "@fncts/base/control/Pure/api"
  */
-export declare function ap<W, S, A, R1, E1>(fb: Pure<W, S, S, R1, E1, A>): <R, E, B>(self: import("@fncts/base/control/Pure/definition").Pure<W, S, S, R, E, (a: A) => B>) => Pure<W, S, S, R & R1, E | E1, B>;
+export declare function ap<W, S, A, R1, E1>(fb: Pure<W, S, S, R1, E1, A>): <R, E, B>(self: Pure<W, S, S, R, E, (a: A) => B>) => Pure<W, S, S, R & R1, E | E1, B>;
 /**
  * @tsplus pipeable fncts.control.Pure zipLeft
  * @tsplus location "@fncts/base/control/Pure/api"

package/data/Datum/api.d.ts

@@ -175,7 +175,7 @@ export declare function toReplete<A>(self: Datum<A>): Datum<A>;
  * @tsplus getter fncts.Datum traverse
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function _traverse<A>(self: Datum<A>): <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E1, B>(f: (a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, B>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, import("@fncts/base/data/Datum/definition").Datum<B>>;
+export declare function _traverse<A>(self: Datum<A>): <G extends HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E1, B>(f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, B>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, Datum<B>>;
 export declare const traverse: P.Traversable<DatumF>["traverse"];
 /**
  * @tsplus pipeable fncts.Datum zip

package/data/DatumEither/api.d.ts

@@ -157,7 +157,7 @@ export declare const toReplete: <E, A>(self: DatumEither<E, A>) => DatumEither<E
  * @tsplus getter fncts.DatumEither traverse
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function _traverse<E, A>(self: DatumEither<E, A>): <G extends import("@fncts/typelevel/HKT.js").HKT, GC = import("@fncts/typelevel/HKT.js").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E1, B>(f: (a: A) => import("@fncts/typelevel/HKT.js").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, B>) => import("@fncts/typelevel/HKT.js").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, import("@fncts/base/data/DatumEither/definition").DatumEither<E, B>>;
+export declare function _traverse<E, A>(self: DatumEither<E, A>): <G extends HKT, GC = import("@fncts/typelevel/HKT.js").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E1, B>(f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, B>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, DatumEither<E, B>>;
 export declare const traverse: P.Traversable<DatumEitherF>["traverse"];
 /**
  * @tsplus pipeable fncts.DatumEither zipWith

package/data/Either/api.d.ts

@@ -11,7 +11,7 @@ import { Left, Right } from "./definition.js";
  * @tsplus pipeable fncts.Either ap
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function ap<A, E2>(fa: Either<E2, A>): <E1, B>(self: import("./definition.js").Either<E1, (a: A) => B>) => Either<E1 | E2, B>;
+export declare function ap<A, E2>(fa: Either<E2, A>): <E1, B>(self: Either<E1, (a: A) => B>) => Either<E1 | E2, B>;
 /**
  * @tsplus pipeable fncts.Either bimap
  * @tsplus location "@fncts/base/data/Either/api"
@@ -114,7 +114,7 @@ export declare function swap<E, A>(self: Either<E, A>): Either<A, E>;
  * @tsplus getter fncts.Either traverse
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function _traverse<E, A>(self: Either<E, A>): <G extends import("@fncts/typelevel/HKT.js").HKT, GC = import("@fncts/typelevel/HKT.js").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E1, B>(f: (a: A) => import("@fncts/typelevel/HKT.js").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, B>) => import("@fncts/typelevel/HKT.js").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, import("./definition.js").Either<E, B>>;
+export declare function _traverse<E, A>(self: Either<E, A>): <G extends HKT, GC = import("@fncts/typelevel/HKT.js").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E1, B>(f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, B>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, Either<E, B>>;
 export declare const traverse_: P.Traversable<EitherF>["traverse"];
 /**
  * @tsplus pipeable fncts.Either zipWith

package/data/EitherT/api.d.ts

@@ -32,22 +32,22 @@ export declare function leftF<F extends HKT, FC>(F: P.Functor<F, FC>): <K, Q, W,
  * @tsplus static fncts.EitherTOps map
  * @tsplus location "@fncts/base/data/EitherT/api"
  */
-export declare function map<F extends HKT, FC>(F: P.Functor<F, FC>): <A, B>(f: (a: A) => B) => <K, Q, W, X, I, S, R, FE, E>(self: EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, B>;
+export declare function map<F extends HKT, FC>(F: P.Functor<F, FC>): <A, B>(f: (a: A) => B) => (<K, Q, W, X, I, S, R, FE, E>(self: EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, B>);
 /**
  * @tsplus static fncts.EitherTOps mapLeft
  * @tsplus location "@fncts/base/data/EitherT/api"
  */
-export declare function mapLeft<F extends HKT, FC = HKT.None>(F: P.Functor<F, FC>): <E, E1>(f: (e: E) => E1) => <K, Q, W, X, I, S, R, FE, A>(self: import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, import("../Either.js").Either<E, A>>) => import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, import("../Either.js").Either<E1, A>>;
+export declare function mapLeft<F extends HKT, FC = HKT.None>(F: P.Functor<F, FC>): <E, E1>(f: (e: E) => E1) => (<K, Q, W, X, I, S, R, FE, A>(self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E, A>>) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E1, A>>);
 /**
  * @tsplus static fncts.EitherTOps bimap
  * @tsplus location "@fncts/base/data/EitherT/api"
  */
-export declare function bimap<F extends HKT, FC = HKT.None>(F: P.Functor<F, FC>): <E, A, E1, B>(f: (e: E) => E1, g: (a: A) => B) => <K, Q, W, X, I, S, R, FE>(self: import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, import("../Either.js").Either<E, A>>) => import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, import("../Either.js").Either<E1, B>>;
+export declare function bimap<F extends HKT, FC = HKT.None>(F: P.Functor<F, FC>): <E, A, E1, B>(f: (e: E) => E1, g: (a: A) => B) => (<K, Q, W, X, I, S, R, FE>(self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E, A>>) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E1, B>>);
 /**
  * @tsplus static fncts.EitherTOps flatMap
  * @tsplus location "@fncts/base/data/EitherT/api"
  */
-export declare function flatMap<F extends HKT, FC>(F: P.Monad<F, FC>): <K, Q, W, X, I, S, R, FE, A, K1, Q1, W1, X1, I1, S1, R1, FE1, E1, B>(f: (a: A) => HKT.Kind<F, FC, HKT.Intro<F, "K", K, K1>, HKT.Intro<F, "Q", Q, Q1>, HKT.Intro<F, "W", W, W1>, HKT.Intro<F, "X", X, X1>, HKT.Intro<F, "I", I, I1>, HKT.Intro<F, "S", S, S1>, HKT.Intro<F, "R", R, R1>, HKT.Intro<F, "E", FE, FE1>, Either<E1, B>>) => <E>(self: EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>) => EitherT<F, FC, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "K", [K, K1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "Q", [Q, Q1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "W", [W, W1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "X", [X, X1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "I", [I, I1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "S", [S, S1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "R", [R, R1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "E", [FE, FE1]>, E1 | E, B>;
+export declare function flatMap<F extends HKT, FC>(F: P.Monad<F, FC>): <K, Q, W, X, I, S, R, FE, A, K1, Q1, W1, X1, I1, S1, R1, FE1, E1, B>(f: (a: A) => HKT.Kind<F, FC, HKT.Intro<F, "K", K, K1>, HKT.Intro<F, "Q", Q, Q1>, HKT.Intro<F, "W", W, W1>, HKT.Intro<F, "X", X, X1>, HKT.Intro<F, "I", I, I1>, HKT.Intro<F, "S", S, S1>, HKT.Intro<F, "R", R, R1>, HKT.Intro<F, "E", FE, FE1>, Either<E1, B>>) => (<E>(self: EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>) => EitherT<F, FC, HKT.Mix<F, "K", [K, K1]>, HKT.Mix<F, "Q", [Q, Q1]>, HKT.Mix<F, "W", [W, W1]>, HKT.Mix<F, "X", [X, X1]>, HKT.Mix<F, "I", [I, I1]>, HKT.Mix<F, "S", [S, S1]>, HKT.Mix<F, "R", [R, R1]>, HKT.Mix<F, "E", [FE, FE1]>, E | E1, B>);
 /**
  * @tsplus static fncts.EitherTOps zipWith
  * @tsplus location "@fncts/base/data/EitherT/api"

package/data/Eq/api.d.ts

@@ -4,3 +4,8 @@ import { Eq } from "@fncts/base/data/Eq/definition";
  * @tsplus location "@fncts/base/data/Eq/api"
  */
 export declare function contramap<A, B>(f: (b: B) => A): (self: Eq<A>) => Eq<B>;
+/**
+ * @tsplus static fncts.EqOps all
+ * @tsplus location "@fncts/base/data/Eq/api"
+ */
+export declare function all<A>(collection: Iterable<Eq<A>>): Eq<ReadonlyArray<A>>;

package/data/Exit/api.d.ts

@@ -6,7 +6,7 @@ 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: import("./definition.js").Exit<G, (a: A) => B>) => Exit<E | G, B>;
+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 location "@fncts/base/data/Exit/api"

package/data/FiberId/definition.d.ts

@@ -6,7 +6,7 @@ export type FiberIdTypeId = typeof FiberIdTypeId;
 export declare class None implements Hashable, Equatable {
     readonly [FiberIdTypeId]: FiberIdTypeId;
     readonly _tag = "None";
-    [Symbol.equals](that: unknown): boolean;
+    [Symbol.equals](that: unknown): that is None;
     get [Symbol.hash](): number;
 }
 export declare class Runtime implements Hashable, Equatable {

package/data/Guard/api.d.ts

@@ -224,7 +224,7 @@ export declare function deriveValidation<A extends Brand.Valid<any, any>>(...[ba
  * @tsplus static fncts.GuardOps validation
  * @tsplus location "@fncts/base/data/Guard/api"
  */
-export declare function validation<A, B extends ReadonlyArray<Validation<A, any>>>(...validations: B): (base: Guard<A>) => Guard<A & { [K in keyof B]: B[K] extends Validation<any, infer S extends string> ? Brand.Valid<A, S> : never; }[number]>;
+export declare function validation<A, B extends ReadonlyArray<Validation<A, any>>>(...validations: B): (base: Guard<A>) => Guard<A & { [K in keyof B]: B[K] extends Validation<any, infer S> ? Brand.Valid<A, S> : never; }[number]>;
 /**
  * @tsplus derive fncts.Guard<_> 10
  * @tsplus location "@fncts/base/data/Guard/api"

package/data/Identity/api.d.ts

@@ -4,7 +4,7 @@ import { Zipped } from "@fncts/base/data/Zipped";
  * @tsplus pipeable fncts.Identity ap
  * @tsplus location "@fncts/base/data/Identity/api"
  */
-export declare function ap<A>(fa: Identity<A>): <B>(fab: import("./definition").Identity<(a: A) => B>) => Identity<B>;
+export declare function ap<A>(fa: Identity<A>): <B>(fab: Identity<(a: A) => B>) => Identity<B>;
 /**
  * @tsplus pipeable fncts.Identity map
  * @tsplus location "@fncts/base/data/Identity/api"

package/data/Maybe/api.d.ts

@@ -10,7 +10,7 @@ import type { Nullable } from "@fncts/base/types";
  * @tsplus pipeable fncts.Maybe ap
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function ap<A>(fa: Maybe<A>): <B>(self: import("./definition.js").Maybe<(a: A) => B>) => Maybe<B>;
+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`.

package/data/Ord/api.d.ts

@@ -1,3 +1,16 @@
+import { Ord } from "@fncts/base/data/Ord/definition";
+/**
+ * @tsplus static fncts.OrdOps all
+ * @tsplus location "@fncts/base/data/Ord/api"
+ */
+export declare function all<A>(collection: Iterable<Ord<A>>): Ord<ReadonlyArray<A>>;
+/**
+ * @tsplus static fncts.OrdOps tuple
+ * @tsplus location "@fncts/base/data/Ord/api"
+ */
+export declare function tuple<T extends ReadonlyArray<Ord<any>>>(...elements: T): Ord<Readonly<{
+    [I in keyof T]: [T[I]] extends [Ord<infer A>] ? A : never;
+}>>;
 export * from "./api/min.js";
 export * from "./api/max.js";
 export * from "./api/contramap.js";

package/data/Struct/api.d.ts

@@ -17,7 +17,7 @@ export declare function makeStruct<A>(a: A): Struct<A>;
  * @tsplus pipeable fncts.Struct set
  * @tsplus location "@fncts/base/data/Struct/api"
  */
-export declare function set<N extends string, B>(key: EnsureLiteral<N>, value: B): <A>(self: Struct<A>) => Struct<{ [P in N | Exclude<keyof A, N>]: P extends Exclude<keyof A, N> ? A[P] : B; }>;
+export declare function set<N extends string, B>(key: EnsureLiteral<N>, value: B): <A>(self: Struct<A>) => Struct<{ [P in Exclude<keyof A, N> | N]: P extends Exclude<keyof A, N> ? A[P] : B; }>;
 /**
  * @tsplus pipeable fncts.Struct hmap
  * @tsplus location "@fncts/base/data/Struct/api"
@@ -29,7 +29,7 @@ export declare function hmap<A extends {}, F extends {
  * @tsplus pipeable fncts.Struct modify
  * @tsplus location "@fncts/base/data/Struct/api"
  */
-export declare function modify<A, N extends keyof A, B>(key: N, f: (a: A[N]) => B): (self: Struct<A>) => Struct<{ readonly [P in N | Exclude<keyof A, N>]: P extends Exclude<keyof A, N> ? A[P] : B; }>;
+export declare function modify<A, N extends keyof A, B>(key: N, f: (a: A[N]) => B): (self: Struct<A>) => Struct<{ readonly [P in Exclude<keyof A, N> | N]: P extends Exclude<keyof A, N> ? A[P] : B; }>;
 /**
  * @tsplus pipeable fncts.Struct pick
  * @tsplus location "@fncts/base/data/Struct/api"

package/data/These/api.d.ts

@@ -46,7 +46,7 @@ export declare function zip<E, B>(that: These<E, B>, /** @tsplus auto */ S: P.Se
  * @tsplus pipeable fncts.These ap
  * @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: import("@fncts/base/data/These/definition").These<E, (a: A) => B>) => These<E, B>;
+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 pipeable fncts.These flatMap
  * @tsplus location "@fncts/base/data/These/api"

package/data/function/api.d.ts

@@ -2,7 +2,7 @@
  * @tsplus pipeable fncts.Function compose
  * @tsplus location "@fncts/base/data/function/api"
  */
-export declare function compose<B, C>(g: (b: B) => C): <A extends readonly any[]>(f: (...params: A) => B) => (...params: A) => C;
+export declare function compose<B, C>(g: (b: B) => C): <A extends ReadonlyArray<any>>(f: (...params: A) => B) => ((...params: A) => C);
 /**
  * @tsplus static fncts.FunctionOps constVoid
  * @tsplus location "@fncts/base/data/function/api"

package/data.d.ts

@@ -33,11 +33,8 @@ export type {} from "./data/Equatable.js";
 export type {} from "./data/Eq.js";
 export type {} from "./data/EnvironmentPatch.js";
 export type {} from "./data/Environment.js";
-export type {} from "./data/Encoder.js";
 export type {} from "./data/Either.js";
 export type {} from "./data/Duration.js";
-export type {} from "./data/Decoder.js";
-export type {} from "./data/DecodeError.js";
 export type {} from "./data/DatumEither.js";
 export type {} from "./data/Date.js";
 export type {} from "./data/Data.js";

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@fncts/base",
-  "version": "0.0.35",
+  "version": "0.0.37",
   "dependencies": {
-    "@fncts/typelevel": "0.0.18",
-    "uuid": "^9.0.1"
+    "@fncts/typelevel": "0.0.19",
+    "uuid": "^10.0.0"
   },
   "exports": {
     "./*": {

package/util/pattern.d.ts

@@ -44,13 +44,13 @@ export declare const matchTag_: {
     }, K extends { [k in X["_tag"]]: (_: Extract<X, {
         _tag: k;
     }>) => any; }>(m: X, _: K): ReturnType<K[keyof K]>;
-    <X_1 extends {
+    <X extends {
         _tag: string;
-    }, K_1 extends { [k_1 in X_1["_tag"]]?: ((_: Extract<X_1, {
-        _tag: k_1;
-    }>) => any) | undefined; }, H>(m: X_1, _: K_1, __: (_: Exclude<X_1, {
-        _tag: keyof K_1;
-    }>) => H): H | { [k_2 in keyof K_1]: ReturnType<NonNullable<K_1[k_2]>>; }[keyof K_1];
+    }, K extends { [k in X["_tag"]]?: ((_: Extract<X, {
+        _tag: k;
+    }>) => any) | undefined; }, H>(m: X, _: K, __: (_: Exclude<X, {
+        _tag: keyof K;
+    }>) => H): { [k_1 in keyof K]: ReturnType<NonNullable<K[k_1]>>; }[keyof K] | H;
 };
 export declare const matchTag: {
     <X extends {
@@ -58,11 +58,11 @@ export declare const matchTag: {
     }, K extends { [k in X["_tag"]]: (_: Extract<X, {
         _tag: k;
     }>) => any; }>(_: K): (m: X) => ReturnType<K[keyof K]>;
-    <X_1 extends {
+    <X extends {
         _tag: string;
-    }, K_1 extends { [k_1 in X_1["_tag"]]?: ((_: Extract<X_1, {
-        _tag: k_1;
-    }>) => any) | undefined; }, H>(_: K_1, __: (_: Exclude<X_1, {
-        _tag: keyof K_1;
-    }>) => H): (m: X_1) => H | { [k_2 in keyof K_1]: ReturnType<NonNullable<K_1[k_2]>>; }[keyof K_1];
+    }, K extends { [k in X["_tag"]]?: ((_: Extract<X, {
+        _tag: k;
+    }>) => any) | undefined; }, H>(_: K, __: (_: Exclude<X, {
+        _tag: keyof K;
+    }>) => H): (m: X) => { [k_1 in keyof K]: ReturnType<NonNullable<K[k_1]>>; }[keyof K] | H;
 };

package/util/predicates.d.ts

@@ -23,6 +23,11 @@ export declare function isBigInt(value: unknown): value is bigint;
 export declare function isByte(n: unknown): n is number;
 export declare function isSymbol(value: unknown): value is symbol;
 export declare function isPlain(value: unknown): value is object;
+/**
+ * @tsplus pipeable global hasProperty
+ * @tsplus location "@fncts/base/util/predicates"
+ */
+export declare function hasProperty<P extends PropertyKey>(property: P): (self: unknown) => self is { [K in P]: unknown; };
 export declare function isInstanceOf<C extends Constructor<A>, A>(type: C): (value: unknown) => value is A;
 export declare function isMap(u: unknown): u is Map<unknown, unknown>;
 export declare function isWeakMap(u: unknown): u is WeakMap<object, unknown>;