functype 0.8.61 → 0.8.62

package/dist/fpromise/FPromise.d.ts

@@ -0,0 +1,369 @@
+import { Either } from '../either/Either';
+import { Type } from '../functor';
+/**
+ * Error context information that provides additional metadata about errors.
+ * This context is passed to error mapping functions to provide more information
+ * about the error that occurred.
+ *
+ * @property originalError - The original error that was thrown
+ * @property stack - The stack trace of the error, if available
+ * @property timestamp - The timestamp when the error occurred
+ */
+export type ErrorContext = {
+    originalError: unknown;
+    stack?: string;
+    timestamp: number;
+};
+/**
+ * FPromise is a functional wrapper around JavaScript's Promise with enhanced error handling.
+ * It implements the Functor and AsyncFunctor interfaces, providing map and flatMap operations
+ * for functional composition.
+ *
+ * FPromise adds several features not available in standard Promises:
+ * - Generic error typing for better type safety
+ * - Error recovery mechanisms (recover, recoverWith, recoverWithF)
+ * - Error filtering and categorization
+ * - Side effect methods (tap, tapError)
+ * - Error context preservation
+ * - Conversion to/from Either for more functional error handling
+ *
+ * @template T - The type of the value that the FPromise resolves to
+ * @template E - The type of the error that the FPromise may reject with (defaults to unknown)
+ */
+/**
+ * FPromise type that defines the function signature and methods
+ */
+export interface FPromise<T extends Type, E extends Type = unknown> extends PromiseLike<T> {
+    readonly _tag: "FPromise";
+    tap: (f: (value: T) => void) => FPromise<T, E>;
+    mapError: <E2>(f: (error: E, context: ErrorContext) => E2) => FPromise<T, E2>;
+    tapError: (f: (error: E) => void) => FPromise<T, E>;
+    recover: (fallback: T) => FPromise<T, never>;
+    recoverWith: (f: (error: E) => T) => FPromise<T, never>;
+    recoverWithF: <E2>(f: (error: E) => FPromise<T, E2>) => FPromise<T, E2>;
+    filterError: <E2 extends E>(predicate: (error: E) => boolean, handler: (error: E) => FPromise<T, E2>) => FPromise<T, E>;
+    logError: (logger: (error: E, context: ErrorContext) => void) => FPromise<T, E>;
+    toPromise: () => Promise<T>;
+    toEither: () => Promise<T>;
+    map: <U extends Type>(f: (value: T) => U) => FPromise<U, E>;
+    flatMap: <U extends Type>(f: (value: T) => FPromise<U, E> | PromiseLike<U>) => FPromise<U, E>;
+    flatMapAsync: <U extends Type>(f: (value: T) => PromiseLike<U>) => Promise<U>;
+}
+/**
+ * Static utility methods for FPromise using the Companion pattern.
+ * These methods provide factory functions and utilities for working with FPromises.
+ */
+export declare const FPromiseCompanion: {
+    /**
+     * Creates an FPromise that resolves to the provided value.
+     *
+     * @template T - The type of the value
+     * @template E - The type of the error (defaults to never since this FPromise won't reject)
+     * @param value - The value to resolve with
+     * @returns An FPromise that resolves to the value
+     *
+     * @example
+     * const promise = FPromise.resolve(42)
+     * // promise resolves to 42
+     */
+    resolve: <T, E = never>(value: T | PromiseLike<T>) => FPromise<T, E>;
+    /**
+     * Creates an FPromise that rejects with the provided reason.
+     *
+     * @template T - The type of the value (which will never be produced)
+     * @template E - The type of the error
+     * @param reason - The reason for rejection
+     * @returns An FPromise that rejects with the reason
+     *
+     * @example
+     * const promise = FPromise.reject<number, Error>(new Error("Something went wrong"))
+     * // promise rejects with Error("Something went wrong")
+     */
+    reject: <T, E = unknown>(reason: E) => FPromise<T, E>;
+    /**
+     * Creates an FPromise from a regular Promise.
+     *
+     * @template T - The type of the value
+     * @template E - The type of the error
+     * @param promise - The Promise to convert
+     * @returns An FPromise that resolves or rejects with the same value or error
+     *
+     * @example
+     * const promise = FPromise.from(fetch("https://api.example.com/data"))
+     * // promise is an FPromise that resolves or rejects based on the fetch result
+     */
+    from: <T, E = unknown>(promise: Promise<T>) => FPromise<T, E>;
+    /**
+     * Creates an FPromise from an Either.
+     * If the Either is a Right, the FPromise resolves with the Right value.
+     * If the Either is a Left, the FPromise rejects with the Left value.
+     *
+     * @template L - The type of the Left value (error)
+     * @template R - The type of the Right value (success)
+     * @param either - The Either to convert
+     * @returns An FPromise that resolves or rejects based on the Either
+     *
+     * @example
+     * const either = Right<Error, number>(42)
+     * const promise = FPromise.fromEither(either)
+     * // promise resolves to 42
+     */
+    fromEither: <L, R>(either: Either<L, R>) => FPromise<R, L>;
+    /**
+     * Runs multiple FPromises in parallel and returns an array of results.
+     * Similar to Promise.all, this will reject if any of the promises reject.
+     *
+     * @template T - The type of the values
+     * @template E - The type of the error
+     * @param promises - An array of FPromises, Promises, or values
+     * @returns An FPromise that resolves to an array of results
+     *
+     * @example
+     * const promises = [FPromise.resolve(1), FPromise.resolve(2), 3]
+     * const result = await FPromise.all(promises).toPromise()
+     * // result is [1, 2, 3]
+     */
+    all: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T> | T>) => FPromise<T[], E>;
+    /**
+     * Like Promise.allSettled, returns results of all promises whether they succeed or fail.
+     * This will always resolve, never reject.
+     *
+     * @template T - The type of the values
+     * @template E - The type of the errors
+     * @param promises - An array of FPromises or Promises
+     * @returns An FPromise that resolves to an array of Either results
+     *
+     * @example
+     * const promises = [FPromise.resolve(1), FPromise.reject<number, Error>(new Error("Failed"))]
+     * const result = await FPromise.allSettled(promises).toPromise()
+     * // result is [Right(1), Left(Error("Failed"))]
+     */
+    allSettled: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T>>) => FPromise<Array<Either<E, T>>, never>;
+    /**
+     * Like Promise.race, returns the first promise to settle (either resolve or reject).
+     *
+     * @template T - The type of the values
+     * @template E - The type of the errors
+     * @param promises - An array of FPromises or Promises
+     * @returns An FPromise that resolves or rejects with the result of the first promise to settle
+     *
+     * @example
+     * const slow = FPromise.resolve(1).tap(() => new Promise(r => setTimeout(r, 100)))
+     * const fast = FPromise.resolve(2).tap(() => new Promise(r => setTimeout(r, 50)))
+     * const result = await FPromise.race([slow, fast]).toPromise()
+     * // result is 2
+     */
+    race: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T>>) => FPromise<T, E>;
+    /**
+     * Like Promise.any, returns the first promise to fulfill.
+     * This will only reject if all promises reject.
+     *
+     * @template T - The type of the values
+     * @template E - The type of the errors
+     * @param promises - An array of FPromises or Promises
+     * @returns An FPromise that resolves with the first promise to fulfill or rejects if all promises reject
+     *
+     * @example
+     * const promises = [
+     *   FPromise.reject<number, Error>(new Error("First failed")),
+     *   FPromise.resolve(2),
+     *   FPromise.reject<number, Error>(new Error("Third failed"))
+     * ]
+     * const result = await FPromise.any(promises).toPromise()
+     * // result is 2
+     */
+    any: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T>>) => FPromise<T, E>;
+    /**
+     * Retries an operation with exponential backoff.
+     * This is useful for operations that may fail temporarily, such as network requests.
+     *
+     * @template T - The type of the value
+     * @template E - The type of the error
+     * @param operation - A function that returns an FPromise
+     * @param options - Configuration options for the retry
+     * @param options.maxRetries - Maximum number of retry attempts
+     * @param options.baseDelay - Base delay in milliseconds (default: 100)
+     * @param options.shouldRetry - Function that determines whether to retry based on the error (default: always retry)
+     * @returns An FPromise that resolves when the operation succeeds or rejects after all retries fail
+     *
+     * @example
+     * const operation = () => {
+     *   if (Math.random() > 0.8) {
+     *     return FPromise.resolve("Success!")
+     *   }
+     *   return FPromise.reject<string, Error>(new Error("Temporary failure"))
+     * }
+     *
+     * const result = await FPromise.retryWithBackoff(operation, {
+     *   maxRetries: 3,
+     *   baseDelay: 100,
+     *   shouldRetry: (error) => error.message === "Temporary failure"
+     * }).toPromise()
+     */
+    retryWithBackoff: <T, E = unknown>(operation: () => FPromise<T, E>, options: {
+        maxRetries: number;
+        baseDelay?: number;
+        shouldRetry?: (error: E, attempt: number) => boolean;
+    }) => FPromise<T, E>;
+};
+/**
+ * Creates an FPromise from an executor function.
+ *
+ * @template T - The type of the value that the FPromise resolves to
+ * @template E - The type of the error that the FPromise may reject with
+ * @param executor - A function that receives resolve and reject functions
+ * @returns An FPromise instance
+ */
+export declare const FPromise: (<T extends Type, E = unknown>(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: E) => void) => void) => FPromise<T, E>) & {
+    /**
+     * Creates an FPromise that resolves to the provided value.
+     *
+     * @template T - The type of the value
+     * @template E - The type of the error (defaults to never since this FPromise won't reject)
+     * @param value - The value to resolve with
+     * @returns An FPromise that resolves to the value
+     *
+     * @example
+     * const promise = FPromise.resolve(42)
+     * // promise resolves to 42
+     */
+    resolve: <T, E = never>(value: T | PromiseLike<T>) => FPromise<T, E>;
+    /**
+     * Creates an FPromise that rejects with the provided reason.
+     *
+     * @template T - The type of the value (which will never be produced)
+     * @template E - The type of the error
+     * @param reason - The reason for rejection
+     * @returns An FPromise that rejects with the reason
+     *
+     * @example
+     * const promise = FPromise.reject<number, Error>(new Error("Something went wrong"))
+     * // promise rejects with Error("Something went wrong")
+     */
+    reject: <T, E = unknown>(reason: E) => FPromise<T, E>;
+    /**
+     * Creates an FPromise from a regular Promise.
+     *
+     * @template T - The type of the value
+     * @template E - The type of the error
+     * @param promise - The Promise to convert
+     * @returns An FPromise that resolves or rejects with the same value or error
+     *
+     * @example
+     * const promise = FPromise.from(fetch("https://api.example.com/data"))
+     * // promise is an FPromise that resolves or rejects based on the fetch result
+     */
+    from: <T, E = unknown>(promise: Promise<T>) => FPromise<T, E>;
+    /**
+     * Creates an FPromise from an Either.
+     * If the Either is a Right, the FPromise resolves with the Right value.
+     * If the Either is a Left, the FPromise rejects with the Left value.
+     *
+     * @template L - The type of the Left value (error)
+     * @template R - The type of the Right value (success)
+     * @param either - The Either to convert
+     * @returns An FPromise that resolves or rejects based on the Either
+     *
+     * @example
+     * const either = Right<Error, number>(42)
+     * const promise = FPromise.fromEither(either)
+     * // promise resolves to 42
+     */
+    fromEither: <L, R>(either: Either<L, R>) => FPromise<R, L>;
+    /**
+     * Runs multiple FPromises in parallel and returns an array of results.
+     * Similar to Promise.all, this will reject if any of the promises reject.
+     *
+     * @template T - The type of the values
+     * @template E - The type of the error
+     * @param promises - An array of FPromises, Promises, or values
+     * @returns An FPromise that resolves to an array of results
+     *
+     * @example
+     * const promises = [FPromise.resolve(1), FPromise.resolve(2), 3]
+     * const result = await FPromise.all(promises).toPromise()
+     * // result is [1, 2, 3]
+     */
+    all: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T> | T>) => FPromise<T[], E>;
+    /**
+     * Like Promise.allSettled, returns results of all promises whether they succeed or fail.
+     * This will always resolve, never reject.
+     *
+     * @template T - The type of the values
+     * @template E - The type of the errors
+     * @param promises - An array of FPromises or Promises
+     * @returns An FPromise that resolves to an array of Either results
+     *
+     * @example
+     * const promises = [FPromise.resolve(1), FPromise.reject<number, Error>(new Error("Failed"))]
+     * const result = await FPromise.allSettled(promises).toPromise()
+     * // result is [Right(1), Left(Error("Failed"))]
+     */
+    allSettled: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T>>) => FPromise<Array<Either<E, T>>, never>;
+    /**
+     * Like Promise.race, returns the first promise to settle (either resolve or reject).
+     *
+     * @template T - The type of the values
+     * @template E - The type of the errors
+     * @param promises - An array of FPromises or Promises
+     * @returns An FPromise that resolves or rejects with the result of the first promise to settle
+     *
+     * @example
+     * const slow = FPromise.resolve(1).tap(() => new Promise(r => setTimeout(r, 100)))
+     * const fast = FPromise.resolve(2).tap(() => new Promise(r => setTimeout(r, 50)))
+     * const result = await FPromise.race([slow, fast]).toPromise()
+     * // result is 2
+     */
+    race: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T>>) => FPromise<T, E>;
+    /**
+     * Like Promise.any, returns the first promise to fulfill.
+     * This will only reject if all promises reject.
+     *
+     * @template T - The type of the values
+     * @template E - The type of the errors
+     * @param promises - An array of FPromises or Promises
+     * @returns An FPromise that resolves with the first promise to fulfill or rejects if all promises reject
+     *
+     * @example
+     * const promises = [
+     *   FPromise.reject<number, Error>(new Error("First failed")),
+     *   FPromise.resolve(2),
+     *   FPromise.reject<number, Error>(new Error("Third failed"))
+     * ]
+     * const result = await FPromise.any(promises).toPromise()
+     * // result is 2
+     */
+    any: <T, E = unknown>(promises: Array<FPromise<T, E> | PromiseLike<T>>) => FPromise<T, E>;
+    /**
+     * Retries an operation with exponential backoff.
+     * This is useful for operations that may fail temporarily, such as network requests.
+     *
+     * @template T - The type of the value
+     * @template E - The type of the error
+     * @param operation - A function that returns an FPromise
+     * @param options - Configuration options for the retry
+     * @param options.maxRetries - Maximum number of retry attempts
+     * @param options.baseDelay - Base delay in milliseconds (default: 100)
+     * @param options.shouldRetry - Function that determines whether to retry based on the error (default: always retry)
+     * @returns An FPromise that resolves when the operation succeeds or rejects after all retries fail
+     *
+     * @example
+     * const operation = () => {
+     *   if (Math.random() > 0.8) {
+     *     return FPromise.resolve("Success!")
+     *   }
+     *   return FPromise.reject<string, Error>(new Error("Temporary failure"))
+     * }
+     *
+     * const result = await FPromise.retryWithBackoff(operation, {
+     *   maxRetries: 3,
+     *   baseDelay: 100,
+     *   shouldRetry: (error) => error.message === "Temporary failure"
+     * }).toPromise()
+     */
+    retryWithBackoff: <T, E = unknown>(operation: () => FPromise<T, E>, options: {
+        maxRetries: number;
+        baseDelay?: number;
+        shouldRetry?: (error: E, attempt: number) => boolean;
+    }) => FPromise<T, E>;
+};

package/dist/fpromise/index.d.ts

@@ -1,3 +1,2 @@
-export { f as ErrorContext, F as FPromise, g as FPromiseCompanion } from '../option/index.js';
-import '../Tuple-GXgoHfiN.js';
-import '../branded/index.js';
+export * from './FPromise';
+export * from './retry';

package/dist/fpromise/index.mjs

@@ -1,2 +1,6 @@
-export{s as FPromise,r as FPromiseCompanion}from'../chunk-A3EHNBZM.mjs';import'../chunk-OQWAJKZJ.mjs';import'../chunk-TQJDL6YW.mjs';//# sourceMappingURL=index.mjs.map
-//# sourceMappingURL=index.mjs.map
+import { F as r, d as s } from "../index-CgMYHgdG.mjs";
+export {
+  r as FPromise,
+  s as FPromiseCompanion
+};
+//# sourceMappingURL=index.mjs.map

package/dist/fpromise/index.mjs.map

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

package/dist/fpromise/retry.d.ts

@@ -0,0 +1,106 @@
+import { FPromise } from './FPromise';
+/**
+ * A utility function to retry an operation multiple times until it succeeds.
+ * This function will attempt the operation and retry it up to maxRetries times if it fails.
+ * Unlike retryWithBackoff, this function retries immediately without any delay between attempts.
+ *
+ * @template T - The type of the value that the operation produces
+ * @template E - The type of the error that the operation may produce
+ * @param operation - A function that returns an FPromise
+ * @param maxRetries - Maximum number of retry attempts
+ * @returns An FPromise that will be resolved when the operation succeeds or rejected after all retries fail
+ *
+ * @example
+ * const unreliableOperation = () => {
+ *   if (Math.random() < 0.7) {
+ *     return FPromise.reject(new Error("Operation failed"));
+ *   }
+ *   return FPromise.resolve("Success!");
+ * };
+ *
+ * retry(unreliableOperation, 3)
+ *   .toPromise()
+ *   .then(result => console.log(result))
+ *   .catch(error => console.error("All attempts failed:", error));
+ */
+export declare const retry: <T, E = unknown>(operation: () => FPromise<T, E>, maxRetries: number) => FPromise<T, E>;
+/**
+ * A version of retry that uses exponential backoff between retry attempts.
+ * This is useful for operations that may fail due to rate limiting or temporary network issues.
+ * The delay between retries increases exponentially: baseDelay * 2^attempt.
+ *
+ * @template T - The type of the value that the operation produces
+ * @template E - The type of the error that the operation may produce
+ * @param operation - A function that returns an FPromise
+ * @param maxRetries - Maximum number of retry attempts
+ * @param baseDelay - Base delay in milliseconds (default: 100ms)
+ * @param shouldRetry - Optional function to determine if a retry should be attempted based on the error
+ * @returns An FPromise that will be resolved when the operation succeeds or rejected after all retries fail
+ *
+ * @example
+ * const fetchData = () => {
+ *   return FPromise.from(fetch('https://api.example.com/data'))
+ *     .flatMap(response => {
+ *       if (!response.ok) {
+ *         return FPromise.reject(new Error(`HTTP error: ${response.status}`));
+ *       }
+ *       return FPromise.from(response.json());
+ *     });
+ * };
+ *
+ * retryWithBackoff(fetchData, 3, 200, (error) => {
+ *   // Only retry on network errors or 429 (Too Many Requests)
+ *   return error.name === 'NetworkError' ||
+ *          (error.message && error.message.includes('HTTP error: 429'));
+ * })
+ *   .toPromise()
+ *   .then(data => console.log("Data:", data))
+ *   .catch(error => console.error("Failed to fetch data:", error));
+ */
+export declare const retryWithBackoff: <T, E = unknown>(operation: () => FPromise<T, E>, maxRetries: number, baseDelay?: number, shouldRetry?: (error: E, attempt: number) => boolean) => FPromise<T, E>;
+/**
+ * A highly configurable version of retry that allows for custom delay calculation,
+ * conditional retries, and retry event callbacks.
+ *
+ * @template T - The type of the value that the operation produces
+ * @template E - The type of the error that the operation may produce
+ * @param operation - A function that returns an FPromise
+ * @param options - Configuration options for the retry
+ * @param options.maxRetries - Maximum number of retry attempts
+ * @param options.delayFn - Optional function to calculate delay between retries (default: no delay)
+ * @param options.shouldRetry - Optional function to determine if a retry should be attempted (default: always retry)
+ * @param options.onRetry - Optional callback that is called before each retry attempt
+ * @returns An FPromise that will be resolved when the operation succeeds or rejected after all retries fail
+ *
+ * @example
+ * const fetchWithAuth = () => {
+ *   return FPromise.from(fetch('https://api.example.com/protected', {
+ *     headers: { 'Authorization': `Bearer ${getToken()}` }
+ *   }))
+ *   .flatMap(response => {
+ *     if (response.status === 401) {
+ *       return FPromise.reject(new AuthError("Unauthorized"));
+ *     }
+ *     return FPromise.from(response.json());
+ *   });
+ * };
+ *
+ * retryWithOptions(fetchWithAuth, {
+ *   maxRetries: 2,
+ *   delayFn: (attempt) => 500 * attempt, // Linear backoff: 500ms, 1000ms
+ *   shouldRetry: (error) => error instanceof AuthError,
+ *   onRetry: (error, attempt) => {
+ *     console.log(`Retry attempt ${attempt} after auth error, refreshing token...`);
+ *     refreshAuthToken();
+ *   }
+ * })
+ *   .toPromise()
+ *   .then(data => console.log("Data:", data))
+ *   .catch(error => console.error("Failed after retries:", error));
+ */
+export declare const retryWithOptions: <T, E = unknown>(operation: () => FPromise<T, E>, options: {
+    maxRetries: number;
+    delayFn?: (attempt: number) => number;
+    shouldRetry?: (error: E, attempt: number) => boolean;
+    onRetry?: (error: E, attempt: number) => void;
+}) => FPromise<T, E>;

package/dist/functor/index.d.ts

@@ -0,0 +1,18 @@
+export type SingleType = unknown;
+export type ArrayType = SingleType[];
+export type Type = SingleType | ArrayType;
+export type AbstractFunctor<A extends Type> = {
+    map(f: (value: A) => Type): AbstractFunctor<Type>;
+    flatMap(f: (value: A) => AbstractFunctor<Type>): AbstractFunctor<Type>;
+};
+export type Functor<A extends Type> = AbstractFunctor<A> & {
+    map<B extends Type>(f: (value: A) => B): Functor<B>;
+    flatMap<B extends Type>(f: (value: A) => Functor<B>): Functor<B>;
+};
+export type AsyncFunctor<A extends Type> = {
+    flatMapAsync(f: (value: A) => PromiseLike<AsyncFunctor<A>>): PromiseLike<AsyncFunctor<A>>;
+};
+export type ArrayFunctor<A extends ArrayType> = AbstractFunctor<A> & {
+    map<U extends ArrayType>(f: (value: A) => U): ArrayFunctor<U>;
+    flatMap<U extends ArrayType>(f: (value: A) => ArrayFunctor<U>): ArrayFunctor<U>;
+};

package/dist/hkt/index.d.ts

@@ -0,0 +1,49 @@
+import { Either } from '../either/Either';
+import { Type } from '../functor';
+import { List } from '../list/List';
+import { Option } from '../option/Option';
+import { Try } from '../try/Try';
+/**
+ * Type function for representing higher-kinded types
+ */
+export type Kind<F, A> = F extends (arg: infer T) => infer R ? R : never;
+/**
+ * Type constructors for common Functype data types
+ */
+export type OptionKind = <A>(a: A) => Option<A>;
+export type ListKind = <A>(a: A) => List<A>;
+export type EitherKind<E> = <A>(a: A) => Either<E, A>;
+export type TryKind = <A>(a: A) => Try<A>;
+/**
+ * Universal type that includes all potential return types from the HKT functions
+ * Used to avoid 'any' usage which the linter prohibits
+ */
+export type UniversalContainer = Option<unknown> | List<unknown> | Either<unknown, unknown> | Try<unknown>;
+/**
+ * HKT provides utilities for working with higher-kinded types
+ * This allows writing generic code that works across different
+ * container types like Option, List, Either, etc.
+ */
+export declare const HKT: {
+    (): {
+        _type: string;
+        map: <F, A, B>(fa: unknown, f: (a: A) => B) => unknown;
+        flatten: <F, A>(ffa: unknown) => unknown;
+        flatMap: <F, A, B>(fa: unknown, f: (a: A) => unknown) => unknown;
+        ap: <F, A, B>(ff: unknown, fa: unknown) => unknown;
+        sequence: <F, G, A>(fga: unknown) => unknown;
+        traverse: <F, G, A, B>(fa: unknown, f: (a: A) => unknown) => unknown;
+        toString(): string;
+        _tag: string;
+    };
+    map<F = unknown, A = unknown, B = unknown>(fa: unknown, f: (a: A) => B): unknown;
+    flatten<F = unknown, A = unknown>(ffa: unknown): unknown;
+    flatMap<F = unknown, A = unknown, B = unknown>(fa: unknown, f: (a: A) => unknown): unknown;
+    ap<F = unknown, A = unknown, B = unknown>(ff: unknown, fa: unknown): unknown;
+    sequence<F = unknown, G = unknown, A = unknown>(fga: unknown): unknown;
+    traverse<F = unknown, G = unknown, A = unknown, B = unknown>(fa: unknown, f: (a: A) => unknown): unknown;
+    isOption: <T extends Type>(value: unknown) => value is Option<T>;
+    isList: <T extends Type>(value: unknown) => value is List<T>;
+    isEither: <E extends Type, A extends Type>(value: unknown) => value is Either<E, A>;
+    isTry: <T extends Type>(value: unknown) => value is Try<T>;
+};

package/dist/identity/Identity.d.ts

@@ -0,0 +1,5 @@
+export type Identity<T> = {
+    id: T;
+    isSame?: (other: Identity<T>) => boolean;
+};
+export declare function Identity<T>(value: T): Identity<T>;

package/dist/identity/index.d.ts

@@ -0,0 +1 @@
+export * from './Identity';