@fncts/base 0.0.6 → 0.0.7

package/_src/data/Cause/api.ts

@@ -1,3 +1,5 @@
+import { EitherTag } from "@fncts/base/data/Either";
+
 import { Stack } from "../../internal/Stack.js";
 import { identity } from "../function.js";
 import { _Empty, Both, Cause, CauseTag, Empty, Fail, Halt, Interrupt, Stackless, Then } from "./definition.js";
@@ -55,7 +57,7 @@ export function both<E, E1>(left: Cause<E>, right: Cause<E1>): Cause<E | E1> {
  * @tsplus fluent fncts.Cause flatMap
  */
 export function flatMap_<E, D>(self: Cause<E>, f: (e: E) => Cause<D>): Cause<D> {
-  return Eval.run(chainEval(self, f));
+  return chainEval(self, f).run;
 }
 
 /**
@@ -64,7 +66,7 @@ export function flatMap_<E, D>(self: Cause<E>, f: (e: E) => Cause<D>): Cause<D>
  * @tsplus fluent fncts.Cause contains
  */
 export function contains_<E, E1 extends E = E>(self: Cause<E>, that: Cause<E1>): boolean {
-  return Eval.run(containsEval(self, that));
+  return containsEval(self, that).run;
 }
 
 /**
@@ -640,6 +642,15 @@ export function isInterrupt<E>(self: Cause<E>): self is Interrupt {
   return self._tag === CauseTag.Interrupt;
 }
 
+/**
+ * Determines if the `Cause` contains an interruption.
+ *
+ * @tsplus getter fncts.Cause isInterrupted
+ */
+export function isInterrupted<E>(self: Cause<E>): boolean {
+  return self.find((cause) => (cause.isInterrupt() ? Just(cause) : Nothing())).isJust();
+}
+
 /**
  * A type-guard matching `Traced`
  *
@@ -649,9 +660,9 @@ export function isTraced<E>(self: Cause<E>): boolean {
   return self
     .find((cause) => {
       switch (cause._tag) {
-        case "Halt":
-        case "Fail":
-        case "Interrupt":
+        case CauseTag.Halt:
+        case CauseTag.Fail:
+        case CauseTag.Interrupt:
           return cause.trace !== Trace.none ? Just(undefined) : Nothing();
         default:
           return Nothing();
@@ -687,8 +698,10 @@ export function interruptOption<E>(self: Cause<E>): Maybe<FiberId> {
  *
  * @tsplus getter fncts.Cause interruptors
  */
-export function interruptors<E>(self: Cause<E>): ReadonlySet<FiberId> {
-  return self.foldLeft(new Set(), (s, c) => (c._tag === CauseTag.Interrupt ? Just(s.add(c.id)) : Nothing()));
+export function interruptors<E>(self: Cause<E>): HashSet<FiberId> {
+  return self.foldLeft(HashSet.makeDefault(), (s, c) =>
+    c._tag === CauseTag.Interrupt ? Just(s.add(c.id)) : Nothing(),
+  );
 }
 
 /**
@@ -786,6 +799,39 @@ export function stripFailures<A>(self: Cause<A>): Cause<never> {
   });
 }
 
+/**
+ * Remove all `Halt` causes that the specified partial function is defined at,
+ * returning `Just` with the remaining causes or `Nothing` if there are no
+ * remaining causes.
+ *
+ * @tsplus fluent fncts.Cause stripSomeDefects
+ */
+export function stripSomeDefects<E>(self: Cause<E>, p: Predicate<unknown>): Maybe<Cause<E>> {
+  return self.fold({
+    Empty: () => Just(Empty()),
+    Fail: (e, trace) => Just(Fail(e, trace)),
+    Halt: (t, trace) => (p(t) ? Nothing() : Just(Halt(t, trace))),
+    Interrupt: (fiberId, trace) => Just(Interrupt(fiberId, trace)),
+    Then: (l, r) =>
+      l.isJust() && r.isJust()
+        ? Just(Then(l.value, r.value))
+        : l.isJust()
+        ? Just(l.value)
+        : r.isJust()
+        ? Just(r.value)
+        : Nothing(),
+    Both: (l, r) =>
+      l.isJust() && r.isJust()
+        ? Just(Then(l.value, r.value))
+        : l.isJust()
+        ? Just(l.value)
+        : r.isJust()
+        ? Just(r.value)
+        : Nothing(),
+    Stackless: (causeOption, stackless) => causeOption.map((cause) => Stackless(cause, stackless)),
+  });
+}
+
 function sequenceCauseEitherEval<E, A>(self: Cause<Either<E, A>>): Eval<Either<Cause<E>, A>> {
   switch (self._tag) {
     case CauseTag.Empty: {
@@ -811,8 +857,8 @@ function sequenceCauseEitherEval<E, A>(self: Cause<Either<E, A>>): Eval<Either<C
         (lefts, rights) => {
           Either.concrete(lefts);
           Either.concrete(rights);
-          return lefts._tag === "Left"
-            ? rights._tag === "Right"
+          return lefts._tag === EitherTag.Left
+            ? rights._tag === EitherTag.Right
               ? Either.right(rights.right)
               : Either.left(Cause.then(lefts.left, rights.left))
             : Either.right(lefts.right);
@@ -825,8 +871,8 @@ function sequenceCauseEitherEval<E, A>(self: Cause<Either<E, A>>): Eval<Either<C
         (lefts, rights) => {
           Either.concrete(lefts);
           Either.concrete(rights);
-          return lefts._tag === "Left"
-            ? rights._tag === "Right"
+          return lefts._tag === EitherTag.Left
+            ? rights._tag === EitherTag.Right
               ? Either.right(rights.right)
               : Either.left(Cause.both(lefts.left, rights.left))
             : Either.right(lefts.right);
@@ -870,11 +916,11 @@ function sequenceCauseMaybeEval<E>(self: Cause<Maybe<E>>): Eval<Maybe<Cause<E>>>
         (lefts, rights) => {
           Maybe.concrete(lefts);
           Maybe.concrete(rights);
-          return lefts._tag === "Just"
-            ? rights._tag === "Just"
+          return lefts._tag === MaybeTag.Just
+            ? rights._tag === MaybeTag.Just
               ? Maybe.just(Cause.then(lefts.value, rights.value))
               : lefts
-            : rights._tag === "Just"
+            : rights._tag === MaybeTag.Just
             ? rights
             : Maybe.nothing();
         },
@@ -886,11 +932,11 @@ function sequenceCauseMaybeEval<E>(self: Cause<Maybe<E>>): Eval<Maybe<Cause<E>>>
         (lefts, rights) => {
           Maybe.concrete(lefts);
           Maybe.concrete(rights);
-          return lefts._tag === "Just"
-            ? rights._tag === "Just"
+          return lefts._tag === MaybeTag.Just
+            ? rights._tag === MaybeTag.Just
               ? Maybe.just(Cause.both(lefts.value, rights.value))
               : lefts
-            : rights._tag === "Just"
+            : rights._tag === MaybeTag.Just
             ? rights
             : Maybe.nothing();
         },
@@ -913,52 +959,31 @@ export function sequenceCauseMaybe<E>(self: Cause<Maybe<E>>): Maybe<Cause<E>> {
   return Eval.run(sequenceCauseMaybeEval(self));
 }
 
-// /**
-//  * Squashes a `Cause` down to a single `Error`, chosen to be the
-//  * "most important" `Error`.
-//  */
-// export function squash_<Id>(
-//   S: P.Show<Id>
-// ): <E>(cause: Cause<E>, f: (e: E) => unknown) => unknown {
-//   return (cause, f) =>
-//     cause.failureOption
-//       .map(f)
-//       .orElse(
-//         interrupted(cause)
-//           ? Maybe.just<unknown>(
-//               new InterruptedException(
-//                 "Interrupted by fibers: " +
-//                   Array.from(interruptors(cause))
-//                     .map((id) => S.show(id))
-//                     .join(", ")
-//               )
-//             )
-//           : Maybe.nothing()
-//       )
-//       .orElse(defects(cause).head)
-//       .getOrElse(new InterruptedException("Interrupted"));
-// }
-
-// /**
-//  * @tsplus getter PCause squash
-//  */
-// export function squash0<Id, E>(self: Cause<E>) {
-//   return (S: P.Show<Id>) =>
-//     (f: (e: E) => unknown): unknown =>
-//       squash_(S)(self, f);
-// }
-
-// /**
-//  * Squashes a `Cause` down to a single `Error`, chosen to be the
-//  * "most important" `Error`.
-//  *
-//  * @dataFirst squash_
-//  */
-// export function squash<Id>(
-//   S: P.Show<Id>
-// ): <E>(f: (e: E) => unknown) => (cause: Cause<E>) => unknown {
-//   return (f) => (cause) => squash_(S)(cause, f);
-// }
+/**
+ * Squashes a `Cause` down to a single `Error`, chosen to be the
+ * "most important" `Error`.
+ *
+ * @tsplus fluent fncts.Cause squashWith
+ */
+export function squashWith_<E>(self: Cause<E>, f: (e: E) => unknown): unknown {
+  return self.failureMaybe
+    .map(f)
+    .orElse(
+      self.isInterrupted
+        ? Just(
+            new InterruptedException(
+              "Interrupted by fibers: " +
+                self.interruptors
+                  .flatMap((id) => id.ids)
+                  .map((id) => `#${id}`)
+                  .join(", "),
+            ),
+          )
+        : Nothing(),
+    )
+    .orElse(self.defects.head)
+    .getOrElse(new InterruptedException());
+}
 
 /**
  * Constructs a `Cause` from two `Cause`s, representing sequential failures.

package/_src/data/Const/instances.ts

@@ -1,5 +1,5 @@
 import type * as P from "../../typeclass.js";
-import type { Const1F,ConstF } from "@fncts/base/data/Const/definition";
+import type { Const1F } from "@fncts/base/data/Const/definition";
 
 import { Const } from "@fncts/base/data/Const/definition";
 

package/_src/data/Either/api.ts

@@ -140,6 +140,11 @@ export function map_<E, A, B>(self: Either<E, A>, f: (a: A) => B): Either<E, B>
   return self._tag === EitherTag.Left ? self : Right(f(self.right));
 }
 
+/**
+ * @tsplus static fncts.EitherOps map
+ */
+export const map = Pipeable(map_);
+
 /**
  * @tsplus fluent fncts.Either mapLeft
  */

package/_src/data/Exit/api.ts

@@ -5,7 +5,7 @@ import { ExitTag } from "./definition.js";
  * @tsplus fluent fncts.Exit ap
  */
 export function ap_<E, A, G, B>(fab: Exit<G, (a: A) => B>, fa: Exit<E, A>): Exit<E | G, B> {
-  return flatMap_(fab, (f) => map_(fa, (a) => f(a)));
+  return fab.flatMap((f) => fa.map((a) => f(a)));
 }
 
 /**

package/_src/data/Struct/api.ts

@@ -1,5 +1,97 @@
+import type { Union } from "@fncts/typelevel";
+
+import { Eq } from "@fncts/base/typeclass";
+
 import { Struct } from "./definition.js";
 
+export type EnsureLiteral<N> = string extends N ? never : [N] extends [Union.IntersectionOf<N>] ? N : never;
+
+export type TestLiteral<N> = string extends N ? unknown : [N] extends [Union.IntersectionOf<N>] ? N : unknown;
+
+export type EnsureNonexistentProperty<T, N extends string> = Extract<keyof T, N> extends never ? T : never;
+
+export type EnsureLiteralKeys<O> = string extends keyof O ? never : O;
+
+export type EnsureLiteralTuple<A extends ReadonlyArray<unknown>> = unknown extends {
+  [K in keyof A]: A[K] extends string ? TestLiteral<A[K]> : unknown;
+}[number]
+  ? never
+  : A;
+
+/**
+ * @tsplus static fncts.StructOps __call
+ * @tsplus macro identity
+ */
+export function makeStruct<A>(a: A): Struct<A> {
+  return Struct.get(a);
+}
+
+/**
+ * @tsplus fluent fncts.Struct set
+ */
+export function set_<A, N extends string, B>(
+  self: Struct<A>,
+  key: EnsureLiteral<N>,
+  value: B,
+): Struct<{ [P in Exclude<keyof A, N> | N]: P extends Exclude<keyof A, N> ? A[P] : B }> {
+  return Struct.get({ ...self.getStruct, [key]: value }) as Struct<any>;
+}
+
+/**
+ * @tsplus fluent fncts.Struct hmap
+ */
+export function hmap_<A extends {}, F extends { [N in keyof A]: (a: A[N]) => any }>(
+  self: Struct<A>,
+  fs: F,
+): Struct<{ readonly [K in keyof F]: ReturnType<F[K]> }> {
+  const keys = self.keys;
+  const out  = {} as any;
+  for (const key of keys) {
+    out[key] = fs[key](unsafeCoerce(self.getStruct[key]));
+  }
+  return out;
+}
+
+/**
+ * @tsplus fluent fncts.Struct modify
+ */
+export function modify_<A, N extends keyof A, B>(
+  self: Struct<A>,
+  key: N,
+  f: (a: A[N]) => B,
+): Struct<{ readonly [P in Exclude<keyof A, N> | N]: P extends Exclude<keyof A, N> ? A[P] : B }> {
+  return Struct.get({ ...self.getStruct, [key]: f(self.getStruct[key]) }) as Struct<any>;
+}
+
+/**
+ * @tsplus fluent fncts.Struct pick
+ */
+export function pick_<A, N extends ReadonlyArray<keyof A>>(
+  self: Struct<A>,
+  keys: [...N],
+): Struct<{ readonly [P in N[number]]: A[P] }> {
+  const out = {} as Pick<A, N[number]>;
+  for (const key of keys) {
+    out[key] = self.getStruct[key];
+  }
+  return Struct.get(out);
+}
+
+/**
+ * @tsplus fluent fncts.Struct omit
+ */
+export function omit_<A extends {}, N extends ReadonlyArray<keyof A>>(
+  self: Struct<A>,
+  keys: [...N],
+): Struct<{ readonly [P in Exclude<keyof A, N[number]>]: A[P] }> {
+  const newKeys = keys.asImmutableArray.difference(self.keys.asImmutableArray, Eq({ equals: (x, y) => x === y }));
+  const out     = {} as any;
+  for (const key of newKeys) {
+    out[key] = self.getStruct[key];
+  }
+  return Struct.get(out);
+}
+
 /**
  * @tsplus fluent fncts.Struct map
  */
@@ -8,15 +100,22 @@ export function map_<A, B>(self: Struct<A>, f: (a: A[keyof A]) => B): Struct<Rec
   const keys = Object.keys(self);
   for (let i = 0; i < keys.length; i++) {
     const k = keys[i]! as keyof A;
-    out[k]  = f(self.reverseGet[k]);
+    out[k]  = f(self.getStruct[k]);
   }
   return Struct.get(out);
 }
 
 /**
- * @tsplus getter fncts.Struct reverseGet
+ * @tsplus getter fncts.Struct keys
+ */
+export function keys<A extends {}>(self: Struct<A>): ReadonlyArray<keyof A> {
+  return unsafeCoerce(Object.keys(self.getStruct));
+}
+
+/**
+ * @tsplus getter fncts.Struct getStruct
  * @tsplus macro identity
  */
-export function reverseGet<A>(self: Struct<A>): A {
+export function getStruct<A>(self: Struct<A>): A {
   return Struct.reverseGet(self);
 }

package/_src/data/exceptions/InterruptedException.ts

@@ -5,7 +5,7 @@ export type InterruptedExceptionTypeId = typeof InterruptedExceptionTypeId;
 
 export class InterruptedException {
   readonly _typeId: InterruptedExceptionTypeId = InterruptedExceptionTypeId;
-  constructor(readonly message: string) {}
+  constructor(readonly message?: string) {}
 }
 
 export function isInterruptedException(u: unknown): u is InterruptedException {

package/_src/typeclass/MonadExcept.ts

@@ -4,7 +4,7 @@ import type { Monad } from "@fncts/base/typeclass/Monad";
 /**
  * @tsplus type fncts.MonadExcept
  */
-export interface MonadExcept<F> extends Monad<F>, ApplicativeExcept<F> {}
+export interface MonadExcept<F extends HKT> extends Monad<F>, ApplicativeExcept<F> {}
 
 /**
  * @tsplus type fncts.MonadExceptOps

package/_src/typeclass/Showable/show.ts

@@ -400,9 +400,9 @@ function showRaw(value: object, typedArray?: string): ShowComputation {
               case "InspectionInfo": {
                 base = Z.succeedNow(info.base);
                 keys = Conc.from(info.keys)
-                  .traverse((key) => showProperty(value, key, info.extrasType))
+                  .traverse((key) => showProperty(value, key, info.extrasType), Z.Applicative)
                   .crossWith(
-                    info.protoProps.traverse((key) => showProperty(value, key, PROTO_TYPE)),
+                    info.protoProps.traverse((key) => showProperty(value, key, PROTO_TYPE), Z.Applicative),
                     (k1, k2) => k1.concat(k2),
                   );
                 indices    = info.formatter(value);
@@ -546,6 +546,7 @@ function showMap(value: Map<unknown, unknown>): ShowComputationChunk {
     .apSecond(
       (value as Iterable<[unknown, unknown]>).traverseToConc(([k, v]) =>
         _show(k).crossWith(_show(v), (k, v) => `${k} => ${v}`),
+        Z.Applicative
       ),
     )
     .apFirst(
@@ -577,7 +578,7 @@ function showTypedArray(value: TypedArray): ShowComputationChunk {
           .apSecond(
             Z.succeedNow(output).flatMap((output) =>
               Conc("BYTES_PER_ELEMENT", "length", "byteLength", "byteOffset", "buffer")
-                .traverse((key) => _show(value[key as keyof TypedArray]).map((shown) => `[${key}]: ${shown}`))
+                .traverse((key) => _show(value[key as keyof TypedArray]).map((shown) => `[${key}]: ${shown}`), Z.Applicative)
                 .map((shownKeys) => output.concat(shownKeys)),
             ),
           )

package/_src/util/AnsiFormat.ts

@@ -246,11 +246,11 @@ function generateStyles() {
   }));
 
   return {
-    ...Struct.get(modifiers).map(([open, close]) => style(open, close)).reverseGet,
-    ...Struct.get(colors).map(([open, close]) => style(open, close)).reverseGet,
-    ...Struct.get(colorsBright).map(([open, close]) => style(open, close)).reverseGet,
-    ...Struct.get(colorsBg).map(([open, close]) => style(open, close)).reverseGet,
-    ...Struct.get(colorsBrightBg).map(([open, close]) => style(open, close)).reverseGet,
+    ...Struct(modifiers).map(([open, close]) => style(open, close)).getStruct,
+    ...Struct(colors).map(([open, close]) => style(open, close)).getStruct,
+    ...Struct(colorsBright).map(([open, close]) => style(open, close)).getStruct,
+    ...Struct(colorsBg).map(([open, close]) => style(open, close)).getStruct,
+    ...Struct(colorsBrightBg).map(([open, close]) => style(open, close)).getStruct,
   };
 }
 

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

@@ -1,9 +1,20 @@
 import { Dictionary } from "@fncts/base/collection/immutable/Dictionary/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+/**
+ * @tsplus fluent fncts.Dictionary foldLeft
+ * @tsplus location "@fncts/base/collection/immutable/Dictionary/api"
+ */
+export declare function foldLeft_<A, B>(self: Dictionary<A>, b: B, f: (b: B, a: A) => B): B;
 /**
  * @tsplus fluent fncts.Dictionary foldLeftWithIndex
  * @tsplus location "@fncts/base/collection/immutable/Dictionary/api"
  */
 export declare function foldLeftWithIndex_<A, B>(self: Dictionary<A>, b: B, f: (k: string, b: B, a: A) => B): B;
+/**
+ * @tsplus fluent fncts.Dictionary get
+ * @tsplus location "@fncts/base/collection/immutable/Dictionary/api"
+ */
+export declare function get_<A>(self: Dictionary<A>, key: string): Maybe<A>;
 /**
  * @tsplus getter fncts.Dictionary keys
  * @tsplus location "@fncts/base/collection/immutable/Dictionary/api"
@@ -25,3 +36,8 @@ export declare function mapWithIndex_<A, B>(self: Dictionary<A>, f: (k: string,
  * @tsplus location "@fncts/base/collection/immutable/Dictionary/api"
  */
 export declare function toRecord<A>(self: Dictionary<A>): Record<string, A>;
+/**
+ * @tsplus fluent fncts.Dictionary unsafeGet
+ * @tsplus location "@fncts/base/collection/immutable/Dictionary/api"
+ */
+export declare function unsafeGet_<A>(self: Dictionary<A>, key: string): A | undefined;

package/data/Cause/api.d.ts

@@ -6,6 +6,7 @@ import { Either } from "@fncts/base/data/Either/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
+import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
 import { Both, Cause, Fail, Halt, Interrupt, Then } from "./definition.js";
 /**
  * @tsplus fluent fncts.Cause as
@@ -187,6 +188,12 @@ export declare function isThen<E>(self: Cause<E>): self is Then<E>;
  * @tsplus location "@fncts/base/data/Cause/api"
  */
 export declare function isInterrupt<E>(self: Cause<E>): self is Interrupt;
+/**
+ * Determines if the `Cause` contains an interruption.
+ * @tsplus getter fncts.Cause isInterrupted
+ * @tsplus location "@fncts/base/data/Cause/api"
+ */
+export declare function isInterrupted<E>(self: Cause<E>): boolean;
 /**
  * A type-guard matching `Traced`
  * @tsplus getter fncts.Cause isTraced
@@ -211,7 +218,7 @@ export declare function interruptOption<E>(self: Cause<E>): Maybe<FiberId>;
  * @tsplus getter fncts.Cause interruptors
  * @tsplus location "@fncts/base/data/Cause/api"
  */
-export declare function interruptors<E>(self: Cause<E>): ReadonlySet<FiberId>;
+export declare function interruptors<E>(self: Cause<E>): HashSet<FiberId>;
 /**
  * Determines if the `Cause` contains only interruptions and not any `Halt` or
  * `Fail` causes.
@@ -248,6 +255,14 @@ export declare function stackless<E>(cause: Cause<E>, stackless: boolean): Cause
  * @tsplus location "@fncts/base/data/Cause/api"
  */
 export declare function stripFailures<A>(self: Cause<A>): Cause<never>;
+/**
+ * Remove all `Halt` causes that the specified partial function is defined at,
+ * returning `Just` with the remaining causes or `Nothing` if there are no
+ * remaining causes.
+ * @tsplus fluent fncts.Cause stripSomeDefects
+ * @tsplus location "@fncts/base/data/Cause/api"
+ */
+export declare function stripSomeDefects<E>(self: Cause<E>, p: Predicate<unknown>): Maybe<Cause<E>>;
 /**
  * Converts the specified `Cause<Either<E, A>>` to an `Either<Cause<E>, A>`.
  * @tsplus getter fncts.Cause sequenceCauseEither
@@ -260,6 +275,13 @@ export declare function sequenceCauseEither<E, A>(self: Cause<Either<E, A>>): Ei
  * @tsplus location "@fncts/base/data/Cause/api"
  */
 export declare function sequenceCauseMaybe<E>(self: Cause<Maybe<E>>): Maybe<Cause<E>>;
+/**
+ * Squashes a `Cause` down to a single `Error`, chosen to be the
+ * "most important" `Error`.
+ * @tsplus fluent fncts.Cause squashWith
+ * @tsplus location "@fncts/base/data/Cause/api"
+ */
+export declare function squashWith_<E>(self: Cause<E>, f: (e: E) => unknown): unknown;
 /**
  * Constructs a `Cause` from two `Cause`s, representing sequential failures.
  * @note If one of the `Cause`s is `Empty`, the non-empty `Cause` is returned

package/data/Either/api.d.ts

@@ -87,6 +87,12 @@ export declare function isRight<E, A>(self: Either<E, A>): self is Right<A>;
  * @tsplus location "@fncts/base/data/Either/api"
  */
 export declare function map_<E, A, B>(self: Either<E, A>, f: (a: A) => B): Either<E, B>;
+/**
+ * @tsplus static fncts.EitherOps map
+ * @tsplus pipeable fncts.Either map
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare const map: <A, B>(f: (a: A) => B) => <E>(self: import("./definition.js").Either<E, A>) => import("./definition.js").Either<E, B>;
 /**
  * @tsplus fluent fncts.Either mapLeft
  * @tsplus location "@fncts/base/data/Either/api"

package/data/Struct/api.d.ts

@@ -1,12 +1,68 @@
+import type { Union } from "@fncts/typelevel";
 import { Struct } from "./definition.js";
+export declare type EnsureLiteral<N> = string extends N ? never : [N] extends [Union.IntersectionOf<N>] ? N : never;
+export declare type TestLiteral<N> = string extends N ? unknown : [N] extends [Union.IntersectionOf<N>] ? N : unknown;
+export declare type EnsureNonexistentProperty<T, N extends string> = Extract<keyof T, N> extends never ? T : never;
+export declare type EnsureLiteralKeys<O> = string extends keyof O ? never : O;
+export declare type EnsureLiteralTuple<A extends ReadonlyArray<unknown>> = unknown extends {
+    [K in keyof A]: A[K] extends string ? TestLiteral<A[K]> : unknown;
+}[number] ? never : A;
+/**
+ * @tsplus static fncts.StructOps __call
+ * @tsplus macro identity
+ * @tsplus location "@fncts/base/data/Struct/api"
+ */
+export declare function makeStruct<A>(a: A): Struct<A>;
+/**
+ * @tsplus fluent fncts.Struct set
+ * @tsplus location "@fncts/base/data/Struct/api"
+ */
+export declare function set_<A, N extends string, B>(self: Struct<A>, key: EnsureLiteral<N>, value: B): Struct<{
+    [P in Exclude<keyof A, N> | N]: P extends Exclude<keyof A, N> ? A[P] : B;
+}>;
+/**
+ * @tsplus fluent fncts.Struct hmap
+ * @tsplus location "@fncts/base/data/Struct/api"
+ */
+export declare function hmap_<A extends {}, F extends {
+    [N in keyof A]: (a: A[N]) => any;
+}>(self: Struct<A>, fs: F): Struct<{
+    readonly [K in keyof F]: ReturnType<F[K]>;
+}>;
+/**
+ * @tsplus fluent fncts.Struct modify
+ * @tsplus location "@fncts/base/data/Struct/api"
+ */
+export declare function modify_<A, N extends keyof A, B>(self: Struct<A>, key: N, f: (a: A[N]) => B): Struct<{
+    readonly [P in Exclude<keyof A, N> | N]: P extends Exclude<keyof A, N> ? A[P] : B;
+}>;
+/**
+ * @tsplus fluent fncts.Struct pick
+ * @tsplus location "@fncts/base/data/Struct/api"
+ */
+export declare function pick_<A, N extends ReadonlyArray<keyof A>>(self: Struct<A>, keys: [...N]): Struct<{
+    readonly [P in N[number]]: A[P];
+}>;
+/**
+ * @tsplus fluent fncts.Struct omit
+ * @tsplus location "@fncts/base/data/Struct/api"
+ */
+export declare function omit_<A extends {}, N extends ReadonlyArray<keyof A>>(self: Struct<A>, keys: [...N]): Struct<{
+    readonly [P in Exclude<keyof A, N[number]>]: A[P];
+}>;
 /**
  * @tsplus fluent fncts.Struct map
  * @tsplus location "@fncts/base/data/Struct/api"
  */
 export declare function map_<A, B>(self: Struct<A>, f: (a: A[keyof A]) => B): Struct<Record<keyof A, B>>;
 /**
- * @tsplus getter fncts.Struct reverseGet
+ * @tsplus getter fncts.Struct keys
+ * @tsplus location "@fncts/base/data/Struct/api"
+ */
+export declare function keys<A extends {}>(self: Struct<A>): ReadonlyArray<keyof A>;
+/**
+ * @tsplus getter fncts.Struct getStruct
  * @tsplus macro identity
  * @tsplus location "@fncts/base/data/Struct/api"
  */
-export declare function reverseGet<A>(self: Struct<A>): A;
+export declare function getStruct<A>(self: Struct<A>): A;

package/data/exceptions/InterruptedException.d.ts

@@ -1,8 +1,8 @@
 export declare const InterruptedExceptionTypeId: unique symbol;
 export declare type InterruptedExceptionTypeId = typeof InterruptedExceptionTypeId;
 export declare class InterruptedException {
-    readonly message: string;
+    readonly message?: string | undefined;
     readonly _typeId: InterruptedExceptionTypeId;
-    constructor(message: string);
+    constructor(message?: string | undefined);
 }
 export declare function isInterruptedException(u: unknown): u is InterruptedException;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fncts/base",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "dependencies": {
     "@fncts/typelevel": "0.0.6"
   },

package/typeclass/MonadExcept.d.ts

@@ -5,7 +5,7 @@ import type { Monad } from "@fncts/base/typeclass/Monad";
 /**
  * @tsplus type fncts.MonadExcept
  */
-export interface MonadExcept<F> extends Monad<F>, ApplicativeExcept<F> {
+export interface MonadExcept<F extends HKT> extends Monad<F>, ApplicativeExcept<F> {
 }
 /**
  * @tsplus type fncts.MonadExceptOps