@fncts/base 0.0.12 → 0.0.13

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> {
+    readonly _A: () => A;
     readonly _typeId: MaybeTypdId;
-    readonly [HKT.F]: MaybeF;
-    readonly [HKT.A]: () => A;
-    readonly [HKT.T]: Maybe<HKT._A<this>>;
 }
 /**
  * @tsplus type fncts.Just

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/optics/Traversal/api/fromTraversable.d.ts

@@ -5,4 +5,4 @@ import { PTraversal } from "@fncts/base/optics/Traversal/definition";
  * @tsplus static fncts.optics.PTraversalOps fromTraversable
  * @tsplus location "@fncts/base/optics/Traversal/api/fromTraversable"
  */
-export declare function fromTraversable<T extends HKT>(T: P.Traversable<T>): <A, B, K = any, Q = unknown, W = never, X = never, I = any, S = any, R = unknown, E = never>() => PTraversal<import("@fncts/typelevel/HKT").HKT.Kind<T, K, Q, W, X, I, S, R, E, A>, import("@fncts/typelevel/HKT").HKT.Kind<T, K, Q, W, X, I, S, R, E, B>, A, B>;
+export declare function fromTraversable<F extends HKT, FC = HKT.None>(T: P.Traversable<F, FC>): <A, B, K = import("@fncts/typelevel/HKT").HKT.Low<F, "K">, Q = import("@fncts/typelevel/HKT").HKT.Low<F, "Q">, W = import("@fncts/typelevel/HKT").HKT.Low<F, "W">, X = import("@fncts/typelevel/HKT").HKT.Low<F, "X">, I = import("@fncts/typelevel/HKT").HKT.Low<F, "I">, S = import("@fncts/typelevel/HKT").HKT.Low<F, "S">, R = import("@fncts/typelevel/HKT").HKT.Low<F, "R">, E = import("@fncts/typelevel/HKT").HKT.Low<F, "E">>() => PTraversal<import("@fncts/typelevel/HKT").HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, import("@fncts/typelevel/HKT").HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>, A, B>;

package/optics/Traversal/definition.d.ts

@@ -6,12 +6,10 @@ import { PSetter } from "@fncts/base/optics/Setter";
  * @tsplus type fncts.optics.PTraversal
  */
 export interface PTraversal<S, T, A, B> extends PSetter<S, T, A, B>, Fold<S, A> {
-    modifyA<F extends HKT, K, Q, W, X, I, _S, R, E>(s: S, f: (a: A) => HKT.Kind<F, K, Q, W, X, I, _S, R, E, B>, 
-    /** @tsplus auto */ F: Applicative<F>): HKT.Kind<F, K, Q, W, X, I, _S, R, E, T>;
+    modifyA: <F extends HKT, FC = HKT.None>(F: Applicative<F, FC>) => <K, Q, W, X, I, _S, R, E>(s: S, f: (a: A) => HKT.Kind<F, FC, K, Q, W, X, I, _S, R, E, B>) => HKT.Kind<F, FC, K, Q, W, X, I, _S, R, E, T>;
 }
 export interface PTraversalMin<S, T, A, B> {
-    modifyA<F extends HKT, K, Q, W, X, I, _S, R, E>(s: S, f: (a: A) => HKT.Kind<F, K, Q, W, X, I, _S, R, E, B>, 
-    /** @tsplus auto */ F: Applicative<F>): HKT.Kind<F, K, Q, W, X, I, _S, R, E, T>;
+    modifyA: <F extends HKT, FC = HKT.None>(F: Applicative<F, FC>) => <K, Q, W, X, I, _S, R, E>(s: S, f: (a: A) => HKT.Kind<F, FC, K, Q, W, X, I, _S, R, E, B>) => HKT.Kind<F, FC, K, Q, W, X, I, _S, R, E, T>;
 }
 /**
  * @tsplus type fncts.optics.PTraversalOps

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@fncts/base",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "dependencies": {
-    "@fncts/typelevel": "0.0.10"
+    "@fncts/typelevel": "0.0.11"
   },
   "exports": {
     "./*": {

package/typeclass/Align.d.ts

@@ -4,7 +4,7 @@ import type { Semialign } from "@fncts/base/typeclass/Semialign";
 /**
  * @tsplus type fncts.Align
  */
-export interface Align<F extends HKT> extends Semialign<F>, Nil<F> {
+export interface Align<F extends HKT, FC = HKT.None> extends Semialign<F, FC>, Nil<F, FC> {
 }
 /**
  * @tsplus type fncts.AlignOps

package/typeclass/Alt.d.ts

@@ -4,8 +4,8 @@ import type { Functor } from "@fncts/base/typeclass/Functor";
 /**
  * @tsplus type fncts.Alt
  */
-export interface Alt<F extends HKT> extends Functor<F> {
-    alt<K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, that: Lazy<HKT.Kind<F, HKT.Intro<"K", K, K1>, HKT.Intro<"Q", Q, Q1>, HKT.Intro<"W", W, W1>, HKT.Intro<"X", X, X1>, HKT.Intro<"I", I, I1>, HKT.Intro<"S", S, S1>, HKT.Intro<"R", R, R1>, HKT.Intro<"E", E, E1>, HKT.Intro<"A", A, B>>>): HKT.Kind<F, HKT.Mix<"K", [K, K1]>, HKT.Mix<"Q", [Q, Q1]>, HKT.Mix<"W", [W, W1]>, HKT.Mix<"X", [X, X1]>, HKT.Mix<"I", [I, I1]>, HKT.Mix<"S", [S, S1]>, HKT.Mix<"R", [R, R1]>, HKT.Mix<"E", [E, E1]>, HKT.Mix<"A", [A, B]>>;
+export interface Alt<F extends HKT, FC = HKT.None> extends Functor<F, FC> {
+    alt: <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, 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", E, E1>, HKT.Intro<F, "A", A, 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", [E, E1]>, HKT.Mix<F, "A", [A, B]>>;
 }
 /**
  * @tsplus type fncts.AltOps
@@ -13,5 +13,3 @@ export interface Alt<F extends HKT> extends Functor<F> {
 export interface AltOps {
 }
 export declare const Alt: AltOps;
-export declare function alt<F extends HKT, K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(self: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, that: Lazy<HKT.Kind<F, HKT.Intro<"K", K, K1>, HKT.Intro<"Q", Q, Q1>, HKT.Intro<"W", W, W1>, HKT.Intro<"X", X, X1>, HKT.Intro<"I", I, I1>, HKT.Intro<"S", S, S1>, HKT.Intro<"R", R, R1>, HKT.Intro<"E", E, E1>, HKT.Intro<"A", A, B>>>, 
-/** @tsplus auto */ F: Alt<F>): HKT.Kind<F, HKT.Mix<"K", [K, K1]>, HKT.Mix<"Q", [Q, Q1]>, HKT.Mix<"W", [W, W1]>, HKT.Mix<"X", [X, X1]>, HKT.Mix<"I", [I, I1]>, HKT.Mix<"S", [S, S1]>, HKT.Mix<"R", [R, R1]>, HKT.Mix<"E", [E, E1]>, HKT.Mix<"A", [A, B]>>;

package/typeclass/Alternative.d.ts

@@ -5,7 +5,7 @@ import type { Nil } from "@fncts/base/typeclass/Nil";
 /**
  * @tsplus type fncts.Alternative
  */
-export interface Alternative<F extends HKT> extends Applicative<F>, Nil<F>, Alt<F> {
+export interface Alternative<F extends HKT, FC = HKT.None> extends Applicative<F, FC>, Nil<F, FC>, Alt<F, FC> {
 }
 /**
  * @tsplus type fncts.AlternativeOps

package/typeclass/Applicative.d.ts

@@ -1,7 +1,7 @@
 import { HKT } from "@fncts/typelevel/HKT";
 import type { Apply } from "@fncts/base/typeclass/Apply";
 import type { Pointed } from "@fncts/base/typeclass/Pointed";
-export interface Applicative<F extends HKT> extends Apply<F>, Pointed<F> {
+export interface Applicative<F extends HKT, FC = HKT.None> extends Apply<F, FC>, Pointed<F, FC> {
 }
 /**
  * @tsplus type fncts.ApplicativeOps
@@ -9,3 +9,4 @@ export interface Applicative<F extends HKT> extends Apply<F>, Pointed<F> {
 export interface ApplicativeOps {
 }
 export declare const Applicative: ApplicativeOps;
+export declare type CompatibleApplicative<F extends HKT, FC, A> = Applicative<F, FC> & ([A] extends [HKT.Kind<F, any, any, any, any, any, any, any, any, any, any>] ? unknown : ["invalid Applicative instance for", A]);

package/typeclass/ApplicativeExcept.d.ts

@@ -6,8 +6,8 @@ import type { Fail } from "@fncts/base/typeclass/Fail";
 /**
  * @tsplus type fncts.ApplicativeExcept
  */
-export interface ApplicativeExcept<F extends HKT> extends Applicative<F>, Fail<F> {
-    catchAll<K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, f: (e: E) => HKT.Kind<F, HKT.Intro<"K", K, K1>, HKT.Intro<"Q", Q, Q1>, HKT.Intro<"W", W, W1>, HKT.Intro<"X", X, X1>, HKT.Intro<"I", I, I1>, HKT.Intro<"S", S, S1>, HKT.Intro<"R", R, R1>, HKT.Intro<"E", E, E1>, A1>): HKT.Kind<F, HKT.Mix<"K", [K, K1]>, HKT.Mix<"Q", [Q, Q1]>, HKT.Mix<"W", [W, W1]>, HKT.Mix<"X", [X, X1]>, HKT.Mix<"I", [I, I1]>, HKT.Mix<"S", [S, S1]>, HKT.Mix<"R", [R, R1]>, E1, A | A1>;
+export interface ApplicativeExcept<F extends HKT, FC = HKT.None> extends Applicative<F, FC>, Fail<F, FC> {
+    catchAll: <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, f: (e: E) => 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", E, E1>, A1>) => 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]>, E1, A | A1>;
 }
 /**
  * @tsplus type fncts.ApplicativeExceptOps
@@ -15,21 +15,13 @@ export interface ApplicativeExcept<F extends HKT> extends Applicative<F>, Fail<F
 export interface ApplicativeExceptOps {
 }
 export declare const ApplicativeExcept: ApplicativeExceptOps;
-/**
- * @tsplus fluent fncts.Kind catchAll
- * @tsplus location "@fncts/base/typeclass/ApplicativeExcept"
- */
-export declare function catchAll<F extends HKT, K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, f: (e: E) => HKT.Kind<F, HKT.Intro<"K", K, K1>, HKT.Intro<"Q", Q, Q1>, HKT.Intro<"W", W, W1>, HKT.Intro<"X", X, X1>, HKT.Intro<"I", I, I1>, HKT.Intro<"S", S, S1>, HKT.Intro<"R", R, R1>, HKT.Intro<"E", E, E1>, A1>, 
-/** @tsplus auto */ F: ApplicativeExcept<F>): HKT.Kind<F, HKT.Mix<"K", [K, K1]>, HKT.Mix<"Q", [Q, Q1]>, HKT.Mix<"W", [W, W1]>, HKT.Mix<"X", [X, X1]>, HKT.Mix<"I", [I, I1]>, HKT.Mix<"S", [S, S1]>, HKT.Mix<"R", [R, R1]>, E1, A | A1>;
 /**
  * @tsplus fluent fncts.Kind catchJust
  * @tsplus location "@fncts/base/typeclass/ApplicativeExcept"
  */
-export declare function catchJust<F extends HKT, K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, f: (e: E) => Maybe<HKT.Kind<F, HKT.Intro<"K", K, K1>, HKT.Intro<"Q", Q, Q1>, HKT.Intro<"W", W, W1>, HKT.Intro<"X", X, X1>, HKT.Intro<"I", I, I1>, HKT.Intro<"S", S, S1>, HKT.Intro<"R", R, R1>, HKT.Intro<"E", E, E1>, A1>>, 
-/** @tsplus auto */ F: ApplicativeExcept<F>): HKT.Kind<F, HKT.Mix<"K", [K, K1]>, HKT.Mix<"Q", [Q, Q1]>, HKT.Mix<"W", [W, W1]>, HKT.Mix<"X", [X, X1]>, HKT.Mix<"I", [I, I1]>, HKT.Mix<"S", [S, S1]>, HKT.Mix<"R", [R, R1]>, HKT.Mix<"E", [E, E1]>, A | A1>;
+export declare function catchJust<F extends HKT, FC = HKT.None>(F: ApplicativeExcept<F, FC>): <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, f: (e: E) => Maybe<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", E, E1>, A1>>) => 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", [E, E1]>, A | A1>;
 /**
- * @tsplus fluent fncts.Kind either
+ * @tsplus static fncts.ApplicativeExceptOps either
  * @tsplus location "@fncts/base/typeclass/ApplicativeExcept"
  */
-export declare function either<F extends HKT, K, Q, W, X, I, S, R, E, A>(self: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, 
-/** @tsplus auto */ F: ApplicativeExcept<F>): HKT.Kind<F, K, Q, W, X, I, S, R, never, Either<E, A>>;
+export declare function either<F extends HKT, FC = HKT.None>(F: ApplicativeExcept<F, FC>): <K, Q, W, X, I, S, R, E, A>(self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, never, Either<E, A>>;