@fncts/base 0.0.26 → 0.0.28

package/data/Branded/definition.d.ts

@@ -29,11 +29,12 @@ export declare namespace Brand {
  */
 export declare class Validation<in out A, in out K extends string> {
     readonly validate: Refinement<A, A & Brand.Valid<A, K>>;
-    constructor(validate: Refinement<A, A & Brand.Valid<A, K>>);
+    readonly name: K;
+    constructor(validate: Refinement<A, A & Brand.Valid<A, K>>, name: K);
 }
 /**
  * @tsplus static fncts.ValidationOps __call
  * @tsplus location "@fncts/base/data/Branded/definition"
  */
-export declare function makeValidation<A, K extends string>(p: Predicate<A>): Validation<A, K>;
+export declare function makeValidation<A, K extends string>(p: Predicate<A>, name: K): Validation<A, K>;
 export {};

package/data/Cause/api.d.ts

@@ -12,7 +12,7 @@ import { Both, Cause, Fail, Halt, Interrupt, Then } from "./definition.js";
  * @tsplus pipeable fncts.Cause as
  * @tsplus location "@fncts/base/data/Cause/api"
  */
-export declare function as_<B>(b: Lazy<B>): <A>(self: Cause<A>) => Cause<B>;
+export declare function as<B>(b: Lazy<B>): <A>(self: Cause<A>) => Cause<B>;
 /**
  * Constructs a `Cause` from two `Cause`s, representing parallel failures.
  * @note If one of the `Cause`s is `Empty`, the non-empty `Cause` is returned

package/data/Either/api.d.ts

@@ -146,5 +146,10 @@ export declare function partitionMap<E, A, B, C>(f: (a: A) => Either<B, C>, /**
  * @tsplus location "@fncts/base/data/Either/api"
  */
 export declare function partition<E, A>(p: Predicate<A>, /** @tsplus auto */ M: P.Monoid<E>): (self: Either<E, A>) => readonly [Either<E, A>, Either<E, A>];
+/**
+ * @tsplus getter fncts.Either toMaybe
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function toMaybe<E, A>(self: Either<E, A>): Maybe<A>;
 export * from "./api/align.js";
 export * from "./api/alignWith.js";

package/data/Either/constructors.d.ts

@@ -9,13 +9,13 @@ import { Either } from "./definition.js";
  * @tsplus static fncts.Either.LeftOps __call
  * @tsplus location "@fncts/base/data/Either/constructors"
  */
-export declare function left<E = never, A = never>(e: E): Either<E, A>;
+export declare function left<E = never, A = never>(e: E, __tsplusTrace?: string): Either<E, A>;
 /**
  * @tsplus static fncts.EitherOps right
  * @tsplus static fncts.Either.RightOps __call
  * @tsplus location "@fncts/base/data/Either/constructors"
  */
-export declare function right<E = never, A = never>(a: A): Either<E, A>;
+export declare function right<E = never, A = never>(a: A, __tsplusTrace?: string): Either<E, A>;
 /**
  * @tsplus static fncts.EitherOps fromMaybe
  * @tsplus pipeable fncts.Maybe toEither

package/data/Either/definition.d.ts

@@ -1,4 +1,6 @@
 import { HKT } from "@fncts/typelevel/HKT";
+import { Hashable } from "@fncts/base/data/Hashable";
+import type { EqualsContext } from "@fncts/base/data/Equatable";
 export declare const enum EitherTag {
     Left = "Left",
     Right = "Right"
@@ -14,12 +16,16 @@ export interface EitherF extends HKT {
         A: "+";
     };
 }
+declare const IOTypeId: unique symbol;
+type IOTypeId = typeof IOTypeId;
 /**
  * @tsplus type fncts.Either
  * @tsplus companion fncts.EitherOps
  */
 export declare class Either<E, A> {
     readonly [EitherTypeId]: EitherTypeId;
+    readonly [IOTypeId]: IOTypeId;
+    readonly trace?: string | undefined;
     [EitherVariance]: {
         readonly _E: (_: never) => E;
         readonly _A: (_: never) => A;
@@ -31,8 +37,11 @@ export declare class Either<E, A> {
  */
 export declare class Left<E> extends Either<E, never> {
     readonly left: E;
+    readonly trace?: string | undefined;
     readonly _tag = EitherTag.Left;
-    constructor(left: E);
+    constructor(left: E, trace?: string | undefined);
+    get [Symbol.hash](): number;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus type fncts.Either.Right
@@ -40,8 +49,11 @@ export declare class Left<E> extends Either<E, never> {
  */
 export declare class Right<A> extends Either<never, A> {
     readonly right: A;
+    readonly trace?: string | undefined;
     readonly _tag = EitherTag.Right;
-    constructor(right: A);
+    constructor(right: A, trace?: string | undefined);
+    get [Symbol.hash](): number;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus unify fncts.Either
@@ -54,3 +66,4 @@ export declare function unifyEither<X extends Either<any, any>>(self: X): Either
  * @tsplus location "@fncts/base/data/Either/definition"
  */
 export declare function concrete<E, A>(self: Either<E, A>): asserts self is Left<E> | Right<A>;
+export {};

package/data/Eq/api.d.ts

@@ -0,0 +1,6 @@
+import { Eq } from "@fncts/base/data/Eq/definition";
+/**
+ * @tsplus pipeable fncts.Eq contramap
+ * @tsplus location "@fncts/base/data/Eq/api"
+ */
+export declare function contramap<A, B>(f: (b: B) => A): (self: Eq<A>) => Eq<B>;

package/data/Eq.d.ts

@@ -1,2 +1,3 @@
+export * from "./Eq/api.js";
 export * from "./Eq/definition.js";
 export {} from "./Eq/derivations.js";

package/data/Equatable/api.d.ts

@@ -2,10 +2,16 @@
  * @tsplus static fncts.EquatableOps deepEquals
  * @tsplus location "@fncts/base/data/Equatable/api"
  */
-export declare const deepEquals: (a: any, b: any, meta?: any) => boolean;
+export declare function deepEquals<A>(a: A, b: unknown): boolean;
 /**
  * @tsplus static fncts.EquatableOps strictEquals
  * @tsplus operator fncts.Equatable ==
  * @tsplus location "@fncts/base/data/Equatable/api"
  */
 export declare function strictEquals<A>(a: A, b: unknown): boolean;
+/**
+ * @tsplus static fncts.EquatableOps strictNotEquals
+ * @tsplus operator fncts.Equatable !=
+ * @tsplus location "@fncts/base/data/Equatable/api"
+ */
+export declare function strictNotEquals<A>(a: A, b: unknown): boolean;

package/data/Equatable/definition.d.ts

@@ -3,11 +3,14 @@
  * @tsplus location "@fncts/base/data/Equatable/definition"
  */
 export declare const equalsSymbol: unique symbol;
+export interface EqualsContext {
+    comparator: (a: unknown, b: unknown) => boolean;
+}
 /**
  * @tsplus type fncts.Equatable
  */
 export interface Equatable {
-    [equalsSymbol](that: unknown): boolean;
+    [equalsSymbol](that: unknown, context: EqualsContext): boolean;
 }
 export declare function isEquatable(u: unknown): u is Equatable;
 /**

package/data/Exit/api.d.ts

@@ -97,3 +97,15 @@ export declare function zipConcurrent<EB, B>(that: Exit<EB, B>): <EA, A>(self: i
  * @tsplus location "@fncts/base/data/Exit/api"
  */
 export declare function zipWithCause<E, A, G, B, C>(fb: Exit<G, B>, f: (a: A, b: B) => C, g: (ea: Cause<E>, eb: Cause<G>) => Cause<E | G>): (fa: Exit<E, A>) => Exit<E | G, C>;
+/**
+ * Returns the Exit's Success value if it exists
+ * @tsplus getter fncts.Exit value
+ * @tsplus location "@fncts/base/data/Exit/api"
+ */
+export declare function value<E, A>(self: Exit<E, A>): A | undefined;
+/**
+ * Returns the Exit's Success value if it exists, or throws the pretty-printed Cause if it doesn't
+ * @tsplus getter fncts.Exit valueOrThrow
+ * @tsplus location "@fncts/base/data/Exit/api"
+ */
+export declare function valueOrThrow<E, A>(self: Exit<E, A>): A;

package/data/Exit/constructors.d.ts

@@ -7,12 +7,12 @@ import { FiberId } from "@fncts/base/data/FiberId/definition";
  * @tsplus static fncts.ExitOps halt
  * @tsplus location "@fncts/base/data/Exit/constructors"
  */
-export declare function halt(defect: unknown): Exit<never, never>;
+export declare function halt(defect: unknown, __tsplusTrace?: string): Exit<never, never>;
 /**
  * @tsplus static fncts.ExitOps fail
  * @tsplus location "@fncts/base/data/Exit/constructors"
  */
-export declare function fail<E = never, A = never>(e: E): Exit<E, A>;
+export declare function fail<E = never, A = never>(e: E, __tsplusTrace?: string): Exit<E, A>;
 /**
  * @tsplus static fncts.ExitOps fromEither
  * @tsplus location "@fncts/base/data/Exit/constructors"
@@ -27,17 +27,17 @@ export declare function fromMaybe<E, A>(fa: Maybe<A>, onNothing: () => E): Exit<
  * @tsplus static fncts.ExitOps failCause
  * @tsplus location "@fncts/base/data/Exit/constructors"
  */
-export declare function failCause<E = never, A = never>(cause: Cause<E>): Exit<E, A>;
+export declare function failCause<E = never, A = never>(cause: Cause<E>, __tsplusTrace?: string): Exit<E, A>;
 /**
  * @tsplus static fncts.ExitOps interrupt
  * @tsplus location "@fncts/base/data/Exit/constructors"
  */
-export declare function interrupt(id: FiberId): Exit<never, never>;
+export declare function interrupt(id: FiberId, __tsplusTrace?: string): Exit<never, never>;
 /**
  * @tsplus static fncts.ExitOps succeed
  * @tsplus location "@fncts/base/data/Exit/constructors"
  */
-export declare function succeed<E = never, A = never>(value: A): Exit<E, A>;
+export declare function succeed<E = never, A = never>(value: A, __tsplusTrace?: string): Exit<E, A>;
 /**
  * @tsplus static fncts.ExitOps unit
  * @tsplus location "@fncts/base/data/Exit/constructors"

package/data/Exit/definition.d.ts

@@ -19,19 +19,23 @@ export declare const enum ExitTag {
     Success = "Success",
     Failure = "Failure"
 }
+declare const IOTypeId: unique symbol;
+type IOTypeId = typeof IOTypeId;
 /**
  * @tsplus type fncts.Exit.Failure
  * @tsplus companion fncts.Exit.FailureOps
  */
 export declare class Failure<E> {
     readonly cause: Cause<E>;
+    readonly trace?: string | undefined;
     readonly [ExitTypeId]: ExitTypeId;
     [ExitVariance]: {
         readonly _E: (_: never) => E;
         readonly _A: (_: never) => never;
     };
+    readonly [IOTypeId]: IOTypeId;
     readonly _tag = ExitTag.Failure;
-    constructor(cause: Cause<E>);
+    constructor(cause: Cause<E>, trace?: string | undefined);
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
 }
@@ -41,13 +45,15 @@ export declare class Failure<E> {
  */
 export declare class Success<A> implements P.Hashable, P.Equatable {
     readonly value: A;
+    readonly trace?: string | undefined;
     readonly [ExitTypeId]: ExitTypeId;
     [ExitVariance]: {
         readonly _E: (_: never) => never;
         readonly _A: (_: never) => A;
     };
+    readonly [IOTypeId]: IOTypeId;
     readonly _tag = ExitTag.Success;
-    constructor(value: A);
+    constructor(value: A, trace?: string | undefined);
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
 }
@@ -75,3 +81,4 @@ export declare function isSuccess<E, A>(exit: Exit<E, A>): exit is Success<A>;
  * @tsplus unify fncts.Exit
  */
 export declare function unifyExit<X extends Exit<any, any>>(_: X): Exit<[X] extends [Exit<infer E, any>] ? E : never, [X] extends [Exit<any, infer A>] ? A : never>;
+export {};

package/data/Maybe/constructors.d.ts

@@ -7,13 +7,13 @@ import type { Nullable } from "@fncts/base/types";
  * @tsplus static fncts.JustOps __call
  * @tsplus location "@fncts/base/data/Maybe/constructors"
  */
-export declare function just<A>(a: A): Maybe<A>;
+export declare function just<A>(a: A, __tsplusTrace?: string): Maybe<A>;
 /**
  * @tsplus static fncts.MaybeOps nothing
  * @tsplus static fncts.NothingOps __call
  * @tsplus location "@fncts/base/data/Maybe/constructors"
  */
-export declare function nothing<A = never>(): Maybe<A>;
+export declare function nothing<A = never>(__tsplusTrace?: string): Maybe<A>;
 /**
  * @tsplus static fncts.MaybeOps fromNullable
  * @tsplus location "@fncts/base/data/Maybe/constructors"

package/data/Maybe/definition.d.ts

@@ -9,6 +9,8 @@ export declare const MaybeVariance: unique symbol;
 export type MaybeVariance = typeof MaybeVariance;
 export declare const MaybeTypeId: unique symbol;
 export type MaybeTypeId = typeof MaybeTypeId;
+declare const IOTypeId: unique symbol;
+type IOTypeId = typeof IOTypeId;
 export interface MaybeF extends HKT {
     type: Maybe<this["A"]>;
     variance: {
@@ -24,6 +26,8 @@ export declare abstract class Maybe<A> {
         readonly _A: (_: never) => A;
     };
     readonly [MaybeTypeId]: MaybeTypeId;
+    readonly [IOTypeId]: IOTypeId;
+    readonly trace?: string | undefined;
 }
 /**
  * @tsplus type fncts.Just
@@ -31,8 +35,9 @@ export declare abstract class Maybe<A> {
  */
 export declare class Just<A> extends Maybe<A> {
     readonly value: A;
+    readonly trace?: string | undefined;
     readonly _tag = MaybeTag.Just;
-    constructor(value: A);
+    constructor(value: A, trace?: string | undefined);
     [Symbol.equals](that: unknown): boolean;
     get [Symbol.hash](): number;
 }
@@ -41,7 +46,9 @@ export declare class Just<A> extends Maybe<A> {
  * @tsplus companion fncts.NothingOps
  */
 export declare class Nothing extends Maybe<never> {
+    readonly trace?: string | undefined;
     readonly _tag = MaybeTag.Nothing;
+    constructor(trace?: string | undefined);
     [Symbol.equals](that: unknown): boolean;
     get [Symbol.hash](): number;
 }
@@ -77,3 +84,4 @@ export declare function isNothing<A>(self: Maybe<A>): self is Nothing;
  * @tsplus location "@fncts/base/data/Maybe/definition"
  */
 export declare function concrete<A>(self: Maybe<A>): asserts self is Just<A> | Nothing;
+export {};

package/data/Maybe/instances.d.ts

@@ -4,11 +4,35 @@ import { Decoder } from "@fncts/base/data/Decoder/definition";
 import { Encoder } from "@fncts/base/data/Encoder/definition";
 import type * as P from "../../typeclass.js";
 import type { MaybeF } from "@fncts/base/data/Maybe/definition";
+/**
+ * @tsplus static fncts.MaybeOps Functor
+ * @tsplus location "@fncts/base/data/Maybe/instances"
+ */
 export declare const Functor: P.Functor<MaybeF, import("@fncts/typelevel/HKT.js").HKT.None>;
+/**
+ * @tsplus static fncts.MaybeOps Apply
+ * @tsplus location "@fncts/base/data/Maybe/instances"
+ */
 export declare const Apply: P.Apply<MaybeF, import("@fncts/typelevel/HKT.js").HKT.None>;
+/**
+ * @tsplus static fncts.MaybeOps Applicative
+ * @tsplus location "@fncts/base/data/Maybe/instances"
+ */
 export declare const Applicative: P.Applicative<MaybeF, import("@fncts/typelevel/HKT.js").HKT.None>;
+/**
+ * @tsplus static fncts.MaybeOps Monad
+ * @tsplus location "@fncts/base/data/Maybe/instances"
+ */
 export declare const Monad: P.Monad<MaybeF, import("@fncts/typelevel/HKT.js").HKT.None>;
+/**
+ * @tsplus static fncts.MaybeOps Foldable
+ * @tsplus location "@fncts/base/data/Maybe/instances"
+ */
 export declare const Foldable: P.Foldable<MaybeF, import("@fncts/typelevel/HKT.js").HKT.None>;
+/**
+ * @tsplus static fncts.MaybeOps Filterable
+ * @tsplus location "@fncts/base/data/Maybe/instances"
+ */
 export declare const Filterable: P.Filterable<MaybeF, import("@fncts/typelevel/HKT.js").HKT.None>;
 /**
  * @tsplus derive fncts.Guard[fncts.Maybe]<_> 10

package/data/exceptions/IOError.d.ts

@@ -0,0 +1,9 @@
+import { Cause } from "@fncts/base/data/Cause/definition";
+export declare const IOErrorTypeId: unique symbol;
+export type IOErrorTypeId = typeof IOErrorTypeId;
+export declare class IOError<E> {
+    readonly cause: Cause<E>;
+    readonly [IOErrorTypeId]: IOErrorTypeId;
+    constructor(cause: Cause<E>);
+}
+export declare function isIOError(u: unknown): u is IOError<unknown>;

package/data/exceptions/NoSuchElementError.d.ts

@@ -1,5 +1,5 @@
 export declare const NoSuchElementErrorTag = "NoSuchElementError";
 export declare class NoSuchElementError extends Error {
     readonly _tag = "NoSuchElementError";
-    constructor(message: string);
+    constructor(message?: string);
 }

package/data/exceptions.d.ts

@@ -4,5 +4,6 @@ export * from "./exceptions/IllegalStateError.js";
 export * from "./exceptions/IndexOutOfBoundsError.js";
 export * from "./exceptions/InterruptedException.js";
 export * from "./exceptions/InvalidCapacityError.js";
+export * from "./exceptions/IOError.js";
 export * from "./exceptions/NoSuchElementError.js";
 export * from "./exceptions/RuntimeError.js";

package/data.d.ts

@@ -37,6 +37,7 @@ export type {} from "./data/Predicate.js";
 export type {} from "./data/Refinement.js";
 export type {} from "./data/Showable.js";
 export type {} from "./data/string.js";
+export type {} from "./data/Struct.js";
 export type {} from "./data/Tag.js";
 export type {} from "./data/These.js";
 export type {} from "./data/Trace.js";

package/package.json

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

package/typeclass.d.ts

@@ -29,7 +29,7 @@ export * from "./typeclass/Witherable.js";
 export * from "./typeclass/WitherableWithIndex.js";
 export { Eq } from "./data/Eq.js";
 export { Equatable } from "./data/Equatable.js";
-export { Guard } from "./data/Guard.js";
+export { Guard } from "./data/Guard/definition.js";
 export { Hash } from "./data/Hash.js";
 export { Hashable } from "./data/Hashable.js";
 export { HashEq } from "./data/HashEq.js";

package/types.d.ts

@@ -1,3 +1,2 @@
 export * from "./types/extractions.js";
-export * from "./types/test.js";
 export * from "./types/utility.js";

package/util/predicates.d.ts

@@ -11,6 +11,7 @@ export declare function isArray<A>(value: unknown): value is Array<A>;
 export declare function isObject<A extends Function>(value: A): false;
 export declare function isObject(value: unknown): value is object & Record<PropertyKey, any>;
 export declare function isObject<A>(value: A | Primitive): value is A & Record<PropertyKey, unknown>;
+export declare function isRecord(value: unknown): value is object & Record<PropertyKey, unknown>;
 export declare function hasTypeId<X extends symbol>(value: unknown, typeId: X): value is {
     readonly [K in X]: X;
 } & Record<PropertyKey, unknown>;

package/_cjs/types/test.cjs

@@ -1,6 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-//# sourceMappingURL=test.cjs.map

package/_cjs/types/test.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"test.cjs","mappings":"","names":[],"sourceRoot":"","sources":[],"sourcesContent":[]}

package/_mjs/types/test.mjs

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=test.mjs.map

package/_mjs/types/test.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"test.mjs","mappings":"","names":[],"sourceRoot":"","sources":[],"sourcesContent":[]}

package/types/test.d.ts

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