@fncts/base 0.0.12 → 0.0.13

package/_src/collection/immutable/ImmutableArray/api.ts

@@ -84,8 +84,8 @@ export function crossWith_<A, B, C>(
 /**
  * @tsplus fluent fncts.ImmutableArray cross
  */
-export function cross_<A, B>(self: ImmutableArray<A>, fb: ImmutableArray<B>): ImmutableArray<readonly [A, B]> {
-  return self.crossWith(fb, tuple);
+export function cross_<A, B>(self: ImmutableArray<A>, fb: ImmutableArray<B>): ImmutableArray<Zipped.Make<A, B>> {
+  return self.crossWith(fb, (a, b) => Zipped(a, b));
 }
 
 /**
@@ -228,7 +228,9 @@ function comprehensionLoop<A, R>(
   if (input.length === 0) {
     return g(...scope) ? Eval.now(ImmutableArray(f(...scope))) : Eval.now(ImmutableArray.empty());
   } else {
-    return input[0]!.traverse((a) => comprehensionLoop(scope.append(a), input.slice(1), f, g)).map((rs) => rs.flatten);
+    return input[0]!
+      .traverse(Eval.Applicative)((a) => comprehensionLoop(scope.append(a), input.slice(1), f, g))
+      .map((rs) => rs.flatten);
   }
 }
 
@@ -1164,16 +1166,20 @@ export function takeWhile_<A>(self: ImmutableArray<A>, p: Predicate<A>): Immutab
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray traverseWithIndex
+ * @tsplus getter fncts.ImmutableArray traverseWithIndex
  */
-export const traverseWithIndex_: P.TraversableWithIndex<ImmutableArrayF>["traverseWithIndex"] = (ta, f, G) =>
-  ta.foldLeftWithIndex(G.pure(ImmutableArray.empty()), (i, fbs, a) => fbs.zipWith(f(i, a), (bs, b) => bs.append(b), G));
+export const traverseWithIndex_ = P.TraversableWithIndex.makeTraverseWithIndex<ImmutableArrayF>()(
+  () => (ta) => (G) => (f) =>
+    ta.foldLeftWithIndex(G.pure(ImmutableArray.empty()), (i, fbs, a) =>
+      G.zipWith(fbs, f(i, a), (bs, b) => bs.append(b)),
+    ),
+);
 
 /**
- * @tsplus fluent fncts.ImmutableArray traverse
+ * @tsplus getter fncts.ImmutableArray traverse
  */
-export const traverse_: P.Traversable<ImmutableArrayF>["traverse"] = (self, f, G) =>
-  self.traverseWithIndex((_, a) => f(a), G);
+export const traverse_: P.Traversable<ImmutableArrayF>["traverse"] = (self) => (G) => (f) =>
+  self.traverseWithIndex(G)((_, a) => f(a));
 
 /**
  * @tsplus fluent fncts.ImmutableArray union
@@ -1292,122 +1298,59 @@ export function updateAt_<A>(as: ImmutableArray<A>, i: number, a: A): Maybe<Immu
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray wilt
- */
-export function wilt_<G extends HKT, KG, QG, WG, XG, IG, SG, RG, EG, B1, A, B>(
-  self: ImmutableArray<A>,
-  f: (a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B1>>,
-  /** @tsplus auto */
-  G: P.Applicative<G>,
-): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, readonly [ImmutableArray<B>, ImmutableArray<B1>]> {
-  return self
-    .foldLeft(
-      G.pure([[] as Array<B>, [] as Array<B1>] as const) as HKT.Kind<
-        G,
-        KG,
-        QG,
-        WG,
-        XG,
-        IG,
-        SG,
-        RG,
-        EG,
-        readonly [B[], B1[]]
-      >,
-      (fbs, a) =>
-        f(a).zipWith(
-          fbs,
-          (eb, r) =>
-            eb.match(
-              (b1) => {
-                r[0].push(b1);
-                return r;
-              },
-              (b2) => {
-                r[1].push(b2);
-                return r;
-              },
-            ),
-          G,
-        ),
-    )
-    .map(([b1s, b2s]) => [b1s.asImmutableArray, b2s.asImmutableArray], G);
-}
-
-export function wiltWithIndex_<G extends HKT, KG, QG, WG, XG, IG, SG, RG, EG, B1, A, B>(
-  self: ImmutableArray<A>,
-  f: (i: number, a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B1>>,
-  /** @tsplus auto */
-  G: P.Applicative<G>,
-): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, readonly [ImmutableArray<B>, ImmutableArray<B1>]> {
-  return self
-    .foldLeftWithIndex(
-      G.pure([[] as Array<B>, [] as Array<B1>] as const) as HKT.Kind<
-        G,
-        KG,
-        QG,
-        WG,
-        XG,
-        IG,
-        SG,
-        RG,
-        EG,
-        readonly [B[], B1[]]
-      >,
-      (i, fbs, a) =>
-        f(i, a).zipWith(
-          fbs,
-          (eb, r) =>
-            eb.match(
-              (b1) => {
-                r[0].push(b1);
-                return r;
-              },
-              (b2) => {
-                r[1].push(b2);
-                return r;
-              },
-            ),
-          G,
+ * @tsplus getter fncts.ImmutableArray wiltWithIndex
+ */
+export const wiltWithIndex = P.WitherableWithIndex.makeWiltWithIndex<ImmutableArrayF>()(
+  (_) => (self) => (G) => (f) =>
+    G.map(
+      self.foldLeftWithIndex(G.pure([[] as Array<typeof _["B"]>, [] as Array<typeof _["B1"]>] as const), (i, fbs, a) =>
+        G.zipWith(f(i, a), fbs, (eb, r) =>
+          eb.match(
+            (b1) => {
+              r[0].push(b1);
+              return r;
+            },
+            (b2) => {
+              r[1].push(b2);
+              return r;
+            },
+          ),
         ),
-    )
-    .map(([b1s, b2s]) => [b1s.asImmutableArray, b2s.asImmutableArray], G);
-}
+      ),
+      ([b1s, b2s]) => [b1s.asImmutableArray, b2s.asImmutableArray],
+    ),
+);
 
 /**
- * @tsplus fluent fncts.ImmutableArray wither
+ * @tsplus getter fncts.ImmutableArray wilt
  */
-export function wither_<G extends HKT, KG, QG, WG, XG, IG, SG, RG, EG, A, B>(
-  self: ImmutableArray<A>,
-  f: (a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>,
-  /** @tsplus auto */ G: P.Applicative<G>,
-): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, ImmutableArray<B>> {
-  return self.witherWithIndex((_, a) => f(a));
-}
+export const wilt: P.WitherableWithIndex<ImmutableArrayF>["wilt"] = (self) => (G) => (f) =>
+  self.wiltWithIndex(G)((_, a) => f(a));
 
 /**
- * @tsplus fluent fncts.ImmutableArray witherWithIndex
+ * @tsplus getter fncts.ImmutableArray witherWithIndex
  */
-export function witherWithIndex_<G extends HKT, KG, QG, WG, XG, IG, SG, RG, EG, A, B>(
-  self: ImmutableArray<A>,
-  f: (k: number, a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>,
-  /** @tsplus auto */ G: P.Applicative<G>,
-): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, ImmutableArray<B>> {
-  return self
-    .foldLeftWithIndex(G.pure([] as Array<B>) as HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, B[]>, (i, b, a) =>
-      f(i, a).zipWith(
-        b,
-        (maybeB, bs) => {
+export const witherWithIndex = P.WitherableWithIndex.makeWitherWithIndex<ImmutableArrayF>()(
+  (_) => (self) => (G) => (f) => {
+    return G.map(
+      self.foldLeftWithIndex(G.pure([] as Array<typeof _["B"]>), (i, b, a) =>
+        G.zipWith(f(i, a), b, (maybeB, bs) => {
           if (maybeB.isJust()) {
             bs.push(maybeB.value);
           }
           return bs;
-        },
-        G,
+        }),
       ),
-    )
-    .map((bs) => bs.asImmutableArray, G);
-}
+      (bs) => bs.asImmutableArray,
+    );
+  },
+);
+
+/**
+ * @tsplus getter fncts.ImmutableArray wither
+ */
+export const wither: P.Witherable<ImmutableArrayF>["wither"] = (self) => (G) => (f) =>
+  self.witherWithIndex(G)((_, a) => f(a));
 
 /**
  * @tsplus fluent fncts.ImmutableArray zip

package/_src/collection/immutable/ImmutableArray/definition.ts

@@ -1,7 +1,13 @@
 export const ImmutableArrayTypeId = Symbol.for("fncts.ImmutableArray");
 export type ImmutableArrayTypeId = typeof ImmutableArrayTypeId;
 
-export interface ImmutableArrayF extends ImmutableArray<any> {}
+export interface ImmutableArrayF extends HKT {
+  type: ImmutableArray<this["A"]>;
+  variance: {
+    A: "+";
+  };
+  index: number;
+}
 
 /**
  * @tsplus type fncts.ImmutableArray
@@ -9,10 +15,7 @@ export interface ImmutableArrayF extends ImmutableArray<any> {}
  */
 export class ImmutableArray<A> implements Equatable, Hashable, Iterable<A> {
   readonly _typeId: ImmutableArrayTypeId = ImmutableArrayTypeId;
-  [HKT.F]?: ImmutableArrayF;
-  [HKT.A]?: () => A;
-  [HKT.T]?: ImmutableArray<HKT._A<this>>;
-  [HKT.Ix]?: number;
+  readonly _A!: () => A;
   constructor(readonly _array: ReadonlyArray<A>) {}
 
   [Symbol.equals](that: unknown): boolean {

package/_src/collection/immutable/ImmutableArray/instances.ts

@@ -23,168 +23,168 @@ import {
   partitionWithIndex_,
   traverse_,
   traverseWithIndex_,
-  wilt_,
-  wiltWithIndex_,
-  wither_,
-  witherWithIndex_,
+  wilt,
+  wiltWithIndex,
+  wither,
+  witherWithIndex,
 } from "@fncts/base/collection/immutable/ImmutableArray/api";
 import { empty } from "@fncts/base/collection/immutable/ImmutableArray/constructors";
 
 /**
  * @tsplus implicit
  */
-export const Align: P.Align<ImmutableArrayF> = {
+export const Align = HKT.instance<P.Align<ImmutableArrayF>>({
   map: map_,
   alignWith: alignWith_,
   nil: empty,
-};
+});
 
 /**
  * @tsplus implicit
  */
-export const Functor: P.Functor<ImmutableArrayF> = {
+export const Functor = HKT.instance<P.Functor<ImmutableArrayF>>({
   map: map_,
-};
+});
 
 /**
  * @tsplus implicit
  */
-export const FunctorWithIndex: P.FunctorWithIndex<ImmutableArrayF> = {
+export const FunctorWithIndex = HKT.instance<P.FunctorWithIndex<ImmutableArrayF>>({
   map: map_,
   mapWithIndex: mapWithIndex_,
-};
+});
 
 /**
  * @tsplus implicit
  */
-export const Apply: P.Apply<ImmutableArrayF> = {
+export const Apply = HKT.instance<P.Apply<ImmutableArrayF>>({
   map: map_,
   zip: cross_,
   zipWith: crossWith_,
-};
+});
 
 /**
  * @tsplus implicit
  */
-export const Applicative: P.Applicative<ImmutableArrayF> = {
+export const Applicative = HKT.instance<P.Applicative<ImmutableArrayF>>({
   map: map_,
   zip: cross_,
   zipWith: crossWith_,
   pure: (a) => ImmutableArray(a),
-};
+});
 
 /**
  * @tsplus implicit
  */
-export const Alt: P.Alt<ImmutableArrayF> = {
+export const Alt = HKT.instance<P.Alt<ImmutableArrayF>>({
   map: map_,
   alt: alt_,
-};
+});
 
 /**
  * @tsplus implicit
  */
-export const Alternative: P.Alternative<ImmutableArrayF> = {
+export const Alternative = HKT.instance<P.Alternative<ImmutableArrayF>>({
   map: map_,
   zip: cross_,
   zipWith: crossWith_,
   pure: (a) => ImmutableArray(a),
   alt: alt_,
   nil: empty,
-};
+});
 
 /**
  * @tsplus implicit
  */
-export const Filterable: P.Filterable<ImmutableArrayF> = {
+export const Filterable = HKT.instance<P.Filterable<ImmutableArrayF>>({
   map: map_,
   filter: filter_,
   filterMap: filterMap_,
   partition: partition_,
   partitionMap: partitionMap_,
-};
+});
 
 /**
  * @tsplus implicit
  */
-export const FilterableWithIndex: P.FilterableWithIndex<ImmutableArrayF> = {
+export const FilterableWithIndex = HKT.instance<P.FilterableWithIndex<ImmutableArrayF>>({
   ...FunctorWithIndex,
   ...Filterable,
   filterWithIndex: filterWithIndex_,
   filterMapWithIndex: filterMapWithIndex_,
   partitionWithIndex: partitionWithIndex_,
   partitionMapWithIndex: partitionMapWithIndex_,
-};
+});
 
 /**
  * @tsplus implicit
  */
-export const Foldable: P.Foldable<ImmutableArrayF> = {
+export const Foldable = HKT.instance<P.Foldable<ImmutableArrayF>>({
   foldLeft: foldLeft_,
   foldRight: foldRight_,
-};
+});
 
 /**
  * @tsplus implicit
  */
-export const FoldableWithIndex: P.FoldableWithIndex<ImmutableArrayF> = {
+export const FoldableWithIndex = HKT.instance<P.FoldableWithIndex<ImmutableArrayF>>({
   ...Foldable,
   foldLeftWithIndex: foldLeftWithIndex_,
   foldRightWithIndex: foldRightWithIndex_,
-};
+});
 
 /**
  * @tsplus implicit
  */
-export const FlatMap: P.FlatMap<ImmutableArrayF> = {
+export const FlatMap = HKT.instance<P.FlatMap<ImmutableArrayF>>({
   ...Functor,
   flatMap: flatMap_,
-};
+});
 
 /**
  * @tsplus implicit
  */
-export const Monad: P.Monad<ImmutableArrayF> = {
+export const Monad = HKT.instance<P.Monad<ImmutableArrayF>>({
   ...Applicative,
   ...FlatMap,
-};
+});
 
 /**
  * @tsplus implicit
  */
-export const Traversable: P.Traversable<ImmutableArrayF> = {
+export const Traversable = HKT.instance<P.Traversable<ImmutableArrayF>>({
   ...Functor,
   ...Foldable,
   traverse: traverse_,
-};
+});
 
 /**
  * @tsplus implicit
  */
-export const TraversableWithIndex: P.TraversableWithIndex<ImmutableArrayF> = {
+export const TraversableWithIndex = HKT.instance<P.TraversableWithIndex<ImmutableArrayF>>({
   ...Traversable,
   ...FoldableWithIndex,
   ...FunctorWithIndex,
   traverseWithIndex: traverseWithIndex_,
-};
+});
 
 /**
  * @tsplus implicit
  */
-export const Witherable: P.Witherable<ImmutableArrayF> = {
+export const Witherable = HKT.instance<P.Witherable<ImmutableArrayF>>({
   ...Traversable,
   ...Filterable,
-  wither: wither_,
-  wilt: wilt_,
-};
+  wither,
+  wilt,
+});
 
 /**
  * @tsplus implicit
  */
-export const WitherableWithIndex: P.WitherableWithIndex<ImmutableArrayF> = {
+export const WitherableWithIndex = HKT.instance<P.WitherableWithIndex<ImmutableArrayF>>({
   ...TraversableWithIndex,
   ...FilterableWithIndex,
   ...Witherable,
-  witherWithIndex: witherWithIndex_,
-  wiltWithIndex: wiltWithIndex_,
-};
+  witherWithIndex,
+  wiltWithIndex,
+});

package/_src/collection/immutable/ImmutableNonEmptyArray/api.ts

@@ -174,8 +174,8 @@ export function crossWith_<A, B, C>(
 export function cross_<A, B>(
   self: ImmutableNonEmptyArray<A>,
   fb: ImmutableNonEmptyArray<B>,
-): ImmutableNonEmptyArray<readonly [A, B]> {
-  return self.crossWith(fb, (a, b) => [a, b]);
+): ImmutableNonEmptyArray<Zipped.Make<A, B>> {
+  return self.crossWith(fb, (a, b) => Zipped(a, b));
 }
 
 /**
@@ -394,19 +394,21 @@ export function sort<A>(self: ImmutableNonEmptyArray<A>, /** @tsplus auto */ O:
 }
 
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray traverseWithIndex
+ * @tsplus getter fncts.ImmutableNonEmptyArray traverseWithIndex
  */
-export const traverseWithIndex_: P.TraversableWithIndex<ImmutableNonEmptyArrayF>["traverseWithIndex"] = (self, f, G) =>
-  self.tail.foldLeftWithIndex(
-    f(0, self.head).map((b) => ImmutableNonEmptyArray(b), G),
-    (i, fbs, a) => fbs.zipWith(f(i + 1, a), (bs, b) => bs.append(b), G),
-  );
+export const traverseWithIndex = P.TraversableWithIndex.makeTraverseWithIndex<ImmutableNonEmptyArrayF>()(
+  () => (self) => (G) => (f) =>
+    self.tail.foldLeftWithIndex(
+      G.map(f(0, self.head), (b) => ImmutableNonEmptyArray(b)),
+      (i, fbs, a) => G.zipWith(fbs, f(i + 1, a), (bs, b) => bs.append(b)),
+    ),
+);
 
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray traverse
+ * @tsplus getter fncts.ImmutableNonEmptyArray traverse
  */
-export const traverse_: P.Traversable<ImmutableNonEmptyArrayF>["traverse"] = (self, f, A) =>
-  self.traverseWithIndex((_, a) => f(a), A);
+export const traverse: P.Traversable<ImmutableNonEmptyArrayF>["traverse"] = (self) => (G) => (f) =>
+  self.traverseWithIndex(G)((_, a) => f(a));
 
 /**
  * @tsplus fluent fncts.ImmutableNonEmptyArray uniq

package/_src/collection/immutable/ImmutableNonEmptyArray/definition.ts

@@ -1,14 +1,19 @@
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 
-export interface ImmutableNonEmptyArrayF extends ImmutableNonEmptyArray<any> {}
+export interface ImmutableNonEmptyArrayF extends HKT {
+  type: ImmutableNonEmptyArray<this["A"]>;
+  variance: {
+    A: "+";
+  };
+  index: number;
+}
 
 /**
  * @tsplus type fncts.ImmutableNonEmptyArray
  * @tsplus companion fncts.ImmutableNonEmptyArrayOps
  */
 export class ImmutableNonEmptyArray<A> extends ImmutableArray<A> {
-  [HKT.F]!: ImmutableNonEmptyArrayF;
-  [HKT.T]!: ImmutableNonEmptyArray<HKT._A<this>>;
+  readonly _A!: () => A;
   constructor(readonly _array: ReadonlyNonEmptyArray<A>) {
     super(_array);
   }

package/_src/collection/immutable/ImmutableNonEmptyArray/instances.ts

@@ -4,7 +4,6 @@ import type * as P from "@fncts/base/typeclass";
 import {
   align_,
   alignWith_,
-  ap_,
   cross_,
   crossWith_,
   flatMap_,
@@ -14,92 +13,92 @@ import {
   foldRightWithIndex_,
   map_,
   mapWithIndex_,
-  traverse_,
-  traverseWithIndex_,
+  traverse,
+  traverseWithIndex,
 } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api";
 import { make } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/constructors";
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Semialign
  */
-export const Semialign: P.Semialign<ImmutableNonEmptyArrayF> = {
+export const Semialign = HKT.instance<P.Semialign<ImmutableNonEmptyArrayF>>({
   map: map_,
   alignWith: alignWith_,
-};
+});
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Functor
  */
-export const Functor: P.Functor<ImmutableNonEmptyArrayF> = {
+export const Functor = HKT.instance<P.Functor<ImmutableNonEmptyArrayF>>({
   map: map_,
-};
+});
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps FunctorWithIndex
  */
-export const FunctorWithIndex: P.FunctorWithIndex<ImmutableNonEmptyArrayF> = {
+export const FunctorWithIndex = HKT.instance<P.FunctorWithIndex<ImmutableNonEmptyArrayF>>({
   map: map_,
   mapWithIndex: mapWithIndex_,
-};
+});
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Apply
  */
-export const Apply: P.Apply<ImmutableNonEmptyArrayF> = {
+export const Apply = HKT.instance<P.Apply<ImmutableNonEmptyArrayF>>({
   ...Functor,
   zip: cross_,
   zipWith: crossWith_,
-};
+});
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Applicative
  */
-export const Applicative: P.Applicative<ImmutableNonEmptyArrayF> = {
+export const Applicative = HKT.instance<P.Applicative<ImmutableNonEmptyArrayF>>({
   ...Apply,
   pure: make,
-};
+});
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Monad
  */
-export const Monad: P.Monad<ImmutableNonEmptyArrayF> = {
+export const Monad = HKT.instance<P.Monad<ImmutableNonEmptyArrayF>>({
   ...Applicative,
   flatMap: flatMap_,
-};
+});
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Foldable
  */
-export const Foldable: P.Foldable<ImmutableNonEmptyArrayF> = {
+export const Foldable = HKT.instance<P.Foldable<ImmutableNonEmptyArrayF>>({
   foldLeft: foldLeft_,
   foldRight: foldRight_,
-};
+});
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps FoldableWithIndex
  */
-export const FoldableWithIndex: P.FoldableWithIndex<ImmutableNonEmptyArrayF> = {
+export const FoldableWithIndex = HKT.instance<P.FoldableWithIndex<ImmutableNonEmptyArrayF>>({
   ...Foldable,
   foldLeftWithIndex: foldLeftWithIndex_,
   foldRightWithIndex: foldRightWithIndex_,
-};
+});
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Traversable
  */
-export const Traversable: P.Traversable<ImmutableNonEmptyArrayF> = {
+export const Traversable = HKT.instance<P.Traversable<ImmutableNonEmptyArrayF>>({
   ...Functor,
   ...Foldable,
-  traverse: traverse_,
-};
+  traverse: traverse,
+});
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps TraversableWithIndex
  */
-export const TraversableWithIndex: P.TraversableWithIndex<ImmutableNonEmptyArrayF> = {
+export const TraversableWithIndex = HKT.instance<P.TraversableWithIndex<ImmutableNonEmptyArrayF>>({
   ...Functor,
   ...FunctorWithIndex,
   ...FoldableWithIndex,
   ...Traversable,
-  traverseWithIndex: traverseWithIndex_,
-};
+  traverseWithIndex: traverseWithIndex,
+});

package/_src/collection/immutable/RoseTree/definition.ts

@@ -1,7 +1,12 @@
 export const RoseTreeTypeId = Symbol.for("fncts.RoseTree");
 export type RoseTreeTypeId = typeof RoseTreeTypeId;
 
-export interface RoseTreeF extends RoseTree<any> {}
+export interface RoseTreeF extends HKT {
+  type: RoseTree<this["A"]>;
+  variance: {
+    A: "+";
+  };
+}
 
 /**
  * @tsplus type fncts.RoseTree
@@ -9,9 +14,7 @@ export interface RoseTreeF extends RoseTree<any> {}
  */
 export class RoseTree<A> implements Hashable, Equatable {
   readonly _typeId: RoseTreeTypeId = RoseTreeTypeId;
-  readonly [HKT.F]!: RoseTreeF;
-  readonly [HKT.A]!: () => A;
-  readonly [HKT.T]!: RoseTree<HKT._A<this>>;
+  declare _A: () => A;
   constructor(readonly value: A, readonly forest: Vector<RoseTree<A>>) {}
   [Symbol.equals](that: unknown): boolean {
     return isRoseTree(that) ? Equatable.strictEquals(this.value, that.value) && this.forest == that.forest : false;