@fncts/base 0.0.12 → 0.0.15

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

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

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

@@ -55,8 +55,8 @@ export function makeDefault<K, V>(): HashMap<K, V> {
  *
  * @tsplus fluent fncts.HashMapOps fromFoldable
  */
-export function fromFoldable<F extends HKT, C, K, A>(config: P.HashEq<K>, S: P.Semigroup<A>, F: P.Foldable<F>) {
-  return <K_, Q, W, X, I, S, R, E>(fka: HKT.Kind<F, K_, Q, W, X, I, S, R, E, readonly [K, A]>): HashMap<K, A> => {
+export function fromFoldable<F extends HKT, C, K, A>(config: P.HashEq<K>, S: P.Semigroup<A>, F: P.Foldable<F, C>) {
+  return <K_, Q, W, X, I, S, R, E>(fka: HKT.Kind<F, C, K_, Q, W, X, I, S, R, E, readonly [K, A]>): HashMap<K, A> => {
     return F.foldLeft(fka, makeWith(config), (b, [k, a]) => {
       const oa = b.get(k);
       if (oa.isJust()) {
@@ -529,15 +529,18 @@ export function foldLeft_<K, V, Z>(map: HashMap<K, V>, z: Z, f: (z: Z, v: V) =>
 }
 
 /**
- * @tsplus fluent fncts.HashMap traverseWithIndex
+ * @tsplus getter fncts.HashMap traverseWithIndex
  */
-export const traverseWithIndex_: P.TraversableWithIndex<HashMapF>["traverseWithIndex"] = (ta, f, G) =>
-  ta.foldLeftWithIndex(G.pure(makeWith(ta.config)), (k, b, a) => b.zipWith(f(k, a), (map, b) => map.set(k, b), G));
+export const traverseWithIndex = P.TraversableWithIndex.makeTraverseWithIndex<HashMapF>()(
+  () => (ta) => (G) => (f) =>
+    ta.foldLeftWithIndex(G.pure(makeWith(ta.config)), (k, b, a) => G.zipWith(b, f(k, a), (map, b) => map.set(k, b))),
+);
 
 /**
- * @tsplus fluent fncts.HashMap traverse
+ * @tsplus getter fncts.HashMap traverse
  */
-export const traverse_: P.Traversable<HashMapF>["traverse"] = (ta, f, G) => ta.traverseWithIndex((_, a) => f(a), G);
+export const traverse: P.Traversable<HashMapF>["traverse"] = (ta) => (G) => (f) =>
+  ta.traverseWithIndex(G)((_, a) => f(a));
 
 /**
  * @tsplus fluent fncts.HashMap unsafeGet
@@ -547,26 +550,26 @@ export function unsafeGet_<K, V>(self: HashMap<K, V>, key: K): V | undefined {
 }
 
 /**
- * @tsplus fluent fncts.HashMap witherWithIndex
+ * @tsplus getter fncts.HashMap witherWithIndex
  */
-export const witherWithIndex_: P.WitherableWithIndex<HashMapF>["witherWithIndex"] = (wa, f, G) =>
-  wa.traverseWithIndex(f, G).map(compact, G);
+export const witherWithIndex: P.WitherableWithIndex<HashMapF>["witherWithIndex"] = (wa) => (G) => (f) =>
+  G.map(wa.traverseWithIndex(G)(f), compact);
 
 /**
- * @tsplus fluent fncts.HashMap wither
+ * @tsplus getter fncts.HashMap wither
  */
-export const wither_: P.Witherable<HashMapF>["wither"] = (wa, f, G) => wa.witherWithIndex((_, a) => f(a), G);
+export const wither: P.Witherable<HashMapF>["wither"] = (wa) => (G) => (f) => wa.witherWithIndex(G)((_, a) => f(a));
 
 /**
- * @tsplus fluent fncts.HashMap wiltWithIndex
+ * @tsplus getter fncts.HashMap wiltWithIndex
  */
-export const wiltWithIndex_: P.WitherableWithIndex<HashMapF>["wiltWithIndex"] = (wa, f, G) =>
-  wa.traverseWithIndex(f, G).map(separate, G);
+export const wiltWithIndex: P.WitherableWithIndex<HashMapF>["wiltWithIndex"] = (wa) => (G) => (f) =>
+  G.map(wa.traverseWithIndex(G)(f), separate);
 
 /**
- * @tsplus fluent fncts.HashMap wilt
+ * @tsplus getter fncts.HashMap wilt
  */
-export const wilt_: P.Witherable<HashMapF>["wilt"] = (wa, f, G) => wa.wiltWithIndex((_, a) => f(a), G);
+export const wilt: P.Witherable<HashMapF>["wilt"] = (wa) => (G) => (f) => wa.wiltWithIndex(G)((_, a) => f(a));
 
 /**
  * @tsplus fluent fncts.HashMap unionWith

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

@@ -4,18 +4,22 @@ import type { HashEq } from "@fncts/base/typeclass";
 import { isEmptyNode } from "@fncts/base/collection/immutable/HashMap/internal";
 import { identity, tuple } from "@fncts/base/data/function";
 
-export interface HashMapF extends HashMap<any, any> {}
+export interface HashMapF extends HKT {
+  type: HashMap<this["K"], this["A"]>;
+  variance: {
+    K: "+";
+    A: "+";
+  };
+  index: this["K"];
+}
 
 /**
  * @tsplus type fncts.HashMap
  * @tsplus companion fncts.HashMapOps
  */
 export class HashMap<K, V> implements Iterable<readonly [K, V]>, Hashable, Equatable {
-  readonly [HKT.F]!: HashMapF;
-  readonly [HKT.K]!: () => K;
-  readonly [HKT.A]!: () => V;
-  readonly [HKT.T]!: HashMap<HKT._K<this>, HKT._A<this>>;
-  readonly [HKT.Ix]!: K;
+  readonly _K!: () => K;
+  readonly _A!: () => V;
 
   constructor(
     public editable: boolean,

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);
   }
 }
 
@@ -536,7 +538,7 @@ export function findLastMapWithIndex_<A, B>(as: ImmutableArray<A>, f: (i: number
 
 /**
  * @tsplus fluent fncts.ImmutableArray foldLeftWithIndex
- * @tsplus fluent fncts.base.MutableArray foldLeftWithIndex
+ * @tsplus fluent fncts.MutableArray foldLeftWithIndex
  */
 export function foldLeftWithIndex_<A, B>(self: ImmutableArray<A>, b: B, f: (i: number, b: B, a: A) => B): B {
   const len = self.length;
@@ -549,7 +551,7 @@ export function foldLeftWithIndex_<A, B>(self: ImmutableArray<A>, b: B, f: (i: n
 
 /**
  * @tsplus fluent fncts.ImmutableArray foldLeft
- * @tsplus fluent fncts.base.MutableArray foldLeft
+ * @tsplus fluent fncts.MutableArray foldLeft
  */
 export function foldLeft_<A, B>(self: ImmutableArray<A>, b: B, f: (b: B, a: A) => B): B {
   return self.foldLeftWithIndex(b, (_, b, a) => f(b, a));
@@ -557,7 +559,7 @@ export function foldLeft_<A, B>(self: ImmutableArray<A>, b: B, f: (b: B, a: A) =
 
 /**
  * @tsplus fluent fncts.ImmutableArray foldLeftWhile
- * @tsplus fluent fncts.base.MutableArray foldLeftWhile
+ * @tsplus fluent fncts.MutableArray foldLeftWhile
  */
 export function foldLeftWhile_<A, B>(self: ImmutableArray<A>, b: B, p: Predicate<B>, f: (b: B, a: A) => B): B {
   return self.foldLeftWithIndexWhile(b, p, (_, b, a) => f(b, a));
@@ -565,7 +567,7 @@ export function foldLeftWhile_<A, B>(self: ImmutableArray<A>, b: B, p: Predicate
 
 /**
  * @tsplus fluent fncts.ImmutableArray foldLeftWithIndexWhile
- * @tsplus fluent fncts.base.MutableArray foldLeftWithIndexWhile
+ * @tsplus fluent fncts.MutableArray foldLeftWithIndexWhile
  */
 export function foldLeftWithIndexWhile_<A, B>(
   self: ImmutableArray<A>,
@@ -659,7 +661,7 @@ export function forEach_<A, B>(self: ImmutableArray<A>, f: (a: A) => B): void {
 
 /**
  * @tsplus fluent fncts.ImmutableArray get
- * @tsplus fluent fncts.base.MutableArray get
+ * @tsplus fluent fncts.MutableArray get
  */
 export function get_<A>(self: ImmutableArray<A>, i: number): Maybe<A> {
   return self.isOutOfBound(i) ? Nothing() : Just(self._array[i]!);
@@ -952,7 +954,7 @@ export function prepend_<A, B>(self: ImmutableArray<A>, head: B): ImmutableArray
 
 /**
  * @tsplus fluent fncts.ImmutableArray prependAll
- * @tsplus fluent fncts.base.MutableArray prependAll
+ * @tsplus fluent fncts.MutableArray prependAll
  */
 export function prependAll_<A>(self: ImmutableArray<A>, a: A): ImmutableArray<A> {
   const out: Array<A> = [];
@@ -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/constructors.ts

@@ -1,6 +1,6 @@
 /**
- * @tsplus getter fncts.base.ReadonlyArray asImmutableArray
- * @tsplus getter fncts.base.Array asImmutableArray
+ * @tsplus getter fncts.ReadonlyArray asImmutableArray
+ * @tsplus getter fncts.Array asImmutableArray
  */
 export function asImmutableArray<A>(self: ReadonlyArray<A>): ImmutableArray<A> {
   return new ImmutableArray(self);

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 {
@@ -32,6 +35,9 @@ export class ImmutableArray<A> implements Equatable, Hashable, Iterable<A> {
   }
 }
 
+/**
+ * @tsplus static fncts.ImmutableArrayOps is
+ */
 export function isImmutableArray(u: unknown): u is ImmutableArray<unknown> {
   return hasTypeId(u, ImmutableArrayTypeId);
 }

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

@@ -0,0 +1,28 @@
+import type { Check } from "@fncts/typelevel/Check";
+
+/**
+ * @tsplus derive fncts.Guard[fncts.ImmutableArray]<_> 10
+ */
+export function deriveGuard<A extends ImmutableArray<any>>(
+  ...[element]: [A] extends [ImmutableArray<infer A>] ? [element: Guard<A>] : never
+): Guard<A> {
+  return Guard((u): u is A => {
+    if (ImmutableArray.is(u)) {
+      return u._array.every(element.is);
+    }
+    return false;
+  });
+}
+
+/**
+ * @tsplus derive fncts.Decoder[fncts.ImmutableArray]<_> 10
+ */
+export function deriveDecoder<A extends ImmutableArray<any>>(
+  ...[array, elem]: [A] extends [ImmutableArray<infer _A>]
+    ? Check<Check.IsEqual<A, ImmutableArray<_A>>> extends Check.True
+      ? [array: Decoder<Array<_A>>, elem: Decoder<_A>]
+      : never
+    : never
+): Decoder<A> {
+  return Decoder((u) => array.decode(u).map((as) => new ImmutableArray(as) as A), `ImmutableArray<${elem.label}>`);
+}

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

@@ -1,5 +1,7 @@
 import type { ImmutableArrayF } from "@fncts/base/collection/immutable/ImmutableArray/definition";
+import type { DecodeError } from "@fncts/base/data/DecodeError";
 import type * as P from "@fncts/base/typeclass";
+import type { Check } from "@fncts/typelevel/Check";
 
 import {
   alignWith_,
@@ -23,168 +25,171 @@ 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";
+import { isImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
+import { CompoundError, OptionalIndexError, PrimitiveError } from "@fncts/base/data/DecodeError";
+import { Decoder } from "@fncts/base/data/Decoder";
 
 /**
  * @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,
+});