@fncts/base 0.0.12 → 0.0.15

package/_src/data/EitherT/api.ts

@@ -0,0 +1,239 @@
+import type { EitherT } from "./definition.js";
+import type * as P from "@fncts/base/typeclass";
+
+/**
+ * @tsplus static fncts.EitherTOps __call
+ */
+export 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> {
+  return self;
+}
+
+/**
+ * @tsplus static fncts.EitherTOps right
+ */
+export 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> {
+  return (a) => F.pure(Either.right(a));
+}
+
+/**
+ * @tsplus static fncts.EitherTOps left
+ */
+export 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> {
+  return (e) => F.pure(Either.left(e));
+}
+
+/**
+ * @tsplus static fncts.EitherTOps rightF
+ */
+export 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> {
+  return (self) => F.map(self, Either.right);
+}
+
+/**
+ * @tsplus static fncts.EitherTOps leftF
+ */
+export 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> {
+  return (self) => F.map(self, Either.left);
+}
+
+/**
+ * @tsplus static fncts.EitherTOps map
+ */
+export 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> {
+  return (self, f) => F.map(self, (either) => either.map(f));
+}
+
+/**
+ * @tsplus static fncts.EitherTOps mapLeft
+ */
+export 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>> {
+  return (self, f) => F.map(self, (either) => either.mapLeft(f));
+}
+
+/**
+ * @tsplus static fncts.EitherTOps bimap
+ */
+export 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>> {
+  return (self, f, g) => F.map(self, (either) => either.bimap(f, g));
+}
+
+/**
+ * @tsplus static fncts.EitherTOps flatMap
+ */
+export function flatMap<F extends HKT, FC>(F: P.Monad<F, FC>) {
+  return <K, Q, W, X, I, S, R, FE, E, A, K1, Q1, W1, X1, I1, S1, R1, FE1, E1, B>(
+    self: EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>,
+    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>
+    >,
+  ): 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
+  > =>
+    F.flatMap(
+      self,
+      (either) =>
+        either.match(
+          (e) => F.pure(Either.left(e)),
+          (a) => f(a),
+        ) as 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>
+        >,
+    );
+}
+
+/**
+ * @tsplus static fncts.EitherTOps zipWith
+ */
+export 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>
+>;
+export function zipWith<F extends HKT>(
+  F: P.Apply<HKT.F<F>>,
+): <E, A, E1, B, C>(
+  self: HKT.FK1<F, Either<E, A>>,
+  that: HKT.FK1<F, Either<E1, B>>,
+  f: (a: A, b: B) => C,
+) => HKT.FK1<F, Either<E | E1, C>> {
+  return (self, that, f) => F.zipWith(self, that, (a, b) => a.zipWith(b, f));
+}
+
+/**
+ * @tsplus static fncts.EitherTOps orElse
+ */
+export 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>
+>;
+export function orElse<F>(
+  F: P.Monad<HKT.F1<F>>,
+): <E, A, E1, B>(
+  self: HKT.FK1<F, Either<E, A>>,
+  that: Lazy<HKT.FK1<F, Either<E1, B>>>,
+) => HKT.FK1<F, Either<E | E1, A | B>> {
+  return (self, that) =>
+    F.flatMap(self, (either) =>
+      either.match(
+        () => that(),
+        () => F.pure(either),
+      ),
+    );
+}

package/_src/data/EitherT/definition.ts

@@ -0,0 +1,23 @@
+/**
+ * @tsplus type fncts.EitherT
+ */
+export 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 const EitherT: EitherTOps = {};

package/_src/data/Environment/api.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus fluent fncts.Environment add
  */
-export function add<R, S, H extends S = S>(self: Environment<R>, service: H, tag: Tag<S>): Environment<R & Has<S>> {
+export function add<R, H extends S, S = H>(self: Environment<R>, service: H, tag: Tag<S>): Environment<R | S> {
   const self0 = self.index === Number.MAX_SAFE_INTEGER ? self.clean : self;
   return new Environment(self0.map.set(tag, [service, self0.index]), self0.index + 1);
 }
@@ -11,11 +11,13 @@ export function add<R, S, H extends S = S>(self: Environment<R>, service: H, tag
  */
 export const empty = Environment();
 
+type Tags<R> = R extends infer S ? Tag<S> : never;
+
 /**
  * @tsplus fluent fncts.Environment get
  */
-export function get<R extends Has<S>, S>(self: Environment<R>, tag: Tag<S>): S {
-  return self.unsafeGet(tag);
+export function get<R, T extends Tags<R>>(self: Environment<R>, tag: T): T extends Tag<infer S> ? S : never {
+  return unsafeCoerce(self.unsafeGet(tag));
 }
 
 /**
@@ -28,7 +30,7 @@ export function getMaybe<R extends Has<S>, S>(self: Environment<R>, tag: Tag<S>)
 /**
  * @tsplus static fncts.EnvironmentOps __call
  */
-export function make(): Environment<unknown> {
+export function make(): Environment<never> {
   return new Environment(HashMap.makeDefault(), 0, HashMap.makeDefault());
 }
 
@@ -88,6 +90,6 @@ export function unsafeGet<R, S>(self: Environment<R>, tag: Tag<S>): S {
 /**
  * @tsplus fluent fncts.Environment update
  */
-export function update<R extends Has<S>, S>(self: Environment<R>, f: (s: S) => S, tag: Tag<S>): Environment<R> {
-  return self.add(f(self.get(tag)), tag);
+export function update<R, S extends R>(self: Environment<R>, f: (s: S) => S, tag: Tag<S>): Environment<R> {
+  return self.add(f(self.unsafeGet(tag)), tag);
 }

package/_src/data/Environment/definition.ts

@@ -13,9 +13,9 @@ export class Environment<R> implements Hashable, Equatable {
   readonly _typeId: EnvSymbol = EnvSymbol;
   readonly [EnvSymbol]!: (_: never) => R;
   constructor(
-    readonly map: HashMap<Tag<unknown>, readonly [unknown, number]>,
+    readonly map: HashMap<Tag<any>, readonly [unknown, number]>,
     readonly index: number,
-    public cache: HashMap<Tag<unknown>, unknown> = HashMap.makeDefault(),
+    public cache: HashMap<Tag<any>, unknown> = HashMap.makeDefault(),
   ) {}
 
   get [Symbol.hash](): number {

package/_src/data/Identity/api.ts

@@ -30,8 +30,8 @@ export function zipWith_<A, B, C>(fa: Identity<A>, fb: Identity<B>, f: (a: A, b:
 /**
  * @tsplus fluent fncts.Identity zip
  */
-export function zip_<A, B>(fa: Identity<A>, fb: Identity<B>): Identity<readonly [A, B]> {
-  return fa.zipWith(fb, (a, b) => [a, b]);
+export function zip_<A, B>(fa: Identity<A>, fb: Identity<B>): Identity<Zipped.Make<A, B>> {
+  return fa.zipWith(fb, (a, b) => Zipped(a, b));
 }
 
 /**

package/_src/data/Identity/definition.ts

@@ -1,5 +1,5 @@
-export interface IdentityN {
-  readonly [HKT.T]: Identity<HKT._A<this>>;
+export interface IdentityN extends HKT {
+  type: Identity<this["A"]>;
 }
 
 /**

package/_src/data/Identity/instances.ts

@@ -1,28 +1,28 @@
 import type * as P from "../../typeclass.js";
 import type { IdentityN } from "@fncts/base/data/Identity/definition";
 
-import { ap_, map_, pure, zip_, zipWith_ } from "./api.js";
+import { map_, pure, zip_, zipWith_ } from "./api.js";
 
 /**
  * @tsplus static fncts.IdentityOps Functor
  */
-export const Functor: P.Functor<IdentityN> = {
+export const Functor = HKT.instance<P.Functor<IdentityN>>({
   map: map_,
-};
+});
 
 /**
  * @tsplus static fncts.IdentityOps Apply
  */
-export const Apply: P.Apply<IdentityN> = {
+export const Apply = HKT.instance<P.Apply<IdentityN>>({
   ...Functor,
   zip: zip_,
   zipWith: zipWith_,
-};
+});
 
 /**
  * @tsplus static fncts.IdentityOps Applicative
  */
-export const Applicative: P.Applicative<IdentityN> = {
+export const Applicative = HKT.instance<P.Applicative<IdentityN>>({
   ...Apply,
   pure,
-};
+});

package/_src/data/Intervals.ts

@@ -0,0 +1,126 @@
+/**
+ * @tsplus type fncts.Intervals
+ * @tsplus companion fncts.IntervalsOps
+ */
+export class Intervals {
+  constructor(readonly intervals: List<Interval>) {}
+}
+
+/**
+ * @tsplus static fncts.IntervalsOps __call
+ */
+export function make(intervals: List<Interval>): Intervals {
+  return new Intervals(intervals);
+}
+
+/**
+ * @tsplus fluent fncts.Intervals union
+ * @tsplus operator fncts.Intervals ||
+ */
+export function union(self: Intervals, that: Intervals): Intervals {
+  if (that.intervals.isEmpty()) {
+    return self;
+  } else if (self.intervals.isEmpty()) {
+    return that;
+  } else if (self.intervals.head.startMilliseconds < that.intervals.head.startMilliseconds) {
+    return unionLoop(self.intervals.tail, that.intervals, self.intervals.head, Nil());
+  } else {
+    return unionLoop(self.intervals, that.intervals.tail, that.intervals.head, Nil());
+  }
+}
+
+/**
+ * @tsplus tailRec
+ */
+function unionLoop(left: List<Interval>, right: List<Interval>, interval: Interval, acc: List<Interval>): Intervals {
+  if (left.isEmpty() && right.isEmpty()) {
+    return Intervals((interval + acc).reverse);
+  } else if (left.isEmpty() && right.isNonEmpty()) {
+    const rightHead = right.head;
+    const rights    = right.tail;
+    if (interval.endMilliseconds < rightHead.startMilliseconds)
+      return unionLoop(Nil(), rights, rightHead, interval + acc);
+    else return unionLoop(Nil(), rights, Interval(interval.startMilliseconds, rightHead.endMilliseconds), acc);
+  } else if (left.isNonEmpty() && right.isEmpty()) {
+    const leftHead = left.head;
+    const lefts    = left.tail;
+    if (interval.endMilliseconds < leftHead.startMilliseconds) return unionLoop(lefts, Nil(), leftHead, interval + acc);
+    else return unionLoop(lefts, Nil(), Interval(interval.startMilliseconds, leftHead.endMilliseconds), acc);
+  } else {
+    const leftHead  = left.unsafeHead;
+    const lefts     = left.unsafeTail;
+    const rightHead = right.unsafeHead;
+    const rights    = right.unsafeTail;
+    if (leftHead.startMilliseconds < rightHead.startMilliseconds) {
+      if (interval.endMilliseconds < leftHead.startMilliseconds)
+        return unionLoop(lefts, right, leftHead, interval + acc);
+      else return unionLoop(lefts, right, Interval(interval.startMilliseconds, leftHead.endMilliseconds), acc);
+    } else {
+      if (interval.endMilliseconds < rightHead.startMilliseconds)
+        return unionLoop(left, rights, rightHead, interval + acc);
+      else return unionLoop(left, rights, Interval(interval.startMilliseconds, rightHead.endMilliseconds), acc);
+    }
+  }
+}
+
+/**
+ * @tsplus fluent fncts.Intervals intersect
+ * @tsplus operator fncts.Intervals &&
+ */
+export function intersect(self: Intervals, that: Intervals): Intervals {
+  return intersectLoop(self.intervals, that.intervals, Nil());
+}
+
+/**
+ * @tsplus tailRec
+ */
+function intersectLoop(left: List<Interval>, right: List<Interval>, acc: List<Interval>): Intervals {
+  if (left.isEmpty() || right.isEmpty()) {
+    return Intervals(acc.reverse);
+  } else {
+    const leftHead  = left.head;
+    const lefts     = left.tail;
+    const rightHead = right.head;
+    const rights    = right.tail;
+    const interval  = leftHead.intersect(rightHead);
+    const intervals = interval.isEmpty ? acc : interval + acc;
+    if (leftHead < rightHead) return intersectLoop(lefts, right, intervals);
+    else return intersectLoop(left, rights, intervals);
+  }
+}
+
+/**
+ * @tsplus getter fncts.Intervals start
+ */
+export function start(self: Intervals): number {
+  return self.intervals.head.getOrElse(Interval.empty).startMilliseconds;
+}
+
+/**
+ * @tsplus getter fncts.Intervals end
+ */
+export function end(self: Intervals): number {
+  return self.intervals.head.getOrElse(Interval.empty).endMilliseconds;
+}
+
+/**
+ * @tsplus fluent fncts.Intervals lt
+ * @tsplus operator fncts.Intervals <
+ */
+export function lt(self: Intervals, that: Intervals): boolean {
+  return self.start < that.start;
+}
+
+/**
+ * @tsplus fluent fncts.Intervals max
+ */
+export function max(self: Intervals, that: Intervals): Intervals {
+  return self < that ? that : self;
+}
+
+/**
+ * @tsplus getter fncts.Intervals isNonEmpty
+ */
+export function isNonEmpty(self: Intervals): boolean {
+  return self.intervals.isNonEmpty();
+}

package/_src/data/Maybe/api.ts

@@ -172,6 +172,6 @@ export function zipWith_<A, B, C>(self: Maybe<A>, fb: Maybe<B>, f: (a: A, b: B)
 /**
  * @tsplus fluent fncts.Maybe zip
  */
-export function zip_<A, B>(self: Maybe<A>, that: Maybe<B>): Maybe<readonly [A, B]> {
-  return self.zipWith(that, (a, b) => [a, b]);
+export function zip_<A, B>(self: Maybe<A>, that: Maybe<B>): Maybe<Zipped.Make<A, B>> {
+  return self.zipWith(that, (a, b) => Zipped(a, b));
 }

package/_src/data/Maybe/definition.ts

@@ -8,7 +8,12 @@ export const enum MaybeTag {
 export const MaybeTypeId = Symbol.for("fncts.Maybe");
 export type MaybeTypdId = typeof MaybeTypeId;
 
-export type MaybeF = Maybe<any>;
+export interface MaybeF extends HKT {
+  type: Maybe<this["A"]>;
+  variance: {
+    A: "+";
+  };
+}
 
 const _justHash    = Hashable.string("fncts.Just");
 const _nothingHash = Hashable.string("fncts.Nothing");
@@ -18,10 +23,8 @@ const _nothingHash = Hashable.string("fncts.Nothing");
  * @tsplus companion fncts.MaybeOps
  */
 export class Maybe<A> {
+  declare _A: () => A;
   readonly _typeId: MaybeTypdId = MaybeTypeId;
-  readonly [HKT.F]!: MaybeF;
-  readonly [HKT.A]!: () => A;
-  readonly [HKT.T]!: Maybe<HKT._A<this>>;
 }
 
 /**
@@ -58,7 +61,7 @@ export class Nothing extends Maybe<never> {
 /**
  * @tsplus unify fncts.Maybe
  */
-export function unifyMaybe<X extends Maybe<any>>(self: X): Maybe<[X] extends [Maybe<infer A>] ? A : never> {
+export function unifyMaybe<X extends Maybe<any>>(self: X): Maybe<[X] extends [{ _A: () => infer A }] ? A : never> {
   return self;
 }
 

package/_src/data/Maybe/instances.ts

@@ -17,32 +17,32 @@ import {
 } from "./api.js";
 import { just } from "./constructors.js";
 
-export const Functor: P.Functor<MaybeF> = { map: map_ };
+export const Functor = HKT.instance<P.Functor<MaybeF>>({ map: map_ });
 
-export const Apply: P.Apply<MaybeF> = { ...Functor, zip: zip_, zipWith: zipWith_ };
+export const Apply = HKT.instance<P.Apply<MaybeF>>({ ...Functor, zip: zip_, zipWith: zipWith_ });
 
-export const Applicative: P.Applicative<MaybeF> = {
+export const Applicative = HKT.instance<P.Applicative<MaybeF>>({
   ...Apply,
   pure: just,
-};
+});
 
-export const Monad: P.Monad<MaybeF> = {
+export const Monad = HKT.instance<P.Monad<MaybeF>>({
   ...Applicative,
   flatMap: flatMap_,
-};
+});
 
-export const Foldable: P.Foldable<MaybeF> = {
+export const Foldable = HKT.instance<P.Foldable<MaybeF>>({
   foldLeft: foldLeft_,
   foldRight: foldRight_,
-};
+});
 
-export const Filterable: P.Filterable<MaybeF> = {
+export const Filterable = HKT.instance<P.Filterable<MaybeF>>({
   ...Functor,
   filter: filter_,
   filterMap: filterMap_,
   partition: partition_,
   partitionMap: partitionMap_,
-};
+});
 
 /**
  * @tsplus derive fncts.Guard[fncts.Maybe]<_> 10

package/_src/data/Newtype.ts

@@ -1,13 +1,14 @@
 /**
  * @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 {
-  export type Iso<N extends NewtypeHKT> = NewtypeIso<N>;
+  export type Iso<N extends NewtypeHKT, C = N["type"]["_C"]> = NewtypeIso<N, C>;
 }
 
 /**
@@ -18,22 +19,42 @@ export interface NewtypeOps {}
 export 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"];
 }
 
 /**

package/_src/data/Struct/definition.ts

@@ -1,5 +1,5 @@
 interface StructN extends HKT {
-  readonly [HKT.T]: Struct<HKT._A<this>>;
+  type: Struct<this["A"]>;
 }
 
 /**

package/_src/data/Tag/definition.ts

@@ -11,8 +11,8 @@ const _tagHash = Hashable.string("fncts.Tag");
  * @tsplus type fncts.Tag
  * @tsplus companion fncts.TagOps
  */
-export class Tag<T> implements Hashable, Equatable {
-  readonly _T!: (_: never) => T;
+export class Tag<in out T> implements Hashable, Equatable {
+  declare _T: (_: T) => T;
   readonly _typeId: TagTypeId = TagTypeId;
   private static counter      = new AtomicNumber(0);
   readonly id                 = Tag.counter.getAndIncrement();