@fncts/base 0.0.19 → 0.0.21

package/data/Tag/definition.d.ts

@@ -12,7 +12,6 @@ export declare class Tag<in out T> implements Hashable, Equatable {
     readonly id: string;
     _T: (_: T) => T;
     readonly _typeId: TagTypeId;
-    private static counter;
     constructor(id: string);
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;

package/data/These/api.d.ts

@@ -18,56 +18,52 @@ export declare function isRight<E, A>(self: These<E, A>): self is Right<A>;
  */
 export declare function isBoth<E, A>(self: These<E, A>): self is Both<E, A>;
 /**
- * @tsplus fluent fncts.These map
+ * @tsplus pipeable fncts.These map
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function map<E, A, B>(self: These<E, A>, f: (a: A) => B): These<E, B>;
+export declare function map<A, B>(f: (a: A) => B): <E>(self: import("@fncts/base/data/These/definition").These<E, A>) => import("@fncts/base/data/These/definition").These<E, B>;
 /**
- * @tsplus fluent fncts.These mapLeft
+ * @tsplus pipeable fncts.These mapLeft
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function mapLeft<E, A, E1>(self: These<E, A>, f: (e: E) => E1): These<E1, A>;
+export declare function mapLeft<E, E1>(f: (e: E) => E1): <A>(self: import("@fncts/base/data/These/definition").These<E, A>) => import("@fncts/base/data/These/definition").These<E1, A>;
 /**
- * @tsplus fluent fncts.These bimap
+ * @tsplus pipeable fncts.These bimap
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function bimap<E, A, E1, B>(self: These<E, A>, f: (e: E) => E1, g: (a: A) => B): These<E1, B>;
+export declare function bimap<E, A, E1, B>(f: (e: E) => E1, g: (a: A) => B): (self: These<E, A>) => These<E1, B>;
 /**
- * @tsplus fluent fncts.These zipWith
+ * @tsplus pipeable fncts.These zipWith
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function zipWith<E, A, B, C>(self: These<E, A>, that: These<E, B>, f: (a: A, b: B) => C, 
-/** @tsplus auto */ S: P.Semigroup<E>): These<E, C>;
+export declare function zipWith<E, A, B, C>(that: These<E, B>, f: (a: A, b: B) => C, /** @tsplus auto */ S: P.Semigroup<E>): (self: These<E, A>) => These<E, C>;
 /**
- * @tsplus fluent fncts.These zip
+ * @tsplus pipeable fncts.These zip
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function zip<E, A, B>(self: These<E, A>, that: These<E, B>, 
-/** @tsplus auto */ S: P.Semigroup<E>): These<E, readonly [A, B]>;
+export declare function zip<E, B>(that: These<E, B>, /** @tsplus auto */ S: P.Semigroup<E>): <A>(self: import("@fncts/base/data/These/definition").These<E, A>) => import("@fncts/base/data/These/definition").These<E, readonly [A, B]>;
 /**
- * @tsplus fluent fncts.These ap
+ * @tsplus pipeable fncts.These ap
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function ap<E, A, B>(self: These<E, (a: A) => B>, that: These<E, A>, 
-/** @tsplus auto */ S: P.Semigroup<E>): These<E, B>;
+export declare function ap<E, A>(that: These<E, A>, /** @tsplus auto */ S: P.Semigroup<E>): <B>(self: import("@fncts/base/data/These/definition").These<E, (a: A) => B>) => import("@fncts/base/data/These/definition").These<E, B>;
 /**
- * @tsplus fluent fncts.These flatMap
+ * @tsplus pipeable fncts.These flatMap
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function flatMap<E, A, B>(self: These<E, A>, f: (a: A) => These<E, B>, 
-/** @tsplus auto */ S: P.Semigroup<E>): These<E, B>;
+export declare function flatMap<E, A, B>(f: (a: A) => These<E, B>, /** @tsplus auto */ S: P.Semigroup<E>): (self: These<E, A>) => These<E, B>;
 /**
- * @tsplus fluent fncts.These catchAll
+ * @tsplus pipeable fncts.These catchAll
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function catchAll_<E, A, B>(self: These<E, A>, f: (e: E) => These<E, B>): These<E, A | B>;
+export declare function catchAll<E, B>(f: (e: E) => These<E, B>): <A>(self: import("@fncts/base/data/These/definition").These<E, A>) => import("@fncts/base/data/These/definition").These<E, B | A>;
 /**
  * @tsplus getter fncts.These condemn
  * @tsplus location "@fncts/base/data/These/api"
  */
 export declare function condemn<E, A>(self: These<E, A>): These<E, A>;
 /**
- * @tsplus fluent fncts.These condemnWhen
+ * @tsplus pipeable fncts.These condemnWhen
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function condemnWhen<E, A>(self: These<E, A>, p: Predicate<E>): These<E, A>;
+export declare function condemnWhen<E>(p: Predicate<E>): <A>(self: import("@fncts/base/data/These/definition").These<E, A>) => import("@fncts/base/data/These/definition").These<E, A>;

package/data/These/destructors.d.ts

@@ -21,12 +21,12 @@ export declare function rightMaybe<E, A>(self: These<E, A>): Maybe<A>;
  */
 export declare function leftMaybe<E, A>(self: These<E, A>): Maybe<E>;
 /**
- * @tsplus fluent fncts.These match
+ * @tsplus pipeable fncts.These match
  * @tsplus location "@fncts/base/data/These/destructors"
  */
-export declare function match_<E, A, B, C, D>(self: These<E, A>, left: (e: E) => B, right: (a: A) => C, both: (e: E, a: A) => D): B | C | D;
+export declare function match<E, A, B, C, D>(left: (e: E) => B, right: (a: A) => C, both: (e: E, a: A) => D): (self: These<E, A>) => B | C | D;
 /**
- * @tsplus fluent fncts.These match2
+ * @tsplus pipeable fncts.These match2
  * @tsplus location "@fncts/base/data/These/destructors"
  */
-export declare function match2<E, A, B, C>(self: These<E, A>, left: (e: E) => B, right: (e: Maybe<E>, a: A) => C): B | C;
+export declare function match2<E, A, B, C>(left: (e: E) => B, right: (e: Maybe<E>, a: A) => C): (self: These<E, A>) => B | C;

package/data/Trace/api.d.ts

@@ -1,10 +1,10 @@
 import { Trace } from "@fncts/base/data/Trace/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 /**
- * @tsplus fluent fncts.Trace combine
+ * @tsplus pipeable fncts.Trace combine
  * @tsplus location "@fncts/base/data/Trace/api"
  */
-export declare function combine_(self: Trace, that: Trace): Trace;
+export declare function combine(that: Trace): (self: Trace) => Trace;
 /**
  * @tsplus getter fncts.Trace toJS
  * @tsplus location "@fncts/base/data/Trace/api"

package/data/function/api.d.ts

@@ -1,8 +1,8 @@
 /**
- * @tsplus fluent fncts.Function compose
+ * @tsplus pipeable fncts.Function compose
  * @tsplus location "@fncts/base/data/function/api"
  */
-export declare function compose_<A extends ReadonlyArray<any>, B, C>(f: (...params: A) => B, g: (b: B) => C): (...params: A) => C;
+export declare function compose<B, C>(g: (b: B) => C): <A extends readonly any[]>(f: (...params: A) => B) => (...params: A) => C;
 /**
  * @tsplus static fncts.FunctionOps constVoid
  * @tsplus location "@fncts/base/data/function/api"
@@ -30,4 +30,4 @@ export declare function tupled<A, B, C>(f: (a: A, b: B) => C): (_: readonly [A,
  * @tsplus macro identity
  * @tsplus location "@fncts/base/data/function/api"
  */
-export declare function unsafeCoerce<A, B>(a: A): B;
+export declare function unsafeCoerce<B, A = unknown>(a: A): B;

package/data/function/pipe.d.ts

@@ -1,6 +1,12 @@
 /**
  * @tsplus macro pipe
- * @tsplus fluent fncts.global via
+ * @tsplus operator fncts.global >>
+ * @tsplus location "@fncts/base/data/function/pipe"
+ */
+export declare function pipeOperator<A, B>(a: A, f: (a: A) => B): B;
+/**
+ * @tsplus macro pipe
+ * @tsplus fluent global pipe
  * @tsplus location "@fncts/base/data/function/pipe"
  */
 export declare function pipe<A>(a: A): A;

package/data/string/api.d.ts

@@ -37,18 +37,11 @@ export declare function reverse(s: string): string;
 /**
  * Surround a string. Equivalent to calling `prepend` and `append` with the
  * same outer value.
- * @tsplus fluent fncts.String surround
- * @tsplus location "@fncts/base/data/string/api"
- */
-export declare function surround_(s: string, x: string): string;
-/**
- * Surround a string. Equivalent to calling `prepend` and `append` with the
- * same outer value.
- * @tsplus static fncts.StringOps surround
  * @tsplus pipeable fncts.String surround
+ * @tsplus static fncts.StringOps surround
  * @tsplus location "@fncts/base/data/string/api"
  */
-export declare const surround: (x: string) => (s: string) => string;
+export declare function surround(x: string): (s: string) => string;
 /**
  * Keep the specified number of characters from the start of a string.
  *
@@ -58,16 +51,10 @@ export declare const surround: (x: string) => (s: string) => string;
  * If `n` is not a positive number, an empty string will be returned.
  *
  * If `n` is a float, it will be rounded down to the nearest integer.
- * @tsplus fluent fncts.String take
- * @tsplus location "@fncts/base/data/string/api"
- */
-export declare function take_(s: string, n: number): string;
-/**
- * @tsplus static fncts.StringOps take
  * @tsplus pipeable fncts.String take
  * @tsplus location "@fncts/base/data/string/api"
  */
-export declare const take: (n: number) => (s: string) => string;
+export declare function take(n: number): (s: string) => string;
 /**
  * Keep the specified number of characters from the end of a string.
  *
@@ -77,69 +64,42 @@ export declare const take: (n: number) => (s: string) => string;
  * If `n` is not a positive number, an empty string will be returned.
  *
  * If `n` is a float, it will be rounded down to the nearest integer.
- * @tsplus fluent fncts.String takeLast
- * @tsplus location "@fncts/base/data/string/api"
- */
-export declare function takeLast_(s: string, n: number): string;
-/**
- * @tsplus static fncts.StringOps takeLast
  * @tsplus pipeable fncts.String takeLast
  * @tsplus location "@fncts/base/data/string/api"
  */
-export declare const takeLast: (n: number) => (s: string) => string;
+export declare function takeLast(n: number): (s: string) => string;
 /**
  * Removes the given string from the beginning, if it exists
- * @tsplus fluent fncts.String unprepend
- * @tsplus location "@fncts/base/data/string/api"
- */
-export declare function unprepend_(s: string, s1: string): string;
-/**
- * @tsplus static fncts.StringOps unprepend
  * @tsplus pipeable fncts.String unprepend
  * @tsplus location "@fncts/base/data/string/api"
  */
-export declare const unprepend: (s1: string) => (s: string) => string;
+export declare function unprepend(s1: string): (s: string) => string;
 /**
  * Remove the end of a string, if it exists.
- * @tsplus fluent fncts.String unappend
- * @tsplus location "@fncts/base/data/string/api"
- */
-export declare function unappend_(s: string, x: string): string;
-/**
  * @tsplus static fncts.StringOps unappend
  * @tsplus pipeable fncts.String unappend
  * @tsplus location "@fncts/base/data/string/api"
  */
-export declare const unappend: (x: string) => (s: string) => string;
+export declare function unappend(x: string): (s: string) => string;
 /**
  * Remove the start and end of a string, if they both exist.
- * @tsplus fluent fncts.String unsurround
- * @tsplus location "@fncts/base/data/string/api"
- */
-export declare function unsurround_(s: string, x: string): string;
-/**
  * @tsplus static fncts.StringOps unsurround
  * @tsplus pipeable fncts.String unsurround
  * @tsplus location "@fncts/base/data/string/api"
  */
-export declare const unsurround: (x: string) => (s: string) => string;
+export declare function unsurround(x: string): (s: string) => string;
 /**
  * Apply an endomorphism upon an array of characters against a string.
  * This is useful as it allows you to run many polymorphic functions targeting
  * arrays against strings without having to rewrite them.
- * @tsplus fluent fncts.String under
- * @tsplus location "@fncts/base/data/string/api"
- */
-export declare function under_(s: string, f: (chars: Array<string>) => Array<string>): string;
-/**
  * @tsplus static fncts.StringOps under
  * @tsplus pipeable fncts.String under
  * @tsplus location "@fncts/base/data/string/api"
  */
-export declare const under: (f: (chars: Array<string>) => Array<string>) => (s: string) => string;
+export declare function under(f: (chars: Array<string>) => Array<string>): (s: string) => string;
 /**
  * Join newline-separated strings together.
- * @tsplus getter fncts.ImmutableArray unlines
+ * @tsplus getter fncts.ReadonlyArray unlines
  * @tsplus location "@fncts/base/data/string/api"
  */
 export declare function unlines(as: ReadonlyArray<string>): string;

package/data.d.ts

@@ -9,7 +9,9 @@ export type {} from "./data/DecodeError.js";
 export type {} from "./data/Decoder.js";
 export type {} from "./data/Duration.js";
 export type {} from "./data/Either.js";
+export type {} from "./data/Encoder.js";
 export type {} from "./data/Environment.js";
+export type {} from "./data/EnvironmentPatch.js";
 export type {} from "./data/exceptions.js";
 export type {} from "./data/ExecutionStrategy.js";
 export type {} from "./data/Exit.js";
@@ -22,7 +24,6 @@ export type {} from "./data/Maybe.js";
 export type {} from "./data/Newtype.js";
 export type {} from "./data/number.js";
 export type {} from "./data/object.js";
-export type {} from "./data/Patch.js";
 export type {} from "./data/Predicate.js";
 export type {} from "./data/Refinement.js";
 export type {} from "./data/string.js";

package/global/api.d.ts

@@ -1,8 +1,8 @@
 import { Refinement } from "@fncts/base/data/Refinement/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
 /**
- * @tsplus fluent global if
+ * @tsplus pipeable global if
  * @tsplus location "@fncts/base/global/api"
  */
-export declare function matchPredicate<A, B extends A, C, D>(self: A, predicate: Refinement<A, B>, onFalse: (a: A) => C, onTrue: (a: B) => D): C | D;
-export declare function matchPredicate<A, B, C>(self: A, predicate: Predicate<A>, onFalse: (a: A) => B, onTrue: (a: A) => C): B | C;
+export declare function matchPredicate<A, B extends A, C, D>(predicate: Refinement<A, B>, onFalse: (a: A) => C, onTrue: (a: B) => D): (self: A) => C | D;
+export declare function matchPredicate<A, B, C>(predicate: Predicate<A>, onFalse: (a: A) => B, onTrue: (a: A) => C): (self: A) => B | C;

package/global.d.ts

@@ -114,10 +114,18 @@ import { Duration } from "@fncts/base/data/Duration/definition";
  * @tsplus global
  */
 import { Either } from "@fncts/base/data/Either/definition";
+/**
+ * @tsplus global
+ */
+import { Encoder } from "@fncts/base/data/Encoder/definition";
 /**
  * @tsplus global
  */
 import { Environment } from "@fncts/base/data/Environment/definition";
+/**
+ * @tsplus global
+ */
+import { EnvironmentPatch } from "@fncts/base/data/EnvironmentPatch";
 /**
  * @tsplus global
  */

package/internal/Stack.d.ts

@@ -20,7 +20,7 @@ interface Node<A> {
  * @tsplus static fncts.StackOps __call
  * @tsplus location "@fncts/base/internal/Stack"
  */
-export declare function mkStack<A>(): Stack<A>;
+export declare function makeStack<A>(): Stack<A>;
 /**
  * @tsplus static fncts.StackOps single
  * @tsplus location "@fncts/base/internal/Stack"

package/optics/At/definition.d.ts

@@ -7,7 +7,7 @@ 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 set: (i: I) => (a: A) => (s: S) => S;
 } | At<S, I, A>;
 /**
  * @tsplus type fncts.optics.AtOps

package/optics/Fold/definition.d.ts

@@ -1,7 +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;
 }
@@ -9,7 +6,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>;
 }
 /**
@@ -19,10 +15,10 @@ export interface FoldOps {
 }
 export declare const Fold: FoldOps;
 export interface FoldMin<S, A> {
-    readonly foldMap_: foldMap_<S, A>;
+    readonly foldMap: foldMap<S, A>;
 }
 /**
  * @tsplus static fncts.optics.FoldOps __call
  * @tsplus location "@fncts/base/optics/Fold/definition"
  */
-export declare function mkFold<S, A>(F: FoldMin<S, A>): Fold<S, A>;
+export declare function makeFold<S, A>(F: FoldMin<S, A>): Fold<S, A>;

package/optics/Getter/definition.d.ts

@@ -21,4 +21,4 @@ export interface GetterMin<S, A> {
  * @tsplus static fncts.optics.GetterOps __call
  * @tsplus location "@fncts/base/optics/Getter/definition"
  */
-export declare function mkGetter<S, A>(F: GetterMin<S, A>): Getter<S, A>;
+export declare function makeGetter<S, A>(F: GetterMin<S, A>): Getter<S, A>;

package/optics/Index/definition.d.ts

@@ -16,4 +16,4 @@ export declare const Index: IndexOps;
  * @tsplus static fncts.optics.IndexOps __call
  * @tsplus location "@fncts/base/optics/Index/definition"
  */
-export declare function mkIndex<S, I, A>(F: IndexMin<S, I, A>): Index<S, I, A>;
+export declare function makeIndex<S, I, A>(F: IndexMin<S, I, A>): Index<S, I, A>;

package/optics/Iso/api.d.ts

@@ -1,6 +1,6 @@
 import { PIso } from "@fncts/base/optics/Iso/definition";
 /**
- * @tsplus fluent fncts.optics.PIso compose
+ * @tsplus pipeable fncts.optics.PIso compose
  * @tsplus location "@fncts/base/optics/Iso/api"
  */
-export declare 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>;
+export declare function compose<A, B, C, D>(that: PIso<A, B, C, D>): <S, T>(self: PIso<S, T, A, B>) => PIso<S, T, C, D>;

package/optics/Iso/definition.d.ts

@@ -22,7 +22,7 @@ export interface PIsoMin<S, T, A, B> {
  * @tsplus static fncts.optics.PIsoOps __call
  * @tsplus location "@fncts/base/optics/Iso/definition"
  */
-export declare function mkPIso<S, T, A, B>(F: PIsoMin<S, T, A, B>): PIso<S, T, A, B>;
+export declare function makePIso<S, T, A, B>(F: PIsoMin<S, T, A, B>): PIso<S, T, A, B>;
 /**
  * @tsplus type fncts.optics.Iso
  */
@@ -37,4 +37,4 @@ export interface IsoOps {
  * @tsplus static fncts.optics.IsoOps __call
  * @tsplus location "@fncts/base/optics/Iso/definition"
  */
-export declare function mkIso<S, A>(F: PIsoMin<S, S, A, A>): Iso<S, A>;
+export declare function makeIso<S, A>(F: PIsoMin<S, S, A, A>): Iso<S, A>;

package/optics/Lens/api.d.ts

@@ -3,15 +3,15 @@ import type { Optional } from "@fncts/base/optics/Optional";
 import type { AutoPath, Path } from "@fncts/typelevel/Object";
 import { Lens, PLens } from "@fncts/base/optics/Lens/definition";
 /**
- * @tsplus fluent fncts.optics.PLens component
+ * @tsplus pipeable fncts.optics.PLens component
  * @tsplus location "@fncts/base/optics/Lens/api"
  */
-export declare function component_<S, A extends ReadonlyArray<unknown>, P extends keyof A>(self: Lens<S, A>, component: P): Lens<S, A[P]>;
+export declare function component<A extends ReadonlyArray<unknown>, P extends keyof A>(component: P): <S>(self: Lens<S, A>) => Lens<S, A[P]>;
 /**
- * @tsplus fluent fncts.optics.PLens compose
+ * @tsplus pipeable fncts.optics.PLens compose
  * @tsplus location "@fncts/base/optics/Lens/api"
  */
-export declare 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>;
+export declare function compose<A, B, C, D>(that: PLens<A, B, C, D>): <S, T>(self: PLens<S, T, A, B>) => PLens<S, T, C, D>;
 /**
  * @tsplus static fncts.optics.PLensOps fromNullable
  * @tsplus location "@fncts/base/optics/Lens/api"
@@ -33,17 +33,17 @@ export declare function getProp<A extends Record<string, any>>(): <P extends key
  */
 export declare function id<S, A = S>(): PLens<S, A, S, A>;
 /**
- * @tsplus fluent fncts.optics.PLensOps invmap
+ * @tsplus pipeable fncts.optics.PLensOps invmap
  * @tsplus location "@fncts/base/optics/Lens/api"
  */
-export declare function invmap_<S, A, B>(self: Lens<S, A>, f: (a: A) => B, g: (b: B) => A): Lens<S, B>;
+export declare function invmap_<A, B>(f: (a: A) => B, g: (b: B) => A): <S>(self: Lens<S, A>) => Lens<S, B>;
 /**
- * @tsplus fluent fncts.optics.Lens prop
+ * @tsplus pipeable fncts.optics.Lens prop
  * @tsplus location "@fncts/base/optics/Lens/api"
  */
-export declare function prop_<S, A extends Record<string, any>, P extends keyof A>(self: Lens<S, A>, prop: P): Lens<S, A[P]>;
+export declare function prop<A extends Record<string, any>, P extends keyof A>(prop: P): <S>(self: Lens<S, A>) => Lens<S, A[P]>;
 /**
- * @tsplus fluent fncts.optics.Lens path
+ * @tsplus pipeable fncts.optics.Lens path
  * @tsplus location "@fncts/base/optics/Lens/api"
  */
-export declare 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>>;
+export declare function path<A extends Record<string, unknown>, P extends Array<string>>(path: readonly [...AutoPath<A, P>]): <S>(self: Lens<S, A>) => Lens<S, Path<A, P>>;

package/optics/Lens/definition.d.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";
 /**
@@ -15,13 +15,13 @@ export interface PLensOps {
 export declare 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
  * @tsplus location "@fncts/base/optics/Lens/definition"
  */
-export declare function mkPLens<S, T, A, B>(F: PLensMin<S, T, A, B>): PLens<S, T, A, B>;
+export declare function makePLens<S, T, A, B>(F: PLensMin<S, T, A, B>): PLens<S, T, A, B>;
 /**
  * @tsplus type fncts.optics.Lens
  */
@@ -37,4 +37,4 @@ export declare const Lens: LensOps;
  * @tsplus static fncts.optics.LensOps __call
  * @tsplus location "@fncts/base/optics/Lens/definition"
  */
-export declare function mkLens<S, A>(F: PLensMin<S, S, A, A>): Lens<S, A>;
+export declare function makeLens<S, A>(F: PLensMin<S, S, A, A>): Lens<S, A>;

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

@@ -1,6 +1,6 @@
 import { POptional } from "@fncts/base/optics/Optional/definition";
 /**
- * @tsplus fluent fncts.optics.POptional compose 3
+ * @tsplus pipeable fncts.optics.POptional compose 3
  * @tsplus location "@fncts/base/optics/Optional/api/compose"
  */
-export declare 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>;
+export declare function compose<A, B, C, D>(that: POptional<A, B, C, D>): <S, T>(self: POptional<S, T, A, B>) => POptional<S, T, C, D>;

package/optics/Optional/definition.d.ts

@@ -1,6 +1,6 @@
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Either } from "@fncts/base/data/Either/definition";
-import type { set_ } from "@fncts/base/optics/Setter";
+import type { set } from "@fncts/base/optics/Setter";
 import { PTraversal } from "@fncts/base/optics/Traversal";
 /**
  * @tsplus type fncts.optics.POptional
@@ -8,12 +8,11 @@ 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>;
 }
 /**
  * @tsplus type fncts.optics.POptionalOps
@@ -25,7 +24,7 @@ export declare const POptional: POptionalOps;
  * @tsplus static fncts.optics.POptionalOps __call
  * @tsplus location "@fncts/base/optics/Optional/definition"
  */
-export declare function mkPOptional<S, T, A, B>(F: POptionalMin<S, T, A, B>): POptional<S, T, A, B>;
+export declare function makePOptional<S, T, A, B>(F: POptionalMin<S, T, A, B>): POptional<S, T, A, B>;
 /**
  * @tsplus type fncts.optics.Optional
  */
@@ -41,16 +40,13 @@ export declare const Optional: OptionalOps;
  * @tsplus static fncts.optics.OptionalOps __call
  * @tsplus location "@fncts/base/optics/Optional/definition"
  */
-export declare function mkOptional<S, A>(F: POptionalMin<S, S, A, A>): Optional<S, A>;
+export declare function makeOptional<S, A>(F: POptionalMin<S, S, A, A>): Optional<S, A>;
 export interface getMaybe<S, A> {
     (s: S): Maybe<A>;
 }
 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/optics/Prism/api/compose.d.ts

@@ -1,6 +1,6 @@
 import { PPrism } from "@fncts/base/optics/Prism/definition";
 /**
- * @tsplus fluent fncts.optics.PPrism compose
+ * @tsplus pipeable fncts.optics.PPrism compose
  * @tsplus location "@fncts/base/optics/Prism/api/compose"
  */
-export declare 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>;
+export declare function compose<A, B, C, D>(that: PPrism<A, B, C, D>): <S, T>(self: PPrism<S, T, A, B>) => PPrism<S, T, C, D>;

package/optics/Prism/definition.d.ts

@@ -20,7 +20,7 @@ export interface PPrismMin<S, T, A, B> {
  * @tsplus static fncts.optics.PPrismOps __call
  * @tsplus location "@fncts/base/optics/Prism/definition"
  */
-export declare function mkPPrism<S, T, A, B>(F: PPrismMin<S, T, A, B>): PPrism<S, T, A, B>;
+export declare function makePPrism<S, T, A, B>(F: PPrismMin<S, T, A, B>): PPrism<S, T, A, B>;
 /**
  * @tsplus type fncts.optics.Prism
  */
@@ -36,7 +36,7 @@ export declare const Prism: PrismOps;
  * @tsplus static fncts.optics.PrismOps __call
  * @tsplus location "@fncts/base/optics/Prism/definition"
  */
-export declare function mkPrism<S, A>(F: PPrismMin<S, S, A, A>): Prism<S, A>;
+export declare function makePrism<S, A>(F: PPrismMin<S, S, A, A>): Prism<S, A>;
 export interface reverseGet<T, B> {
     (b: B): T;
 }

package/optics/Setter/definition.d.ts

@@ -2,15 +2,9 @@
  * @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
  */
@@ -21,7 +15,7 @@ export declare const PSetter: PSetterOps;
  * @tsplus static fncts.optics.PSetterOps __call
  * @tsplus location "@fncts/base/optics/Setter/definition"
  */
-export declare function mkPSetter<S, T, A, B>(F: PSetterMin<S, T, A, B>): PSetter<S, T, A, B>;
+export declare function makePSetter<S, T, A, B>(F: PSetter<S, T, A, B>): PSetter<S, T, A, B>;
 /**
  * @tsplus type fncts.optics.Setter
  */
@@ -36,16 +30,10 @@ export interface SetterOps extends PSetterOps {
  * @tsplus static fncts.optics.SetterOps __call
  * @tsplus location "@fncts/base/optics/Setter/definition"
  */
-export declare function mkSetter<S, A>(F: PSetterMin<S, S, A, A>): Setter<S, A>;
-export interface modify_<S, T, A, B> {
-    (s: S, f: (a: A) => B): T;
-}
+export declare function makeSetter<S, A>(F: PSetter<S, S, A, A>): Setter<S, A>;
 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/optics/Traversal/api/compose.d.ts

@@ -1,6 +1,6 @@
 import { PTraversal } from "@fncts/base/optics/Traversal/definition";
 /**
- * @tsplus fluent fncts.optics.PTraversal compose 4
+ * @tsplus pipeable fncts.optics.PTraversal compose 4
  * @tsplus location "@fncts/base/optics/Traversal/api/compose"
  */
-export declare 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>;
+export declare function compose<A, B, C, D>(that: PTraversal<A, B, C, D>): <S, T>(self: PTraversal<S, T, A, B>) => PTraversal<S, T, C, D>;