@fncts/base 0.0.2 → 0.0.5

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

@@ -19,7 +19,7 @@ export function find_<K, V>(m: SortedMap<K, V>, key: K, direction: 0 | 1 = 0): S
   return {
     ord: m.ord,
     [Symbol.iterator]() {
-      const cmp = m.ord.compare_;
+      const cmp = m.ord.compare;
       let n     = m.root;
       const stack: Array<Node<K, V>> = [];
       while (n) {
@@ -124,7 +124,7 @@ export function forEachGt_<K, V>(m: SortedMap<K, V>, min: K, visit: (k: K, v: V)
  * @tsplus fluent fncts.SortedMap get
  */
 export function get_<K, V>(m: SortedMap<K, V>, key: K): Maybe<V> {
-  const cmp = m.ord.compare_;
+  const cmp = m.ord.compare;
   let n     = m.root;
   while (n) {
     const d = cmp(key, n.key);
@@ -151,7 +151,7 @@ export function get_<K, V>(m: SortedMap<K, V>, key: K): Maybe<V> {
  * @tsplus fluent fncts.SortedMap getGt
  */
 export function getGt_<K, V>(m: SortedMap<K, V>, key: K): Maybe<V> {
-  const cmp     = m.ord.compare_;
+  const cmp     = m.ord.compare;
   let n         = m.root;
   let lastValue = Nothing<V>();
   while (n) {
@@ -175,7 +175,7 @@ export function getGt_<K, V>(m: SortedMap<K, V>, key: K): Maybe<V> {
  * @tsplus fluent fncts.SortedMap getLt
  */
 export function getLt_<K, V>(m: SortedMap<K, V>, key: K): Maybe<V> {
-  const cmp     = m.ord.compare_;
+  const cmp     = m.ord.compare;
   let n         = m.root;
   let lastValue = Nothing<V>();
   while (n) {
@@ -198,7 +198,7 @@ export function getLt_<K, V>(m: SortedMap<K, V>, key: K): Maybe<V> {
  * @tsplus fluent fncts.SortedMap getLte
  */
 export function getLte_<K, V>(m: SortedMap<K, V>, key: K): Maybe<V> {
-  const cmp     = m.ord.compare_;
+  const cmp     = m.ord.compare;
   let n         = m.root;
   let lastValue = Nothing<V>();
   while (n) {
@@ -222,7 +222,7 @@ export function getLte_<K, V>(m: SortedMap<K, V>, key: K): Maybe<V> {
  * @tsplus fluent fncts.SortedMap getGte
  */
 export function getGte_<K, V>(m: SortedMap<K, V>, key: K): Maybe<V> {
-  const cmp     = m.ord.compare_;
+  const cmp     = m.ord.compare;
   let n         = m.root;
   let lastValue = Nothing<V>();
   while (n) {
@@ -251,7 +251,7 @@ export function insert_<K, V>(m: SortedMap<K, V>, key: K, value: V): SortedMap<K
   if (isEmptyNode(m.root)) {
     return new SortedMap(m.ord, new Node(Color.R, Leaf, key, value, Leaf, 1));
   }
-  const cmp = m.ord.compare_;
+  const cmp = m.ord.compare;
   const nodeStack: Array<Node<K, V>> = [];
   const orderStack: Array<Ordering>  = [];
   let n: RBNode<K, V>                = m.root;
@@ -277,49 +277,52 @@ export function insert_<K, V>(m: SortedMap<K, V>, key: K, value: V): SortedMap<K
  * Inserts an element into the correct position in the map, combining the values of keys of equal ordering
  * with a `Semigroup` instance
  */
-export function insertWith_<V>(S: Semigroup<V>) {
-  return <K>(m: SortedMap<K, V>, key: K, value: V) => {
-    if (isEmptyNode(m.root)) {
-      return new SortedMap(m.ord, new Node(Color.R, Leaf, key, value, Leaf, 1));
-    }
-    const com = S.combine_;
-    const cmp = m.ord.compare_;
-    const nodeStack: Array<Node<K, V>> = [];
-    const orderStack: Array<1 | -1>    = [];
-    let n: RBNode<K, V>                = m.root;
-    let cv: V | null                   = null;
-    while (n && !cv) {
-      const d = cmp(key, n.key);
-      nodeStack.push(n);
-      switch (d) {
-        case -1: {
-          orderStack.push(d);
-          n = n.left;
-          break;
-        }
-        case 1: {
-          orderStack.push(d);
-          n = n.right;
-          break;
-        }
-        case 0: {
-          cv = com(n.value, value);
-          break;
-        }
+export function insertWith_<K, V>(
+  m: SortedMap<K, V>,
+  key: K,
+  value: V,
+  /** @tsplus auto */ S: Semigroup<V>,
+): SortedMap<K, V> {
+  if (isEmptyNode(m.root)) {
+    return new SortedMap(m.ord, new Node(Color.R, Leaf, key, value, Leaf, 1));
+  }
+  const com = S.combine;
+  const cmp = m.ord.compare;
+  const nodeStack: Array<Node<K, V>> = [];
+  const orderStack: Array<1 | -1>    = [];
+  let n: RBNode<K, V>                = m.root;
+  let cv: V | null                   = null;
+  while (n && !cv) {
+    const d = cmp(key, n.key);
+    nodeStack.push(n);
+    switch (d) {
+      case -1: {
+        orderStack.push(d);
+        n = n.left;
+        break;
+      }
+      case 1: {
+        orderStack.push(d);
+        n = n.right;
+        break;
+      }
+      case 0: {
+        cv = com(n.value, value);
+        break;
       }
     }
-    if (cv) {
-      const u                         = nodeStack[nodeStack.length - 1]!;
-      const updated                   = new Node(u.color, u.left, u.key, cv, u.right, u.count);
-      nodeStack[nodeStack.length - 1] = updated;
-      rebuildModifiedPath(nodeStack, orderStack, 0);
-    } else {
-      nodeStack.push(new Node(Color.R, Leaf, key, value, Leaf, 1));
-      rebuildModifiedPath(nodeStack, orderStack);
-      balanceModifiedPath(nodeStack);
-    }
-    return new SortedMap(m.ord, nodeStack[0]!);
-  };
+  }
+  if (cv) {
+    const u                         = nodeStack[nodeStack.length - 1]!;
+    const updated                   = new Node(u.color, u.left, u.key, cv, u.right, u.count);
+    nodeStack[nodeStack.length - 1] = updated;
+    rebuildModifiedPath(nodeStack, orderStack, 0);
+  } else {
+    nodeStack.push(new Node(Color.R, Leaf, key, value, Leaf, 1));
+    rebuildModifiedPath(nodeStack, orderStack);
+    balanceModifiedPath(nodeStack);
+  }
+  return new SortedMap(m.ord, nodeStack[0]!);
 }
 
 /**
@@ -386,7 +389,7 @@ export function visitLte<K, V, A>(m: SortedMap<K, V>, max: K, visit: (k: K, v: V
   let current: RBNode<K, V>      = m.root;
   const stack: Stack<Node<K, V>> = Stack();
   let done  = false;
-  const cmp = m.ord.compare_;
+  const cmp = m.ord.compare;
 
   while (!done) {
     if (current) {
@@ -416,7 +419,7 @@ export function visitLt<K, V, A>(m: SortedMap<K, V>, max: K, visit: (k: K, v: V)
   let current: RBNode<K, V>      = m.root;
   const stack: Stack<Node<K, V>> = Stack();
   let done  = false;
-  const cmp = m.ord.compare_;
+  const cmp = m.ord.compare;
 
   while (!done) {
     if (current) {
@@ -446,7 +449,7 @@ export function visitGte<K, V, A>(m: SortedMap<K, V>, min: K, visit: (k: K, v: V
   let current: RBNode<K, V>      = m.root;
   const stack: Stack<Node<K, V>> = Stack();
   let done  = false;
-  const cmp = m.ord.compare_;
+  const cmp = m.ord.compare;
 
   while (!done) {
     if (current) {
@@ -479,7 +482,7 @@ export function visitGt<K, V, A>(m: SortedMap<K, V>, min: K, visit: (k: K, v: V)
   let current: RBNode<K, V>      = m.root;
   const stack: Stack<Node<K, V>> = Stack();
   let done  = false;
-  const cmp = m.ord.compare_;
+  const cmp = m.ord.compare;
 
   while (!done) {
     if (current) {
@@ -512,7 +515,7 @@ export function visitBetween<K, V, A>(m: SortedMap<K, V>, min: K, max: K, visit:
   let current: RBNode<K, V>      = m.root;
   const stack: Stack<Node<K, V>> = Stack();
   let done  = false;
-  const cmp = m.ord.compare_;
+  const cmp = m.ord.compare;
 
   while (!done) {
     if (current) {

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

@@ -1,6 +1,6 @@
 /* eslint-disable prefer-const */
-import type { MutableVector } from "@fncts/base/collection/immutable/Vector/definition";
-import type { Eq, Monoid, Ord, Ordering } from "@fncts/base/typeclass";
+import type { MutableVector, VectorF } from "@fncts/base/collection/immutable/Vector/definition";
+import type { Eq, Monoid, Ord, Ordering, Traversable, TraversableWithIndex } from "@fncts/base/typeclass";
 
 import {
   affixPush,
@@ -36,6 +36,7 @@ import {
   nodeNth,
   nodeNthDense,
   prependNodeToTree,
+  push,
   reverseArray,
   setDepth,
   setPrefix,
@@ -54,6 +55,7 @@ import {
  * @complexity O(n)
  *
  * @tsplus fluent fncts.Vector append
+ * @tsplus operator fncts.Vector +
  */
 export function append_<A>(as: Vector<A>, a: A): Vector<A> {
   const suffixSize = getSuffixSize(as);
@@ -111,6 +113,7 @@ export function chunksOf_<A>(as: Vector<A>, size: number): Vector<Vector<A>> {
  *
  * @complexity O(log(n))
  * @tsplus fluent fncts.Vector concat
+ * @tsplus operator fncts.Vector + 1
  */
 export function concat_<A, B>(self: Vector<A>, that: Vector<B>): Vector<A | B>;
 export function concat_<A>(self: Vector<A>, that: Vector<A>): Vector<A> {
@@ -267,7 +270,7 @@ function elemCb(value: any, state: ElemState): boolean {
  */
 export function elem_<A>(self: Vector<A>) {
   return (E: Eq<A>) => {
-    const elemState: ElemState = { equals: E.equals_, element: undefined, result: false };
+    const elemState: ElemState = { equals: E.equals, element: undefined, result: false };
     return (a: A): boolean => {
       elemState.element = a;
       return foldLeftCb(elemCb, elemState, self).result;
@@ -506,21 +509,21 @@ export function foldRightWhile_<A, B>(fa: Vector<A>, b: B, cont: Predicate<B>, f
 }
 
 /**
- * @tsplus getter fncts.Vector foldMap
+ * @tsplus fluent fncts.Vector foldMap
  */
-export function foldMap_<A>(self: Vector<A>) {
-  return <M>(M: Monoid<M>) =>
-    (f: (a: A) => M): M =>
-      self.foldMapWithIndex(M)((_, a) => f(a));
+export function foldMap_<A, M>(self: Vector<A>, f: (a: A) => M, /** @tsplus auto */ M: Monoid<M>): M {
+  return self.foldMapWithIndex((_, a) => f(a), M);
 }
 
 /**
- * @tsplus getter fncts.Vector foldMapWithIndex
+ * @tsplus fluent fncts.Vector foldMapWithIndex
  */
-export function foldMapWithIndex_<A>(self: Vector<A>) {
-  return <M>(M: Monoid<M>) =>
-    (f: (i: number, a: A) => M): M =>
-      self.foldLeftWithIndex(M.nat, (i, b, a) => M.combine_(b, f(i, a)));
+export function foldMapWithIndex_<A, M>(
+  self: Vector<A>,
+  f: (i: number, a: A) => M,
+  /** @tsplus auto */ M: Monoid<M>,
+): M {
+  return self.foldLeftWithIndex(M.nat, (i, b, a) => M.combine(b, f(i, a)));
 }
 
 /**
@@ -857,6 +860,13 @@ export function prepend_<A>(as: Vector<A>, a: A): Vector<A> {
   }
 }
 
+/**
+ * @tsplus operator fncts.Vector +
+ */
+export function prependOperator<A>(a: A, as: Vector<A>): Vector<A> {
+  return as.prepend(a);
+}
+
 /**
  * Returns a Vector of numbers between an inclusive lower bound and an exclusive upper bound.
  *
@@ -900,6 +910,13 @@ export function replicate<A>(n: number, a: A): Vector<A> {
   return l;
 }
 
+/**
+ * @tsplus getter fncts.Vector reverse
+ */
+export function reverse<A>(self: Vector<A>): Vector<A> {
+  return self.foldLeft(Vector.empty(), (vec, elem) => vec.prepend(elem));
+}
+
 /**
  * Folds a function over a Vector from left to right while collecting
  * all the intermediate steps in a resulting Vector.
@@ -1039,10 +1056,10 @@ export function slice_<A>(as: Vector<A>, from: number, to: number): Vector<A> {
 }
 
 /**
- * @tsplus getter fncts.Vector sort
+ * @tsplus fluent fncts.Vector sort
  */
-export function sort_<A>(self: Vector<A>) {
-  return (O: Ord<A>): Vector<A> => self.sortWith(O.compare_);
+export function sort_<A>(self: Vector<A>, /** @tsplus auto */ O: Ord<A>): Vector<A> {
+  return self.sortWith(O.compare);
 }
 
 /**
@@ -1183,6 +1200,29 @@ export function toList<A>(self: Vector<A>): List<A> {
   return buffer.toList;
 }
 
+/**
+ * @tsplus fluent fncts.Vector traverseWithIndex
+ */
+export const traverseWithIndex: TraversableWithIndex<VectorF>["traverseWithIndex"] = (self, f, G) => {
+  return self.foldLeftWithIndex(G.pure(Vector.emptyPushable()), (i, b, a) =>
+    b.zipWith(
+      f(i, a),
+      (v, b) => {
+        push(v, b);
+        return v;
+      },
+      G,
+    ),
+  );
+};
+
+/**
+ * @tsplus fluent fncts.Vector traverse
+ */
+export const traverse: Traversable<VectorF>["traverse"] = (self, f, G) => {
+  return self.traverseWithIndex((_, a) => f(a));
+};
+
 /**
  * Returns a new Vector without repeated elements by using the given
  * Eq instance to determine when elements are equal
@@ -1191,7 +1231,7 @@ export function toList<A>(self: Vector<A>): List<A> {
  * @tsplus getter fncts.Vector uniq
  */
 export function uniq<A>(as: Vector<A>) {
-  return (E: Eq<A>) => as.dropRepeatsWith(E.equals_);
+  return (E: Eq<A>) => as.dropRepeatsWith(E.equals);
 }
 
 /**

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

@@ -8,6 +8,8 @@ import { ForwardVectorIterator } from "@fncts/base/collection/immutable/Vector/i
 export const VectorTypeId = Symbol.for("fncts.Vector");
 export type VectorTypeId = typeof VectorTypeId;
 
+export interface VectorF extends Vector<any> {}
+
 /**
  * Represents a Vector of elements.
  *
@@ -16,6 +18,10 @@ export type VectorTypeId = typeof VectorTypeId;
  */
 export class Vector<A> implements Iterable<A> {
   readonly _typeId: VectorTypeId = VectorTypeId;
+  readonly [HKT.F]!: VectorF;
+  readonly [HKT.A]!: () => A;
+  readonly [HKT.T]!: Vector<HKT._A<this>>;
+  readonly [HKT.Ix]!: number
   constructor(
     /** @private */
     readonly bits: number,
@@ -48,6 +54,10 @@ export class Vector<A> implements Iterable<A> {
  */
 export interface MutableVector<A> {
   readonly _typeId: VectorTypeId;
+  readonly [HKT.F]: VectorF;
+  readonly [HKT.A]: () => A;
+  readonly [HKT.T]: Vector<HKT._A<this>>;
+  readonly [HKT.Ix]: number
   bits: number;
   offset: number;
   length: number;

package/_src/collection/mutable/HashMap.ts

@@ -80,7 +80,7 @@ export class HashMap<K, V> implements Iterable<readonly [K, V]> {
       let prev: Node<K, V> | undefined = undefined;
       let nd: Node<K, V> | undefined   = n;
       while (nd) {
-        if (hash === nd.hash && this.config.equals_(key, nd.key)) {
+        if (hash === nd.hash && this.config.equals(key, nd.key)) {
           previousNode = prev;
           foundNode    = nd;
           break;
@@ -158,7 +158,7 @@ export class HashMap<K, V> implements Iterable<readonly [K, V]> {
       const old = n;
       let prev: Node<K, V> | undefined = undefined;
       while (n !== undefined && n.hash <= hash) {
-        if (n.hash === hash && this.config.equals_(key, n.key)) {
+        if (n.hash === hash && this.config.equals(key, n.key)) {
           const old = n.value;
           n.value   = value;
           if (getOld) return Just(old);
@@ -186,7 +186,7 @@ export class HashMap<K, V> implements Iterable<readonly [K, V]> {
     const nd  = this.table[idx];
     if (nd === undefined) {
       return undefined;
-    } else if (nd.hash === hash && this.config.equals_(nd.key, key)) {
+    } else if (nd.hash === hash && this.config.equals(nd.key, key)) {
       this.table[idx]   = nd.next;
       this.contentSize -= 1;
       return nd;
@@ -194,7 +194,7 @@ export class HashMap<K, V> implements Iterable<readonly [K, V]> {
       let prev = nd;
       let next = nd.next;
       while (next && next.hash <= hash) {
-        if (next.hash === hash && this.config.equals_(next.key, key)) {
+        if (next.hash === hash && this.config.equals(next.key, key)) {
           prev.next         = next.next;
           this.contentSize -= 1;
           return next;
@@ -221,7 +221,7 @@ export class HashMap<K, V> implements Iterable<readonly [K, V]> {
   private findNode(key: K): Node<K, V> | undefined {
     const hash = this.computeHash(key);
     const n    = this.table[this.index(hash)];
-    return n === undefined ? n : n.findNode(key, hash, this.config.equals_);
+    return n === undefined ? n : n.findNode(key, hash, this.config.equals);
   }
 
   private growTable(newLen: number) {

package/_src/collection/mutable/HashSet.ts

@@ -81,7 +81,7 @@ export class HashSet<A> implements Iterable<A> {
       const old                     = n;
       let prev: Node<A> | undefined = undefined;
       while (n !== undefined && n.hash <= hash) {
-        if (n.hash === hash && this.config.equals_(elem, n.key)) {
+        if (n.hash === hash && this.config.equals(elem, n.key)) {
           return false;
         }
         prev = n;
@@ -102,7 +102,7 @@ export class HashSet<A> implements Iterable<A> {
     const n   = this.table[idx];
     if (n === undefined) {
       return false;
-    } else if (n.hash === hash && this.config.equals_(n.key, elem)) {
+    } else if (n.hash === hash && this.config.equals(n.key, elem)) {
       this.table[idx]   = n.next;
       this.contentSize -= 1;
       return true;
@@ -110,7 +110,7 @@ export class HashSet<A> implements Iterable<A> {
       let prev = n;
       let next = n.next;
       while (next && next.hash <= hash) {
-        if (next.hash === hash && this.config.equals_(next.key, elem)) {
+        if (next.hash === hash && this.config.equals(next.key, elem)) {
           prev.next         = next.next;
           this.contentSize -= 1;
           return true;
@@ -137,7 +137,7 @@ export class HashSet<A> implements Iterable<A> {
   private findNode(key: A): Node<A> | undefined {
     const hash = this.computeHash(key);
     const n    = this.table[this.index(hash)];
-    return n === undefined ? n : n.findNode(key, hash, this.config.equals_);
+    return n === undefined ? n : n.findNode(key, hash, this.config.equals);
   }
 
   private growTable(newLen: number) {

package/_src/control/Eval/api.ts

@@ -1,7 +1,7 @@
 import type { _A } from "@fncts/base/types";
 
 import { Chain } from "@fncts/base/control/Eval/definition";
-import { identity } from "@fncts/base/data/function";
+import { identity, tuple } from "@fncts/base/data/function";
 
 /**
  * @tsplus fluent fncts.control.Eval and
@@ -38,6 +38,10 @@ export function zipWith_<A, B, C>(self: Eval<A>, fb: Eval<B>, f: (a: A, b: B) =>
   return self.flatMap((a) => fb.map((b) => f(a, b)));
 }
 
+export function zip_<A, B>(self: Eval<A>, fb: Eval<B>): Eval<readonly [A, B]> {
+  return self.zipWith(fb, tuple);
+}
+
 /**
  * @tsplus fluent fncts.control.Eval ap
  */

package/_src/control/Eval/definition.ts

@@ -1,12 +1,16 @@
 export const EvalTypeId = Symbol.for("@fncts.base/control/Eval");
 export type EvalTypeId = typeof EvalTypeId;
 
+export interface EvalF extends Eval<any> {}
+
 /**
  * @tsplus type fncts.control.Eval
  */
 export interface Eval<A> {
   readonly _typeId: EvalTypeId;
-  readonly _A: () => A;
+  [HKT.F]?: EvalF;
+  [HKT.A]?: () => A;
+  [HKT.T]?: Eval<HKT._A<this>>;
 }
 
 /**
@@ -58,10 +62,3 @@ export function concrete(_: Eval<any>): asserts _ is Concrete {
 export function unifyEval<X extends Eval<any>>(self: X): Eval<[X] extends [Eval<infer A>] ? A : never> {
   return self;
 }
-
-export interface EvalF extends HKT {
-  readonly type: Eval<this["A"]>;
-  readonly variance: {
-    readonly A: "-";
-  };
-}

package/_src/control/Eval/instance.ts

@@ -1,31 +1,32 @@
 import type { EvalF } from "@fncts/base/control/Eval/definition";
+import type * as P from "@fncts/base/typeclass";
 
-import { ap_, map_, zipWith_ } from "@fncts/base/control/Eval/api";
+import { ap_, map_, zip_, zipWith_ } from "@fncts/base/control/Eval/api";
 import { now } from "@fncts/base/control/Eval/constructors";
-import * as P from "@fncts/base/typeclass";
 
 /**
  * @tsplus static fncts.control.EvalOps Functor
+ * @tsplus implicit
  */
-export const Functor: P.Functor<EvalF> = P.Functor({
-  map_,
-});
+export const Functor: P.Functor<EvalF> = {
+  map: map_,
+};
 
 /**
  * @tsplus static fncts.control.EvalOps Apply
+ * @tsplus implicit
  */
-export const Apply: P.Apply<EvalF> = P.Apply({
-  map_,
-  ap_,
-  zipWith_,
-});
+export const Apply: P.Apply<EvalF> = {
+  map: map_,
+  zip: zip_,
+  zipWith: zipWith_,
+};
 
 /**
  * @tsplus static fncts.control.EvalOps Applicative
+ * @tsplus implicit
  */
-export const Applicative: P.Applicative<EvalF> = P.Applicative({
-  map_,
-  ap_,
-  zipWith_,
+export const Applicative: P.Applicative<EvalF> = {
+  ...Apply,
   pure: now,
-});
+};

package/_src/control/Z/definition.ts

@@ -1,17 +1,8 @@
-import type { _A, _E, _R, _S1, _S2, _W } from "../../types.js";
-
 import { hasTypeId } from "../../util/predicates.js";
 
-export interface ZF extends HKT {
-  readonly type: Z<this["W"], this["S"], this["S"], this["R"], this["E"], this["A"]>;
-  readonly variance: {
-    readonly W: "_";
-    readonly S: "_";
-    readonly R: "-";
-    readonly E: "+";
-    readonly A: "+";
-  };
-}
+export interface ZF extends Z<any, any, any, any, any, any> {}
+
+export interface ZFixedF extends ZFixed<any, any, any, any, any> {}
 
 export const ZTypeId = Symbol.for("@principia/base/Z");
 export type ZTypeId = typeof ZTypeId;
@@ -31,18 +22,34 @@ export type ZTypeId = typeof ZTypeId;
  */
 export abstract class Z<W, S1, S2, R, E, A> {
   readonly _typeId: ZTypeId = ZTypeId;
-  readonly _W!: () => W;
-  readonly _S1!: (_: S1) => void;
-  readonly _S2!: () => S2;
-  readonly _R!: (_: R) => void;
-  readonly _E!: () => E;
-  readonly _A!: () => A;
+  readonly [HKT.F]!: ZF;
+  readonly [HKT.W]!: () => W;
+  readonly [HKT.Q]!: (_: S1) => void;
+  readonly [HKT.S]!: () => S2;
+  readonly [HKT.R]!: (_: R) => void;
+  readonly [HKT.E]!: () => E;
+  readonly [HKT.A]!: () => A;
+  readonly [HKT.T]!: Z<HKT._W<this>, HKT._Q<this>, HKT._S<this>, HKT._R<this>, HKT._E<this>, HKT._A<this>>;
+}
+
+export interface ZFixed<W, S, R, E, A> {
+  readonly _typeId: ZTypeId;
+  readonly [HKT.F]: ZF;
+  readonly [HKT.W]: () => W;
+  readonly [HKT.Q]: (_: S) => void;
+  readonly [HKT.S]: () => S;
+  readonly [HKT.R]: (_: R) => void;
+  readonly [HKT.E]: () => E;
+  readonly [HKT.A]: () => A;
+  readonly [HKT.T]: Z<HKT._W<this>, HKT._S<this>, HKT._S<this>, HKT._R<this>, HKT._E<this>, HKT._A<this>>;
 }
 
 /**
  * @tsplus unify fncts.control.Z
  */
-export function unifyZ<X extends Z<any, any, any, any, any, any>>(_: X): Z<_W<X>, _S1<X>, _S2<X>, _R<X>, _E<X>, _A<X>> {
+export function unifyZ<X extends Z<any, any, any, any, any, any>>(
+  _: X,
+): Z<HKT._W<X>, HKT._Q<X>, HKT._S<X>, HKT._R<X>, HKT._E<X>, HKT._A<X>> {
   return _;
 }
 

package/_src/control/Z/instances.ts

@@ -1,14 +1,15 @@
-import type { ZF } from "./definition.js";
+import type * as P from "../../typeclass.js";
+import type { ZFixedF } from "./definition.js";
 
-import * as P from "../../typeclass.js";
-import { ap_, crossWith_, map_, succeedNow } from "./api.js";
+import { map_, succeedNow, zip_, zipWith_ } from "./api.js";
 
 /**
  * @tsplus static fncts.control.ZOps Applicative
+ * @tsplus implicit
  */
-export const Applicative: P.Applicative<ZF> = P.Applicative({
-  map_,
-  ap_,
-  zipWith_: crossWith_,
+export const Applicative: P.Applicative<ZFixedF> = {
+  map: map_,
+  zip: zip_,
+  zipWith: zipWith_,
   pure: succeedNow,
-});
+};