@fncts/base 0.0.12 → 0.0.15

package/data/Either/instances.d.ts

@@ -1,14 +1,15 @@
+import { HKT } from "@fncts/typelevel/HKT";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { Guard } from "@fncts/base/typeclass/Guard";
 import { Decoder } from "@fncts/base/data/Decoder";
-import type { Either1F, EitherF } from "@fncts/base/data/Either/definition.js";
+import type { EitherF } from "@fncts/base/data/Either/definition.js";
 import { Either } from "@fncts/base/data/Either/definition";
 import * as P from "../../typeclass.js";
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/data/Either/instances"
  */
-export declare const Functor: P.Functor<EitherF>;
+export declare const Functor: P.Functor<EitherF, import("@fncts/typelevel/HKT.js").HKT.None>;
 /**
  * @tsplus static fncts.EitherOps getEq
  * @tsplus location "@fncts/base/data/Either/instances"
@@ -23,7 +24,7 @@ export declare function deriveEq<A extends Either<any, any>>(...[left, right]: [
  * @tsplus static fncts.EitherOps getFilterable
  * @tsplus location "@fncts/base/data/Either/instances"
  */
-export declare function getFilerable<E>(/** @tsplus auto */ ME: P.Monoid<E>): P.Filterable<Either1F<E>>;
+export declare function getFilerable<E>(/** @tsplus auto */ ME: P.Monoid<E>): P.Filterable<EitherF, HKT.Fix<"E", E>>;
 /**
  * @tsplus derive fncts.Guard[fncts.Either]<_> 10
  * @tsplus location "@fncts/base/data/Either/instances"

package/data/EitherT/api.d.ts

@@ -0,0 +1,60 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import { Either } from "@fncts/base/data/Either/definition";
+import { Lazy } from "@fncts/base/data/function/definition";
+import type { EitherT } from "./definition.js";
+import type * as P from "@fncts/base/typeclass";
+/**
+ * @tsplus static fncts.EitherTOps __call
+ * @tsplus location "@fncts/base/data/EitherT/api"
+ */
+export declare function make<F extends HKT, FC, K, Q, W, X, I, S, R, FE, E, A>(self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E, A>>): EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>;
+/**
+ * @tsplus static fncts.EitherTOps right
+ * @tsplus location "@fncts/base/data/EitherT/api"
+ */
+export declare function right<F extends HKT, FC>(F: P.Pointed<F, FC>): <K, Q, W, X, I, S, R, FE, E = never, A = never>(a: A) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>;
+/**
+ * @tsplus static fncts.EitherTOps left
+ * @tsplus location "@fncts/base/data/EitherT/api"
+ */
+export declare function left<F extends HKT, FC>(F: P.Pointed<F, FC>): <K, Q, W, X, I, S, R, FE, E, A = never>(e: E) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>;
+/**
+ * @tsplus static fncts.EitherTOps rightF
+ * @tsplus location "@fncts/base/data/EitherT/api"
+ */
+export declare function rightF<F extends HKT, FC>(F: P.Functor<F, FC>): <K, Q, W, X, I, S, R, FE, E = never, A = never>(self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, A>) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>;
+/**
+ * @tsplus static fncts.EitherTOps leftF
+ * @tsplus location "@fncts/base/data/EitherT/api"
+ */
+export declare function leftF<F extends HKT, FC>(F: P.Functor<F, FC>): <K, Q, W, X, I, S, R, FE, E = never, A = never>(self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, E>) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>;
+/**
+ * @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>): <K, Q, W, X, I, S, R, FE, E, A, B>(self: EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>, f: (a: A) => B) => 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>): <K, Q, W, X, I, S, R, FE, E, A, E1>(self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E, A>>, f: (e: E) => E1) => 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>): <K, Q, W, X, I, S, R, FE, E, A, E1, B>(self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E, A>>, f: (e: E) => E1, g: (a: A) => B) => 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, E, A, K1, Q1, W1, X1, I1, S1, R1, FE1, E1, B>(self: import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, import("../Either.js").Either<E, A>>, f: (a: A) => import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "K", K, K1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "Q", Q, Q1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "W", W, W1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "X", X, X1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "I", I, I1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "S", S, S1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "R", R, R1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "E", FE, FE1>, import("../Either.js").Either<E1, B>>) => import("@fncts/typelevel/HKT.js").HKT.Kind<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]>, import("../Either.js").Either<E | E1, B>>;
+/**
+ * @tsplus static fncts.EitherTOps zipWith
+ * @tsplus location "@fncts/base/data/EitherT/api"
+ */
+export declare function zipWith<F extends HKT, FC = HKT.None>(F: P.Apply<F, FC>): <K, Q, W, X, I, S, R, EF, E, A, K1, Q1, W1, X1, I1, S1, R1, EF1, E1, B, C>(self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, EF, Either<E, A>>, that: 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", EF, EF1>, Either<E1, B>>, f: (a: A, b: B) => C) => 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", EF, EF1>, Either<E | E1, C>>;
+/**
+ * @tsplus static fncts.EitherTOps orElse
+ * @tsplus location "@fncts/base/data/EitherT/api"
+ */
+export declare function orElse<F extends HKT, FC = HKT.None>(F: P.Monad<F, FC>): <K, Q, W, X, I, S, R, EF, E, A, K1, Q1, W1, X1, I1, S1, R1, EF1, E1, B>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, EF, Either<E, A>>, that: Lazy<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", EF, EF1>, Either<E1, B>>>) => HKT.Kind<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", [EF, EF1]>, Either<E | E1, A | B>>;

package/data/EitherT/definition.d.ts

@@ -0,0 +1,12 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import { Either } from "@fncts/base/data/Either/definition";
+/**
+ * @tsplus type fncts.EitherT
+ */
+export declare type EitherT<F extends HKT, FC, K, Q, W, X, I, S, R, EF, E, A> = HKT.Kind<F, FC, K, Q, W, X, I, S, R, EF, Either<E, A>>;
+/**
+ * @tsplus type fncts.EitherTOps
+ */
+export interface EitherTOps {
+}
+export declare const EitherT: EitherTOps;

package/data/Environment/api.d.ts

@@ -6,17 +6,18 @@ import { Maybe } from "@fncts/base/data/Maybe/definition";
  * @tsplus fluent fncts.Environment add
  * @tsplus location "@fncts/base/data/Environment/api"
  */
-export declare function add<R, S, H extends S = S>(self: Environment<R>, service: H, tag: Tag<S>): Environment<R & Has<S>>;
+export declare function add<R, H extends S, S = H>(self: Environment<R>, service: H, tag: Tag<S>): Environment<R | S>;
 /**
  * @tsplus static fncts.EnvironmentOps empty
  * @tsplus location "@fncts/base/data/Environment/api"
  */
-export declare const empty: import("./definition").Environment<unknown>;
+export declare const empty: import("./definition").Environment<never>;
+declare type Tags<R> = R extends infer S ? Tag<S> : never;
 /**
  * @tsplus fluent fncts.Environment get
  * @tsplus location "@fncts/base/data/Environment/api"
  */
-export declare function get<R extends Has<S>, S>(self: Environment<R>, tag: Tag<S>): S;
+export declare function get<R, T extends Tags<R>>(self: Environment<R>, tag: T): T extends Tag<infer S> ? S : never;
 /**
  * @tsplus fluent fncts.Environment getMaybe
  * @tsplus location "@fncts/base/data/Environment/api"
@@ -26,7 +27,7 @@ export declare function getMaybe<R extends Has<S>, S>(self: Environment<R>, tag:
  * @tsplus static fncts.EnvironmentOps __call
  * @tsplus location "@fncts/base/data/Environment/api"
  */
-export declare function make(): Environment<unknown>;
+export declare function make(): Environment<never>;
 /**
  * @tsplus operator fncts.Environment +
  * @tsplus fluent fncts.Environment union
@@ -47,4 +48,5 @@ export declare function unsafeGet<R, S>(self: Environment<R>, tag: Tag<S>): S;
  * @tsplus fluent fncts.Environment update
  * @tsplus location "@fncts/base/data/Environment/api"
  */
-export declare function update<R extends Has<S>, S>(self: Environment<R>, f: (s: S) => S, tag: Tag<S>): Environment<R>;
+export declare function update<R, S extends R>(self: Environment<R>, f: (s: S) => S, tag: Tag<S>): Environment<R>;
+export {};

package/data/Environment/definition.d.ts

@@ -13,12 +13,12 @@ export declare type EnvSymbol = typeof EnvSymbol;
  * @tsplus companion fncts.EnvironmentOps
  */
 export declare class Environment<R> implements Hashable, Equatable {
-    readonly map: HashMap<Tag<unknown>, readonly [unknown, number]>;
+    readonly map: HashMap<Tag<any>, readonly [unknown, number]>;
     readonly index: number;
-    cache: HashMap<Tag<unknown>, unknown>;
+    cache: HashMap<Tag<any>, unknown>;
     readonly _typeId: EnvSymbol;
     readonly [EnvSymbol]: (_: never) => R;
-    constructor(map: HashMap<Tag<unknown>, readonly [unknown, number]>, index: number, cache?: HashMap<Tag<unknown>, unknown>);
+    constructor(map: HashMap<Tag<any>, readonly [unknown, number]>, index: number, cache?: HashMap<Tag<any>, unknown>);
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
 }

package/data/Identity/api.d.ts

@@ -1,4 +1,5 @@
 import { Identity } from "@fncts/base/data/Identity/definition";
+import { Zipped } from "@fncts/base/data/Zipped";
 /**
  * @tsplus fluent fncts.Identity ap
  * @tsplus location "@fncts/base/data/Identity/api"
@@ -24,7 +25,7 @@ export declare function zipWith_<A, B, C>(fa: Identity<A>, fb: Identity<B>, f: (
  * @tsplus fluent fncts.Identity zip
  * @tsplus location "@fncts/base/data/Identity/api"
  */
-export declare function zip_<A, B>(fa: Identity<A>, fb: Identity<B>): Identity<readonly [A, B]>;
+export declare function zip_<A, B>(fa: Identity<A>, fb: Identity<B>): Identity<Zipped.Make<A, B>>;
 /**
  * @tsplus getter fncts.Identity getIdentity
  * @tsplus macro identity

package/data/Identity/definition.d.ts

@@ -1,7 +1,7 @@
 import { HKT } from "@fncts/typelevel/HKT";
 import { Newtype, NewtypeIso } from "@fncts/base/data/Newtype";
-export interface IdentityN {
-    readonly [HKT.T]: Identity<HKT._A<this>>;
+export interface IdentityN extends HKT {
+    type: Identity<this["A"]>;
 }
 /**
  * @tsplus type fncts.Identity

package/data/Identity/instances.d.ts

@@ -4,14 +4,14 @@ import type { IdentityN } from "@fncts/base/data/Identity/definition";
  * @tsplus static fncts.IdentityOps Functor
  * @tsplus location "@fncts/base/data/Identity/instances"
  */
-export declare const Functor: P.Functor<IdentityN>;
+export declare const Functor: P.Functor<IdentityN, import("@fncts/typelevel/HKT.js").HKT.None>;
 /**
  * @tsplus static fncts.IdentityOps Apply
  * @tsplus location "@fncts/base/data/Identity/instances"
  */
-export declare const Apply: P.Apply<IdentityN>;
+export declare const Apply: P.Apply<IdentityN, import("@fncts/typelevel/HKT.js").HKT.None>;
 /**
  * @tsplus static fncts.IdentityOps Applicative
  * @tsplus location "@fncts/base/data/Identity/instances"
  */
-export declare const Applicative: P.Applicative<IdentityN>;
+export declare const Applicative: P.Applicative<IdentityN, import("@fncts/typelevel/HKT.js").HKT.None>;

package/data/Intervals.d.ts

@@ -0,0 +1,53 @@
+import { List } from "@fncts/base/collection/immutable/List/definition";
+import { Interval } from "@fncts/base/data/Interval";
+/**
+ * @tsplus type fncts.Intervals
+ * @tsplus companion fncts.IntervalsOps
+ */
+export declare class Intervals {
+    readonly intervals: List<Interval>;
+    constructor(intervals: List<Interval>);
+}
+/**
+ * @tsplus static fncts.IntervalsOps __call
+ * @tsplus location "@fncts/base/data/Intervals"
+ */
+export declare function make(intervals: List<Interval>): Intervals;
+/**
+ * @tsplus fluent fncts.Intervals union
+ * @tsplus operator fncts.Intervals ||
+ * @tsplus location "@fncts/base/data/Intervals"
+ */
+export declare function union(self: Intervals, that: Intervals): Intervals;
+/**
+ * @tsplus fluent fncts.Intervals intersect
+ * @tsplus operator fncts.Intervals &&
+ * @tsplus location "@fncts/base/data/Intervals"
+ */
+export declare function intersect(self: Intervals, that: Intervals): Intervals;
+/**
+ * @tsplus getter fncts.Intervals start
+ * @tsplus location "@fncts/base/data/Intervals"
+ */
+export declare function start(self: Intervals): number;
+/**
+ * @tsplus getter fncts.Intervals end
+ * @tsplus location "@fncts/base/data/Intervals"
+ */
+export declare function end(self: Intervals): number;
+/**
+ * @tsplus fluent fncts.Intervals lt
+ * @tsplus operator fncts.Intervals <
+ * @tsplus location "@fncts/base/data/Intervals"
+ */
+export declare function lt(self: Intervals, that: Intervals): boolean;
+/**
+ * @tsplus fluent fncts.Intervals max
+ * @tsplus location "@fncts/base/data/Intervals"
+ */
+export declare function max(self: Intervals, that: Intervals): Intervals;
+/**
+ * @tsplus getter fncts.Intervals isNonEmpty
+ * @tsplus location "@fncts/base/data/Intervals"
+ */
+export declare function isNonEmpty(self: Intervals): boolean;

package/data/Maybe/api.d.ts

@@ -3,6 +3,7 @@ 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 { Zipped } from "@fncts/base/data/Zipped";
 import type { Eq, Monoid } from "@fncts/base/typeclass";
 import type { Nullable } from "@fncts/base/types";
 /**
@@ -108,4 +109,4 @@ export declare function zipWith_<A, B, C>(self: Maybe<A>, fb: Maybe<B>, f: (a: A
  * @tsplus fluent fncts.Maybe zip
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function zip_<A, B>(self: Maybe<A>, that: Maybe<B>): Maybe<readonly [A, B]>;
+export declare function zip_<A, B>(self: Maybe<A>, that: Maybe<B>): Maybe<Zipped.Make<A, B>>;

package/data/Maybe/definition.d.ts

@@ -7,16 +7,19 @@ export declare const enum MaybeTag {
 }
 export declare const MaybeTypeId: unique symbol;
 export declare type MaybeTypdId = typeof MaybeTypeId;
-export declare type MaybeF = Maybe<any>;
+export interface MaybeF extends HKT {
+    type: Maybe<this["A"]>;
+    variance: {
+        A: "+";
+    };
+}
 /**
  * @tsplus type fncts.Maybe
  * @tsplus companion fncts.MaybeOps
  */
 export declare class Maybe<A> {
+    _A: () => A;
     readonly _typeId: MaybeTypdId;
-    readonly [HKT.F]: MaybeF;
-    readonly [HKT.A]: () => A;
-    readonly [HKT.T]: Maybe<HKT._A<this>>;
 }
 /**
  * @tsplus type fncts.Just
@@ -41,7 +44,9 @@ export declare class Nothing extends Maybe<never> {
 /**
  * @tsplus unify fncts.Maybe
  */
-export declare function unifyMaybe<X extends Maybe<any>>(self: X): Maybe<[X] extends [Maybe<infer A>] ? A : never>;
+export declare function unifyMaybe<X extends Maybe<any>>(self: X): Maybe<[X] extends [{
+    _A: () => infer A;
+}] ? A : never>;
 /**
  * @tsplus static fncts.MaybeOps isMaybe
  * @tsplus location "@fncts/base/data/Maybe/definition"

package/data/Maybe/instances.d.ts

@@ -3,12 +3,12 @@ import { Guard } from "@fncts/base/typeclass/Guard";
 import { Decoder } from "@fncts/base/data/Decoder";
 import type * as P from "../../typeclass.js";
 import type { MaybeF } from "@fncts/base/data/Maybe/definition";
-export declare const Functor: P.Functor<MaybeF>;
-export declare const Apply: P.Apply<MaybeF>;
-export declare const Applicative: P.Applicative<MaybeF>;
-export declare const Monad: P.Monad<MaybeF>;
-export declare const Foldable: P.Foldable<MaybeF>;
-export declare const Filterable: P.Filterable<MaybeF>;
+export declare const Functor: P.Functor<MaybeF, import("@fncts/typelevel/HKT.js").HKT.None>;
+export declare const Apply: P.Apply<MaybeF, import("@fncts/typelevel/HKT.js").HKT.None>;
+export declare const Applicative: P.Applicative<MaybeF, import("@fncts/typelevel/HKT.js").HKT.None>;
+export declare const Monad: P.Monad<MaybeF, import("@fncts/typelevel/HKT.js").HKT.None>;
+export declare const Foldable: P.Foldable<MaybeF, import("@fncts/typelevel/HKT.js").HKT.None>;
+export declare const Filterable: P.Filterable<MaybeF, import("@fncts/typelevel/HKT.js").HKT.None>;
 /**
  * @tsplus derive fncts.Guard[fncts.Maybe]<_> 10
  * @tsplus location "@fncts/base/data/Maybe/instances"

package/data/Newtype.d.ts

@@ -2,12 +2,13 @@ import { HKT } from "@fncts/typelevel/HKT";
 /**
  * @tsplus type fncts.Newtype
  */
-export interface Newtype<URI, A> {
+export interface Newtype<URI, A, C = HKT.None> {
     readonly _URI: URI;
-    readonly [HKT.A]: A;
+    readonly _A: A;
+    readonly _C: C;
 }
 export declare namespace Newtype {
-    type Iso<N extends NewtypeHKT> = NewtypeIso<N>;
+    type Iso<N extends NewtypeHKT, C = N["type"]["_C"]> = NewtypeIso<N, C>;
 }
 /**
  * @tsplus type fncts.NewtypeOps
@@ -16,20 +17,20 @@ export interface NewtypeOps {
 }
 export declare const Newtype: NewtypeOps;
 export interface NewtypeHKT extends HKT {
-    readonly [HKT.T]: Newtype<any, any>;
+    readonly type: Newtype<any, any>;
 }
-export interface NewtypeIso<N extends NewtypeHKT> {
+export interface NewtypeIso<N extends NewtypeHKT, C = N["type"]["_C"]> {
     /**
      * @tsplus macro identity
      */
-    get: <K, Q, W, X, I, S, R, E, A>(_: HKT.Kind<N, K, Q, W, X, I, S, R, E, A>[HKT.A]) => HKT.Kind<N, K, Q, W, X, I, S, R, E, A>;
+    get: <K extends HKT.GetExtends<C, "K", any>, Q extends HKT.GetExtends<C, "Q", any>, W extends HKT.GetExtends<C, "W", any>, X extends HKT.GetExtends<C, "X", any>, I extends HKT.GetExtends<C, "I", any>, S extends HKT.GetExtends<C, "S", any>, R extends HKT.GetExtends<C, "E", any>, E extends HKT.GetExtends<C, "E", any>, A extends HKT.GetExtends<C, "A", any>>(_: HKT.Kind<N, N["type"]["_C"], K, Q, W, X, I, S, R, E, A>["_A"]) => HKT.Kind<N, HKT.None, K, Q, W, X, I, S, R, E, A>;
     /**
      * @tsplus macro identity
      */
-    reverseGet: <K, Q, W, X, I, S, R, E, A>(_: HKT.Kind<N, K, Q, W, X, I, S, R, E, A>) => HKT.Kind<N, K, Q, W, X, I, S, R, E, A>[HKT.A];
+    reverseGet: <K extends HKT.GetExtends<C, "K", any>, Q extends HKT.GetExtends<C, "Q", any>, W extends HKT.GetExtends<C, "W", any>, X extends HKT.GetExtends<C, "X", any>, I extends HKT.GetExtends<C, "I", any>, S extends HKT.GetExtends<C, "S", any>, R extends HKT.GetExtends<C, "E", any>, E extends HKT.GetExtends<C, "E", any>, A extends HKT.GetExtends<C, "A", any>>(_: HKT.Kind<N, HKT.None, K, Q, W, X, I, S, R, E, A>) => HKT.Kind<N, HKT.None, K, Q, W, X, I, S, R, E, A>["_A"];
 }
 /**
  * @tsplus static fncts.NewtypeOps __call
  * @tsplus location "@fncts/base/data/Newtype"
  */
-export declare const newtype: <N extends NewtypeHKT>() => NewtypeIso<N>;
+export declare const newtype: <N extends NewtypeHKT>() => NewtypeIso<N, N["type"]["_C"]>;

package/data/Struct/definition.d.ts

@@ -1,7 +1,7 @@
 import { HKT } from "@fncts/typelevel/HKT";
 import { Newtype, NewtypeIso } from "@fncts/base/data/Newtype";
 interface StructN extends HKT {
-    readonly [HKT.T]: Struct<HKT._A<this>>;
+    type: Struct<this["A"]>;
 }
 /**
  * @tsplus type fncts.Struct

package/data/Tag/definition.d.ts

@@ -8,8 +8,8 @@ export declare type TagTypeId = typeof TagTypeId;
  * @tsplus type fncts.Tag
  * @tsplus companion fncts.TagOps
  */
-export declare class Tag<T> implements Hashable, Equatable {
-    readonly _T: (_: never) => T;
+export declare class Tag<in out T> implements Hashable, Equatable {
+    _T: (_: T) => T;
     readonly _typeId: TagTypeId;
     private static counter;
     readonly id: number;

package/data/Zipped.d.ts

@@ -0,0 +1,24 @@
+export declare const ZippedTypeId: unique symbol;
+export declare type ZippedTypeId = typeof ZippedTypeId;
+export declare type Zipped<A extends Array<any>> = Readonly<A> & {
+    readonly [ZippedTypeId]: ZippedTypeId;
+};
+export declare namespace Zipped {
+    type Make<A, B> = [A] extends [Zipped<infer X>] ? [B] extends [Zipped<infer Y>] ? Zipped<[...X, ...Y]> : Zipped<[...X, B]> : [B] extends [Zipped<infer Y>] ? Zipped<[A, ...Y]> : Zipped<[A, B]>;
+}
+/**
+ * @tsplus type fncts.ZippedOps
+ */
+export interface ZippedOps {
+}
+export declare const Zipped: ZippedOps;
+/**
+ * @tsplus static fncts.ZippedOps is
+ * @tsplus location "@fncts/base/data/Zipped"
+ */
+export declare function isZipped(a: unknown): a is Zipped<Array<unknown>>;
+/**
+ * @tsplus static fncts.ZippedOps __call
+ * @tsplus location "@fncts/base/data/Zipped"
+ */
+export declare function make<A, B>(a: A, b: B): Zipped.Make<A, B>;

package/data/function/api.d.ts

@@ -20,6 +20,12 @@ export declare function identity<A>(a: A): A;
  */
 export declare function tuple<A extends ReadonlyArray<unknown>>(...as: A): A;
 /**
+ * @tsplus getter fncts.Function tupled
+ * @tsplus location "@fncts/base/data/function/api"
+ */
+export declare function tupled<A, B, C>(f: (a: A, b: B) => C): (_: readonly [A, B]) => C;
+/**
+ * @tsplus fluent global unsafeCoerce
  * @tsplus static fncts.FunctionOps unsafeCoerce
  * @tsplus macro identity
  * @tsplus location "@fncts/base/data/function/api"

package/data/object/instances.d.ts

@@ -1,7 +1,12 @@
+import type { Check } from "@fncts/typelevel/Check";
 import * as P from "@fncts/base/typeclass";
 /**
- * @tsplus implicit
  * @tsplus static fncts.globalOps Guard
  * @tsplus location "@fncts/base/data/object/instances"
  */
 export declare const Guard: P.Guard<{}>;
+/**
+ * @tsplus derive fncts.Guard<_> 10
+ * @tsplus location "@fncts/base/data/object/instances"
+ */
+export declare function deriveGuard<A extends {}>(..._: Check<Check.IsEqual<A, {}>> extends Check.True ? [] : never): P.Guard<A>;

package/data/string/api.d.ts

@@ -139,7 +139,7 @@ export declare function under_(s: string, f: (chars: Array<string>) => Array<str
 export declare const under: (f: (chars: Array<string>) => Array<string>) => (s: string) => string;
 /**
  * Join newline-separated strings together.
- * @tsplus getter fncts.base.ImmutableArray unlines
+ * @tsplus getter fncts.ImmutableArray unlines
  * @tsplus location "@fncts/base/data/string/api"
  */
 export declare function unlines(as: ReadonlyArray<string>): string;

package/data.d.ts

@@ -0,0 +1,33 @@
+export type {} from "./data/bigint.js";
+export type {} from "./data/boolean.js";
+export type {} from "./data/Branded.js";
+export type {} from "./data/Byte.js";
+export type {} from "./data/CaseClass.js";
+export type {} from "./data/Cause.js";
+export type {} from "./data/Const.js";
+export type {} from "./data/DecodeError.js";
+export type {} from "./data/Decoder.js";
+export type {} from "./data/Duration.js";
+export type {} from "./data/Either.js";
+export type {} from "./data/Environment.js";
+export type {} from "./data/exceptions.js";
+export type {} from "./data/ExecutionStrategy.js";
+export type {} from "./data/Exit.js";
+export type {} from "./data/FiberId.js";
+export type {} from "./data/function.js";
+export type {} from "./data/Identity.js";
+export type {} from "./data/Interval.js";
+export type {} from "./data/Intervals.js";
+export type {} from "./data/Maybe.js";
+export type {} from "./data/Newtype.js";
+export type {} from "./data/number.js";
+export type {} from "./data/object.js";
+export type {} from "./data/Patch.js";
+export type {} from "./data/Predicate.js";
+export type {} from "./data/Refinement.js";
+export type {} from "./data/string.js";
+export type {} from "./data/Tag.js";
+export type {} from "./data/These.js";
+export type {} from "./data/Trace.js";
+export type {} from "./data/TraceElement.js";
+export type {} from "./data/Zipped.js";