@fncts/base 0.0.20 → 0.0.21

package/_src/optics/Traversal/definition.ts

@@ -10,18 +10,16 @@ export interface PTraversal<S, T, A, B> extends PSetter<S, T, A, B>, Fold<S, A>
   modifyA: <F extends HKT, FC = HKT.None>(
     F: Applicative<F, FC>,
   ) => <K, Q, W, X, I, _S, R, E>(
-    s: S,
     f: (a: A) => 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, T>;
+  ) => (s: S) => HKT.Kind<F, FC, K, Q, W, X, I, _S, R, E, T>;
 }
 
 export interface PTraversalMin<S, T, A, B> {
   modifyA: <F extends HKT, FC = HKT.None>(
     F: Applicative<F, FC>,
   ) => <K, Q, W, X, I, _S, R, E>(
-    s: S,
     f: (a: A) => 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, T>;
+  ) => (s: S) => HKT.Kind<F, FC, K, Q, W, X, I, _S, R, E, T>;
 }
 
 /**
@@ -34,22 +32,19 @@ export const PTraversal: PTraversalOps = {};
 /**
  * @tsplus static fncts.optics.PTraversalOps __call
  */
-export function mkPTraversal<S, T, A, B>(F: PTraversalMin<S, T, A, B>): PTraversal<S, T, A, B> {
+export function makePTraversal<S, T, A, B>(F: PTraversalMin<S, T, A, B>): PTraversal<S, T, A, B> {
   return {
     modifyA: F.modifyA,
     ...PSetter<S, T, A, B>({
-      modify_: (s, f) =>
-        F.modifyA(Identity.Applicative)(
-          s,
-          f.compose((b) => Identity.get(b)),
-        ).getIdentity,
-      set_: (s, b) => F.modifyA(Identity.Applicative)(s, () => Identity.get(b)).getIdentity,
+      modify: (f) => (s) => s.pipe(F.modifyA(Identity.Applicative)(f.compose((b) => Identity.get(b)))).getIdentity,
+      set: (b) => (s) => s.pipe(F.modifyA(Identity.Applicative)(() => Identity.get(b))).getIdentity,
     }),
     ...Fold<S, A>({
-      foldMap_:
+      foldMap:
         <M>(M: Monoid<M>) =>
-        (s: S, f: (a: A) => M) =>
-          F.modifyA(Const.getApplicative(M))(s, (a) => Const(f(a))).getConst,
+        (f: (a: A) => M) =>
+        (s) =>
+          s.pipe(F.modifyA(Const.getApplicative(M))((a) => Const(f(a)))).getConst,
     }),
   };
 }
@@ -67,6 +62,6 @@ export interface TraversalOps extends PTraversalOps {}
 /**
  * @tsplus static fncts.optics.TraversalOps __call
  */
-export function mkTraversal<S, A>(F: PTraversalMin<S, S, A, A>): Traversal<S, A> {
+export function makeTraversal<S, A>(F: PTraversalMin<S, S, A, A>): Traversal<S, A> {
   return PTraversal(F);
 }

package/_src/optics/Traversal.ts

@@ -1,7 +1,6 @@
 // codegen:start { preset: barrel, include: ./Traversal/*.ts }
 export * from "./Traversal/definition.js";
 // codegen:end
-
 // codegen:start { preset: barrel, include: ./Traversal/api/*.ts }
 export * from "./Traversal/api/compose.js";
 export * from "./Traversal/api/fromTraversable.js";

package/_src/typeclass/Align.ts

@@ -1,14 +1,11 @@
 import type { Nil } from "@fncts/base/typeclass/Nil";
 import type { Semialign } from "@fncts/base/typeclass/Semialign";
-
 /**
  * @tsplus type fncts.Align
  */
 export interface Align<F extends HKT, FC = HKT.None> extends Semialign<F, FC>, Nil<F, FC> {}
-
 /**
  * @tsplus type fncts.AlignOps
  */
 export interface AlignOps {}
-
 export const Align: AlignOps = {};

package/_src/typeclass/Alt.ts

@@ -5,7 +5,6 @@ import type { Functor } from "@fncts/base/typeclass/Functor";
  */
 export interface Alt<F extends HKT, FC = HKT.None> extends Functor<F, FC> {
   alt: <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>,
     that: Lazy<
       HKT.Kind<
         F,
@@ -21,6 +20,8 @@ export interface Alt<F extends HKT, FC = HKT.None> extends Functor<F, FC> {
         HKT.Intro<F, "A", A, B>
       >
     >,
+  ) => (
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
   ) => HKT.Kind<
     F,
     FC,

package/_src/typeclass/Applicative.ts

@@ -1,6 +1,5 @@
 import type { Apply } from "@fncts/base/typeclass/Apply";
 import type { Pointed } from "@fncts/base/typeclass/Pointed";
-
 export interface Applicative<F extends HKT, FC = HKT.None> extends Apply<F, FC>, Pointed<F, FC> {}
 
 /**

package/_src/typeclass/ApplicativeExcept.ts

@@ -1,14 +1,13 @@
 import type { Applicative } from "@fncts/base/typeclass/Applicative";
 import type { Fail } from "@fncts/base/typeclass/Fail";
 
-import { identity } from "@fncts/base/data/function";
+import { identity, pipe } from "@fncts/base/data/function";
 
 /**
  * @tsplus type fncts.ApplicativeExcept
  */
 export interface ApplicativeExcept<F extends HKT, FC = HKT.None> extends Applicative<F, FC>, Fail<F, FC> {
-  catchAll: <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(
-    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  catchAll: <K, Q, W, X, I, S, R, E, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(
     f: (
       e: E,
     ) => HKT.Kind<
@@ -24,6 +23,8 @@ export interface ApplicativeExcept<F extends HKT, FC = HKT.None> extends Applica
       HKT.Intro<F, "E", E, E1>,
       A1
     >,
+  ) => <A>(
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
   ) => HKT.Kind<
     F,
     FC,
@@ -46,13 +47,9 @@ export interface ApplicativeExceptOps {}
 
 export const ApplicativeExcept: ApplicativeExceptOps = {};
 
-/**
- * @tsplus fluent fncts.Kind catchJust
- */
 export function catchJust<F extends HKT, FC = HKT.None>(
   F: ApplicativeExcept<F, FC>,
-): <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(
-  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, A1>(
   f: (
     e: E,
   ) => Maybe<
@@ -70,6 +67,8 @@ export function catchJust<F extends HKT, FC = HKT.None>(
       A1
     >
   >,
+) => <A>(
+  fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
 ) => HKT.Kind<
   F,
   FC,
@@ -83,7 +82,8 @@ export function catchJust<F extends HKT, FC = HKT.None>(
   HKT.Mix<F, "E", [E, E1]>,
   A | A1
 > {
-  return (fa, f) => F.catchAll(fa, (e) => unsafeCoerce(f(e).match(() => F.fail(e), identity)));
+  // @ts-expect-error
+  return (f) => F.catchAll((e) => f(e).match(() => F.fail(e), identity));
 }
 
 /**
@@ -97,5 +97,10 @@ export function either<F extends HKT, FC = HKT.None>(
 export function either<F>(
   F: ApplicativeExcept<HKT.FCoE<F>>,
 ): <E, A>(self: HKT.FK2<F, E, A>) => HKT.FK2<F, never, Either<E, A>> {
-  return (self) => F.catchAll(F.map(self, Either.right), (e) => F.pure(Either.left(e)));
+  return (self) =>
+    pipe(
+      self,
+      F.map(Either.right),
+      F.catchAll((e) => F.pure(Either.left(e))),
+    );
 }

package/_src/typeclass/Apply.ts

@@ -2,14 +2,13 @@ import type { Functor } from "@fncts/base/typeclass/Functor";
 import type { Semimonoidal } from "@fncts/base/typeclass/Semimonoidal";
 import type { Object } from "@fncts/typelevel";
 
-import { tuple } from "@fncts/base/data/function";
+import { pipe, tuple } from "@fncts/base/data/function";
 
 /**
  * @tsplus type fncts.Apply
  */
 export interface Apply<F extends HKT, FC = HKT.None> extends Semimonoidal<F, FC>, Functor<F, FC> {
   zipWith: <K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B, D>(
-    self: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
     that: HKT.Kind<
       F,
       FC,
@@ -24,6 +23,8 @@ export interface Apply<F extends HKT, FC = HKT.None> extends Semimonoidal<F, FC>
       B
     >,
     f: (a: A, b: B) => D,
+  ) => (
+    self: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
   ) => HKT.Kind<
     F,
     FC,
@@ -38,7 +39,6 @@ export interface Apply<F extends HKT, FC = HKT.None> extends Semimonoidal<F, FC>
     D
   >;
 }
-
 /**
  * @tsplus type fncts.ApplyOps
  */
@@ -51,8 +51,7 @@ export const Apply: ApplyOps = {};
  */
 export function ap<F extends HKT, FC = HKT.None>(
   F: Apply<F, FC>,
-): <K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(
-  fab: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, (a: A) => B>,
+): <K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2>(
   fa: HKT.Kind<
     F,
     FC,
@@ -66,6 +65,8 @@ export function ap<F extends HKT, FC = HKT.None>(
     HKT.Intro<F, "E", E1, E2>,
     A
   >,
+) => <B>(
+  fab: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, (a: A) => B>,
 ) => HKT.Kind<
   F,
   FC,
@@ -79,16 +80,14 @@ export function ap<F extends HKT, FC = HKT.None>(
   HKT.Mix<F, "E", [E1, E2]>,
   B
 > {
-  return (fab, fa) => F.zipWith(fab, fa, (f, a) => f(a));
+  return (fa) => F.zipWith(fa, (f, a) => f(a));
 }
-
 /**
  * @tsplus static fncts.ApplyOps apFirst
  */
 export function apFirst<F extends HKT, FC = HKT.None>(
   F: Apply<F, FC>,
-): <K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(
-  fa: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
+): <K1, Q1, W1, X1, I1, S1, R1, E1, K2, Q2, W2, X2, I2, S2, R2, E2, B>(
   fb: HKT.Kind<
     F,
     FC,
@@ -102,6 +101,8 @@ export function apFirst<F extends HKT, FC = HKT.None>(
     HKT.Intro<F, "E", E1, E2>,
     B
   >,
+) => <A>(
+  fa: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
 ) => HKT.Kind<
   F,
   FC,
@@ -115,16 +116,14 @@ export function apFirst<F extends HKT, FC = HKT.None>(
   HKT.Mix<F, "E", [E1, E2]>,
   A
 > {
-  return (fa, fb) => F.zipWith(fa, fb, (a, _) => a);
+  return (fb) => F.zipWith(fb, (a, _) => a);
 }
-
 /**
  * @tsplus static fncts.ApplyOps apSecond
  */
 export function apSecond<F extends HKT, FC = HKT.None>(
   F: Apply<F, FC>,
-): <K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(
-  fa: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
+): <K1, Q1, W1, X1, I1, S1, R1, E1, K2, Q2, W2, X2, I2, S2, R2, E2, B>(
   fb: HKT.Kind<
     F,
     FC,
@@ -138,6 +137,8 @@ export function apSecond<F extends HKT, FC = HKT.None>(
     HKT.Intro<F, "E", E1, E2>,
     B
   >,
+) => <A>(
+  fa: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
 ) => HKT.Kind<
   F,
   FC,
@@ -151,13 +152,11 @@ export function apSecond<F extends HKT, FC = HKT.None>(
   HKT.Mix<F, "E", [E1, E2]>,
   B
 > {
-  return (fa, fb) => F.zipWith(fa, fb, (_, b) => b);
+  return (fb) => F.zipWith(fb, (_, b) => b);
 }
-
 export function apS<F extends HKT, FC = HKT.None>(
   F: Apply<F, FC>,
 ): <K1, Q1, W1, X1, I1, S1, R1, E1, A, BN extends string, K2, Q2, W2, X2, I2, S2, R2, E2, B>(
-  fa: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
   name: Exclude<BN, keyof A>,
   fb: HKT.Kind<
     F,
@@ -172,7 +171,7 @@ export function apS<F extends HKT, FC = HKT.None>(
     HKT.Intro<F, "E", E1, E2>,
     B
   >,
-) => HKT.Kind<
+) => (fa: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>) => HKT.Kind<
   F,
   FC,
   HKT.Mix<F, "K", [K1, K2]>,
@@ -183,11 +182,12 @@ export function apS<F extends HKT, FC = HKT.None>(
   HKT.Mix<F, "S", [S1, S2]>,
   HKT.Mix<F, "R", [R1, R2]>,
   HKT.Mix<F, "E", [E1, E2]>,
-  { [K in keyof A | BN]: K extends keyof A ? A[K] : B }
+  {
+    [K in keyof A | BN]: K extends keyof A ? A[K] : B;
+  }
 > {
-  return (fa, name, fb) => F.zipWith(fa, fb, (a, b) => unsafeCoerce({ ...a, [name]: b }));
+  return (name, fb) => F.zipWith(fb, (a, b) => unsafeCoerce({ ...a, [name]: b }));
 }
-
 /**
  * @tsplus static fncts.ApplyOps sequenceS
  */
@@ -259,14 +259,13 @@ export function sequenceS<F extends HKT, FC = HKT.None>(
     const keys = globalThis.Object.keys(r);
     const len  = keys.length;
     const f    = getRecordConstructor(keys);
-    let fr     = F.map(r[keys[0]!]!, f);
+    let fr     = pipe(r[keys[0]!]!, F.map(f));
     for (let i = 1; i < len; i++) {
-      fr = Apply.ap(F)(fr, unsafeCoerce(r[keys[i]!]!));
+      fr = pipe(fr, Apply.ap(F)(unsafeCoerce(r[keys[i]!]!)));
     }
     return unsafeCoerce(fr);
   };
 }
-
 export function sequenceT<F extends HKT, FC = HKT.None>(
   F: Apply<F, FC>,
 ): <
@@ -327,20 +326,18 @@ export function sequenceT<F extends HKT, FC = HKT.None>(
   return (t) => {
     const len = t.length;
     const f   = getTupleConstructor(len);
-    let fas   = F.map(t[0], f);
+    let fas   = pipe(t[0], F.map(f));
     for (let i = 1; i < len; i++) {
-      fas = Apply.ap(F)(fas, unsafeCoerce(t[i]!));
+      fas = pipe(fas, Apply.ap(F)(unsafeCoerce(t[i]!)));
     }
     return unsafeCoerce(fas);
   };
 }
-
 /*
  * -------------------------------------------------------------------------------------------------
  * internal
  * -------------------------------------------------------------------------------------------------
  */
-
 /**
  * @internal
  */
@@ -365,7 +362,6 @@ const tupleConstructors: Record<number, (a: unknown) => any> = {
   4: (a) => (b: any) => (c: any) => (d: any) => [a, b, c, d],
   5: (a) => (b: any) => (c: any) => (d: any) => (e: any) => [a, b, c, d, e],
 };
-
 /**
  * @internal
  */
@@ -375,7 +371,6 @@ function getTupleConstructor(len: number): (a: unknown) => any {
   }
   return tupleConstructors[len]!;
 }
-
 /**
  * @internal
  */
@@ -393,7 +388,6 @@ function getRecordConstructor(keys: ReadonlyArray<string>) {
     [],
   );
 }
-
 /**
  * @internal
  */
@@ -401,9 +395,10 @@ type InferMixStruct<F extends HKT, FC, P extends HKT.ParamName, T, KS> = HKT.Mix
   F,
   P,
   T,
-  { [K in keyof KS]: HKT.Infer<F, FC, P, KS[K]> }
+  {
+    [K in keyof KS]: HKT.Infer<F, FC, P, KS[K]>;
+  }
 >;
-
 /**
  * @internal
  */
@@ -411,5 +406,7 @@ type InferMixTuple<F extends HKT, FC, P extends HKT.ParamName, T, KT> = HKT.MixS
   F,
   P,
   T,
-  { [K in keyof KT & number]: HKT.Infer<F, FC, P, KT[K]> }
+  {
+    [K in keyof KT & number]: HKT.Infer<F, FC, P, KT[K]>;
+  }
 >;

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/Eq/definition.ts

@@ -4,14 +4,11 @@
 export interface Eq<A> {
   readonly equals: (x: A, y: A) => boolean;
 }
-
 /**
  * @tsplus type fncts.EqOps
  */
 export interface EqOps {}
-
 export const Eq: EqOps = {};
-
 /**
  * @tsplus static fncts.EqOps __call
  */

package/_src/typeclass/Eq/derivations.ts

@@ -2,7 +2,6 @@ import type { Check } from "@fncts/typelevel/Check";
 import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
 
 import { Eq } from "@fncts/base/typeclass/Eq/definition";
-
 /**
  * @tsplus derive fncts.Eq lazy
  */
@@ -18,7 +17,6 @@ export function deriveLazy<A>(fn: (_: Eq<A>) => Eq<A>): Eq<A> {
   });
   return eq;
 }
-
 /**
  * @tsplus derive fncts.Eq<_> 20
  */

package/_src/typeclass/Equatable/api.ts

@@ -4,7 +4,6 @@ import {
   createComparator,
   sameValueZeroEqual,
 } from "@fncts/base/typeclass/Equatable/fast-equals";
-
 /**
  * @tsplus static fncts.EquatableOps deepEquals
  */
@@ -19,7 +18,6 @@ export const deepEquals = createComparator(
     }
   }),
 );
-
 /**
  * @tsplus static fncts.EquatableOps strictEquals
  * @tsplus operator fncts.Equatable ==

package/_src/typeclass/Equatable/definition.ts

@@ -2,21 +2,17 @@
  * @tsplus static fncts.builtin.SymbolOps equals
  */
 export const equalsSymbol: unique symbol = Symbol.for("fncts.Equatable");
-
 /**
  * @tsplus type fncts.Equatable
  */
 export interface Equatable {
   [equalsSymbol](that: unknown): boolean;
 }
-
 export function isEquatable(u: unknown): u is Equatable {
   return isObject(u) && Symbol.equals in u;
 }
-
 /**
  * @tsplus type fncts.EquatableOps
  */
 export interface EquatableOps {}
-
 export const Equatable: EquatableOps = {};