@fncts/base 0.0.31 → 0.0.32

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

@@ -22,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

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