@fncts/base 0.0.30 → 0.0.32

package/_src/typeclass/MonadExcept.ts

@@ -24,5 +24,5 @@ export function absolve<F extends HKT, FC = HKT.None>(
 export function absolve<F>(
   F: MonadExcept<HKT.F<F>>,
 ): <E, A, E1>(fa: HKT.FK2<F, E, Either<E1, A>>) => HKT.FK2<F, HKT.Mix<HKT.F<F>, "E", [E, E1]>, A> {
-  return F.flatMap((r) => r.match(F.fail, F.pure));
+  return F.flatMap((r) => r.match({ Left: F.fail, Right: F.pure }));
 }

package/collection/compat/Array/api.d.ts

@@ -1,3 +1,4 @@
+import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { ReadonlyNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
 import type { Eq } from "@fncts/base/typeclass";
 /**
@@ -6,6 +7,18 @@ import type { Eq } from "@fncts/base/typeclass";
  * @tsplus location "@fncts/base/collection/compat/Array/api"
  */
 export declare function elem<A>(self: ReadonlyArray<A>): (eq: Eq<A>) => (a: A) => boolean;
+/**
+ * @tsplus pipeable fncts.Array filterMap
+ * @tsplus pipeable fncts.ReadonlyArray filterMap
+ * @tsplus location "@fncts/base/collection/compat/Array/api"
+ */
+export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): (self: ReadonlyArray<A>) => ReadonlyArray<B>;
+/**
+ * @tsplus pipeable fncts.Array filterMap
+ * @tsplus pipeable fncts.ReadonlyArray filterMap
+ * @tsplus location "@fncts/base/collection/compat/Array/api"
+ */
+export declare function filterMapUndefined<A, B>(f: (a: A) => B | undefined): (self: ReadonlyArray<A>) => ReadonlyArray<B>;
 /**
  * @tsplus fluent fncts.Array isEmpty
  * @tsplus fluent fncts.ReadonlyArray isEmpty
@@ -30,3 +43,9 @@ export declare function foldLeft<A, B>(b: B, f: (b: B, a: A) => B): (self: Reado
  * @tsplus location "@fncts/base/collection/compat/Array/api"
  */
 export declare function foldLeftWithIndex<A, B>(b: B, f: (i: number, b: B, a: A) => B): (self: ReadonlyArray<A>) => B;
+/**
+ * @tsplus pipeable fncts.Array updateAt
+ * @tsplus pipeable fncts.ReadonlyArray updateAt
+ * @tsplus location "@fncts/base/collection/compat/Array/api"
+ */
+export declare function updateAt<A>(i: number, a: A): (self: ReadonlyArray<A>) => ReadonlyArray<A>;

package/collection/immutable/Dictionary/api.d.ts

@@ -15,6 +15,21 @@ export declare function foldLeftWithIndex<A, B>(b: B, f: (k: string, b: B, a: A)
  * @tsplus location "@fncts/base/collection/immutable/Dictionary/api"
  */
 export declare function get(key: string): <A>(self: import("./definition").Dictionary<A>) => import("../../../data/Maybe").Maybe<A>;
+/**
+ * @tsplus pipeable fncts.Dictionary set
+ * @tsplus location "@fncts/base/collection/immutable/Dictionary/api"
+ */
+export declare function set<A>(key: string, value: A): (self: Dictionary<A>) => Dictionary<A>;
+/**
+ * @tsplus pipeable fncts.Dictionary remove
+ * @tsplus location "@fncts/base/collection/immutable/Dictionary/api"
+ */
+export declare function remove(key: string): <A>(self: import("./definition").Dictionary<A>) => import("./definition").Dictionary<A>;
+/**
+ * @tsplus pipeable fncts.Dictionary update
+ * @tsplus location "@fncts/base/collection/immutable/Dictionary/api"
+ */
+export declare function update<A>(key: string, f: (a: Maybe<A>) => Maybe<A>): (self: Dictionary<A>) => Dictionary<A>;
 /**
  * @tsplus getter fncts.Dictionary keys
  * @tsplus location "@fncts/base/collection/immutable/Dictionary/api"
@@ -30,6 +45,12 @@ export declare function map<A, B>(f: (a: A) => B): (self: Dictionary<A>) => Dict
  * @tsplus location "@fncts/base/collection/immutable/Dictionary/api"
  */
 export declare function mapWithIndex<A, B>(f: (k: string, a: A) => B): (self: Dictionary<A>) => Dictionary<B>;
+/**
+ * @tsplus static fncts.DictionaryOps __call
+ * @tsplus macro identity
+ * @tsplus location "@fncts/base/collection/immutable/Dictionary/api"
+ */
+export declare function fromRecord<A>(self: Record<string, A>): Dictionary<A>;
 /**
  * @tsplus getter fncts.Dictionary toRecord
  * @tsplus macro identity

package/collection/internal.d.ts

@@ -0,0 +1 @@
+export {};

package/collection/mutable/ArrayDeque.d.ts

@@ -0,0 +1,41 @@
+import { IndexOutOfBoundsError, NoSuchElementError } from "@fncts/base/data/exceptions";
+import { Maybe, Nothing, Just } from "@fncts/base/data/Maybe/definition";
+/**
+ * @tsplus type fncts.MutableArrayDeque
+ * @tsplus companion fncts.MutableArrayDeque
+ */
+export declare class ArrayDeque<A> {
+    protected array: Array<A>;
+    private start;
+    private end;
+    constructor(array: Array<A>, start: number, end: number);
+    static empty<A>(initialSize?: number): ArrayDeque<A>;
+    protected requireBounds(idx: number, until?: number): void;
+    get(idx: number): A;
+    update(idx: number, elem: A): void;
+    addOne(elem: A): this;
+    prepend(elem: A): this;
+    insert(idx: number, elem: A): void;
+    remove(idx: number, count: number): void;
+    removeHead(resizeInternalRepr?: boolean): A;
+    removeHeadOption(resizeInternalRepr?: boolean): Maybe<A>;
+    removeLastOption(resizeInternalRepr?: boolean): Maybe<A>;
+    get isEmpty(): boolean;
+    private removeHeadAssumingNonEmpty;
+    private removeLastAssumingNonEmpty;
+    protected prependAssumingCapacity(elem: A): this;
+    protected appendAssumingCapacity(elem: A): this;
+    private ensureSize;
+    private resize;
+    private reset;
+    private mustGrow;
+    protected start_plus(idx: number): number;
+    private start_minus;
+    private end_plus;
+    private end_minus;
+    private _get;
+    private _set;
+    get length(): number;
+    copySliceToArray(srcStart: number, dest: Array<A>, destStart: number, maxItems: number): Array<A>;
+    private shouldShrink;
+}

package/collection/mutable/Queue.d.ts

@@ -0,0 +1,9 @@
+import { ArrayDeque } from "@fncts/base/collection/mutable/ArrayDeque";
+/**
+ * @tsplus type fncts.MutableQueue
+ * @tsplus companion fncts.MutableQueue
+ */
+export declare class Queue<A> extends ArrayDeque<A> {
+    enqueue(elem: A): this;
+    dequeue(): A;
+}

package/collection/mutable.d.ts

@@ -1,4 +1,6 @@
+export type {} from "./mutable/ArrayDeque.js";
 export type {} from "./mutable/HashMap.js";
 export type {} from "./mutable/HashSet.js";
 export type {} from "./mutable/internal.js";
 export type {} from "./mutable/ListBuffer.js";
+export type {} from "./mutable/Queue.js";

package/control/InterruptiblePromise.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @tsplus type fncts.InterruptiblePromise
+ * @tsplus companion fncts.InterruptiblePromiseOps
+ */
+export interface InterruptiblePromise<A> extends Promise<A> {
+    interrupt: () => void;
+}
+/**
+ * @tsplus static fncts.InterruptiblePromiseOps __call
+ * @tsplus location "@fncts/base/control/InterruptiblePromise"
+ */
+export declare function make<A>(executor: (resolve: (value: A | PromiseLike<A>) => void, reject: (reason?: unknown) => void) => (() => void) | void): InterruptiblePromise<A>;

package/data/Date/definition.d.ts

@@ -0,0 +1,9 @@
+declare global {
+    /** @tsplus type fncts.Date */
+    interface Date {
+    }
+    /** @tsplus type fncts.DateOps */
+    interface DateConstructor {
+    }
+}
+export {};

package/data/Date.d.ts

@@ -0,0 +1 @@
+export * from "./Date/definition.js";

package/data/Either/destructors.d.ts

@@ -3,4 +3,7 @@ import { Either } from "@fncts/base/data/Either/definition";
  * @tsplus pipeable fncts.Either match
  * @tsplus location "@fncts/base/data/Either/destructors"
  */
-export declare function match<E, A, B, C>(left: (e: E) => B, right: (a: A) => C): (self: Either<E, A>) => B | C;
+export declare function match<E, A, B, C>(cases: {
+    Left: (e: E) => B;
+    Right: (a: A) => C;
+}): (self: Either<E, A>) => B | C;

package/data/Global.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @since 1.0.0
+ */
+export declare const globalValue: <A>(id: unknown, compute: () => A) => A;

package/data.d.ts

@@ -5,6 +5,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";
@@ -20,6 +21,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/optics/Fold/api/focus.d.ts

@@ -0,0 +1,6 @@
+import type { Fold, FoldPartiallyApplied } from "@fncts/base/optics/Fold";
+/**
+ * @tsplus pipeable global focus 4
+ * @tsplus location "@fncts/base/optics/Fold/api/focus"
+ */
+export declare function focus<S, A>(fold: Fold<S, A>): (self: S) => FoldPartiallyApplied<A>;

package/optics/Fold/definition.d.ts

@@ -2,12 +2,18 @@ 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
  */
 export interface Fold<S, A> {
     readonly foldMap: foldMap<S, A>;
 }
+export interface FoldPartiallyApplied<A> {
+    readonly foldMap: foldMapPartiallyApplied<A>;
+}
 /**
  * @tsplus type fncts.optics.FoldOps
  */

package/optics/Getter/definition.d.ts

@@ -1,13 +1,19 @@
-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
  */
 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/optics/Index/api.d.ts

@@ -12,3 +12,8 @@ export declare function fromAt<T, J, B>(at: At<T, J, Maybe<B>>): Index<T, J, B>;
  * @tsplus location "@fncts/base/optics/Index/api"
  */
 export declare function fromIso<T, S>(iso: Iso<T, S>): <I, A>(index: Index<S, I, A>) => Index<T, I, A>;
+/**
+ * @tsplus static fncts.optics.IndexOps array
+ * @tsplus location "@fncts/base/optics/Index/api"
+ */
+export declare function array<A = never>(): Index<ReadonlyArray<A>, number, A>;

package/optics/Iso/api.d.ts

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

package/optics/Iso/definition.d.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";
 /**
@@ -8,6 +9,8 @@ import { PPrism } from "@fncts/base/optics/Prism";
 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/optics/Lens/api.d.ts

@@ -1,7 +1,13 @@
 import { ReadonlyNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
+import type { PLensPartiallyApplied } from "@fncts/base/optics/Lens/definition";
 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 pipeable global focus
+ * @tsplus location "@fncts/base/optics/Lens/api"
+ */
+export declare function focus<S, T, A, B>(lens: PLens<S, T, A, B>): (self: S) => PLensPartiallyApplied<T, A, B>;
 /**
  * @tsplus pipeable fncts.optics.PLens component
  * @tsplus location "@fncts/base/optics/Lens/api"
@@ -47,3 +53,8 @@ export declare function prop<A extends Record<string, any>, P extends keyof A>(p
  * @tsplus location "@fncts/base/optics/Lens/api"
  */
 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>>;
+/**
+ * @tsplus static fncts.optics.LensOps fromPath
+ * @tsplus location "@fncts/base/optics/Lens/api"
+ */
+export declare function fromPath<S, P extends Array<string>>(path: readonly [...AutoPath<S, P>]): Lens<S, Path<S, P>>;

package/optics/Lens/definition.d.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";
 import { POptional } from "@fncts/base/optics/Optional";
@@ -7,6 +8,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/optics/Optional/api/focus.d.ts

@@ -0,0 +1,6 @@
+import type { POptional, POptionalPartiallyApplied } from "@fncts/base/optics/Optional";
+/**
+ * @tsplus pipeable global focus 1
+ * @tsplus location "@fncts/base/optics/Optional/api/focus"
+ */
+export declare function focus<S, T, A, B>(optional: POptional<S, T, A, B>): (self: S) => POptionalPartiallyApplied<T, A, B>;

package/optics/Optional/api.d.ts

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

package/optics/Optional/definition.d.ts

@@ -1,6 +1,7 @@
 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 { PTraversalPartiallyApplied } from "@fncts/base/optics/Traversal";
 import { PTraversal } from "@fncts/base/optics/Traversal";
 /**
  * @tsplus type fncts.optics.POptional
@@ -10,6 +11,11 @@ export interface POptional<S, T, A, B> extends PTraversal<S, T, A, B> {
     readonly getOrModify: getOrModify<S, T, A>;
     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>;
@@ -56,3 +62,12 @@ 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/optics/Optional.d.ts

@@ -1,2 +1,4 @@
+export * from "./Optional/api.js";
 export * from "./Optional/definition.js";
 export * from "./Optional/api/compose.js";
+export * from "./Optional/api/focus.js";

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

@@ -0,0 +1,6 @@
+import type { PPrism, PPrismPartiallyApplied } from "@fncts/base/optics/Prism";
+/**
+ * @tsplus pipeable global focus
+ * @tsplus location "@fncts/base/optics/Prism/api/focus"
+ */
+export declare function focus<S, T, A, B>(prism: PPrism<S, T, A, B>): (self: S) => PPrismPartiallyApplied<T, A, B>;

package/optics/Prism/definition.d.ts

@@ -1,4 +1,4 @@
-import type { getOrModify } from "@fncts/base/optics/Optional";
+import type { getOrModify, POptionalPartiallyApplied } from "@fncts/base/optics/Optional";
 import { POptional } from "@fncts/base/optics/Optional";
 /**
  * @tsplus type fncts.optics.PPrism
@@ -6,6 +6,9 @@ import { POptional } from "@fncts/base/optics/Optional";
 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
  */

package/optics/Prism.d.ts

@@ -1,4 +1,5 @@
 export * from "./Prism/definition.js";
 export * from "./Prism/api/compose.js";
+export * from "./Prism/api/focus.js";
 export * from "./Prism/api/fromNullable.js";
 export * from "./Prism/api/just.js";

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

@@ -0,0 +1,6 @@
+import type { PSetter, PSetterPartiallyApplied } from "@fncts/base/optics/Setter";
+/**
+ * @tsplus pipeable global focus 3
+ * @tsplus location "@fncts/base/optics/Setter/api/focus"
+ */
+export declare function focus<S, T, A, B>(setter: PSetter<S, T, A, B>): (self: S) => PSetterPartiallyApplied<T, A, B>;

package/optics/Setter/definition.d.ts

@@ -5,6 +5,10 @@ export interface PSetter<S, T, A, B> {
     readonly modify: modify<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
  */
@@ -37,3 +41,9 @@ 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/optics/Traversal/api/focus.d.ts

@@ -0,0 +1,6 @@
+import type { PTraversal, PTraversalPartiallyApplied } from "@fncts/base/optics/Traversal";
+/**
+ * @tsplus pipeable global focus 2
+ * @tsplus location "@fncts/base/optics/Traversal/api/focus"
+ */
+export declare function focus<S, T, A, B>(traversal: PTraversal<S, T, A, B>): (self: S) => PTraversalPartiallyApplied<T, A, B>;

package/optics/Traversal/definition.d.ts

@@ -1,4 +1,6 @@
 import { HKT } from "@fncts/typelevel/HKT";
+import type { FoldPartiallyApplied } from "@fncts/base/optics/Fold";
+import type { PSetterPartiallyApplied } from "@fncts/base/optics/Setter";
 import type { Applicative } from "@fncts/base/typeclass";
 import { Fold } from "@fncts/base/optics/Fold";
 import { PSetter } from "@fncts/base/optics/Setter";
@@ -8,6 +10,9 @@ import { PSetter } from "@fncts/base/optics/Setter";
 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>(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 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>) => <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>;
 }

package/optics/Traversal.d.ts

@@ -1,3 +1,4 @@
 export * from "./Traversal/definition.js";
 export * from "./Traversal/api/compose.js";
+export * from "./Traversal/api/focus.js";
 export * from "./Traversal/api/fromTraversable.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fncts/base",
-  "version": "0.0.30",
+  "version": "0.0.32",
   "dependencies": {
     "@fncts/typelevel": "0.0.15",
     "uuid": "^9.0.0"