@fncts/base 0.0.19 → 0.0.21

package/_src/internal/AtomicNumber.ts

@@ -1,28 +1,21 @@
 import { AtomicReference } from "./AtomicReference.js";
-
 export class AtomicNumber extends AtomicReference<number> {
   constructor(n: number) {
     super(n);
-
     this.incrementAndGet = this.incrementAndGet.bind(this);
     this.decrementAndGet = this.decrementAndGet.bind(this);
   }
-
   incrementAndGet() {
     this.set(this.get + 1);
     return this.get;
   }
-
   decrementAndGet() {
     this.set(this.get - 1);
     return this.get;
   }
-
   getAndIncrement(): number {
     const ret = this.get;
-
     this.set(this.get + 1);
-
     return ret;
   }
 }

package/_src/internal/AtomicReference.ts

@@ -3,15 +3,12 @@ export class AtomicReference<A> {
   constructor(readonly initial: A) {
     this.current = initial;
   }
-
   get get() {
     return this.current;
   }
-
   set(value: A) {
     this.current = value;
   }
-
   compareAndSet(old: A, value: A) {
     if (this.get === old) {
       this.set(value);
@@ -19,7 +16,6 @@ export class AtomicReference<A> {
     }
     return false;
   }
-
   getAndSet(value: A) {
     const previous = this.current;
     this.current   = value;

package/_src/internal/Stack.ts

@@ -4,25 +4,20 @@
  */
 export class Stack<A> {
   constructor(private node?: Node<A>) {}
-
   clone(): Stack<A> {
     return new Stack(this.node);
   }
-
   get hasNext(): boolean {
     return !!this.node;
   }
-
   get isEmpty(): boolean {
     return !this.hasNext;
   }
-
   peek(): A | undefined {
     if (this.node) {
       return this.node.value;
     }
   }
-
   pop(): A | undefined {
     if (this.node) {
       const value = this.node.value;
@@ -30,7 +25,6 @@ export class Stack<A> {
       return value;
     }
   }
-
   push(value: A): void {
     this.node = { value, previous: this.node };
   }
@@ -44,7 +38,7 @@ interface Node<A> {
 /**
  * @tsplus static fncts.StackOps __call
  */
-export function mkStack<A>(): Stack<A> {
+export function makeStack<A>(): Stack<A> {
   return new Stack();
 }
 

package/_src/optics/At/definition.ts

@@ -1,5 +1,4 @@
 import { Lens } from "@fncts/base/optics/Lens";
-
 /**
  * @tsplus type fncts.optics.At
  */
@@ -8,7 +7,10 @@ export interface At<S, I, A> {
 }
 
 export type AtMin<S, I, A> =
-  | { readonly get: (i: I) => (s: S) => A; readonly set: (i: I) => (s: S, a: A) => S }
+  | {
+      readonly get: (i: I) => (s: S) => A;
+      readonly set: (i: I) => (a: A) => (s: S) => S;
+    }
   | At<S, I, A>;
 
 /**
@@ -26,7 +28,7 @@ export function mkAt<S, I, A>(F: AtMin<S, I, A>): At<S, I, A> {
     return F;
   } else {
     return {
-      at: (i) => Lens({ get: F.get(i), set_: F.set(i) }),
+      at: (i) => Lens({ get: F.get(i), set: F.set(i) }),
     };
   }
 }

package/_src/optics/Fold/definition.ts

@@ -1,9 +1,4 @@
 import type { Monoid } from "@fncts/base/typeclass";
-
-export interface foldMap_<S, A> {
-  <M>(M: Monoid<M>): (s: S, f: (a: A) => M) => M;
-}
-
 export interface foldMap<S, A> {
   <M>(M: Monoid<M>): (f: (a: A) => M) => (s: S) => M;
 }
@@ -12,7 +7,6 @@ export interface foldMap<S, A> {
  * @tsplus type fncts.optics.Fold
  */
 export interface Fold<S, A> {
-  readonly foldMap_: foldMap_<S, A>;
   readonly foldMap: foldMap<S, A>;
 }
 
@@ -24,15 +18,14 @@ export interface FoldOps {}
 export const Fold: FoldOps = {};
 
 export interface FoldMin<S, A> {
-  readonly foldMap_: foldMap_<S, A>;
+  readonly foldMap: foldMap<S, A>;
 }
 
 /**
  * @tsplus static fncts.optics.FoldOps __call
  */
-export function mkFold<S, A>(F: FoldMin<S, A>): Fold<S, A> {
+export function makeFold<S, A>(F: FoldMin<S, A>): Fold<S, A> {
   return {
-    foldMap_: F.foldMap_,
-    foldMap: (M) => (f) => (s) => F.foldMap_(M)(s, f),
+    foldMap: F.foldMap,
   };
 }

package/_src/optics/Getter/definition.ts

@@ -25,10 +25,9 @@ export interface GetterMin<S, A> {
 /**
  * @tsplus static fncts.optics.GetterOps __call
  */
-export function mkGetter<S, A>(F: GetterMin<S, A>): Getter<S, A> {
+export function makeGetter<S, A>(F: GetterMin<S, A>): Getter<S, A> {
   return {
     get: F.get,
-    foldMap_: (_) => (s, f) => f(F.get(s)),
     foldMap: (_) => (f) => (s) => f(F.get(s)),
   };
 }

package/_src/optics/Index/definition.ts

@@ -19,6 +19,6 @@ export const Index: IndexOps = {};
 /**
  * @tsplus static fncts.optics.IndexOps __call
  */
-export function mkIndex<S, I, A>(F: IndexMin<S, I, A>): Index<S, I, A> {
+export function makeIndex<S, I, A>(F: IndexMin<S, I, A>): Index<S, I, A> {
   return { index: F.index };
 }

package/_src/optics/Iso/api.ts

@@ -1,11 +1,13 @@
 import { PIso } from "@fncts/base/optics/Iso/definition";
 
 /**
- * @tsplus fluent fncts.optics.PIso compose
+ * @tsplus pipeable fncts.optics.PIso compose
  */
-export function compose_<S, T, A, B, C, D>(self: PIso<S, T, A, B>, that: PIso<A, B, C, D>): PIso<S, T, C, D> {
-  return PIso({
-    get: self.get.compose(that.get),
-    reverseGet: that.reverseGet.compose(self.reverseGet),
-  });
+export function compose<A, B, C, D>(that: PIso<A, B, C, D>) {
+  return <S, T>(self: PIso<S, T, A, B>): PIso<S, T, C, D> => {
+    return PIso({
+      get: self.get.compose(that.get),
+      reverseGet: that.reverseGet.compose(self.reverseGet),
+    });
+  };
 }

package/_src/optics/Iso/definition.ts

@@ -26,10 +26,10 @@ export interface PIsoMin<S, T, A, B> {
 /**
  * @tsplus static fncts.optics.PIsoOps __call
  */
-export function mkPIso<S, T, A, B>(F: PIsoMin<S, T, A, B>): PIso<S, T, A, B> {
+export function makePIso<S, T, A, B>(F: PIsoMin<S, T, A, B>): PIso<S, T, A, B> {
   return {
     ...PPrism({ getOrModify: F.get.compose(Either.right), reverseGet: F.reverseGet }),
-    ...PLens({ get: F.get, set_: (_s, b) => F.reverseGet(b) }),
+    ...PLens({ get: F.get, set: (b) => () => F.reverseGet(b) }),
     reverse: () => PIso({ get: F.reverseGet, reverseGet: F.get }),
   };
 }
@@ -47,6 +47,6 @@ export interface IsoOps {}
 /**
  * @tsplus static fncts.optics.IsoOps __call
  */
-export function mkIso<S, A>(F: PIsoMin<S, S, A, A>): Iso<S, A> {
+export function makeIso<S, A>(F: PIsoMin<S, S, A, A>): Iso<S, A> {
   return PIso(F);
 }

package/_src/optics/Lens/api.ts

@@ -6,23 +6,24 @@ import { Lens, PLens } from "@fncts/base/optics/Lens/definition";
 import { Prism } from "@fncts/base/optics/Prism";
 
 /**
- * @tsplus fluent fncts.optics.PLens component
+ * @tsplus pipeable fncts.optics.PLens component
  */
-export function component_<S, A extends ReadonlyArray<unknown>, P extends keyof A>(
-  self: Lens<S, A>,
-  component: P,
-): Lens<S, A[P]> {
-  return self.compose(Lens.getComponent<A>()(component));
+export function component<A extends ReadonlyArray<unknown>, P extends keyof A>(component: P) {
+  return <S>(self: Lens<S, A>): Lens<S, A[P]> => {
+    return self.compose(Lens.getComponent<A>()(component));
+  };
 }
 
 /**
- * @tsplus fluent fncts.optics.PLens compose
+ * @tsplus pipeable fncts.optics.PLens compose
  */
-export function compose_<S, T, A, B, C, D>(self: PLens<S, T, A, B>, that: PLens<A, B, C, D>): PLens<S, T, C, D> {
-  return PLens({
-    get: self.get.compose(that.get),
-    set_: (s, d) => self.modify_(s, that.set(d)),
-  });
+export function compose<A, B, C, D>(that: PLens<A, B, C, D>) {
+  return <S, T>(self: PLens<S, T, A, B>): PLens<S, T, C, D> => {
+    return PLens({
+      get: self.get.compose(that.get),
+      set: (d) => self.modify(that.set(d)),
+    });
+  };
 }
 
 /**
@@ -39,7 +40,7 @@ export function getComponent<A extends ReadonlyArray<unknown>>() {
   return <P extends keyof A>(component: P): Lens<A, A[P]> =>
     Lens({
       get: (s) => s[component],
-      set_: (s, ap) => {
+      set: (ap) => (s) => {
         if (ap === s[component]) {
           return s;
         }
@@ -57,7 +58,7 @@ export function getProp<A extends Record<string, any>>() {
   return <P extends keyof A>(prop: P): Lens<A, A[P]> =>
     Lens({
       get: (s) => s[prop],
-      set_: (s, ap) => {
+      set: (ap) => (s) => {
         if (ap === s[prop]) {
           return s;
         }
@@ -72,32 +73,35 @@ export function getProp<A extends Record<string, any>>() {
 export function id<S, A = S>(): PLens<S, A, S, A> {
   return PLens({
     get: identity,
-    set_: (_, t) => t,
+    set: (t) => () => t,
   });
 }
 
 /**
- * @tsplus fluent fncts.optics.PLensOps invmap
+ * @tsplus pipeable fncts.optics.PLensOps invmap
  */
-export function invmap_<S, A, B>(self: Lens<S, A>, f: (a: A) => B, g: (b: B) => A): Lens<S, B> {
-  return Lens({
-    get: self.get.compose(f),
-    set_: (s, b) => self.set_(s, g(b)),
-  });
+export function invmap_<A, B>(f: (a: A) => B, g: (b: B) => A) {
+  return <S>(self: Lens<S, A>): Lens<S, B> => {
+    return Lens({
+      get: self.get.compose(f),
+      set: (b) => self.set(g(b)),
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.optics.Lens prop
+ * @tsplus pipeable fncts.optics.Lens prop
  */
-export function prop_<S, A extends Record<string, any>, P extends keyof A>(self: Lens<S, A>, prop: P): Lens<S, A[P]> {
-  return self.compose(Lens.getProp<A>()(prop));
+export function prop<A extends Record<string, any>, P extends keyof A>(prop: P) {
+  return <S>(self: Lens<S, A>): Lens<S, A[P]> => {
+    return self.compose(Lens.getProp<A>()(prop));
+  };
 }
 
 function nestPath<A>(p: ReadonlyNonEmptyArray<string>, a: A): Record<string, unknown> {
   const out: Record<string, unknown> = {};
   let view = out;
   let last = "";
-
   for (let i = 0; i < p.length; i++) {
     const pi = p[i]!;
     view[pi] = {};
@@ -106,27 +110,25 @@ function nestPath<A>(p: ReadonlyNonEmptyArray<string>, a: A): Record<string, unk
     }
     last = pi;
   }
-
   view[last] = a;
   return out;
 }
 
 /**
- * @tsplus fluent fncts.optics.Lens path
+ * @tsplus pipeable fncts.optics.Lens path
  */
-export function path_<S, A extends Record<string, unknown>, P extends Array<string>>(
-  self: Lens<S, A>,
-  path: readonly [...AutoPath<A, P>],
-): Lens<S, Path<A, P>> {
-  return Lens({
-    get: (s) => path.foldLeft<string, Record<string, unknown>>(self.get(s), (b, p) => b[p] as A) as Path<A, P>,
-    set_: (s, a) => {
-      const os = self.get(s);
-      const oa = path.foldLeft(os, (b, p) => b[p as string] as A);
-      if (a === oa) {
-        return s;
-      }
-      return self.set_(s, Object.assign({}, os, path.isNonEmpty() ? nestPath(path, a) : a));
-    },
-  });
+export function path<A extends Record<string, unknown>, P extends Array<string>>(path: readonly [...AutoPath<A, P>]) {
+  return <S>(self: Lens<S, A>): Lens<S, Path<A, P>> => {
+    return Lens({
+      get: (s) => path.foldLeft<string, Record<string, unknown>>(self.get(s), (b, p) => b[p] as A) as Path<A, P>,
+      set: (a) => (s) => {
+        const os = self.get(s);
+        const oa = path.foldLeft(os, (b, p) => b[p as string] as A);
+        if (a === oa) {
+          return s;
+        }
+        return s.pipe(self.set(Object.assign({}, os, path.isNonEmpty() ? nestPath(path, a) : a)));
+      },
+    });
+  };
 }

package/_src/optics/Lens/definition.ts

@@ -1,5 +1,5 @@
 import type { get } from "@fncts/base/optics/Getter";
-import type { set_ } from "@fncts/base/optics/Setter";
+import type { set } from "@fncts/base/optics/Setter";
 
 import { Getter } from "@fncts/base/optics/Getter";
 import { POptional } from "@fncts/base/optics/Optional";
@@ -18,15 +18,15 @@ export const PLens: PLensOps = {};
 
 export interface PLensMin<S, T, A, B> {
   readonly get: get<S, A>;
-  readonly set_: set_<S, T, B>;
+  readonly set: set<S, T, B>;
 }
 
 /**
  * @tsplus static fncts.optics.PLensOps __call
  */
-export function mkPLens<S, T, A, B>(F: PLensMin<S, T, A, B>): PLens<S, T, A, B> {
+export function makePLens<S, T, A, B>(F: PLensMin<S, T, A, B>): PLens<S, T, A, B> {
   return {
-    ...POptional({ replace_: F.set_, getOrModify: (s) => Either.right(F.get(s)) }),
+    ...POptional({ set: F.set, getOrModify: (s) => Either.right(F.get(s)) }),
     ...Getter({ get: F.get }),
   };
 }
@@ -46,6 +46,6 @@ export const Lens: LensOps = {};
 /**
  * @tsplus static fncts.optics.LensOps __call
  */
-export function mkLens<S, A>(F: PLensMin<S, S, A, A>): Lens<S, A> {
+export function makeLens<S, A>(F: PLensMin<S, S, A, A>): Lens<S, A> {
   return PLens(F);
 }

package/_src/optics/Optional/api/compose.ts

@@ -2,14 +2,14 @@ import { identity } from "@fncts/base/data/function";
 import { POptional } from "@fncts/base/optics/Optional/definition";
 
 /**
- * @tsplus fluent fncts.optics.POptional compose 3
+ * @tsplus pipeable fncts.optics.POptional compose 3
  */
-export function compose_<S, T, A, B, C, D>(
-  self: POptional<S, T, A, B>,
-  that: POptional<A, B, C, D>,
-): POptional<S, T, C, D> {
-  return POptional({
-    getOrModify: (s) => self.getOrModify(s).flatMap((a) => that.getOrModify(a).bimap((b) => self.set_(s, b), identity)),
-    replace_: (s, d) => self.modify_(s, that.set(d)),
-  });
+export function compose<A, B, C, D>(that: POptional<A, B, C, D>) {
+  return <S, T>(self: POptional<S, T, A, B>): POptional<S, T, C, D> => {
+    return POptional({
+      getOrModify: (s) =>
+        self.getOrModify(s).flatMap((a) => that.getOrModify(a).bimap((b) => s.pipe(self.set(b)), identity)),
+      set: (d) => self.modify(that.set(d)),
+    });
+  };
 }

package/_src/optics/Optional/definition.ts

@@ -1,5 +1,6 @@
-import type { set_ } from "@fncts/base/optics/Setter";
+import type { set } from "@fncts/base/optics/Setter";
 
+import { pipe } from "@fncts/base/data/function";
 import { PTraversal } from "@fncts/base/optics/Traversal";
 
 /**
@@ -8,13 +9,12 @@ import { PTraversal } from "@fncts/base/optics/Traversal";
 export interface POptional<S, T, A, B> extends PTraversal<S, T, A, B> {
   readonly getMaybe: getMaybe<S, A>;
   readonly getOrModify: getOrModify<S, T, A>;
-  readonly modifyMaybe_: modifyMaybe_<S, T, A, B>;
   readonly modifyMaybe: modifyMaybe<S, T, A, B>;
 }
 
 export interface POptionalMin<S, T, A, B> {
   readonly getOrModify: getOrModify<S, T, A>;
-  readonly replace_: set_<S, T, B>;
+  readonly set: set<S, T, B>;
 }
 
 /**
@@ -27,20 +27,17 @@ export const POptional: POptionalOps = {};
 /**
  * @tsplus static fncts.optics.POptionalOps __call
  */
-export function mkPOptional<S, T, A, B>(F: POptionalMin<S, T, A, B>): POptional<S, T, A, B> {
-  const getMaybe: getMaybe<S, A>               = (s) => F.getOrModify(s).getRight;
-  const modifyMaybe_: modifyMaybe_<S, T, A, B> = (s, f) => getMaybe(s).map((a) => F.replace_(s, f(a)));
-
+export function makePOptional<S, T, A, B>(F: POptionalMin<S, T, A, B>): POptional<S, T, A, B> {
+  const getMaybe: getMaybe<S, A> = (s) => F.getOrModify(s).getRight;
   return {
     getOrModify: F.getOrModify,
     getMaybe,
-    modifyMaybe_,
-    modifyMaybe: (f) => (s) => modifyMaybe_(s, f),
+    modifyMaybe: (f) => (s) => getMaybe(s).map((a) => pipe(s, F.set(f(a)))),
     ...PTraversal<S, T, A, B>({
-      modifyA: (A) => (s, f) =>
+      modifyA: (A) => (f) => (s) =>
         F.getOrModify(s).match(
           (t) => A.pure(t),
-          (a) => A.map(f(a), (b) => F.replace_(s, b)),
+          (a) => f(a).pipe(A.map((b) => s.pipe(F.set(b)))),
         ),
     }),
   };
@@ -61,7 +58,7 @@ export const Optional: OptionalOps = {};
 /**
  * @tsplus static fncts.optics.OptionalOps __call
  */
-export function mkOptional<S, A>(F: POptionalMin<S, S, A, A>): Optional<S, A> {
+export function makeOptional<S, A>(F: POptionalMin<S, S, A, A>): Optional<S, A> {
   return POptional(F);
 }
 
@@ -73,10 +70,6 @@ export interface getOrModify<S, T, A> {
   (s: S): Either<T, A>;
 }
 
-export interface modifyMaybe_<S, T, A, B> {
-  (s: S, f: (a: A) => B): Maybe<T>;
-}
-
 export interface modifyMaybe<S, T, A, B> {
   (f: (a: A) => B): (s: S) => Maybe<T>;
 }

package/_src/optics/Optional.ts

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

package/_src/optics/Prism/api/compose.ts

@@ -2,11 +2,14 @@ import { identity } from "@fncts/base/data/function";
 import { PPrism } from "@fncts/base/optics/Prism/definition";
 
 /**
- * @tsplus fluent fncts.optics.PPrism compose
+ * @tsplus pipeable fncts.optics.PPrism compose
  */
-export function compose_<S, T, A, B, C, D>(self: PPrism<S, T, A, B>, that: PPrism<A, B, C, D>): PPrism<S, T, C, D> {
-  return PPrism({
-    getOrModify: (s) => self.getOrModify(s).flatMap((a) => that.getOrModify(a).bimap((b) => self.set_(s, b), identity)),
-    reverseGet: that.reverseGet.compose(self.reverseGet),
-  });
+export function compose<A, B, C, D>(that: PPrism<A, B, C, D>) {
+  return <S, T>(self: PPrism<S, T, A, B>): PPrism<S, T, C, D> => {
+    return PPrism({
+      getOrModify: (s) =>
+        self.getOrModify(s).flatMap((a) => that.getOrModify(a).bimap((b) => s.pipe(self.set(b)), identity)),
+      reverseGet: that.reverseGet.compose(self.reverseGet),
+    });
+  };
 }

package/_src/optics/Prism/definition.ts

@@ -25,12 +25,12 @@ export interface PPrismMin<S, T, A, B> {
 /**
  * @tsplus static fncts.optics.PPrismOps __call
  */
-export function mkPPrism<S, T, A, B>(F: PPrismMin<S, T, A, B>): PPrism<S, T, A, B> {
+export function makePPrism<S, T, A, B>(F: PPrismMin<S, T, A, B>): PPrism<S, T, A, B> {
   return {
     reverseGet: F.reverseGet,
     ...POptional({
       getOrModify: F.getOrModify,
-      replace_: (s, b) => F.getOrModify(s).match(identity, () => F.reverseGet(b)),
+      set: (b) => (s) => F.getOrModify(s).match(identity, () => F.reverseGet(b)),
     }),
   };
 }
@@ -50,7 +50,7 @@ export const Prism: PrismOps = {};
 /**
  * @tsplus static fncts.optics.PrismOps __call
  */
-export function mkPrism<S, A>(F: PPrismMin<S, S, A, A>): Prism<S, A> {
+export function makePrism<S, A>(F: PPrismMin<S, S, A, A>): Prism<S, A> {
   return PPrism(F);
 }
 

package/_src/optics/Prism.ts

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

package/_src/optics/Setter/definition.ts

@@ -2,17 +2,10 @@
  * @tsplus type fncts.optics.PSetter
  */
 export interface PSetter<S, T, A, B> {
-  readonly modify_: modify_<S, T, A, B>;
   readonly modify: modify<S, T, A, B>;
-  readonly set_: set_<S, T, B>;
   readonly set: set<S, T, B>;
 }
 
-export interface PSetterMin<S, T, A, B> {
-  readonly modify_: modify_<S, T, A, B>;
-  readonly set_: set_<S, T, B>;
-}
-
 /**
  * @tsplus type fncts.optics.PSetterOps
  */
@@ -23,13 +16,8 @@ export const PSetter: PSetterOps = {};
 /**
  * @tsplus static fncts.optics.PSetterOps __call
  */
-export function mkPSetter<S, T, A, B>(F: PSetterMin<S, T, A, B>): PSetter<S, T, A, B> {
-  return {
-    modify_: F.modify_,
-    modify: (f) => (s) => F.modify_(s, f),
-    set_: F.set_,
-    set: (b) => (s) => F.set_(s, b),
-  };
+export function makePSetter<S, T, A, B>(F: PSetter<S, T, A, B>): PSetter<S, T, A, B> {
+  return F;
 }
 
 /**
@@ -45,22 +33,14 @@ export interface SetterOps extends PSetterOps {}
 /**
  * @tsplus static fncts.optics.SetterOps __call
  */
-export function mkSetter<S, A>(F: PSetterMin<S, S, A, A>): Setter<S, A> {
+export function makeSetter<S, A>(F: PSetter<S, S, A, A>): Setter<S, A> {
   return PSetter(F);
 }
 
-export interface modify_<S, T, A, B> {
-  (s: S, f: (a: A) => B): T;
-}
-
 export interface modify<S, T, A, B> {
   (f: (a: A) => B): (s: S) => T;
 }
 
-export interface set_<S, T, B> {
-  (s: S, b: B): T;
-}
-
 export interface set<S, T, B> {
   (b: B): (s: S) => T;
 }

package/_src/optics/Traversal/api/compose.ts

@@ -1,13 +1,12 @@
 import { PTraversal } from "@fncts/base/optics/Traversal/definition";
 
 /**
- * @tsplus fluent fncts.optics.PTraversal compose 4
+ * @tsplus pipeable fncts.optics.PTraversal compose 4
  */
-export function compose_<S, T, A, B, C, D>(
-  self: PTraversal<S, T, A, B>,
-  that: PTraversal<A, B, C, D>,
-): PTraversal<S, T, C, D> {
-  return PTraversal<S, T, C, D>({
-    modifyA: (F) => (s, f) => self.modifyA(F)(s, (a) => that.modifyA(F)(a, f)),
-  });
+export function compose<A, B, C, D>(that: PTraversal<A, B, C, D>) {
+  return <S, T>(self: PTraversal<S, T, A, B>): PTraversal<S, T, C, D> => {
+    return PTraversal<S, T, C, D>({
+      modifyA: (F) => (f) => self.modifyA(F)(that.modifyA(F)(f)),
+    });
+  };
 }

package/_src/optics/Traversal/api/fromTraversable.ts

@@ -19,6 +19,6 @@ export function fromTraversable<F extends HKT, FC = HKT.None>(T: P.Traversable<F
     E = HKT.Low<F, "E">,
   >() =>
     PTraversal<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>, A, B>({
-      modifyA: (F) => (s, f) => T.traverse(s)(F)(f),
+      modifyA: T.traverse,
     });
 }