@fncts/base 0.0.30 → 0.0.32

package/_src/data/Either/api.ts

@@ -97,20 +97,20 @@ export function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>
  * @tsplus getter fncts.Either getLeft
  */
 export function getLeft<E, A>(self: Either<E, A>): Maybe<E> {
-  return self.match(
-    (e) => Just(e),
-    (_a) => Nothing(),
-  );
+  return self.match({
+    Left: (e) => Just(e),
+    Right: (_a) => Nothing(),
+  });
 }
 
 /**
  * @tsplus getter fncts.Either getRight
  */
 export function getRight<E, A>(self: Either<E, A>): Maybe<A> {
-  return self.match(
-    (_e) => Nothing(),
-    (a) => Just(a),
-  );
+  return self.match({
+    Left: (_e) => Nothing(),
+    Right: (a) => Just(a),
+  });
 }
 
 /**
@@ -118,7 +118,7 @@ export function getRight<E, A>(self: Either<E, A>): Maybe<A> {
  */
 export function getOrElse<E, B>(orElse: (e: E) => B) {
   return <A>(self: Either<E, A>): A | B => {
-    return self.match(orElse, identity);
+    return self.match({ Left: orElse, Right: identity });
   };
 }
 
@@ -172,7 +172,7 @@ export function mapLeft<E1, E2>(f: (e: E1) => E2) {
  * @tsplus getter fncts.Either value
  */
 export function merge<E, A>(self: Either<E, A>): E | A {
-  return self.match(identity, identity);
+  return self.match({ Left: identity, Right: identity });
 }
 
 /**
@@ -201,10 +201,10 @@ export function _traverse<E, A>(self: Either<E, A>) {
     <K, Q, W, X, I, S, R, E1, B>(
       f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, B>,
     ): HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, Either<E, B>> =>
-      self.match(
-        (e) => G.pure(Left(e)),
-        (a) => f(a).pipe(G.map((b) => Right(b))),
-      );
+      self.match({
+        Left: (e) => G.pure(Left(e)),
+        Right: (a) => f(a).pipe(G.map((b) => Right(b))),
+      });
 }
 
 export const traverse_: P.Traversable<EitherF>["traverse"] = (A) => (f) => (self) => self.traverse(A)(f);
@@ -288,10 +288,10 @@ export function partition<E, A>(p: Predicate<A>, /** @tsplus auto */ M: P.Monoid
  * @tsplus getter fncts.Either toMaybe
  */
 export function toMaybe<E, A>(self: Either<E, A>): Maybe<A> {
-  return self.match(
-    () => Nothing(),
-    (a) => Just(a),
-  );
+  return self.match({
+    Left: () => Nothing(),
+    Right: (a) => Just(a),
+  });
 }
 
 // codegen:start { preset: barrel, include: api/*.ts }

package/_src/data/Either/destructors.ts

@@ -3,14 +3,14 @@ import { EitherTag } from "./definition.js";
 /**
  * @tsplus pipeable fncts.Either match
  */
-export function match<E, A, B, C>(left: (e: E) => B, right: (a: A) => C) {
+export function match<E, A, B, C>(cases: { Left: (e: E) => B; Right: (a: A) => C }) {
   return (self: Either<E, A>): B | C => {
     self.concrete();
     switch (self._tag) {
       case EitherTag.Left:
-        return left(self.left);
+        return cases.Left(self.left);
       case EitherTag.Right:
-        return right(self.right);
+        return cases.Right(self.right);
     }
   };
 }

package/_src/data/Either/instances.ts

@@ -20,18 +20,18 @@ export function getEq<E, A>(EE: P.Eq<E>, EA: P.Eq<A>): P.Eq<Either<E, A>> {
   return P.Eq({
     equals: (y) => (x) =>
       x === y ||
-      x.match(
-        (e1) =>
-          y.match(
-            (e2) => EE.equals(e2)(e1),
-            () => false,
-          ),
-        (a1) =>
-          y.match(
-            () => false,
-            (a2) => EA.equals(a2)(a1),
-          ),
-      ),
+      x.match({
+        Left: (e1) =>
+          y.match({
+            Left: (e2) => EE.equals(e2)(e1),
+            Right: () => false,
+          }),
+        Right: (a1) =>
+          y.match({
+            Left: () => false,
+            Right: (a2) => EA.equals(a2)(a1),
+          }),
+      }),
   });
 }
 

package/_src/data/EitherT/api.ts

@@ -122,10 +122,10 @@ export function flatMap<F extends HKT, FC>(F: P.Monad<F, FC>) {
   >) =>
     F.flatMap(
       (either) =>
-        either.match(
-          (e) => F.pure(Either.left(e)),
-          (a) => f(a),
-        ) as HKT.Kind<
+        either.match({
+          Left: (e) => F.pure(Either.left(e)),
+          Right: (a) => f(a),
+        }) as HKT.Kind<
           F,
           FC,
           HKT.Intro<F, "K", K, K1>,
@@ -225,9 +225,9 @@ export function orElse<F>(F: P.Monad<HKT.F1<F>>) {
     that: Lazy<HKT.FK1<F, Either<E1, B>>>,
   ): ((self: HKT.FK1<F, Either<E, A>>) => HKT.FK1<F, Either<E | E1, A | B>>) =>
     F.flatMap((either) =>
-      either.match(
-        () => that(),
-        () => F.pure(either),
-      ),
+      either.match({
+        Left: () => that(),
+        Right: () => F.pure(either),
+      }),
     );
 }

package/_src/data/Exit/constructors.ts

@@ -18,7 +18,7 @@ export function fail<E = never, A = never>(e: E, __tsplusTrace?: string): Exit<E
  * @tsplus static fncts.ExitOps fromEither
  */
 export function fromEither<E = never, A = never>(e: Either<E, A>): Exit<E, A> {
-  return e.match(fail, succeed);
+  return e.match({ Left: fail, Right: succeed });
 }
 
 /**

package/_src/data/Global.ts

@@ -0,0 +1,17 @@
+const globalStoreId = Symbol.for("fncts.GlobalStore");
+
+if (!(globalStoreId in globalThis)) {
+  (globalThis as any)[globalStoreId] = new Map();
+}
+
+const globalStore = (globalThis as any)[globalStoreId] as Map<unknown, any>;
+
+/**
+ * @since 1.0.0
+ */
+export const globalValue = <A>(id: unknown, compute: () => A): A => {
+  if (!globalStore.has(id)) {
+    globalStore.set(id, compute());
+  }
+  return globalStore.get(id)!;
+};

package/_src/data/Maybe/api.ts

@@ -95,10 +95,10 @@ export function partitionMap<A, B, C>(f: (a: A) => Either<B, C>) {
   return (self: Maybe<A>): readonly [Maybe<B>, Maybe<C>] => {
     self.concrete();
     if (self._tag === MaybeTag.Just) {
-      return f(self.value).match(
-        (b) => [Just(b), Nothing()],
-        (c) => [Nothing(), Just(c)],
-      );
+      return f(self.value).match({
+        Left: (b) => [Just(b), Nothing()],
+        Right: (c) => [Nothing(), Just(c)],
+      });
     } else {
       return [Nothing(), Nothing()];
     }

package/_src/data.ts

@@ -6,6 +6,7 @@ export type {} from "./data/Byte.js";
 export type {} from "./data/CaseClass.js";
 export type {} from "./data/Cause.js";
 export type {} from "./data/Const.js";
+export type {} from "./data/Date.js";
 export type {} from "./data/DatumEither.js";
 export type {} from "./data/DecodeError.js";
 export type {} from "./data/Decoder.js";
@@ -21,6 +22,7 @@ export type {} from "./data/ExecutionStrategy.js";
 export type {} from "./data/Exit.js";
 export type {} from "./data/FiberId.js";
 export type {} from "./data/function.js";
+export type {} from "./data/Global.js";
 export type {} from "./data/Guard.js";
 export type {} from "./data/Hash.js";
 export type {} from "./data/Hashable.js";

package/_src/optics/Fold/api/focus.ts

@@ -0,0 +1,12 @@
+import type { Fold, FoldPartiallyApplied } from "@fncts/base/optics/Fold";
+
+/**
+ * @tsplus pipeable global focus 4
+ */
+export function focus<S, A>(fold: Fold<S, A>) {
+  return (self: S): FoldPartiallyApplied<A> => {
+    return {
+      foldMap: (M) => (f) => fold.foldMap(M)(f)(self),
+    };
+  };
+}

package/_src/optics/Fold/definition.ts

@@ -1,8 +1,13 @@
 import type { Monoid } from "@fncts/base/typeclass";
+
 export interface foldMap<S, A> {
   <M>(M: Monoid<M>): (f: (a: A) => M) => (s: S) => M;
 }
 
+export interface foldMapPartiallyApplied<A> {
+  <M>(M: Monoid<M>): (f: (a: A) => M) => M;
+}
+
 /**
  * @tsplus type fncts.optics.Fold
  */
@@ -10,6 +15,10 @@ export interface Fold<S, A> {
   readonly foldMap: foldMap<S, A>;
 }
 
+export interface FoldPartiallyApplied<A> {
+  readonly foldMap: foldMapPartiallyApplied<A>;
+}
+
 /**
  * @tsplus type fncts.optics.FoldOps
  */

package/_src/optics/Getter/definition.ts

@@ -1,9 +1,13 @@
-import type { Fold } from "@fncts/base/optics/Fold";
+import type { Fold, FoldPartiallyApplied } from "@fncts/base/optics/Fold";
 
 export interface get<S, A> {
   (s: S): A;
 }
 
+export interface getPartiallyApplied<A> {
+  (): A;
+}
+
 /**
  * @tsplus type fncts.optics.Getter
  */
@@ -11,6 +15,10 @@ export interface Getter<S, A> extends Fold<S, A> {
   readonly get: get<S, A>;
 }
 
+export interface GetterPartiallyApplied<A> extends FoldPartiallyApplied<A> {
+  readonly get: getPartiallyApplied<A>;
+}
+
 /**
  * @tsplus type fncts.optics.GetterOps
  */

package/_src/optics/Index/api.ts

@@ -2,7 +2,8 @@ import type { At } from "@fncts/base/optics/At";
 import type { Iso } from "@fncts/base/optics/Iso";
 
 import { Index } from "@fncts/base/optics/Index/definition";
-import { Prism } from "@fncts/base/optics/Prism";
+import { Optional } from "@fncts/base/optics/Optional/definition";
+import { Prism } from "@fncts/base/optics/Prism/definition";
 
 /**
  * @tsplus static fncts.optics.IndexOps fromAt
@@ -17,3 +18,16 @@ export function fromAt<T, J, B>(at: At<T, J, Maybe<B>>): Index<T, J, B> {
 export function fromIso<T, S>(iso: Iso<T, S>) {
   return <I, A>(index: Index<S, I, A>): Index<T, I, A> => Index({ index: (i) => iso.compose(index.index(i)) });
 }
+
+/**
+ * @tsplus static fncts.optics.IndexOps array
+ */
+export function array<A = never>(): Index<ReadonlyArray<A>, number, A> {
+  return Index({
+    index: (i) =>
+      Optional({
+        getOrModify: (s) => (i in s ? Either.right(s[i]!) : Either.left(s)),
+        set: (a) => (s) => s.updateAt(i, a),
+      }),
+  });
+}

package/_src/optics/Iso/api.ts

@@ -1,3 +1,7 @@
+import type { PIsoPartiallyApplied } from "@fncts/base/optics/Iso/definition";
+import type { PLens } from "@fncts/base/optics/Lens";
+import type { PPrism } from "@fncts/base/optics/Prism";
+
 import { PIso } from "@fncts/base/optics/Iso/definition";
 
 /**
@@ -11,3 +15,15 @@ export function compose<A, B, C, D>(that: PIso<A, B, C, D>) {
     });
   };
 }
+
+/**
+ * @tsplus pipeable global focus
+ */
+export function focus<S, T, A, B>(iso: PIso<S, T, A, B>) {
+  return (self: S): PIsoPartiallyApplied<T, A, B> => {
+    return {
+      ...self.focus(iso as PLens<S, T, A, B>),
+      ...self.focus(iso as PPrism<S, T, A, B>),
+    };
+  };
+}

package/_src/optics/Iso/definition.ts

@@ -1,5 +1,6 @@
 import type { get } from "@fncts/base/optics/Getter";
-import type { reverseGet } from "@fncts/base/optics/Prism";
+import type { PLensPartiallyApplied } from "@fncts/base/optics/Lens";
+import type { PPrismPartiallyApplied, reverseGet } from "@fncts/base/optics/Prism";
 
 import { PLens } from "@fncts/base/optics/Lens";
 import { PPrism } from "@fncts/base/optics/Prism";
@@ -11,6 +12,10 @@ export interface PIso<S, T, A, B> extends PLens<S, T, A, B>, PPrism<S, T, A, B>
   readonly reverse: () => PIso<B, A, T, S>;
 }
 
+export interface PIsoPartiallyApplied<T, A, B>
+  extends PLensPartiallyApplied<T, A, B>,
+    PPrismPartiallyApplied<T, A, B> {}
+
 /**
  * @tsplus type fncts.optics.PIsoOps
  */

package/_src/optics/Lens/api.ts

@@ -1,10 +1,24 @@
-import type { Optional } from "@fncts/base/optics/Optional";
+import type { PLensPartiallyApplied } from "@fncts/base/optics/Lens/definition";
+import type { Optional, POptional } from "@fncts/base/optics/Optional";
+import type { PTraversal } from "@fncts/base/optics/Traversal";
 import type { AutoPath, Path } from "@fncts/typelevel/Object";
 
 import { identity } from "@fncts/base/data/function";
 import { Lens, PLens } from "@fncts/base/optics/Lens/definition";
 import { Prism } from "@fncts/base/optics/Prism";
 
+/**
+ * @tsplus pipeable global focus
+ */
+export function focus<S, T, A, B>(lens: PLens<S, T, A, B>) {
+  return (self: S): PLensPartiallyApplied<T, A, B> => {
+    return {
+      ...self.focus(lens as POptional<S, T, A, B>),
+      get: () => lens.get(self),
+    };
+  };
+}
+
 /**
  * @tsplus pipeable fncts.optics.PLens component
  */
@@ -114,16 +128,14 @@ function nestPath<A>(p: ReadonlyNonEmptyArray<string>, a: A): Record<string, unk
   return out;
 }
 
-/**
- * @tsplus pipeable fncts.optics.Lens path
- */
-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>> => {
+function anyPath(path: ReadonlyArray<string>) {
+  return (self: Lens<any, any>): Lens<any, any> => {
     return Lens({
-      get: (s) => path.foldLeft<string, Record<string, unknown>>(self.get(s), (b, p) => b[p] as A) as Path<A, P>,
+      get: (s) =>
+        path.foldLeft<string, Record<string, unknown>>(self.get(s), (b, p) => b[p] as Record<string, unknown>),
       set: (a) => (s) => {
         const os = self.get(s);
-        const oa = path.foldLeft(os, (b, p) => b[p as string] as A);
+        const oa = path.foldLeft(os, (b, p) => b[p as string] as Record<string, unknown>);
         if (a === oa) {
           return s;
         }
@@ -132,3 +144,19 @@ export function path<A extends Record<string, unknown>, P extends Array<string>>
     });
   };
 }
+
+/**
+ * @tsplus pipeable fncts.optics.Lens path
+ */
+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 anyPath(path)(self);
+  };
+}
+
+/**
+ * @tsplus static fncts.optics.LensOps fromPath
+ */
+export function fromPath<S, P extends Array<string>>(path: readonly [...AutoPath<S, P>]): Lens<S, Path<S, P>> {
+  return anyPath(path)(Lens.id());
+}

package/_src/optics/Lens/definition.ts

@@ -1,4 +1,5 @@
-import type { get } from "@fncts/base/optics/Getter";
+import type { get, GetterPartiallyApplied } from "@fncts/base/optics/Getter";
+import type { POptionalPartiallyApplied } from "@fncts/base/optics/Optional";
 import type { set } from "@fncts/base/optics/Setter";
 
 import { Getter } from "@fncts/base/optics/Getter";
@@ -9,6 +10,8 @@ import { POptional } from "@fncts/base/optics/Optional";
  */
 export interface PLens<S, T, A, B> extends POptional<S, T, A, B>, Getter<S, A> {}
 
+export interface PLensPartiallyApplied<T, A, B> extends POptionalPartiallyApplied<T, A, B>, GetterPartiallyApplied<A> {}
+
 /**
  * @tsplus type fncts.optics.PLensOps
  */

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

@@ -0,0 +1,16 @@
+import type { POptional, POptionalPartiallyApplied } from "@fncts/base/optics/Optional";
+import type { PTraversal } from "@fncts/base/optics/Traversal";
+
+/**
+ * @tsplus pipeable global focus 1
+ */
+export function focus<S, T, A, B>(optional: POptional<S, T, A, B>) {
+  return (self: S): POptionalPartiallyApplied<T, A, B> => {
+    return {
+      ...self.focus(optional as PTraversal<S, T, A, B>),
+      getMaybe: () => optional.getMaybe(self),
+      modifyMaybe: (f) => optional.modifyMaybe(f)(self),
+      getOrModify: () => optional.getOrModify(self),
+    };
+  };
+}

package/_src/optics/Optional/api.ts

@@ -0,0 +1,10 @@
+import type { Optional } from "@fncts/base/optics/Optional/definition";
+
+import { Index } from "@fncts/base/optics/Index";
+
+/**
+ * @tsplus static fncts.optics.OptionalOps index
+ */
+export function index<A>(index: number): Optional<ReadonlyArray<A>, A> {
+  return Index.array<A>().index(index);
+}

package/_src/optics/Optional/definition.ts

@@ -1,4 +1,5 @@
 import type { set } from "@fncts/base/optics/Setter";
+import type { PTraversalPartiallyApplied } from "@fncts/base/optics/Traversal";
 
 import { pipe } from "@fncts/base/data/function";
 import { PTraversal } from "@fncts/base/optics/Traversal";
@@ -12,6 +13,12 @@ export interface POptional<S, T, A, B> extends PTraversal<S, T, A, B> {
   readonly modifyMaybe: modifyMaybe<S, T, A, B>;
 }
 
+export interface POptionalPartiallyApplied<T, A, B> extends PTraversalPartiallyApplied<T, A, B> {
+  readonly getMaybe: getMaybePartiallyApplied<A>;
+  readonly getOrModify: getOrModifyPartiallyApplied<T, A>;
+  readonly modifyMaybe: modifyMaybePartiallyApplied<T, A, B>;
+}
+
 export interface POptionalMin<S, T, A, B> {
   readonly getOrModify: getOrModify<S, T, A>;
   readonly set: set<S, T, B>;
@@ -35,10 +42,10 @@ export function makePOptional<S, T, A, B>(F: POptionalMin<S, T, A, B>): POptiona
     modifyMaybe: (f) => (s) => getMaybe(s).map((a) => pipe(s, F.set(f(a)))),
     ...PTraversal<S, T, A, B>({
       modifyA: (A) => (f) => (s) =>
-        F.getOrModify(s).match(
-          (t) => A.pure(t),
-          (a) => f(a).pipe(A.map((b) => s.pipe(F.set(b)))),
-        ),
+        F.getOrModify(s).match({
+          Left: (t) => A.pure(t),
+          Right: (a) => f(a).pipe(A.map((b) => s.pipe(F.set(b)))),
+        }),
     }),
   };
 }
@@ -81,3 +88,15 @@ export interface replaceMaybe_<S, T, B> {
 export interface replaceMaybe<S, T, B> {
   (b: B): (s: S) => Maybe<T>;
 }
+
+export interface getMaybePartiallyApplied<A> {
+  (): Maybe<A>;
+}
+
+export interface getOrModifyPartiallyApplied<T, A> {
+  (): Either<T, A>;
+}
+
+export interface modifyMaybePartiallyApplied<T, A, B> {
+  (f: (a: A) => B): Maybe<T>;
+}

package/_src/optics/Optional.ts

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

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

@@ -0,0 +1,14 @@
+import type { POptional } from "@fncts/base/optics/Optional";
+import type { PPrism, PPrismPartiallyApplied } from "@fncts/base/optics/Prism";
+
+/**
+ * @tsplus pipeable global focus
+ */
+export function focus<S, T, A, B>(prism: PPrism<S, T, A, B>) {
+  return (self: S): PPrismPartiallyApplied<T, A, B> => {
+    return {
+      ...self.focus(prism as POptional<S, T, A, B>),
+      reverseGet: prism.reverseGet,
+    };
+  };
+}

package/_src/optics/Prism/definition.ts

@@ -1,4 +1,4 @@
-import type { getOrModify } from "@fncts/base/optics/Optional";
+import type { getOrModify, POptionalPartiallyApplied } from "@fncts/base/optics/Optional";
 
 import { identity } from "@fncts/base/data/function";
 import { POptional } from "@fncts/base/optics/Optional";
@@ -10,6 +10,10 @@ export interface PPrism<S, T, A, B> extends POptional<S, T, A, B> {
   readonly reverseGet: reverseGet<T, B>;
 }
 
+export interface PPrismPartiallyApplied<T, A, B> extends POptionalPartiallyApplied<T, A, B> {
+  readonly reverseGet: reverseGet<T, B>;
+}
+
 /**
  * @tsplus type fncts.optics.PPrismOps
  */
@@ -30,7 +34,7 @@ export function makePPrism<S, T, A, B>(F: PPrismMin<S, T, A, B>): PPrism<S, T, A
     reverseGet: F.reverseGet,
     ...POptional({
       getOrModify: F.getOrModify,
-      set: (b) => (s) => F.getOrModify(s).match(identity, () => F.reverseGet(b)),
+      set: (b) => (s) => F.getOrModify(s).match({ Left: identity, Right: () => F.reverseGet(b) }),
     }),
   };
 }

package/_src/optics/Prism.ts

@@ -3,6 +3,7 @@ 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/focus.js";
 export * from "./Prism/api/fromNullable.js";
 export * from "./Prism/api/just.js";
 // codegen:end

package/_src/optics/Setter/api/focus.ts

@@ -0,0 +1,13 @@
+import type { PSetter, PSetterPartiallyApplied } from "@fncts/base/optics/Setter";
+
+/**
+ * @tsplus pipeable global focus 3
+ */
+export function focus<S, T, A, B>(setter: PSetter<S, T, A, B>) {
+  return (self: S): PSetterPartiallyApplied<T, A, B> => {
+    return {
+      set: (b) => setter.set(b)(self),
+      modify: (f) => setter.modify(f)(self),
+    };
+  };
+}

package/_src/optics/Setter/definition.ts

@@ -6,6 +6,11 @@ export interface PSetter<S, T, A, B> {
   readonly set: set<S, T, B>;
 }
 
+export interface PSetterPartiallyApplied<T, A, B> {
+  readonly modify: modifyPartiallyApplied<T, A, B>;
+  readonly set: setPartiallyApplied<T, B>;
+}
+
 /**
  * @tsplus type fncts.optics.PSetterOps
  */
@@ -44,3 +49,11 @@ export interface modify<S, T, A, B> {
 export interface set<S, T, B> {
   (b: B): (s: S) => T;
 }
+
+export interface modifyPartiallyApplied<T, A, B> {
+  (f: (a: A) => B): T;
+}
+
+export interface setPartiallyApplied<T, B> {
+  (b: B): T;
+}

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

@@ -0,0 +1,16 @@
+import type { Fold } from "@fncts/base/optics/Fold";
+import type { PSetter } from "@fncts/base/optics/Setter";
+import type { PTraversal, PTraversalPartiallyApplied } from "@fncts/base/optics/Traversal";
+
+/**
+ * @tsplus pipeable global focus 2
+ */
+export function focus<S, T, A, B>(traversal: PTraversal<S, T, A, B>) {
+  return (self: S): PTraversalPartiallyApplied<T, A, B> => {
+    return {
+      ...self.focus(traversal as PSetter<S, T, A, B>),
+      ...self.focus(traversal as Fold<S, A>),
+      modifyA: (F) => (f) => traversal.modifyA(F)(f)(self),
+    };
+  };
+}

package/_src/optics/Traversal/definition.ts

@@ -1,3 +1,5 @@
+import type { FoldPartiallyApplied } from "@fncts/base/optics/Fold";
+import type { PSetterPartiallyApplied } from "@fncts/base/optics/Setter";
 import type { Applicative, Monoid } from "@fncts/base/typeclass";
 
 import { Fold } from "@fncts/base/optics/Fold";
@@ -14,6 +16,14 @@ export interface PTraversal<S, T, A, B> extends PSetter<S, T, A, B>, Fold<S, A>
   ) => (s: S) => HKT.Kind<F, FC, K, Q, W, X, I, _S, R, E, T>;
 }
 
+export interface PTraversalPartiallyApplied<T, A, B> extends PSetterPartiallyApplied<T, A, B>, FoldPartiallyApplied<A> {
+  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>,
+  ) => 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>,

package/_src/optics/Traversal.ts

@@ -3,5 +3,6 @@ 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/focus.js";
 export * from "./Traversal/api/fromTraversable.js";
 // codegen:end