@fncts/base 0.0.31 → 0.0.33

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,13 @@ export function compose<A, B, C, D>(that: PIso<A, B, C, D>) {
     });
   };
 }
+
+/**
+ * @tsplus fluent global focus
+ */
+export function focus<S, T, A, B>(self: S, iso: PIso<S, T, A, B>): 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/Iso.ts

@@ -1,4 +1,5 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Iso/*.ts }
-export * from "./Iso/api.js";
 export * from "./Iso/definition.js";
+export * from "./Iso/api.js";
 // codegen:end

package/_src/optics/Lens/api.ts

@@ -1,10 +1,21 @@
-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 { 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 fluent global focus
+ */
+export function focus<S, T, A, B>(self: S, lens: PLens<S, T, A, B>): PLensPartiallyApplied<T, A, B> {
+  return {
+    ...self.focus(lens as POptional<S, T, A, B>),
+    get: () => lens.get(self),
+  };
+}
+
 /**
  * @tsplus pipeable fncts.optics.PLens component
  */
@@ -70,7 +81,7 @@ export function getProp<A extends Record<string, any>>() {
 /**
  * @tsplus static fncts.optics.PLensOps id
  */
-export function id<S, A = S>(): PLens<S, A, S, A> {
+export function id<A>(): Lens<A, A> {
   return PLens({
     get: identity,
     set: (t) => () => t,
@@ -114,16 +125,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 +141,19 @@ export function path<A extends Record<string, unknown>, P extends Array<string>>
     });
   };
 }
+
+/**
+ * @tsplus pipeable fncts.optics.Lens path
+ */
+export function path<A extends object, 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/Lens.ts

@@ -1,4 +1,5 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Lens/*.ts }
-export * from "./Lens/api.js";
 export * from "./Lens/definition.js";
+export * from "./Lens/api.js";
 // codegen:end

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

@@ -0,0 +1,14 @@
+import type { POptional, POptionalPartiallyApplied } from "@fncts/base/optics/Optional";
+import type { PTraversal } from "@fncts/base/optics/Traversal";
+
+/**
+ * @tsplus fluent global focus 1
+ */
+export function focus<S, T, A, B>(self: S, optional: POptional<S, T, A, B>): 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,10 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Optional/*.ts }
 export * from "./Optional/definition.js";
+export * from "./Optional/api.js";
 // codegen:end
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Optional/api/*.ts }
+export * from "./Optional/api/focus.js";
 export * from "./Optional/api/compose.js";
 // codegen:end

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

@@ -0,0 +1,12 @@
+import type { POptional } from "@fncts/base/optics/Optional";
+import type { PPrism, PPrismPartiallyApplied } from "@fncts/base/optics/Prism";
+
+/**
+ * @tsplus fluent global focus
+ */
+export function focus<S, T, A, B>(self: S, prism: PPrism<S, T, A, B>): 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

@@ -1,8 +1,11 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Prism/*.ts }
 export * from "./Prism/definition.js";
 // codegen:end
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Prism/api/*.ts }
-export * from "./Prism/api/compose.js";
-export * from "./Prism/api/fromNullable.js";
 export * from "./Prism/api/just.js";
+export * from "./Prism/api/fromNullable.js";
+export * from "./Prism/api/focus.js";
+export * from "./Prism/api/compose.js";
 // codegen:end

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

@@ -0,0 +1,11 @@
+import type { PSetter, PSetterPartiallyApplied } from "@fncts/base/optics/Setter";
+
+/**
+ * @tsplus fluent global focus 3
+ */
+export function focus<S, T, A, B>(self: S, setter: PSetter<S, T, A, B>): 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/Setter.ts

@@ -1,3 +1,4 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Setter/*.ts }
 export * from "./Setter/definition.js";
 // codegen:end

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

@@ -0,0 +1,14 @@
+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 fluent global focus 2
+ */
+export function focus<S, T, A, B>(self: S, traversal: PTraversal<S, T, A, B>): 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

@@ -1,7 +1,10 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Traversal/*.ts }
 export * from "./Traversal/definition.js";
 // codegen:end
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Traversal/api/*.ts }
-export * from "./Traversal/api/compose.js";
 export * from "./Traversal/api/fromTraversable.js";
+export * from "./Traversal/api/focus.js";
+export * from "./Traversal/api/compose.js";
 // codegen:end

package/_src/optics.ts

@@ -1,12 +1,13 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: type-barrel, include: ./optics/*.ts }
-export type {} from "./optics/At.js";
-export type {} from "./optics/Fold.js";
-export type {} from "./optics/Getter.js";
-export type {} from "./optics/Index.js";
-export type {} from "./optics/Iso.js";
-export type {} from "./optics/Lens.js";
-export type {} from "./optics/Optional.js";
-export type {} from "./optics/Prism.js";
-export type {} from "./optics/Setter.js";
 export type {} from "./optics/Traversal.js";
+export type {} from "./optics/Setter.js";
+export type {} from "./optics/Prism.js";
+export type {} from "./optics/Optional.js";
+export type {} from "./optics/Lens.js";
+export type {} from "./optics/Iso.js";
+export type {} from "./optics/Index.js";
+export type {} from "./optics/Getter.js";
+export type {} from "./optics/Fold.js";
+export type {} from "./optics/At.js";
 // codegen:end

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/_src/typeclass/Monoid.ts

@@ -77,6 +77,7 @@ export function deriveStruct<A extends Record<string, any>>(
   const [requiredFields, optionalFields] = args;
   const nat: Record<string, unknown>     = {};
   for (const field in requiredFields) {
+    // @ts-expect-error
     nat[field] = (requiredFields[field] as Monoid<any>).nat;
   }
   for (const field in optionalFields) {

package/_src/typeclass/Semigroup/derivations.ts

@@ -45,6 +45,7 @@ export function deriveStruct<A extends Record<string, any>>(
     combine: (y) => (x) => {
       const out: Record<string, unknown> = {};
       for (const field in requiredFields) {
+        // @ts-expect-error
         out[field] = (requiredFields[field]! as Semigroup<any>).combine(y[field])(x[field]);
       }
       for (const field in optionalFields) {

package/_src/typeclass/Semigroup.ts

@@ -1,4 +1,5 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: Semigroup/*.ts, exclude: Semigroup/derivations.ts }
-export * from "./Semigroup/api.js";
 export * from "./Semigroup/definition.js";
+export * from "./Semigroup/api.js";
 // codegen:end

package/_src/typeclass/builtin.ts

@@ -1,3 +1,4 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./builtin/*.ts }
 export * from "./builtin/Symbol.js";
 // codegen:end

package/_src/typeclass.ts

@@ -1,33 +1,34 @@
-// codegen:start { preset: barrel, include: ./typeclass/*.ts, exclude: ./typeclass/Showable.ts }
-export * from "./typeclass/Align.js";
-export * from "./typeclass/Alt.js";
-export * from "./typeclass/Alternative.js";
-export * from "./typeclass/Applicative.js";
-export * from "./typeclass/ApplicativeExcept.js";
-export * from "./typeclass/Apply.js";
+/* eslint-disable simple-import-sort/exports */
+// codegen:start { preset: barrel, include: ./typeclass/*.ts, exclude: typeclass/Showable.ts }
 export * from "./typeclass/builtin.js";
-export * from "./typeclass/Chain.js";
-export * from "./typeclass/Closure.js";
-export * from "./typeclass/Fail.js";
-export * from "./typeclass/Filterable.js";
-export * from "./typeclass/FilterableWithIndex.js";
-export * from "./typeclass/Foldable.js";
-export * from "./typeclass/FoldableWithIndex.js";
-export * from "./typeclass/Functor.js";
-export * from "./typeclass/FunctorWithIndex.js";
-export * from "./typeclass/Has.js";
-export * from "./typeclass/Monad.js";
-export * from "./typeclass/MonadExcept.js";
-export * from "./typeclass/Monoid.js";
-export * from "./typeclass/Nil.js";
-export * from "./typeclass/Pointed.js";
-export * from "./typeclass/Semialign.js";
-export * from "./typeclass/Semigroup.js";
-export * from "./typeclass/Semimonoidal.js";
-export * from "./typeclass/Traversable.js";
-export * from "./typeclass/TraversableWithIndex.js";
-export * from "./typeclass/Witherable.js";
 export * from "./typeclass/WitherableWithIndex.js";
+export * from "./typeclass/Witherable.js";
+export * from "./typeclass/TraversableWithIndex.js";
+export * from "./typeclass/Traversable.js";
+export * from "./typeclass/Semimonoidal.js";
+export * from "./typeclass/Semigroup.js";
+export * from "./typeclass/Semialign.js";
+export * from "./typeclass/Pointed.js";
+export * from "./typeclass/Nil.js";
+export * from "./typeclass/Monoid.js";
+export * from "./typeclass/MonadExcept.js";
+export * from "./typeclass/Monad.js";
+export * from "./typeclass/Has.js";
+export * from "./typeclass/FunctorWithIndex.js";
+export * from "./typeclass/Functor.js";
+export * from "./typeclass/FoldableWithIndex.js";
+export * from "./typeclass/Foldable.js";
+export * from "./typeclass/FilterableWithIndex.js";
+export * from "./typeclass/Filterable.js";
+export * from "./typeclass/Fail.js";
+export * from "./typeclass/Closure.js";
+export * from "./typeclass/Chain.js";
+export * from "./typeclass/Apply.js";
+export * from "./typeclass/ApplicativeExcept.js";
+export * from "./typeclass/Applicative.js";
+export * from "./typeclass/Alternative.js";
+export * from "./typeclass/Alt.js";
+export * from "./typeclass/Align.js";
 // codegen:end
 
 export { Eq } from "./data/Eq.js";

package/_src/types.ts

@@ -1,4 +1,5 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: types/*.ts }
-export * from "./types/extractions.js";
 export * from "./types/utility.js";
+export * from "./types/extractions.js";
 // codegen:end

package/_src/util.ts

@@ -1,8 +1,9 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: type-barrel, include: ./util/*.ts }
-export type {} from "./util/AnsiFormat.js";
-export type {} from "./util/assert.js";
+export type {} from "./util/rand.js";
+export type {} from "./util/predicates.js";
 export type {} from "./util/pattern.js";
+export type {} from "./util/assert.js";
 export type {} from "./util/PCGRandom.js";
-export type {} from "./util/predicates.js";
-export type {} from "./util/rand.js";
+export type {} from "./util/AnsiFormat.js";
 // codegen:end

package/collection/Iterable/api.d.ts

@@ -14,7 +14,7 @@ export declare function ap<A>(fa: Iterable<A>): <B>(self: Iterable<(a: A) => B>)
  * @tsplus pipeable fncts.Iterable append
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function append<B>(b: B): <A>(self: Iterable<A>) => Iterable<B | A>;
+export declare function append<B>(b: B): <A>(self: Iterable<A>) => Iterable<A | B>;
 /**
  * @tsplus getter fncts.Iterable toIterable
  * @tsplus location "@fncts/base/collection/Iterable/api"

package/collection/Iterable.d.ts

@@ -1,3 +1,3 @@
-export * from "./Iterable/api.js";
-export * from "./Iterable/constructors.js";
 export * from "./Iterable/definition.js";
+export * from "./Iterable/constructors.js";
+export * from "./Iterable/api.js";

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/compat/Array.d.ts

@@ -1,2 +1,2 @@
-export * from "./Array/api.js";
 export * from "./Array/definition.js";
+export * from "./Array/api.js";