@fncts/base 0.0.3 → 0.0.6

package/data/Either/api.d.ts

@@ -1,8 +1,9 @@
 import { Either } from "@fncts/base/data/Either/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
+import { Predicate } from "@fncts/base/data/Predicate/definition";
 import type * as P from "../../typeclass.js";
-import type { EitherF } from "./instances.js";
+import type { EitherF } from "./definition.js";
 import { Left, Right } from "./definition.js";
 /**
  * @tsplus fluent fncts.Either ap
@@ -45,14 +46,10 @@ export declare function foldLeft_<E, A, B>(self: Either<E, A>, b: B, f: (b: B, a
  */
 export declare function foldRight_<E, A, B>(self: Either<E, A>, b: B, f: (a: A, b: B) => B): B;
 /**
- * @constrained
- */
-export declare function foldMap_<M>(M: P.Monoid<M>): <E, A>(self: import("./definition.js").Either<E, A>, f: (a: A) => M) => M;
-/**
- * @tsplus getter fncts.Either foldMap
+ * @tsplus fluent fncts.Either foldMap
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function foldMapSelf<E, A>(self: Either<E, A>): <M>(M: P.Monoid<M>) => (f: (a: A) => M) => M;
+export declare function foldMap_<E, A, M>(self: Either<E, A>, f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): M;
 /**
  * @tsplus getter fncts.Either getLeft
  * @tsplus location "@fncts/base/data/Either/api"
@@ -105,24 +102,39 @@ export declare function merge<E, A>(self: Either<E, A>): E | A;
  * @tsplus location "@fncts/base/data/Either/api"
  */
 export declare function orElse_<E1, A, E2, B>(self: Either<E1, A>, that: Lazy<Either<E2, B>>): Either<E1 | E2, A | B>;
-export declare const sequence: P.sequence<EitherF>;
-/**
- * @tsplus getter fncts.Either sequence
- * @tsplus location "@fncts/base/data/Either/api"
- */
-export declare const sequenceSelf: P.sequenceSelf<EitherF>;
 /**
  * @tsplus getter fncts.Either swap
  * @tsplus location "@fncts/base/data/Either/api"
  */
 export declare function swap<E, A>(self: Either<E, A>): Either<A, E>;
-export declare const traverse_: P.traverse_<EitherF>;
-export declare const traverse: P.traverse<EitherF>;
 /**
- * @tsplus getter fncts.Either traverse
+ * @tsplus fluent fncts.Either traverse
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare const traverseSelf: P.traverseSelf<EitherF>;
+export declare const traverse_: P.Traversable<EitherF>["traverse"];
 export declare function zipWith_<E1, A, E2, B, C>(self: Either<E1, A>, fb: Either<E2, B>, f: (a: A, b: B) => C): Either<E1 | E2, C>;
+/**
+ * @tsplus fluent fncts.Either filterMap
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function filterMap<E, A, B>(self: Either<E, A>, f: (a: A) => Maybe<B>, 
+/** @tsplus auto */ M: P.Monoid<E>): Either<E, B>;
+/**
+ * @tsplus fluent fncts.Either filter
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function filter<E, A>(self: Either<E, A>, f: Predicate<A>, /** @tsplus auto */ M: P.Monoid<E>): Either<E, A>;
+/**
+ * @tsplus fluent fncts.Either partitionMap
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function partitionMap<E, A, B, C>(self: Either<E, A>, f: (a: A) => Either<B, C>, 
+/** @tsplus auto */ M: P.Monoid<E>): readonly [Either<E, B>, Either<E, C>];
+/**
+ * @tsplus fluent fncts.Either partition
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function partition<E, A>(self: Either<E, A>, p: Predicate<A>, 
+/** @tsplus auto */ M: P.Monoid<E>): readonly [Either<E, A>, Either<E, A>];
 export * from "./api/align.js";
 export * from "./api/alignWith.js";

package/data/Either/definition.d.ts

@@ -1,16 +1,38 @@
+import { HKT } from "@fncts/typelevel/HKT";
 export declare const enum EitherTag {
     Left = "Left",
     Right = "Right"
 }
 export declare const EitherTypeId: unique symbol;
 export declare type EitherTypeId = typeof EitherTypeId;
+export interface EitherF extends Either<any, any> {
+}
+export interface Either1F<E> extends Either1<E, any> {
+}
+/**
+ * @tsplus type fncts.Either
+ * @tsplus companion fncts.EitherOps
+ */
+export declare class Either<E, A> {
+    readonly _typeId: EitherTypeId;
+    readonly [HKT.F]: EitherF;
+    readonly [HKT.E]: () => E;
+    readonly [HKT.A]: () => A;
+    readonly [HKT.T]: Either<HKT._E<this>, HKT._A<this>>;
+}
+export interface Either1<E, A> {
+    readonly _typeId: EitherTypeId;
+    readonly [HKT.F]: EitherF;
+    readonly [HKT.E]: () => E;
+    readonly [HKT.A]: () => A;
+    readonly [HKT.T]: Either<E, HKT._A<this>>;
+}
 /**
  * @tsplus type fncts.Either.Left
  * @tsplus companion fncts.Either.LeftOps
  */
-export declare class Left<E> {
+export declare class Left<E> extends Either<E, never> {
     readonly left: E;
-    readonly _typeId: EitherTypeId;
     readonly _tag = EitherTag.Left;
     constructor(left: E);
 }
@@ -18,23 +40,19 @@ export declare class Left<E> {
  * @tsplus type fncts.Either.Right
  * @tsplus companion fncts.Either.RightOps
  */
-export declare class Right<A> {
+export declare class Right<A> extends Either<never, A> {
     readonly right: A;
-    readonly _typeId: EitherTypeId;
     readonly _tag = EitherTag.Right;
     constructor(right: A);
 }
-/**
- * @tsplus type fncts.Either
- */
-export declare type Either<E, A> = Left<E> | Right<A>;
-/**
- * @tsplus type fncts.EitherOps
- */
-export interface EitherOps {
-}
-export declare const Either: EitherOps;
 /**
  * @tsplus unify fncts.Either
  */
 export declare function unifyEither<X extends Either<any, any>>(self: X): Either<[X] extends [Either<infer E, any>] ? E : never, [X] extends [Either<any, infer A>] ? A : never>;
+/**
+ * @tsplus fluent fncts.Either concrete
+ * @tsplus static fncts.EitherOps concrete
+ * @tsplus macro remove
+ * @tsplus location "@fncts/base/data/Either/definition"
+ */
+export declare function concrete<E, A>(self: Either<E, A>): asserts self is Left<E> | Right<A>;

package/data/Either/instances.d.ts

@@ -1,21 +1,36 @@
-import { HKT } from "@fncts/typelevel/HKT";
-import { Either } from "@fncts/base/data/Either/definition";
 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 { Either } from "@fncts/base/data/Either/definition";
 import * as P from "../../typeclass.js";
-export interface EitherF extends HKT {
-    readonly type: Either<this["E"], this["A"]>;
-    readonly variance: {
-        E: "+";
-        A: "+";
-    };
-}
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Either/instances"
+ */
+export declare const Functor: P.Functor<EitherF>;
 /**
  * @tsplus static fncts.EitherOps getEq
  * @tsplus location "@fncts/base/data/Either/instances"
  */
 export declare function getEq<E, A>(EE: P.Eq<E>, EA: P.Eq<A>): P.Eq<Either<E, A>>;
 /**
- * @tsplus static fncts.EitherOps getEq
+ * @tsplus derive fncts.Eq[fncts.Either]<_> 10
+ * @tsplus location "@fncts/base/data/Either/instances"
+ */
+export declare function deriveEq<A extends Either<any, any>>(...[left, right]: [A] extends [Either<infer E, infer A>] ? [left: P.Eq<E>, right: P.Eq<A>] : never): P.Eq<A>;
+/**
+ * @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>>;
+/**
+ * @tsplus derive fncts.Guard[fncts.Either]<_> 10
+ * @tsplus location "@fncts/base/data/Either/instances"
+ */
+export declare function deriveGuard<A extends Either<any, any>>(...[left, right]: [A] extends [Either<infer E, infer A>] ? [left: Guard<E>, right: Guard<A>] : never): Guard<A>;
+/**
+ * @tsplus derive fncts.Decoder[fncts.Either]<_> 10
  * @tsplus location "@fncts/base/data/Either/instances"
  */
-export declare function getFilerable<E>(ME: P.Monoid<E>): P.Filterable<EitherF, import("@fncts/typelevel/HKT.js").HKT.Fix<"E", E>>;
+export declare function deriveDecoder<A extends Either<any, any>>(...[left, right]: [A] extends [Either<infer E, infer A>] ? [left: Decoder<E>, right: Decoder<A>] : never): Decoder<A>;

package/data/Environment/api.d.ts

@@ -33,6 +33,11 @@ export declare function make(): Environment<unknown>;
  * @tsplus location "@fncts/base/data/Environment/api"
  */
 export declare function union<R, R1>(self: Environment<R>, that: Environment<R1>): Environment<R & R1>;
+/**
+ * @tsplus getter fncts.Environment clean
+ * @tsplus location "@fncts/base/data/Environment/api"
+ */
+export declare function clean<R>(self: Environment<R>): Environment<R>;
 /**
  * @tsplus fluent fncts.Environment unsafeGet
  * @tsplus location "@fncts/base/data/Environment/api"

package/data/Exit/definition.d.ts

@@ -1,4 +1,5 @@
 import { Cause } from "@fncts/base/data/Cause/definition";
+import { Hashable } from "@fncts/base/typeclass/Hashable";
 import * as P from "../../typeclass.js";
 export declare const ExitTypeId: unique symbol;
 export declare type ExitTypeId = typeof ExitTypeId;

package/data/Identity/api.d.ts

@@ -20,3 +20,14 @@ export declare function pure<A>(a: A): Identity<A>;
  * @tsplus location "@fncts/base/data/Identity/api"
  */
 export declare function zipWith_<A, B, C>(fa: Identity<A>, fb: Identity<B>, f: (a: A, b: B) => C): Identity<C>;
+/**
+ * @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]>;
+/**
+ * @tsplus getter fncts.Identity getIdentity
+ * @tsplus macro identity
+ * @tsplus location "@fncts/base/data/Identity/api"
+ */
+export declare function getIdentity<A>(self: Identity<A>): A;

package/data/Identity/definition.d.ts

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

package/data/Identity/instances.d.ts

@@ -1,21 +1,17 @@
-import { HKT } from "@fncts/typelevel/HKT";
-import { Identity } from "@fncts/base/data/Identity/definition";
-import * as P from "../../typeclass.js";
-export interface IdentityF extends HKT {
-    readonly type: Identity<this["A"]>;
-}
+import type * as P from "../../typeclass.js";
+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<IdentityF, import("@fncts/typelevel/HKT.js").HKT.None>;
+export declare const Functor: P.Functor<IdentityN>;
 /**
  * @tsplus static fncts.IdentityOps Apply
  * @tsplus location "@fncts/base/data/Identity/instances"
  */
-export declare const Apply: P.Apply<IdentityF, import("@fncts/typelevel/HKT.js").HKT.None>;
+export declare const Apply: P.Apply<IdentityN>;
 /**
  * @tsplus static fncts.IdentityOps Applicative
  * @tsplus location "@fncts/base/data/Identity/instances"
  */
-export declare const Applicative: P.Applicative<IdentityF, import("@fncts/typelevel/HKT.js").HKT.None>;
+export declare const Applicative: P.Applicative<IdentityN>;

package/data/Interval.d.ts

@@ -0,0 +1,71 @@
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+/**
+ * @tsplus type fncts.io.Schedule.Interval
+ * @tsplus companion fncts.io.Schedule.IntervalOps
+ */
+export declare class Interval {
+    readonly startMilliseconds: number;
+    readonly endMilliseconds: number;
+    constructor(startMilliseconds: number, endMilliseconds: number);
+}
+/**
+ * @tsplus static fncts.io.Schedule.IntervalOps after
+ * @tsplus location "@fncts/base/data/Interval"
+ */
+export declare function after(start: number): Interval;
+/**
+ * @tsplus static fncts.io.Schedule.IntervalOps before
+ * @tsplus location "@fncts/base/data/Interval"
+ */
+export declare function before(end: number): Interval;
+/**
+ * @tsplus static fncts.io.Schedule.IntervalOps empty
+ * @tsplus location "@fncts/base/data/Interval"
+ */
+export declare const empty: Interval;
+/**
+ * @tsplus getter fncts.io.Schedule.Interval isEmpty
+ * @tsplus location "@fncts/base/data/Interval"
+ */
+export declare function isEmpty(self: Interval): boolean;
+/**
+ * @tsplus fluent fncts.io.Schedule.Interval intersect
+ * @tsplus location "@fncts/base/data/Interval"
+ */
+export declare function intersect_(self: Interval, that: Interval): Interval;
+/**
+ * @tsplus fluent fncts.io.Schedule.Interval lt
+ * @tsplus operator fncts.io.Schedule.Interval <
+ * @tsplus location "@fncts/base/data/Interval"
+ */
+export declare function lt_(self: Interval, that: Interval): boolean;
+/**
+ * @tsplus static fncts.io.Schedule.IntervalOps __call
+ * @tsplus location "@fncts/base/data/Interval"
+ */
+export declare function makeInterval(start: number, end: number): Interval;
+/**
+ * @tsplus fluent fncts.io.Schedule.Interval max
+ * @tsplus location "@fncts/base/data/Interval"
+ */
+export declare function max_(self: Interval, that: Interval): Interval;
+/**
+ * @tsplus fluent fncts.io.Schedule.Interval min
+ * @tsplus location "@fncts/base/data/Interval"
+ */
+export declare function min_(self: Interval, that: Interval): Interval;
+/**
+ * @tsplus getter fncts.io.Schedule.Interval isNonEmpty
+ * @tsplus location "@fncts/base/data/Interval"
+ */
+export declare function isNonEmpty(self: Interval): boolean;
+/**
+ * @tsplus getter fncts.io.Schedule.Interval size
+ * @tsplus location "@fncts/base/data/Interval"
+ */
+export declare function size(self: Interval): number;
+/**
+ * @tsplus fluent fncts.io.Schedule.Interval union
+ * @tsplus location "@fncts/base/data/Interval"
+ */
+export declare function union_(self: Interval, that: Interval): Maybe<Interval>;

package/data/Maybe/api.d.ts

@@ -3,7 +3,6 @@ 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 type { MaybeF } from "./instances.js";
 import type { Eq, Monoid } from "@fncts/base/typeclass";
 import type { Nullable } from "@fncts/base/types";
 /**
@@ -11,11 +10,6 @@ import type { Nullable } from "@fncts/base/types";
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
 export declare function ap_<A, B>(self: Maybe<(a: A) => B>, fa: Maybe<A>): Maybe<B>;
-/**
- * @tsplus static fncts.MaybeOps sequenceS
- * @tsplus location "@fncts/base/data/Maybe/api"
- */
-export declare const sequenceS: import("@fncts/base/typeclass").sequenceS<MaybeF, import("@fncts/typelevel/HKT.js").HKT.None>;
 /**
  * Applies `f` to the value contained in `Maybe` if it is `Just` and returns the result,
  * otherwise returns `Nothing`.
@@ -23,15 +17,11 @@ export declare const sequenceS: import("@fncts/base/typeclass").sequenceS<MaybeF
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
 export declare function flatMap_<A, B>(self: Maybe<A>, f: (a: A) => Maybe<B>): Maybe<B>;
-/**
- * @constrained
- */
-export declare function elem_<A>(E: Eq<A>): (self: Maybe<A>, elem: A) => boolean;
 /**
  * @tsplus fluent fncts.Maybe elem
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function elemSelf<A>(self: Maybe<A>): (E: Eq<A>) => (elem: A) => boolean;
+export declare function elem_<A>(self: Maybe<A>, elem: A, E: Eq<A>): boolean;
 /**
  * @constrained
  * @tsplus fluent fncts.Maybe exists
@@ -76,14 +66,10 @@ export declare function foldLeft_<A, B>(self: Maybe<A>, b: B, f: (b: B, a: A) =>
  */
 export declare function foldRight_<A, B>(self: Maybe<A>, b: B, f: (a: A, b: B) => B): B;
 /**
- * @constrained
- */
-export declare function foldMap_<M>(M: Monoid<M>): <A>(self: import("./definition.js").Maybe<A>, f: (a: A) => M) => M;
-/**
- * @tsplus getter fncts.Maybe foldMap
+ * @tsplus fluent fncts.Maybe foldMap
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function foldMapSelf<A>(self: Maybe<A>): <M>(M: Monoid<M>) => (f: (a: A) => M) => M;
+export declare function foldMap_<A, M>(self: Maybe<A>, f: (a: A) => M, /** @tsplus auto */ M: Monoid<M>): M;
 /**
  * Extracts the value from `Maybe` if it exists, or returns the result of `orElse`.
  * @tsplus fluent fncts.Maybe getOrElse

package/data/Maybe/definition.d.ts

@@ -1,16 +1,29 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { Hashable } from "@fncts/base/typeclass/Hashable";
 export declare const enum MaybeTag {
     Just = "Just",
     Nothing = "Nothing"
 }
 export declare const MaybeTypeId: unique symbol;
 export declare type MaybeTypdId = typeof MaybeTypeId;
+export declare type MaybeF = Maybe<any>;
+/**
+ * @tsplus type fncts.Maybe
+ * @tsplus companion fncts.MaybeOps
+ */
+export declare class Maybe<A> {
+    readonly _typeId: MaybeTypdId;
+    readonly [HKT.F]: MaybeF;
+    readonly [HKT.A]: () => A;
+    readonly [HKT.T]: Maybe<HKT._A<this>>;
+}
 /**
  * @tsplus type fncts.Just
  * @tsplus companion fncts.JustOps
  */
-export declare class Just<A> {
+export declare class Just<A> extends Maybe<A> {
     readonly value: A;
-    readonly _typeId: MaybeTypdId;
     readonly _tag = MaybeTag.Just;
     constructor(value: A);
     [Symbol.equals](that: unknown): boolean;
@@ -20,22 +33,11 @@ export declare class Just<A> {
  * @tsplus type fncts.Nothing
  * @tsplus companion fncts.NothingOps
  */
-export declare class Nothing {
-    readonly _typeId: MaybeTypdId;
+export declare class Nothing extends Maybe<never> {
     readonly _tag = MaybeTag.Nothing;
     [Symbol.equals](that: unknown): boolean;
     get [Symbol.hash](): number;
 }
-/**
- * @tsplus type fncts.Maybe
- */
-export declare type Maybe<A> = Just<A> | Nothing;
-/**
- * @tsplus type fncts.MaybeOps
- */
-export interface MaybeOps {
-}
-export declare const Maybe: MaybeOps;
 /**
  * @tsplus unify fncts.Maybe
  */
@@ -57,3 +59,10 @@ export declare function isJust<A>(self: Maybe<A>): self is Just<A>;
  * @tsplus location "@fncts/base/data/Maybe/definition"
  */
 export declare function isNothing<A>(self: Maybe<A>): self is Nothing;
+/**
+ * @tsplus fluent fncts.Maybe concrete
+ * @tsplus static fncts.MaybeOps concrete
+ * @tsplus macro remove
+ * @tsplus location "@fncts/base/data/Maybe/definition"
+ */
+export declare function concrete<A>(self: Maybe<A>): asserts self is Just<A> | Nothing;

package/data/Maybe/instances.d.ts

@@ -1,15 +1,21 @@
-import { HKT } from "@fncts/typelevel/HKT";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
-import * as P from "../../typeclass.js";
-export interface MaybeF extends HKT {
-    readonly type: Maybe<this["A"]>;
-    readonly variance: {
-        readonly A: "-";
-    };
-}
+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>;
+/**
+ * @tsplus derive fncts.Guard[fncts.Maybe]<_> 10
+ * @tsplus location "@fncts/base/data/Maybe/instances"
+ */
+export declare function deriveGuard<A extends Maybe<any>>(...[guard]: [A] extends [Maybe<infer A>] ? [guard: Guard<A>] : never): Guard<A>;
+/**
+ * @tsplus derive fncts.Decoder[fncts.Maybe]<_> 10
+ * @tsplus location "@fncts/base/data/Maybe/instances"
+ */
+export declare function deriveDecoder<A extends Maybe<any>>(...[value]: [A] extends [Maybe<infer A>] ? [value: Decoder<A>] : never): Decoder<A>;

package/data/Newtype.d.ts

@@ -2,13 +2,12 @@ import { HKT } from "@fncts/typelevel/HKT";
 /**
  * @tsplus type fncts.Newtype
  */
-export interface Newtype<URI, A, C = HKT.None> {
+export interface Newtype<URI, A> {
     readonly _URI: URI;
-    readonly _A: A;
-    readonly _C: C;
+    readonly [HKT.A]: A;
 }
 export declare namespace Newtype {
-    type Iso<N extends NewtypeHKT, C = N["type"]["_C"]> = NewtypeIso<N, C>;
+    type Iso<N extends NewtypeHKT> = NewtypeIso<N>;
 }
 /**
  * @tsplus type fncts.NewtypeOps
@@ -17,20 +16,20 @@ export interface NewtypeOps {
 }
 export declare const Newtype: NewtypeOps;
 export interface NewtypeHKT extends HKT {
-    readonly type: Newtype<any, any>;
+    readonly [HKT.T]: Newtype<any, any>;
 }
-export interface NewtypeIso<N extends NewtypeHKT, C = N["type"]["_C"]> {
+export interface NewtypeIso<N extends NewtypeHKT> {
     /**
      * @tsplus macro identity
      */
-    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>;
+    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>;
     /**
      * @tsplus macro identity
      */
-    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"];
+    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];
 }
 /**
  * @tsplus static fncts.NewtypeOps __call
  * @tsplus location "@fncts/base/data/Newtype"
  */
-export declare const newtype: <N extends NewtypeHKT>() => NewtypeIso<N, N["type"]["_C"]>;
+export declare const newtype: <N extends NewtypeHKT>() => NewtypeIso<N>;

package/data/Refinement/api.d.ts

@@ -1,10 +1,12 @@
 import { Refinement } from "@fncts/base/data/Refinement/definition";
+import { Predicate } from "@fncts/base/data/Predicate/definition";
 /**
  * @tsplus fluent fncts.Refinement and
  * @tsplus operator fncts.Refinement &&
  * @tsplus location "@fncts/base/data/Refinement/api"
  */
 export declare function and<A, B extends A, C extends B>(self: Refinement<A, B>, that: Refinement<B, C>): Refinement<A, C>;
+export declare function and<A, B extends A>(self: Refinement<A, B>, that: Predicate<B>): Refinement<A, B>;
 /**
  * @tsplus fluent fncts.Refinement contramap
  * @tsplus location "@fncts/base/data/Refinement/api"

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 type: Struct<this["A"]>;
+    readonly [HKT.T]: Struct<HKT._A<this>>;
 }
 /**
  * @tsplus type fncts.Struct

package/data/These/api.d.ts

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