@fncts/base 0.0.36 → 0.0.37

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/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/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.36",
+  "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;
 };