@fncts/base 0.0.20 → 0.0.22

package/_src/typeclass/Chain.ts

@@ -1,9 +1,7 @@
-import { identity } from "@fncts/base/data/function";
+import { identity, pipe } from "@fncts/base/data/function";
 import { Functor } from "@fncts/base/typeclass/Functor";
-
 export interface FlatMap<F extends HKT, FC = HKT.None> extends Functor<F, FC> {
   flatMap: <K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(
-    ma: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
     f: (
       a: A,
     ) => HKT.Kind<
@@ -19,6 +17,8 @@ export interface FlatMap<F extends HKT, FC = HKT.None> extends Functor<F, FC> {
       HKT.Intro<F, "E", E1, E2>,
       B
     >,
+  ) => (
+    ma: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
   ) => HKT.Kind<
     F,
     FC,
@@ -33,16 +33,13 @@ export interface FlatMap<F extends HKT, FC = HKT.None> extends Functor<F, FC> {
     B
   >;
 }
-
 /**
  * @tsplus type fncts.FlatMapOps
  */
 export interface FlatMapOps {}
-
 export const FlatMap: FlatMapOps = {};
-
 /**
- * @tsplus fluent fncts.Kind flatten
+ * @tsplus pipeable fncts.Kind flatten
  */
 export function flatten<F extends HKT, FC = HKT.None>(
   F: FlatMap<F, FC>,
@@ -85,16 +82,14 @@ export function flatten<F extends HKT, FC = HKT.None>(
   HKT.Mix<F, "E", [E2, E1]>,
   A
 > {
-  return (mma) => F.flatMap(mma, identity);
+  return F.flatMap(identity);
 }
-
 /**
- * @tsplus fluent fncts.Kind tap
+ * @tsplus pipeable fncts.Kind tap
  */
 export function tap<F extends HKT, FC = HKT.None>(
   F: FlatMap<F, FC>,
 ): <K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(
-  ma: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
   f: (
     a: A,
   ) => HKT.Kind<
@@ -110,6 +105,8 @@ export function tap<F extends HKT, FC = HKT.None>(
     HKT.Intro<F, "E", E1, E2>,
     B
   >,
+) => (
+  ma: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
 ) => HKT.Kind<
   F,
   FC,
@@ -123,5 +120,5 @@ export function tap<F extends HKT, FC = HKT.None>(
   HKT.Mix<F, "E", [E1, E2]>,
   A
 > {
-  return (ma, f) => F.flatMap(ma, (a) => Functor.as(F)(f(a), a));
+  return (f) => F.flatMap((a) => pipe(f(a), Functor.as(F)(a)));
 }

package/_src/typeclass/Closure.ts

@@ -2,7 +2,7 @@
  * @tsplus type fncts.Closure
  */
 export interface Closure<A> {
-  readonly combine: (x: A, y: A) => A;
+  readonly combine: (y: A) => (x: A) => A;
 }
 
 /**
@@ -15,6 +15,6 @@ export const Closure: ClosureOps = {};
 /**
  * @tsplus static fncts.ClosureOps __call
  */
-export function mkClosure<A>(F: Closure<A>): Closure<A> {
+export function makeClosure<A>(F: Closure<A>): Closure<A> {
   return F;
 }

package/_src/typeclass/Filterable.ts

@@ -4,30 +4,36 @@ import type { Functor } from "@fncts/base/typeclass/Functor";
  * @tsplus type fncts.Filterable
  */
 export interface Filterable<F extends HKT, FC = HKT.None> extends Functor<F, FC> {
-  filter<K, Q, W, X, I, S, R, E, A, B extends A>(
-    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  filter<A, B extends A>(
     refinement: Refinement<A, B>,
-  ): HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;
-  filter<K, Q, W, X, I, S, R, E, A>(
+  ): <K, Q, W, X, I, S, R, E>(
     fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;
+  filter<A>(
     predicate: Predicate<A>,
-  ): HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>;
-  filterMap<K, Q, W, X, I, S, R, E, A, B>(
+  ): <K, Q, W, X, I, S, R, E>(
     fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>;
+  filterMap<A, B>(
     f: (a: A) => Maybe<B>,
-  ): HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;
-  partition<K, Q, W, X, I, S, R, E, A, B extends A>(
+  ): <K, Q, W, X, I, S, R, E>(
     fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;
+  partition<A, B extends A>(
     refinement: Refinement<A, B>,
-  ): readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>];
-  partition<K, Q, W, X, I, S, R, E, A>(
+  ): <K, Q, W, X, I, S, R, E>(
     fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>];
+  partition<A>(
     predicate: Predicate<A>,
-  ): readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>];
-  partitionMap<K, Q, W, X, I, S, R, E, A, B, B1>(
+  ): <K, Q, W, X, I, S, R, E>(
     fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>];
+  partitionMap<A, B, B1>(
     f: (a: A) => Either<B, B1>,
-  ): readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B1>];
+  ): <K, Q, W, X, I, S, R, E>(
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B1>];
 }
 
 /**

package/_src/typeclass/FilterableWithIndex.ts

@@ -5,30 +5,36 @@ import type { FunctorWithIndex } from "@fncts/base/typeclass/FunctorWithIndex";
  * @tsplus type fncts.FilterableWithIndex
  */
 export interface FilterableWithIndex<F extends HKT, FC = HKT.None> extends FunctorWithIndex<F, FC>, Filterable<F, FC> {
-  filterWithIndex<K, Q, W, X, I, S, R, E, A, B extends A>(
-    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  filterWithIndex<K, A, B extends A>(
     refinement: RefinementWithIndex<HKT.IndexFor<F, K>, A, B>,
-  ): HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;
-  filterWithIndex<K, Q, W, X, I, S, R, E, A>(
+  ): <Q, W, X, I, S, R, E>(
     fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;
+  filterWithIndex<K, A>(
     predicate: PredicateWithIndex<HKT.IndexFor<F, K>, A>,
-  ): HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>;
-  filterMapWithIndex<K, Q, W, X, I, S, R, E, A, B>(
+  ): <Q, W, X, I, S, R, E>(
     fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>;
+  filterMapWithIndex<K, A, B>(
     f: (i: HKT.IndexFor<F, K>, a: A) => Maybe<B>,
-  ): HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;
-  partitionWithIndex<K, Q, W, X, I, S, R, E, A, B extends A>(
+  ): <Q, W, X, I, S, R, E>(
     fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;
+  partitionWithIndex<K, A, B extends A>(
     refinement: RefinementWithIndex<HKT.IndexFor<F, K>, A, B>,
-  ): readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>];
-  partitionWithIndex<K, Q, W, X, I, S, R, E, A>(
+  ): <Q, W, X, I, S, R, E>(
     fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>];
+  partitionWithIndex<K, A>(
     predicate: PredicateWithIndex<HKT.IndexFor<F, K>, A>,
-  ): readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>];
-  partitionMapWithIndex<K, Q, W, X, I, S, R, E, A, B, B1>(
+  ): <Q, W, X, I, S, R, E>(
     fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>];
+  partitionMapWithIndex<K, A, B, B1>(
     f: (i: HKT.IndexFor<F, K>, a: A) => Either<B, B1>,
-  ): readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B1>];
+  ): <Q, W, X, I, S, R, E>(
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B1>];
 }
 
 /**

package/_src/typeclass/Foldable.ts

@@ -4,16 +4,14 @@ import type { Monoid } from "@fncts/base/typeclass/Monoid";
  * @tsplus type fncts.Foldable
  */
 export interface Foldable<F extends HKT, FC = HKT.None> extends HKT.Typeclass<F, FC> {
-  foldLeft: <K, Q, W, X, I, S, R, E, A, B>(
-    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  foldLeft: <A, B>(
     b: B,
     f: (b: B, a: A) => B,
-  ) => B;
-  foldRight: <K, Q, W, X, I, S, R, E, A, B>(
-    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => <K, Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => B;
+  foldRight: <A, B>(
     b: Eval<B>,
     f: (a: A, b: Eval<B>) => Eval<B>,
-  ) => Eval<B>;
+  ) => <K, Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => Eval<B>;
 }
 
 /**
@@ -28,10 +26,9 @@ export const Foldable: FoldableOps = {};
  */
 export function foldMap<F extends HKT, FC = HKT.None>(
   F: Foldable<F, FC>,
-): <K, Q, W, X, I, S, R, E, A, M>(
-  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+): <A, M>(
   f: (a: A) => M,
   /** @tsplus auto */ M: Monoid<M>,
-) => M {
-  return (fa, f, M) => F.foldLeft(fa, M.nat, (b, a) => M.combine(b, f(a)));
+) => <K, Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => M {
+  return (f, M) => F.foldLeft(M.nat, (b, a) => M.combine(f(a))(b));
 }

package/_src/typeclass/FoldableWithIndex.ts

@@ -5,16 +5,14 @@ import type { Monoid } from "@fncts/base/typeclass/Monoid";
  * @tsplus type fncts.FoldableWithIndex
  */
 export interface FoldableWithIndex<F extends HKT, FC = HKT.None> extends Foldable<F, FC> {
-  foldLeftWithIndex: <K, Q, W, X, I, S, R, E, A, B>(
-    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  foldLeftWithIndex: <K, A, B>(
     b: B,
     f: (i: HKT.IndexFor<F, K>, b: B, a: A) => B,
-  ) => B;
-  foldRightWithIndex: <K, Q, W, X, I, S, R, E, A, B>(
-    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => <Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => B;
+  foldRightWithIndex: <K, A, B>(
     b: Eval<B>,
     f: (i: HKT.IndexFor<F, K>, a: A, b: Eval<B>) => Eval<B>,
-  ) => Eval<B>;
+  ) => <Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => Eval<B>;
 }
 
 /**
@@ -29,10 +27,9 @@ export const FoldableWithIndex: FoldableWithIndexOps = {};
  */
 export function foldMapWithIndex<F extends HKT, FC = HKT.None>(
   F: FoldableWithIndex<F, FC>,
-): <K, Q, W, X, I, S, R, E, A, M>(
-  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+): <K, A, M>(
   f: (k: HKT.IndexFor<F, K>, a: A) => M,
   /** @tsplus auto */ M: Monoid<M>,
-) => M {
-  return (fa, f, M) => F.foldLeftWithIndex(fa, M.nat, (i, b, a) => M.combine(b, f(i, a)));
+) => <Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => M {
+  return (f, M) => F.foldLeftWithIndex(M.nat, (i, b, a) => M.combine(f(i, a))(b));
 }

package/_src/typeclass/Functor.ts

@@ -2,9 +2,10 @@
  * @tsplus type fncts.Functor
  */
 export interface Functor<F extends HKT, FC = HKT.None> extends HKT.Typeclass<F, FC> {
-  readonly map: <K, Q, W, X, I, S, R, E, A, B>(
-    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  readonly map: <A, B>(
     f: (a: A) => B,
+  ) => <K, Q, W, X, I, S, R, E>(
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
   ) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;
 }
 
@@ -20,9 +21,10 @@ export const Functor: FunctorOps = {};
  */
 export function as<F extends HKT, FC = HKT.None>(
   F: Functor<F, FC>,
-): <K, Q, W, X, I, S, R, E, A, B>(
-  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+): <B>(
   b: Lazy<B>,
+) => <K, Q, W, X, I, S, R, E, A>(
+  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
 ) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B> {
   return F.map;
 }

package/_src/typeclass/FunctorWithIndex.ts

@@ -1,9 +1,10 @@
 import type { Functor } from "@fncts/base/typeclass/Functor";
 
 export interface FunctorWithIndex<F extends HKT, FC = HKT.None> extends Functor<F, FC> {
-  readonly mapWithIndex: <K, W, Q, X, I, S, R, E, A, B>(
-    fa: HKT.Kind<F, FC, K, W, Q, X, I, S, R, E, A>,
+  readonly mapWithIndex: <K, A, B>(
     f: (i: HKT.IndexFor<F, K>, a: A) => B,
+  ) => <W, Q, X, I, S, R, E>(
+    fa: HKT.Kind<F, FC, K, W, Q, X, I, S, R, E, A>,
   ) => HKT.Kind<F, FC, K, W, Q, X, I, S, R, E, B>;
 }
 

package/_src/typeclass/Has.ts

@@ -11,9 +11,11 @@ export interface Has<T> {
 }
 
 /**
- * @tsplus operator fncts.Has &
- * @tsplus fluent fncts.Has merge
+ * @tsplus pipeable-operator fncts.Has &
+ * @tsplus pipeable fncts.Has merge
  */
-export function merge<A extends Has<any>, B extends Has<any>>(self: A, that: B): A & B {
-  return { ...self, ...that };
+export function merge<B extends Has<any>>(that: B) {
+  return <A extends Has<any>>(self: A): A & B => {
+    return { ...self, ...that };
+  };
 }

package/_src/typeclass/MonadExcept.ts

@@ -24,5 +24,5 @@ export function absolve<F extends HKT, FC = HKT.None>(
 export function absolve<F>(
   F: MonadExcept<HKT.F<F>>,
 ): <E, A, E1>(fa: HKT.FK2<F, E, Either<E1, A>>) => HKT.FK2<F, HKT.Mix<HKT.F<F>, "E", [E, E1]>, A> {
-  return (fa) => F.flatMap(fa, (r) => r.match(F.fail, F.pure));
+  return F.flatMap((r) => r.match(F.fail, F.pure));
 }

package/_src/typeclass/Monoid.ts

@@ -37,11 +37,11 @@ export function mkMonoid<A>(F: MonoidMin<A>): Monoid<A> {
 export function deriveLazy<A>(fn: (_: Monoid<A>) => Monoid<A>): Monoid<A> {
   let cached: Monoid<A> | undefined;
   const M: Monoid<A> = Monoid({
-    combine: (x, y) => {
+    combine: (y) => (x) => {
       if (!cached) {
         cached = fn(M);
       }
-      return cached.combine(x, y);
+      return cached.combine(y)(x);
     },
     get nat() {
       if (!cached) {

package/_src/typeclass/Semialign.ts

@@ -18,8 +18,7 @@ export interface SemialignOps {}
 export const Semialign: SemialignOps = {};
 
 export interface align<F extends HKT, FC = HKT.None> {
-  <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
-    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  <K, Q, W, X, I, S, R, E, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
     fb: HKT.Kind<
       F,
       FC,
@@ -33,7 +32,9 @@ export interface align<F extends HKT, FC = HKT.None> {
       HKT.Intro<F, "E", E, E1>,
       B
     >,
-  ): HKT.Kind<
+  ): <A>(
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => HKT.Kind<
     F,
     FC,
     HKT.Mix<F, "K", [K, K1]>,
@@ -53,8 +54,7 @@ export interface align<F extends HKT, FC = HKT.None> {
  */
 export function align<F extends HKT, FC = HKT.None>(
   F: Semialign<F, FC>,
-): <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
-  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+): <K, Q, W, X, I, S, R, E, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
   fb: HKT.Kind<
     F,
     FC,
@@ -68,6 +68,8 @@ export function align<F extends HKT, FC = HKT.None>(
     HKT.Intro<F, "E", E, E1>,
     B
   >,
+) => <A>(
+  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
 ) => HKT.Kind<
   F,
   FC,
@@ -81,12 +83,11 @@ export function align<F extends HKT, FC = HKT.None>(
   HKT.Mix<F, "E", [E, E1]>,
   These<A, B>
 > {
-  return (fa, fb) => F.alignWith(fa, fb, identity);
+  return (fb) => F.alignWith(fb, identity);
 }
 
 export interface alignWith<F extends HKT, FC = HKT.None> {
   <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B, C>(
-    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
     fb: HKT.Kind<
       F,
       FC,
@@ -101,7 +102,9 @@ export interface alignWith<F extends HKT, FC = HKT.None> {
       B
     >,
     f: (th: These<A, B>) => C,
-  ): HKT.Kind<
+  ): (
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => HKT.Kind<
     F,
     FC,
     HKT.Mix<F, "K", [K, K1]>,
@@ -122,7 +125,6 @@ export interface alignWith<F extends HKT, FC = HKT.None> {
 export function alignWith<F extends HKT, FC = HKT.None>(
   F: Semialign<F, FC>,
 ): <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B, C>(
-  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
   fb: HKT.Kind<
     F,
     FC,
@@ -137,6 +139,8 @@ export function alignWith<F extends HKT, FC = HKT.None>(
     B
   >,
   f: (th: These<A, B>) => C,
+) => (
+  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
 ) => HKT.Kind<
   F,
   FC,
@@ -150,12 +154,11 @@ export function alignWith<F extends HKT, FC = HKT.None>(
   HKT.Mix<F, "E", [E, E1]>,
   C
 > {
-  return (fa, fb, f) => F.alignWith(fa, fb, f);
+  return (fb, f) => F.alignWith(fb, f);
 }
 
 export interface alignCombine<F extends HKT, FC = HKT.None> {
   <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1>(
-    self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
     that: HKT.Kind<
       F,
       FC,
@@ -170,7 +173,9 @@ export interface alignCombine<F extends HKT, FC = HKT.None> {
       A
     >,
     S: Semigroup<A>,
-  ): HKT.Kind<
+  ): (
+    self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => HKT.Kind<
     F,
     FC,
     HKT.Mix<F, "K", [K, K1]>,
@@ -191,7 +196,6 @@ export interface alignCombine<F extends HKT, FC = HKT.None> {
 export function alignCombine<F extends HKT, FC = HKT.None>(
   F: Semialign<F, FC>,
 ): <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1>(
-  self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
   that: HKT.Kind<
     F,
     FC,
@@ -206,6 +210,8 @@ export function alignCombine<F extends HKT, FC = HKT.None>(
     A
   >,
   /** @tsplus auto */ S: Semigroup<A>,
+) => (
+  self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
 ) => HKT.Kind<
   F,
   FC,
@@ -219,12 +225,11 @@ export function alignCombine<F extends HKT, FC = HKT.None>(
   HKT.Mix<F, "E", [E, E1]>,
   A
 > {
-  return (self, that, S) => F.alignWith(self, that, (th) => th.match(identity, identity, S.combine));
+  return (that, S) => F.alignWith(that, (th) => th.match(identity, identity, (a, b) => S.combine(b)(a)));
 }
 
 export interface padZip<F extends HKT, FC = HKT.None> {
-  <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
-    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  <K, Q, W, X, I, S, R, E, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
     fb: HKT.Kind<
       F,
       FC,
@@ -238,7 +243,9 @@ export interface padZip<F extends HKT, FC = HKT.None> {
       HKT.Intro<F, "E", E, E1>,
       B
     >,
-  ): HKT.Kind<
+  ): <A>(
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => HKT.Kind<
     F,
     FC,
     HKT.Mix<F, "K", [K, K1]>,
@@ -254,12 +261,11 @@ export interface padZip<F extends HKT, FC = HKT.None> {
 }
 
 /**
- * @tsplus fluent fncts.Kind padZip
+ * @tsplus pipeable fncts.Kind padZip
  */
 export function padZip<F extends HKT, FC = HKT.None>(
   F: Semialign<F, FC>,
-): <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
-  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+): <K, Q, W, X, I, S, R, E, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
   fb: HKT.Kind<
     F,
     FC,
@@ -273,6 +279,8 @@ export function padZip<F extends HKT, FC = HKT.None>(
     HKT.Intro<F, "E", E, E1>,
     B
   >,
+) => <A>(
+  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
 ) => HKT.Kind<
   F,
   FC,
@@ -286,12 +294,11 @@ export function padZip<F extends HKT, FC = HKT.None>(
   HKT.Mix<F, "E", [E, E1]>,
   readonly [Maybe<A>, Maybe<B>]
 > {
-  return (fa, fb) => Semialign.padZipWith(F)(fa, fb, identity);
+  return (fb) => Semialign.padZipWith(F)(fb, identity);
 }
 
 export interface padZipWith<F extends HKT, FC = HKT.None> {
   <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B, D>(
-    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
     fb: HKT.Kind<
       F,
       FC,
@@ -306,7 +313,9 @@ export interface padZipWith<F extends HKT, FC = HKT.None> {
       B
     >,
     f: (_: readonly [Maybe<A>, Maybe<B>]) => D,
-  ): HKT.Kind<
+  ): (
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => HKT.Kind<
     F,
     FC,
     HKT.Mix<F, "K", [K, K1]>,
@@ -327,7 +336,6 @@ export interface padZipWith<F extends HKT, FC = HKT.None> {
 export function padZipWith<F extends HKT, FC = HKT.None>(
   F: Semialign<F, FC>,
 ): <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B, D>(
-  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
   fb: HKT.Kind<
     F,
     FC,
@@ -342,6 +350,8 @@ export function padZipWith<F extends HKT, FC = HKT.None>(
     B
   >,
   f: (_: readonly [Maybe<A>, Maybe<B>]) => D,
+) => (
+  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
 ) => HKT.Kind<
   F,
   FC,
@@ -355,8 +365,8 @@ export function padZipWith<F extends HKT, FC = HKT.None>(
   HKT.Mix<F, "E", [E, E1]>,
   D
 > {
-  return (fa, fb, f) =>
-    F.alignWith(fa, fb, (th) =>
+  return (fb, f) =>
+    F.alignWith(fb, (th) =>
       th.match(
         (a) => f([Just(a), Nothing()]),
         (b) => f([Nothing(), Just(b)]),
@@ -364,10 +374,8 @@ export function padZipWith<F extends HKT, FC = HKT.None>(
       ),
     );
 }
-
 export interface zipAll<F extends HKT, FC = HKT.None> {
   <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
-    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
     fb: HKT.Kind<
       F,
       FC,
@@ -383,7 +391,9 @@ export interface zipAll<F extends HKT, FC = HKT.None> {
     >,
     a: A,
     b: B,
-  ): HKT.Kind<
+  ): (
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => HKT.Kind<
     F,
     FC,
     HKT.Mix<F, "K", [K, K1]>,
@@ -404,7 +414,6 @@ export interface zipAll<F extends HKT, FC = HKT.None> {
 export function zipAll<F extends HKT, FC = HKT.None>(
   F: Semialign<F, FC>,
 ): <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
-  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
   fb: HKT.Kind<
     F,
     FC,
@@ -420,6 +429,8 @@ export function zipAll<F extends HKT, FC = HKT.None>(
   >,
   a: A,
   b: B,
+) => (
+  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
 ) => HKT.Kind<
   F,
   FC,
@@ -433,8 +444,8 @@ export function zipAll<F extends HKT, FC = HKT.None>(
   HKT.Mix<F, "E", [E, E1]>,
   readonly [A, B]
 > {
-  return (fa, fb, a, b) =>
-    F.alignWith(fa, fb, (th) =>
+  return (fb, a, b) =>
+    F.alignWith(fb, (th) =>
       th.match(
         (x) => [x, b],
         (x) => [a, x],

package/_src/typeclass/Semigroup/api.ts

@@ -1,5 +1,3 @@
-import type { Ord } from "@fncts/base/typeclass/Ord";
-
 import { Semigroup } from "@fncts/base/typeclass/Semigroup/definition";
 
 /**

package/_src/typeclass/Semigroup/definition.ts

@@ -1,6 +1,6 @@
 import type { Closure } from "@fncts/base/typeclass/Closure";
 
-import { mkClosure } from "@fncts/base/typeclass/Closure";
+import { makeClosure } from "@fncts/base/typeclass/Closure";
 
 /**
  * @tsplus type fncts.Semigroup
@@ -17,4 +17,4 @@ export const Semigroup: SemigroupOps = {};
 /**
  * @tsplus static fncts.SemigroupOps __call
  */
-export const mkSemigroup = mkClosure;
+export const makeSemigroup = makeClosure;

package/_src/typeclass/Semigroup/derivations.ts

@@ -9,11 +9,11 @@ import { Semigroup } from "@fncts/base/typeclass/Semigroup/definition";
 export function deriveLazy<A>(fn: (_: Semigroup<A>) => Semigroup<A>): Semigroup<A> {
   let cached: Semigroup<A> | undefined;
   const eq: Semigroup<A> = Semigroup({
-    combine: (x, y) => {
+    combine: (y) => (x) => {
       if (!cached) {
         cached = fn(eq);
       }
-      return cached.combine(x, y);
+      return cached.combine(y)(x);
     },
   });
   return eq;
@@ -42,10 +42,10 @@ export function deriveStruct<A extends Record<string, any>>(
     : never
 ): Semigroup<A> {
   return Semigroup({
-    combine: (x, y) => {
+    combine: (y) => (x) => {
       const out: Record<string, unknown> = {};
       for (const field in requiredFields) {
-        out[field] = (requiredFields[field]! as Semigroup<any>).combine(x[field], y[field]);
+        out[field] = (requiredFields[field]! as Semigroup<any>).combine(y[field])(x[field]);
       }
       for (const field in optionalFields) {
         const xf = x[field];
@@ -55,7 +55,7 @@ export function deriveStruct<A extends Record<string, any>>(
         } else if (!(field in y)) {
           out[field] = xf;
         } else {
-          out[field] = optionalFields[field].combine(xf, yf);
+          out[field] = optionalFields[field].combine(yf)(xf);
         }
       }
       return out as A;