@fncts/base 0.0.20 → 0.0.21

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,6 +9,7 @@ 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";

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,6 +114,10 @@ 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
  */

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>;

package/optics/Traversal/definition.d.ts

@@ -6,10 +6,10 @@ import { PSetter } from "@fncts/base/optics/Setter";
  * @tsplus type fncts.optics.PTraversal
  */
 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>;
+    modifyA: <F extends HKT, FC = HKT.None>(F: Applicative<F, FC>) => <K, Q, W, X, I, _S, R, E>(f: (a: A) => HKT.Kind<F, FC, K, Q, W, X, I, _S, R, E, B>) => (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>;
+    modifyA: <F extends HKT, FC = HKT.None>(F: Applicative<F, FC>) => <K, Q, W, X, I, _S, R, E>(f: (a: A) => HKT.Kind<F, FC, K, Q, W, X, I, _S, R, E, B>) => (s: S) => HKT.Kind<F, FC, K, Q, W, X, I, _S, R, E, T>;
 }
 /**
  * @tsplus type fncts.optics.PTraversalOps
@@ -21,7 +21,7 @@ export declare const PTraversal: PTraversalOps;
  * @tsplus static fncts.optics.PTraversalOps __call
  * @tsplus location "@fncts/base/optics/Traversal/definition"
  */
-export declare function mkPTraversal<S, T, A, B>(F: PTraversalMin<S, T, A, B>): PTraversal<S, T, A, B>;
+export declare function makePTraversal<S, T, A, B>(F: PTraversalMin<S, T, A, B>): PTraversal<S, T, A, B>;
 /**
  * @tsplus type fncts.optics.Traversal
  */
@@ -36,4 +36,4 @@ export interface TraversalOps extends PTraversalOps {
  * @tsplus static fncts.optics.TraversalOps __call
  * @tsplus location "@fncts/base/optics/Traversal/definition"
  */
-export declare function mkTraversal<S, A>(F: PTraversalMin<S, S, A, A>): Traversal<S, A>;
+export declare function makeTraversal<S, A>(F: PTraversalMin<S, S, A, A>): Traversal<S, A>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fncts/base",
-  "version": "0.0.20",
+  "version": "0.0.21",
   "dependencies": {
     "@fncts/typelevel": "0.0.14",
     "uuid": "^9.0.0"

package/typeclass/Alt.d.ts

@@ -5,7 +5,7 @@ import type { Functor } from "@fncts/base/typeclass/Functor";
  * @tsplus type fncts.Alt
  */
 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, FC, HKT.Intro<F, "K", K, K1>, HKT.Intro<F, "Q", Q, Q1>, HKT.Intro<F, "W", W, W1>, HKT.Intro<F, "X", X, X1>, HKT.Intro<F, "I", I, I1>, HKT.Intro<F, "S", S, S1>, HKT.Intro<F, "R", R, R1>, HKT.Intro<F, "E", E, E1>, HKT.Intro<F, "A", A, B>>>) => HKT.Kind<F, FC, HKT.Mix<F, "K", [K, K1]>, HKT.Mix<F, "Q", [Q, Q1]>, HKT.Mix<F, "W", [W, W1]>, HKT.Mix<F, "X", [X, X1]>, HKT.Mix<F, "I", [I, I1]>, HKT.Mix<F, "S", [S, S1]>, HKT.Mix<F, "R", [R, R1]>, HKT.Mix<F, "E", [E, E1]>, HKT.Mix<F, "A", [A, B]>>;
+    alt: <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(that: Lazy<HKT.Kind<F, FC, HKT.Intro<F, "K", K, K1>, HKT.Intro<F, "Q", Q, Q1>, HKT.Intro<F, "W", W, W1>, HKT.Intro<F, "X", X, X1>, HKT.Intro<F, "I", I, I1>, HKT.Intro<F, "S", S, S1>, HKT.Intro<F, "R", R, R1>, HKT.Intro<F, "E", E, E1>, HKT.Intro<F, "A", A, B>>>) => (fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => HKT.Kind<F, FC, HKT.Mix<F, "K", [K, K1]>, HKT.Mix<F, "Q", [Q, Q1]>, HKT.Mix<F, "W", [W, W1]>, HKT.Mix<F, "X", [X, X1]>, HKT.Mix<F, "I", [I, I1]>, HKT.Mix<F, "S", [S, S1]>, HKT.Mix<F, "R", [R, R1]>, HKT.Mix<F, "E", [E, E1]>, HKT.Mix<F, "A", [A, B]>>;
 }
 /**
  * @tsplus type fncts.AltOps

package/typeclass/ApplicativeExcept.d.ts

@@ -7,7 +7,7 @@ import type { Fail } from "@fncts/base/typeclass/Fail";
  * @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>, f: (e: E) => HKT.Kind<F, FC, HKT.Intro<F, "K", K, K1>, HKT.Intro<F, "Q", Q, Q1>, HKT.Intro<F, "W", W, W1>, HKT.Intro<F, "X", X, X1>, HKT.Intro<F, "I", I, I1>, HKT.Intro<F, "S", S, S1>, HKT.Intro<F, "R", R, R1>, HKT.Intro<F, "E", E, E1>, A1>) => HKT.Kind<F, FC, HKT.Mix<F, "K", [K, K1]>, HKT.Mix<F, "Q", [Q, Q1]>, HKT.Mix<F, "W", [W, W1]>, HKT.Mix<F, "X", [X, X1]>, HKT.Mix<F, "I", [I, I1]>, HKT.Mix<F, "S", [S, S1]>, HKT.Mix<F, "R", [R, R1]>, E1, A | A1>;
+    catchAll: <K, Q, W, X, I, S, R, E, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(f: (e: E) => HKT.Kind<F, FC, HKT.Intro<F, "K", K, K1>, HKT.Intro<F, "Q", Q, Q1>, HKT.Intro<F, "W", W, W1>, HKT.Intro<F, "X", X, X1>, HKT.Intro<F, "I", I, I1>, HKT.Intro<F, "S", S, S1>, HKT.Intro<F, "R", R, R1>, 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, HKT.Mix<F, "K", [K, K1]>, HKT.Mix<F, "Q", [Q, Q1]>, HKT.Mix<F, "W", [W, W1]>, HKT.Mix<F, "X", [X, X1]>, HKT.Mix<F, "I", [I, I1]>, HKT.Mix<F, "S", [S, S1]>, HKT.Mix<F, "R", [R, R1]>, E1, A | A1>;
 }
 /**
  * @tsplus type fncts.ApplicativeExceptOps
@@ -15,11 +15,7 @@ export interface ApplicativeExcept<F extends HKT, FC = HKT.None> extends Applica
 export interface ApplicativeExceptOps {
 }
 export declare const ApplicativeExcept: ApplicativeExceptOps;
-/**
- * @tsplus fluent fncts.Kind catchJust
- * @tsplus location "@fncts/base/typeclass/ApplicativeExcept"
- */
-export declare 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>, f: (e: E) => Maybe<HKT.Kind<F, FC, HKT.Intro<F, "K", K, K1>, HKT.Intro<F, "Q", Q, Q1>, HKT.Intro<F, "W", W, W1>, HKT.Intro<F, "X", X, X1>, HKT.Intro<F, "I", I, I1>, HKT.Intro<F, "S", S, S1>, HKT.Intro<F, "R", R, R1>, HKT.Intro<F, "E", E, E1>, A1>>) => HKT.Kind<F, FC, HKT.Mix<F, "K", [K, K1]>, HKT.Mix<F, "Q", [Q, Q1]>, HKT.Mix<F, "W", [W, W1]>, HKT.Mix<F, "X", [X, X1]>, HKT.Mix<F, "I", [I, I1]>, HKT.Mix<F, "S", [S, S1]>, HKT.Mix<F, "R", [R, R1]>, HKT.Mix<F, "E", [E, E1]>, A | A1>;
+export declare function catchJust<F extends HKT, FC = HKT.None>(F: ApplicativeExcept<F, FC>): <K, Q, W, X, I, S, R, E, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(f: (e: E) => Maybe<HKT.Kind<F, FC, HKT.Intro<F, "K", K, K1>, HKT.Intro<F, "Q", Q, Q1>, HKT.Intro<F, "W", W, W1>, HKT.Intro<F, "X", X, X1>, HKT.Intro<F, "I", I, I1>, HKT.Intro<F, "S", S, S1>, HKT.Intro<F, "R", R, R1>, 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, HKT.Mix<F, "K", [K, K1]>, HKT.Mix<F, "Q", [Q, Q1]>, HKT.Mix<F, "W", [W, W1]>, HKT.Mix<F, "X", [X, X1]>, HKT.Mix<F, "I", [I, I1]>, HKT.Mix<F, "S", [S, S1]>, HKT.Mix<F, "R", [R, R1]>, HKT.Mix<F, "E", [E, E1]>, A | A1>;
 /**
  * @tsplus static fncts.ApplicativeExceptOps either
  * @tsplus location "@fncts/base/typeclass/ApplicativeExcept"

package/typeclass/Apply.d.ts

@@ -6,7 +6,7 @@ import type { Object } from "@fncts/typelevel";
  * @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, HKT.Intro<F, "K", K1, K2>, HKT.Intro<F, "Q", Q1, Q2>, HKT.Intro<F, "W", W1, W2>, HKT.Intro<F, "X", X1, X2>, HKT.Intro<F, "I", I1, I2>, HKT.Intro<F, "S", S1, S2>, HKT.Intro<F, "R", R1, R2>, HKT.Intro<F, "E", E1, E2>, B>, f: (a: A, b: B) => D) => HKT.Kind<F, FC, HKT.Mix<F, "K", [K1, K2]>, HKT.Mix<F, "Q", [Q1, Q2]>, HKT.Mix<F, "W", [W1, W2]>, HKT.Mix<F, "X", [X1, X2]>, HKT.Mix<F, "I", [I1, I2]>, HKT.Mix<F, "S", [S1, S2]>, HKT.Mix<F, "R", [R1, R2]>, HKT.Mix<F, "E", [E1, E2]>, D>;
+    zipWith: <K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B, D>(that: HKT.Kind<F, FC, HKT.Intro<F, "K", K1, K2>, HKT.Intro<F, "Q", Q1, Q2>, HKT.Intro<F, "W", W1, W2>, HKT.Intro<F, "X", X1, X2>, HKT.Intro<F, "I", I1, I2>, HKT.Intro<F, "S", S1, S2>, HKT.Intro<F, "R", R1, R2>, HKT.Intro<F, "E", E1, E2>, 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, HKT.Mix<F, "K", [K1, K2]>, HKT.Mix<F, "Q", [Q1, Q2]>, HKT.Mix<F, "W", [W1, W2]>, HKT.Mix<F, "X", [X1, X2]>, HKT.Mix<F, "I", [I1, I2]>, HKT.Mix<F, "S", [S1, S2]>, HKT.Mix<F, "R", [R1, R2]>, HKT.Mix<F, "E", [E1, E2]>, D>;
 }
 /**
  * @tsplus type fncts.ApplyOps
@@ -18,18 +18,18 @@ export declare const Apply: ApplyOps;
  * @tsplus static fncts.ApplyOps ap
  * @tsplus location "@fncts/base/typeclass/Apply"
  */
-export declare 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>, fa: HKT.Kind<F, FC, HKT.Intro<F, "K", K1, K2>, HKT.Intro<F, "Q", Q1, Q2>, HKT.Intro<F, "W", W1, W2>, HKT.Intro<F, "X", X1, X2>, HKT.Intro<F, "I", I1, I2>, HKT.Intro<F, "S", S1, S2>, HKT.Intro<F, "R", R1, R2>, HKT.Intro<F, "E", E1, E2>, A>) => HKT.Kind<F, FC, HKT.Mix<F, "K", [K1, K2]>, HKT.Mix<F, "Q", [Q1, Q2]>, HKT.Mix<F, "W", [W1, W2]>, HKT.Mix<F, "X", [X1, X2]>, HKT.Mix<F, "I", [I1, I2]>, HKT.Mix<F, "S", [S1, S2]>, HKT.Mix<F, "R", [R1, R2]>, HKT.Mix<F, "E", [E1, E2]>, B>;
+export declare 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>(fa: HKT.Kind<F, FC, HKT.Intro<F, "K", K1, K2>, HKT.Intro<F, "Q", Q1, Q2>, HKT.Intro<F, "W", W1, W2>, HKT.Intro<F, "X", X1, X2>, HKT.Intro<F, "I", I1, I2>, HKT.Intro<F, "S", S1, S2>, HKT.Intro<F, "R", R1, R2>, 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, HKT.Mix<F, "K", [K1, K2]>, HKT.Mix<F, "Q", [Q1, Q2]>, HKT.Mix<F, "W", [W1, W2]>, HKT.Mix<F, "X", [X1, X2]>, HKT.Mix<F, "I", [I1, I2]>, HKT.Mix<F, "S", [S1, S2]>, HKT.Mix<F, "R", [R1, R2]>, HKT.Mix<F, "E", [E1, E2]>, B>;
 /**
  * @tsplus static fncts.ApplyOps apFirst
  * @tsplus location "@fncts/base/typeclass/Apply"
  */
-export declare 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>, fb: HKT.Kind<F, FC, HKT.Intro<F, "K", K1, K2>, HKT.Intro<F, "Q", Q1, Q2>, HKT.Intro<F, "W", W1, W2>, HKT.Intro<F, "X", X1, X2>, HKT.Intro<F, "I", I1, I2>, HKT.Intro<F, "S", S1, S2>, HKT.Intro<F, "R", R1, R2>, HKT.Intro<F, "E", E1, E2>, B>) => HKT.Kind<F, FC, HKT.Mix<F, "K", [K1, K2]>, HKT.Mix<F, "Q", [Q1, Q2]>, HKT.Mix<F, "W", [W1, W2]>, HKT.Mix<F, "X", [X1, X2]>, HKT.Mix<F, "I", [I1, I2]>, HKT.Mix<F, "S", [S1, S2]>, HKT.Mix<F, "R", [R1, R2]>, HKT.Mix<F, "E", [E1, E2]>, A>;
+export declare function apFirst<F extends HKT, FC = HKT.None>(F: Apply<F, FC>): <K1, Q1, W1, X1, I1, S1, R1, E1, K2, Q2, W2, X2, I2, S2, R2, E2, B>(fb: HKT.Kind<F, FC, HKT.Intro<F, "K", K1, K2>, HKT.Intro<F, "Q", Q1, Q2>, HKT.Intro<F, "W", W1, W2>, HKT.Intro<F, "X", X1, X2>, HKT.Intro<F, "I", I1, I2>, HKT.Intro<F, "S", S1, S2>, HKT.Intro<F, "R", R1, R2>, 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, HKT.Mix<F, "K", [K1, K2]>, HKT.Mix<F, "Q", [Q1, Q2]>, HKT.Mix<F, "W", [W1, W2]>, HKT.Mix<F, "X", [X1, X2]>, HKT.Mix<F, "I", [I1, I2]>, HKT.Mix<F, "S", [S1, S2]>, HKT.Mix<F, "R", [R1, R2]>, HKT.Mix<F, "E", [E1, E2]>, A>;
 /**
  * @tsplus static fncts.ApplyOps apSecond
  * @tsplus location "@fncts/base/typeclass/Apply"
  */
-export declare 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>, fb: HKT.Kind<F, FC, HKT.Intro<F, "K", K1, K2>, HKT.Intro<F, "Q", Q1, Q2>, HKT.Intro<F, "W", W1, W2>, HKT.Intro<F, "X", X1, X2>, HKT.Intro<F, "I", I1, I2>, HKT.Intro<F, "S", S1, S2>, HKT.Intro<F, "R", R1, R2>, HKT.Intro<F, "E", E1, E2>, B>) => HKT.Kind<F, FC, HKT.Mix<F, "K", [K1, K2]>, HKT.Mix<F, "Q", [Q1, Q2]>, HKT.Mix<F, "W", [W1, W2]>, HKT.Mix<F, "X", [X1, X2]>, HKT.Mix<F, "I", [I1, I2]>, HKT.Mix<F, "S", [S1, S2]>, HKT.Mix<F, "R", [R1, R2]>, HKT.Mix<F, "E", [E1, E2]>, B>;
-export declare 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, FC, HKT.Intro<F, "K", K1, K2>, HKT.Intro<F, "Q", Q1, Q2>, HKT.Intro<F, "W", W1, W2>, HKT.Intro<F, "X", X1, X2>, HKT.Intro<F, "I", I1, I2>, HKT.Intro<F, "S", S1, S2>, HKT.Intro<F, "R", R1, R2>, HKT.Intro<F, "E", E1, E2>, B>) => HKT.Kind<F, FC, HKT.Mix<F, "K", [K1, K2]>, HKT.Mix<F, "Q", [Q1, Q2]>, HKT.Mix<F, "W", [W1, W2]>, HKT.Mix<F, "X", [X1, X2]>, HKT.Mix<F, "I", [I1, I2]>, HKT.Mix<F, "S", [S1, S2]>, HKT.Mix<F, "R", [R1, R2]>, HKT.Mix<F, "E", [E1, E2]>, {
+export declare function apSecond<F extends HKT, FC = HKT.None>(F: Apply<F, FC>): <K1, Q1, W1, X1, I1, S1, R1, E1, K2, Q2, W2, X2, I2, S2, R2, E2, B>(fb: HKT.Kind<F, FC, HKT.Intro<F, "K", K1, K2>, HKT.Intro<F, "Q", Q1, Q2>, HKT.Intro<F, "W", W1, W2>, HKT.Intro<F, "X", X1, X2>, HKT.Intro<F, "I", I1, I2>, HKT.Intro<F, "S", S1, S2>, HKT.Intro<F, "R", R1, R2>, 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, HKT.Mix<F, "K", [K1, K2]>, HKT.Mix<F, "Q", [Q1, Q2]>, HKT.Mix<F, "W", [W1, W2]>, HKT.Mix<F, "X", [X1, X2]>, HKT.Mix<F, "I", [I1, I2]>, HKT.Mix<F, "S", [S1, S2]>, HKT.Mix<F, "R", [R1, R2]>, HKT.Mix<F, "E", [E1, E2]>, B>;
+export declare 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>(name: Exclude<BN, keyof A>, fb: HKT.Kind<F, FC, HKT.Intro<F, "K", K1, K2>, HKT.Intro<F, "Q", Q1, Q2>, HKT.Intro<F, "W", W1, W2>, HKT.Intro<F, "X", X1, X2>, HKT.Intro<F, "I", I1, I2>, HKT.Intro<F, "S", S1, S2>, HKT.Intro<F, "R", R1, R2>, HKT.Intro<F, "E", E1, E2>, B>) => (fa: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>) => HKT.Kind<F, FC, HKT.Mix<F, "K", [K1, K2]>, HKT.Mix<F, "Q", [Q1, Q2]>, HKT.Mix<F, "W", [W1, W2]>, HKT.Mix<F, "X", [X1, X2]>, HKT.Mix<F, "I", [I1, I2]>, 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;
 }>;
 /**