@fncts/base 0.0.5 → 0.0.8

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/Conc/api.d.ts

@@ -5,6 +5,7 @@ import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Predicate, PredicateWithIndex } from "@fncts/base/data/Predicate/definition";
 import { Refinement, RefinementWithIndex } from "@fncts/base/data/Refinement/definition";
 import { HKT } from "@fncts/typelevel/HKT";
+import { Byte } from "@fncts/base/data/Byte";
 import type { ConcF } from "@fncts/base/collection/immutable/Conc/definition";
 import type { Eq } from "@fncts/base/typeclass";
 import type * as P from "@fncts/base/typeclass";
@@ -299,6 +300,11 @@ export declare const traverse: P.Traversable<ConcF>["traverse"];
  */
 export declare function traverseWithIndex<G extends HKT, KG, QG, WG, XG, IG, SG, RG, EG, A, B>(self: Conc<A>, f: (i: number, a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, B>, 
 /** @tsplus auto */ G: P.Applicative<G>): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, Conc<B>>;
+/**
+ * @tsplus getter fncts.Conc toBuffer
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function toBuffer(self: Conc<Byte>): Uint8Array;
 /**
  * @tsplus fluent fncts.ConcOps unfold
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"

package/collection/immutable/Conc/definition.d.ts

@@ -1,5 +1,9 @@
 import { Hashable } from "@fncts/base/typeclass/Hashable";
 import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { HKT } from "@fncts/typelevel/HKT";
+import { isByte } from "@fncts/base/util/predicates";
+import { IndexOutOfBoundsError, ArrayIndexOutOfBoundsError } from "@fncts/base/data/exceptions";
+import { unsafeCoerce } from "@fncts/base/data/function/api";
 export declare const BUFFER_SIZE = 64;
 export declare const UPDATE_BUFFER_SIZE = 256;
 export declare const ConcTypeId: unique symbol;

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/collection/immutable/HashMap/definition.d.ts

@@ -1,5 +1,6 @@
 import { Hashable } from "@fncts/base/typeclass/Hashable";
 import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { HKT } from "@fncts/typelevel/HKT";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import type { Node } from "@fncts/base/collection/immutable/HashMap/internal";
 import type { HashEq } from "@fncts/base/typeclass";

package/collection/immutable/HashMap/internal.d.ts

@@ -1,4 +1,4 @@
-import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Nothing, Maybe } from "@fncts/base/data/Maybe/definition";
 import type { Eq } from "@fncts/base/typeclass";
 export declare const SIZE = 5;
 export declare const BUCKET_SIZE: number;

package/collection/immutable/HashSet/definition.d.ts

@@ -1,3 +1,4 @@
+import { Hashable } from "@fncts/base/typeclass/Hashable";
 import * as P from "@fncts/base/typeclass";
 /**
  * @tsplus type fncts.HashSet

package/collection/immutable/ImmutableArray/definition.d.ts

@@ -1,5 +1,6 @@
 import { Equatable } from "@fncts/base/typeclass/Equatable";
 import { Hashable } from "@fncts/base/typeclass/Hashable";
+import { HKT } from "@fncts/typelevel/HKT";
 export declare const ImmutableArrayTypeId: unique symbol;
 export declare type ImmutableArrayTypeId = typeof ImmutableArrayTypeId;
 export interface ImmutableArrayF extends ImmutableArray<any> {

package/collection/immutable/ImmutableNonEmptyArray/definition.d.ts

@@ -1,3 +1,4 @@
+import { HKT } from "@fncts/typelevel/HKT";
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 export interface ImmutableNonEmptyArrayF extends ImmutableNonEmptyArray<any> {
 }

package/collection/immutable/RoseTree/definition.d.ts

@@ -1,5 +1,6 @@
 import { Hashable } from "@fncts/base/typeclass/Hashable";
 import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { HKT } from "@fncts/typelevel/HKT";
 import { Vector } from "@fncts/base/collection/immutable/Vector";
 export declare const RoseTreeTypeId: unique symbol;
 export declare type RoseTreeTypeId = typeof RoseTreeTypeId;

package/collection/immutable/SortedMap/iterator.d.ts

@@ -1,5 +1,5 @@
 import { SortedMap } from "@fncts/base/collection/immutable/SortedMap/definition";
-import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Maybe, Nothing, Just } from "@fncts/base/data/Maybe/definition";
 import type { RBNode } from "@fncts/base/collection/immutable/SortedMap/node";
 import type { Ord } from "@fncts/base/typeclass";
 import { Node } from "@fncts/base/collection/immutable/SortedMap/node";

package/collection/immutable/Vector/definition.d.ts

@@ -1,3 +1,6 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import { Hashable } from "@fncts/base/typeclass/Hashable";
+import { Equatable } from "@fncts/base/typeclass/Equatable";
 import type { Node } from "@fncts/base/collection/immutable/Vector/internal";
 export declare const VectorTypeId: unique symbol;
 export declare type VectorTypeId = typeof VectorTypeId;

package/collection/mutable/HashMap.d.ts

@@ -1,4 +1,5 @@
-import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Maybe, Just, Nothing } from "@fncts/base/data/Maybe/definition";
+import { unsafeCoerce } from "@fncts/base/data/function/api";
 import { HashEq } from "@fncts/base/typeclass/HashEq";
 /**
  * @tsplus type fncts.MutableHashMap

package/collection/mutable/HashSet.d.ts

@@ -1,3 +1,4 @@
+import { unsafeCoerce } from "@fncts/base/data/function/api";
 import { HashEq } from "@fncts/base/typeclass/HashEq";
 /**
  * @tsplus type fncts.MutableHashSet

package/collection/mutable/ListBuffer.d.ts

@@ -1,4 +1,5 @@
 import { List, Cons } from "@fncts/base/collection/immutable/List/definition";
+import { NoSuchElementError, IndexOutOfBoundsError } from "@fncts/base/data/exceptions";
 export declare class ListBuffer<A> implements Iterable<A> {
     private first;
     private last0;

package/control/Eval/definition.d.ts

@@ -1,3 +1,4 @@
+import { HKT } from "@fncts/typelevel/HKT";
 export declare const EvalTypeId: unique symbol;
 export declare type EvalTypeId = typeof EvalTypeId;
 export interface EvalF extends Eval<any> {

package/control/Z/definition.d.ts

@@ -1,3 +1,4 @@
+import { HKT } from "@fncts/typelevel/HKT";
 import { Cause } from "@fncts/base/data/Cause/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 export interface ZF extends Z<any, any, any, any, any, any> {

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/Const/definition.d.ts

@@ -1,3 +1,4 @@
+import { HKT } from "@fncts/typelevel/HKT";
 /**
  * @tsplus type fncts.ConstF
  */

package/data/Decoder/definition.d.ts

@@ -1,3 +1,4 @@
+import { HKT } from "@fncts/typelevel/HKT";
 import { These } from "@fncts/base/data/These";
 import type { DecodeError } from "@fncts/base/data/DecodeError";
 export declare const DecoderTypeId: unique symbol;

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/Either/definition.d.ts

@@ -1,3 +1,4 @@
+import { HKT } from "@fncts/typelevel/HKT";
 export declare const enum EitherTag {
     Left = "Left",
     Right = "Right"

package/data/Exit/definition.d.ts

@@ -1,4 +1,5 @@
 import { Cause } from "@fncts/base/data/Cause/definition";
+import { Hashable } from "@fncts/base/typeclass/Hashable";
 import * as P from "../../typeclass.js";
 export declare const ExitTypeId: unique symbol;
 export declare type ExitTypeId = typeof ExitTypeId;

package/data/Identity/definition.d.ts

@@ -1,3 +1,4 @@
+import { HKT } from "@fncts/typelevel/HKT";
 import { Newtype, NewtypeIso } from "@fncts/base/data/Newtype";
 export interface IdentityN {
     readonly [HKT.T]: Identity<HKT._A<this>>;

package/data/Maybe/definition.d.ts

@@ -1,3 +1,6 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { Hashable } from "@fncts/base/typeclass/Hashable";
 export declare const enum MaybeTag {
     Just = "Just",
     Nothing = "Nothing"

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,8 +1,8 @@
 {
   "name": "@fncts/base",
-  "version": "0.0.5",
+  "version": "0.0.8",
   "dependencies": {
-    "@fncts/typelevel": "0.0.5"
+    "@fncts/typelevel": "0.0.6"
   },
   "exports": {
     "./*": {

package/typeclass/Guard/definition.d.ts

@@ -1,3 +1,4 @@
+import { HKT } from "@fncts/typelevel/HKT";
 import { Refinement } from "@fncts/base/data/Refinement/definition";
 export interface GuardF extends Guard<any> {
 }

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

package/typeclass/Showable/show.d.ts

@@ -1,4 +1,5 @@
 import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
+import { CaseClass } from "@fncts/base/data/CaseClass";
 import { Z } from "@fncts/base/control/Z/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 import type { StyleFunction } from "@fncts/base/typeclass/Showable/styles";