@duplojs/utils 1.4.44 → 1.4.46

package/dist/either/bool/base.mjs

@@ -1,5 +1,9 @@
 import { createEitherKind } from '../kind.mjs';
 
-const eitherBoolKind = createEitherKind("bool");
+const boolKind = createEitherKind("bool");
+/**
+ * @deprecated use boolKind
+ */
+const eitherBoolKind = boolKind;
 
-export { eitherBoolKind };
+export { boolKind, eitherBoolKind };

package/dist/either/bool/create.d.ts

@@ -1,8 +1,8 @@
 import { type FalsyValue, type IsEqual } from "../../common";
-import { type EitherBoolFalsy } from "./falsy";
-import { type EitherBoolTruthy } from "./truthy";
+import { type BoolFalsy } from "./falsy";
+import { type BoolTruthy } from "./truthy";
 /**
- * Converts any value into a boolean monad (EitherBoolTruthy or EitherBoolFalsy). Handy to keep track of the test while benefiting from the whenIsBoolTruthy/whenIsBoolFalsy helpers.
+ * Converts any value into a boolean monad (BoolTruthy or BoolFalsy). Handy to keep track of the test while benefiting from the whenIsBoolTruthy/whenIsBoolFalsy helpers.
  * 
  * Signature: `bool(value)` → returns a value
  * 
@@ -15,7 +15,7 @@ import { type EitherBoolTruthy } from "./truthy";
  * 	E.bool,
  * );
  * 
- * // type: E.EitherBoolFalsy<undefined> | E.EitherBoolTruthy<"nest">
+ * // type: E.BoolFalsy<undefined> | E.BoolTruthy<"nest">
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/bool
@@ -23,5 +23,5 @@ import { type EitherBoolTruthy } from "./truthy";
  * @namespace E
  * 
  */
-export declare function bool<const GenericValue extends unknown = undefined>(value: GenericValue): GenericValue extends FalsyValue ? EitherBoolFalsy<GenericValue> : IsEqual<GenericValue, number> extends true ? EitherBoolTruthy<GenericValue> | EitherBoolFalsy<0> : IsEqual<GenericValue, bigint> extends true ? EitherBoolTruthy<GenericValue> | EitherBoolFalsy<0n> : IsEqual<GenericValue, string> extends true ? EitherBoolTruthy<GenericValue> | EitherBoolFalsy<""> : EitherBoolTruthy<GenericValue>;
-export type Bool<GenericValue extends unknown> = EitherBoolTruthy<GenericValue> | EitherBoolFalsy;
+export declare function bool<const GenericValue extends unknown = undefined>(value: GenericValue): GenericValue extends FalsyValue ? BoolFalsy<GenericValue> : IsEqual<GenericValue, number> extends true ? BoolTruthy<GenericValue> | BoolFalsy<0> : IsEqual<GenericValue, bigint> extends true ? BoolTruthy<GenericValue> | BoolFalsy<0n> : IsEqual<GenericValue, string> extends true ? BoolTruthy<GenericValue> | BoolFalsy<""> : BoolTruthy<GenericValue>;
+export type Bool<GenericValue extends unknown> = BoolTruthy<GenericValue> | BoolFalsy;

package/dist/either/bool/falsy.cjs

@@ -8,7 +8,11 @@ var is = require('../left/is.cjs');
 var is$1 = require('../right/is.cjs');
 var unwrap = require('../../common/unwrap.cjs');
 
-const eitherBoolFalsyKind = kind.createEitherKind("bool-falsy");
+const boolFalsyKind = kind.createEitherKind("bool-falsy");
+/**
+ * @deprecated use boolFalsyKind
+ */
+const eitherBoolFalsyKind = boolFalsyKind;
 /**
  * {@include either/boolFalsy/index.md}
  */
@@ -19,12 +23,12 @@ const eitherBoolFalsyKind = kind.createEitherKind("bool-falsy");
  * {@include either/whenIsBoolFalsy/index.md}
  */
 function boolFalsy(value = undefined) {
-    return base.eitherBoolKind.setTo(eitherBoolFalsyKind.setTo(create.left("bool", value)));
+    return base.boolKind.setTo(boolFalsyKind.setTo(create.left("bool", value)));
 }
 function isBoolFalsy(input) {
     return is.isLeft(input)
-        && base.eitherBoolKind.has(input)
-        && eitherBoolFalsyKind.has(input);
+        && base.boolKind.has(input)
+        && boolFalsyKind.has(input);
 }
 function whenIsBoolFalsy(...args) {
     if (args.length === 1) {
@@ -48,6 +52,7 @@ function whenIsBoolFalsy(...args) {
 }
 
 exports.boolFalsy = boolFalsy;
+exports.boolFalsyKind = boolFalsyKind;
 exports.eitherBoolFalsyKind = eitherBoolFalsyKind;
 exports.isBoolFalsy = isBoolFalsy;
 exports.whenIsBoolFalsy = whenIsBoolFalsy;

package/dist/either/bool/falsy.d.ts

@@ -1,15 +1,23 @@
 import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink, type FalsyValue } from "../../common";
 import { type Kind } from "../../common/kind";
-import { eitherBoolKind } from "./base";
+import { boolKind } from "./base";
 import { bool } from "./create";
-import { type EitherLeft } from "../left";
-import { type EitherRight } from "../right";
+import { type Left } from "../left";
+import { type Right } from "../right";
+export declare const boolFalsyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/bool-falsy", unknown>>;
+/**
+ * @deprecated use boolFalsyKind
+ */
 export declare const eitherBoolFalsyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/bool-falsy", unknown>>;
-type _EitherBoolFalsy<GenericValue extends FalsyValue = FalsyValue> = (EitherLeft<"bool", GenericValue> & Kind<typeof eitherBoolKind.definition> & Kind<typeof eitherBoolFalsyKind.definition>);
-export interface EitherBoolFalsy<GenericValue extends FalsyValue = FalsyValue> extends _EitherBoolFalsy<GenericValue> {
+type _BoolFalsy<GenericValue extends FalsyValue = FalsyValue> = (Left<"bool", GenericValue> & Kind<typeof boolKind.definition> & Kind<typeof boolFalsyKind.definition>);
+export interface BoolFalsy<GenericValue extends FalsyValue = FalsyValue> extends _BoolFalsy<GenericValue> {
 }
 /**
- * Builds an EitherLeft<"bool"> for an explicitly falsy value (0, "", null, undefined, false).
+ * @deprecated use BoolFalsy
+ */
+export type EitherBoolFalsy<GenericValue extends FalsyValue = FalsyValue> = BoolFalsy<GenericValue>;
+/**
+ * Builds an Left<"bool"> for an explicitly falsy value (0, "", null, undefined, false).
  * 
  * Signature: `boolFalsy(value)` → returns a value
  * 
@@ -26,7 +34,7 @@ export interface EitherBoolFalsy<GenericValue extends FalsyValue = FalsyValue> e
  * 	),
  * );
  * 
- * // type: string | E.EitherBoolFalsy<"">
+ * // type: string | E.BoolFalsy<"">
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/boolFalsy
@@ -35,7 +43,7 @@ export interface EitherBoolFalsy<GenericValue extends FalsyValue = FalsyValue> e
  * 
  */
 /**
- * Type guard that detects an EitherBoolFalsy.
+ * Type guard that detects an BoolFalsy.
  * 
  * Signature: `isBoolFalsy(input)` → returns a value
  * 
@@ -45,7 +53,7 @@ export interface EitherBoolFalsy<GenericValue extends FalsyValue = FalsyValue> e
  * const maybeInput = E.bool(true ? true : null);
  * 
  * if (E.isBoolFalsy(maybeInput)) {
- * 	// type: E.EitherBoolFalsy<null>
+ * 	// type: E.BoolFalsy<null>
  * }
  * ```
  * 
@@ -69,7 +77,7 @@ export interface EitherBoolFalsy<GenericValue extends FalsyValue = FalsyValue> e
  * 	E.whenIsBoolFalsy(() => "falsy"),
  * );
  * 
- * // type: E.EitherBoolTruthy<"value"> | "falsy"
+ * // type: E.BoolTruthy<"value"> | "falsy"
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/whenIsBoolFalsy
@@ -77,10 +85,10 @@ export interface EitherBoolFalsy<GenericValue extends FalsyValue = FalsyValue> e
  * @namespace E
  * 
  */
-export declare function boolFalsy<const GenericValue extends FalsyValue = undefined>(value?: GenericValue): EitherBoolFalsy<GenericValue>;
-type Either = EitherRight | EitherLeft;
-export declare function isBoolFalsy<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherBoolFalsy>;
+export declare function boolFalsy<const GenericValue extends FalsyValue = undefined>(value?: GenericValue): BoolFalsy<GenericValue>;
+type Either = Right | Left;
+export declare function isBoolFalsy<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, BoolFalsy>;
 type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof bool<GenericValue>>;
-export declare function whenIsBoolFalsy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherBoolFalsy>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherBoolFalsy>;
-export declare function whenIsBoolFalsy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherBoolFalsy>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherBoolFalsy>;
+export declare function whenIsBoolFalsy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, BoolFalsy>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, BoolFalsy>;
+export declare function whenIsBoolFalsy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, BoolFalsy>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, BoolFalsy>;
 export {};

package/dist/either/bool/falsy.mjs

@@ -1,12 +1,16 @@
 import { createEitherKind } from '../kind.mjs';
-import { eitherBoolKind } from './base.mjs';
+import { boolKind } from './base.mjs';
 import { bool } from './create.mjs';
 import { left } from '../left/create.mjs';
 import { isLeft } from '../left/is.mjs';
 import { isRight } from '../right/is.mjs';
 import { unwrap } from '../../common/unwrap.mjs';
 
-const eitherBoolFalsyKind = createEitherKind("bool-falsy");
+const boolFalsyKind = createEitherKind("bool-falsy");
+/**
+ * @deprecated use boolFalsyKind
+ */
+const eitherBoolFalsyKind = boolFalsyKind;
 /**
  * {@include either/boolFalsy/index.md}
  */
@@ -17,12 +21,12 @@ const eitherBoolFalsyKind = createEitherKind("bool-falsy");
  * {@include either/whenIsBoolFalsy/index.md}
  */
 function boolFalsy(value = undefined) {
-    return eitherBoolKind.setTo(eitherBoolFalsyKind.setTo(left("bool", value)));
+    return boolKind.setTo(boolFalsyKind.setTo(left("bool", value)));
 }
 function isBoolFalsy(input) {
     return isLeft(input)
-        && eitherBoolKind.has(input)
-        && eitherBoolFalsyKind.has(input);
+        && boolKind.has(input)
+        && boolFalsyKind.has(input);
 }
 function whenIsBoolFalsy(...args) {
     if (args.length === 1) {
@@ -45,4 +49,4 @@ function whenIsBoolFalsy(...args) {
     return either;
 }
 
-export { boolFalsy, eitherBoolFalsyKind, isBoolFalsy, whenIsBoolFalsy };
+export { boolFalsy, boolFalsyKind, eitherBoolFalsyKind, isBoolFalsy, whenIsBoolFalsy };

package/dist/either/bool/truthy.cjs

@@ -8,7 +8,11 @@ var is = require('../right/is.cjs');
 var is$1 = require('../left/is.cjs');
 var unwrap = require('../../common/unwrap.cjs');
 
-const eitherBoolTruthyKind = kind.createEitherKind("bool-truthy");
+const boolTruthyKind = kind.createEitherKind("bool-truthy");
+/**
+ * @deprecated use boolTruthyKind
+ */
+const eitherBoolTruthyKind = boolTruthyKind;
 /**
  * {@include either/boolTruthy/index.md}
  */
@@ -19,12 +23,12 @@ const eitherBoolTruthyKind = kind.createEitherKind("bool-truthy");
  * {@include either/whenIsBoolTruthy/index.md}
  */
 function boolTruthy(value) {
-    return base.eitherBoolKind.setTo(eitherBoolTruthyKind.setTo(create.right("bool", value)));
+    return base.boolKind.setTo(boolTruthyKind.setTo(create.right("bool", value)));
 }
 function isBoolTruthy(input) {
     return is.isRight(input)
-        && base.eitherBoolKind.has(input)
-        && eitherBoolTruthyKind.has(input);
+        && base.boolKind.has(input)
+        && boolTruthyKind.has(input);
 }
 function whenIsBoolTruthy(...args) {
     if (args.length === 1) {
@@ -48,6 +52,7 @@ function whenIsBoolTruthy(...args) {
 }
 
 exports.boolTruthy = boolTruthy;
+exports.boolTruthyKind = boolTruthyKind;
 exports.eitherBoolTruthyKind = eitherBoolTruthyKind;
 exports.isBoolTruthy = isBoolTruthy;
 exports.whenIsBoolTruthy = whenIsBoolTruthy;

package/dist/either/bool/truthy.d.ts

@@ -1,15 +1,23 @@
 import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
 import { type Kind } from "../../common/kind";
-import { eitherBoolKind } from "./base";
-import { type EitherLeft } from "../left";
-import { type EitherRight } from "../right";
+import { boolKind } from "./base";
+import { type Left } from "../left";
+import { type Right } from "../right";
 import { bool } from "./create";
+export declare const boolTruthyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/bool-truthy", unknown>>;
+/**
+ * @deprecated use boolTruthyKind
+ */
 export declare const eitherBoolTruthyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/bool-truthy", unknown>>;
-type _EitherBoolTruthy<GenericValue extends unknown = unknown> = (EitherRight<"bool", GenericValue> & Kind<typeof eitherBoolKind.definition> & Kind<typeof eitherBoolTruthyKind.definition>);
-export interface EitherBoolTruthy<GenericValue extends unknown = unknown> extends _EitherBoolTruthy<GenericValue> {
+type _BoolTruthy<GenericValue extends unknown = unknown> = (Right<"bool", GenericValue> & Kind<typeof boolKind.definition> & Kind<typeof boolTruthyKind.definition>);
+export interface BoolTruthy<GenericValue extends unknown = unknown> extends _BoolTruthy<GenericValue> {
 }
 /**
- * Forces the creation of an EitherRight<"bool"> by explicitly marking a truthy value.
+ * @deprecated use BoolTruthy
+ */
+export type EitherBoolTruthy<GenericValue extends unknown = unknown> = BoolTruthy<GenericValue>;
+/**
+ * Forces the creation of an Right<"bool"> by explicitly marking a truthy value.
  * 
  * Signature: `boolTruthy(value)` → returns a value
  * 
@@ -26,7 +34,7 @@ export interface EitherBoolTruthy<GenericValue extends unknown = unknown> extend
  * 	),
  * );
  * 
- * // type: string | E.EitherBoolTruthy<`${string}@${string}`>
+ * // type: string | E.BoolTruthy<`${string}@${string}`>
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/boolTruthy
@@ -45,7 +53,7 @@ export interface EitherBoolTruthy<GenericValue extends unknown = unknown> extend
  * const maybeInput = E.bool(true ? true : null);
  * 
  * if (E.isBoolTruthy(maybeInput)) {
- * 	// type: E.EitherBoolTruthy<true>
+ * 	// type: E.BoolTruthy<true>
  * }
  * ```
  * 
@@ -55,7 +63,7 @@ export interface EitherBoolTruthy<GenericValue extends unknown = unknown> extend
  * 
  */
 /**
- * Callback executed only for EitherBoolTruthy values. Otherwise, the initial value is returned.
+ * Callback executed only for BoolTruthy values. Otherwise, the initial value is returned.
  * 
  * **Supported call styles:**
  * - Classic: `whenIsBoolTruthy(input, theFunction)` → returns a value
@@ -69,7 +77,7 @@ export interface EitherBoolTruthy<GenericValue extends unknown = unknown> extend
  * 	E.whenIsBoolTruthy(S.toUpperCase),
  * );
  * 
- * // type: E.EitherBoolFalsy<null> | "VALUE"
+ * // type: E.BoolFalsy<null> | "VALUE"
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/whenIsBoolTruthy
@@ -77,10 +85,10 @@ export interface EitherBoolTruthy<GenericValue extends unknown = unknown> extend
  * @namespace E
  * 
  */
-export declare function boolTruthy<const GenericValue extends unknown>(value: GenericValue): EitherBoolTruthy<GenericValue>;
-type Either = EitherRight | EitherLeft;
-export declare function isBoolTruthy<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherBoolTruthy>;
+export declare function boolTruthy<const GenericValue extends unknown>(value: GenericValue): BoolTruthy<GenericValue>;
+type Either = Right | Left;
+export declare function isBoolTruthy<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, BoolTruthy>;
 type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof bool<GenericValue>>;
-export declare function whenIsBoolTruthy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherBoolTruthy>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, EitherBoolTruthy>;
-export declare function whenIsBoolTruthy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, EitherBoolTruthy>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, EitherBoolTruthy>;
+export declare function whenIsBoolTruthy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, BoolTruthy>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<ToEither<BreakGenericLink<GenericInput>>, BoolTruthy>;
+export declare function whenIsBoolTruthy<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<ToEither<BreakGenericLink<GenericInput>>, BoolTruthy>>) => GenericOutput): GenericOutput | Exclude<ToEither<GenericInput>, BoolTruthy>;
 export {};

package/dist/either/bool/truthy.mjs

@@ -1,4 +1,4 @@
-import { eitherBoolKind } from './base.mjs';
+import { boolKind } from './base.mjs';
 import { createEitherKind } from '../kind.mjs';
 import { bool } from './create.mjs';
 import { right } from '../right/create.mjs';
@@ -6,7 +6,11 @@ import { isRight } from '../right/is.mjs';
 import { isLeft } from '../left/is.mjs';
 import { unwrap } from '../../common/unwrap.mjs';
 
-const eitherBoolTruthyKind = createEitherKind("bool-truthy");
+const boolTruthyKind = createEitherKind("bool-truthy");
+/**
+ * @deprecated use boolTruthyKind
+ */
+const eitherBoolTruthyKind = boolTruthyKind;
 /**
  * {@include either/boolTruthy/index.md}
  */
@@ -17,12 +21,12 @@ const eitherBoolTruthyKind = createEitherKind("bool-truthy");
  * {@include either/whenIsBoolTruthy/index.md}
  */
 function boolTruthy(value) {
-    return eitherBoolKind.setTo(eitherBoolTruthyKind.setTo(right("bool", value)));
+    return boolKind.setTo(boolTruthyKind.setTo(right("bool", value)));
 }
 function isBoolTruthy(input) {
     return isRight(input)
-        && eitherBoolKind.has(input)
-        && eitherBoolTruthyKind.has(input);
+        && boolKind.has(input)
+        && boolTruthyKind.has(input);
 }
 function whenIsBoolTruthy(...args) {
     if (args.length === 1) {
@@ -45,4 +49,4 @@ function whenIsBoolTruthy(...args) {
     return either;
 }
 
-export { boolTruthy, eitherBoolTruthyKind, isBoolTruthy, whenIsBoolTruthy };
+export { boolTruthy, boolTruthyKind, eitherBoolTruthyKind, isBoolTruthy, whenIsBoolTruthy };

package/dist/either/future/base.cjs

@@ -2,6 +2,11 @@
 
 var kind = require('../kind.cjs');
 
-const eitherFutureKind = kind.createEitherKind("future");
+const futureKind = kind.createEitherKind("future");
+/**
+ * @deprecated use futureKind
+ */
+const eitherFutureKind = futureKind;
 
 exports.eitherFutureKind = eitherFutureKind;
+exports.futureKind = futureKind;

package/dist/either/future/base.d.ts

@@ -1 +1,5 @@
+export declare const futureKind: import("../..").KindHandler<import("../..").KindDefinition<"@DuplojsUtilsEither/future", unknown>>;
+/**
+ * @deprecated use futureKind
+ */
 export declare const eitherFutureKind: import("../..").KindHandler<import("../..").KindDefinition<"@DuplojsUtilsEither/future", unknown>>;

package/dist/either/future/base.mjs

@@ -1,5 +1,9 @@
 import { createEitherKind } from '../kind.mjs';
 
-const eitherFutureKind = createEitherKind("future");
+const futureKind = createEitherKind("future");
+/**
+ * @deprecated use futureKind
+ */
+const eitherFutureKind = futureKind;
 
-export { eitherFutureKind };
+export { eitherFutureKind, futureKind };

package/dist/either/future/create.d.ts

@@ -1,12 +1,12 @@
-import { type EitherLeft } from "../left";
-import { type EitherRight } from "../right";
-import { type EitherFutureSuccess } from "./success";
-import { type EitherFutureError } from "./error";
+import { type Left } from "../left";
+import { type Right } from "../right";
+import { type FutureSuccess } from "./success";
+import { type FutureError } from "./error";
 import { type IsEqual } from "../../common/types/isEqual";
 import { type AnyValue } from "../../common";
-type Either = EitherRight | EitherLeft;
-type ComputeEitherFutureSuccessResult<GenericValue extends unknown> = IsEqual<never, Exclude<GenericValue, Either>> extends false ? EitherFutureSuccess<Exclude<GenericValue, Either>> : never;
-type ComputeEitherFutureErrorResult<GenericValue extends unknown> = GenericValue extends Future<any> ? GenericValue : GenericValue extends Promise<unknown> ? EitherFutureError : never;
+type Either = Right | Left;
+type ComputeEitherFutureSuccessResult<GenericValue extends unknown> = IsEqual<never, Exclude<GenericValue, Either>> extends false ? FutureSuccess<Exclude<GenericValue, Either>> : never;
+type ComputeEitherFutureErrorResult<GenericValue extends unknown> = GenericValue extends Future<any> ? GenericValue : GenericValue extends Promise<unknown> ? FutureError : never;
 type ComputeFutureEitherResult<GenericValue extends unknown = unknown> = Extract<(Extract<Awaited<GenericValue>, Either> | ComputeEitherFutureSuccessResult<Awaited<GenericValue>> | ComputeEitherFutureErrorResult<GenericValue>), any>;
 export type FutureEitherAllResult<GenericArray extends readonly unknown[] | []> = Future<{
     -readonly [Prop in keyof GenericArray]: Awaited<Future<GenericArray[Prop]>>;
@@ -33,7 +33,7 @@ export declare class Future<const GenericValue extends unknown = unknown> extend
  * );
  * 
  * await maybePromise.then((value) => {
- * 	// type: E.EitherFutureSuccess<number> | E.EitherFutureError
+ * 	// type: E.FutureSuccess<number> | E.FutureError
  * 	return value;
  * });
  * ```

package/dist/either/future/error.cjs

@@ -4,13 +4,18 @@ var base = require('./base.cjs');
 var kind = require('../kind.cjs');
 var create = require('../left/create.cjs');
 
-const eitherFutureErrorKind = kind.createEitherKind("future-error");
+const futureErrorKind = kind.createEitherKind("future-error");
+/**
+ * @deprecated use futureErrorKind
+ */
+const eitherFutureErrorKind = futureErrorKind;
 /**
  * {@include either/futureError/index.md}
  */
 function futureError(value) {
-    return base.eitherFutureKind.setTo(eitherFutureErrorKind.setTo(create.left("future", value)));
+    return base.futureKind.setTo(futureErrorKind.setTo(create.left("future", value)));
 }
 
 exports.eitherFutureErrorKind = eitherFutureErrorKind;
 exports.futureError = futureError;
+exports.futureErrorKind = futureErrorKind;

package/dist/either/future/error.d.ts

@@ -1,12 +1,20 @@
 import { type Kind } from "../../common/kind";
-import { type EitherLeft } from "../left";
-import { eitherFutureKind } from "./base";
+import { type Left } from "../left";
+import { futureKind } from "./base";
+export declare const futureErrorKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/future-error", unknown>>;
+/**
+ * @deprecated use futureErrorKind
+ */
 export declare const eitherFutureErrorKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/future-error", unknown>>;
-type _EitherFutureError = (EitherLeft<"future", unknown> & Kind<typeof eitherFutureKind.definition> & Kind<typeof eitherFutureErrorKind.definition>);
-export interface EitherFutureError extends _EitherFutureError {
+type _FutureError = (Left<"future", unknown> & Kind<typeof futureKind.definition> & Kind<typeof futureErrorKind.definition>);
+export interface FutureError extends _FutureError {
 }
 /**
- * Creates a Future resolved with an EitherLeft<"future">, ideal for propagating a standardized rejection.
+ * @deprecated use FutureError
+ */
+export type EitherFutureError = FutureError;
+/**
+ * Creates a Future resolved with an Left<"future">, ideal for propagating a standardized rejection.
  * 
  * Signature: `futureError(value)` → returns a value
  * 
@@ -15,7 +23,7 @@ export interface EitherFutureError extends _EitherFutureError {
  * ```ts
  * const future = E.futureError("error");
  * 
- * // type: E.EitherFutureError
+ * // type: E.FutureError
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/futureError
@@ -23,5 +31,5 @@ export interface EitherFutureError extends _EitherFutureError {
  * @namespace E
  * 
  */
-export declare function futureError(value: unknown): EitherFutureError;
+export declare function futureError(value: unknown): FutureError;
 export {};

package/dist/either/future/error.mjs

@@ -1,13 +1,17 @@
-import { eitherFutureKind } from './base.mjs';
+import { futureKind } from './base.mjs';
 import { createEitherKind } from '../kind.mjs';
 import { left } from '../left/create.mjs';
 
-const eitherFutureErrorKind = createEitherKind("future-error");
+const futureErrorKind = createEitherKind("future-error");
+/**
+ * @deprecated use futureErrorKind
+ */
+const eitherFutureErrorKind = futureErrorKind;
 /**
  * {@include either/futureError/index.md}
  */
 function futureError(value) {
-    return eitherFutureKind.setTo(eitherFutureErrorKind.setTo(left("future", value)));
+    return futureKind.setTo(futureErrorKind.setTo(left("future", value)));
 }
 
-export { eitherFutureErrorKind, futureError };
+export { eitherFutureErrorKind, futureError, futureErrorKind };

package/dist/either/future/success.cjs

@@ -4,13 +4,18 @@ var kind = require('../kind.cjs');
 var base = require('./base.cjs');
 var create = require('../right/create.cjs');
 
-const eitherFutureSuccessKind = kind.createEitherKind("future-success");
+const futureSuccessKind = kind.createEitherKind("future-success");
+/**
+ * @deprecated use futureSuccessKind
+ */
+const eitherFutureSuccessKind = futureSuccessKind;
 /**
  * {@include either/futureSuccess/index.md}
  */
 function futureSuccess(value) {
-    return base.eitherFutureKind.setTo(eitherFutureSuccessKind.setTo(create.right("future", value)));
+    return base.futureKind.setTo(futureSuccessKind.setTo(create.right("future", value)));
 }
 
 exports.eitherFutureSuccessKind = eitherFutureSuccessKind;
 exports.futureSuccess = futureSuccess;
+exports.futureSuccessKind = futureSuccessKind;

package/dist/either/future/success.d.ts

@@ -1,12 +1,20 @@
 import { type Kind } from "../../common/kind";
-import { eitherFutureKind } from "./base";
-import { type EitherRight } from "../right";
+import { futureKind } from "./base";
+import { type Right } from "../right";
+export declare const futureSuccessKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/future-success", unknown>>;
+/**
+ * @deprecated use futureSuccessKind
+ */
 export declare const eitherFutureSuccessKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/future-success", unknown>>;
-type _EitherFutureSuccess<GenericValue extends unknown = unknown> = (EitherRight<"future", GenericValue> & Kind<typeof eitherFutureKind.definition> & Kind<typeof eitherFutureSuccessKind.definition>);
-export interface EitherFutureSuccess<GenericValue extends unknown = unknown> extends _EitherFutureSuccess<GenericValue> {
+type _FutureSuccess<GenericValue extends unknown = unknown> = (Right<"future", GenericValue> & Kind<typeof futureKind.definition> & Kind<typeof futureSuccessKind.definition>);
+export interface FutureSuccess<GenericValue extends unknown = unknown> extends _FutureSuccess<GenericValue> {
 }
 /**
- * Creates a Future resolved with an EitherRight<"future">.
+ * @deprecated use FutureSuccess
+ */
+export type EitherFutureSuccess<GenericValue extends unknown = unknown> = FutureSuccess<GenericValue>;
+/**
+ * Creates a Future resolved with an Right<"future">.
  * 
  * Signature: `futureSuccess(value)` → returns a value
  * 
@@ -15,7 +23,7 @@ export interface EitherFutureSuccess<GenericValue extends unknown = unknown> ext
  * ```ts
  * const future = E.futureSuccess("value");
  * 
- * // type: E.EitherFutureSuccess<"value">
+ * // type: E.FutureSuccess<"value">
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/futureSuccess
@@ -23,5 +31,5 @@ export interface EitherFutureSuccess<GenericValue extends unknown = unknown> ext
  * @namespace E
  * 
  */
-export declare function futureSuccess<const GenericValue extends unknown>(value: GenericValue): EitherFutureSuccess<GenericValue>;
+export declare function futureSuccess<const GenericValue extends unknown>(value: GenericValue): FutureSuccess<GenericValue>;
 export {};

package/dist/either/future/success.mjs

@@ -1,13 +1,17 @@
 import { createEitherKind } from '../kind.mjs';
-import { eitherFutureKind } from './base.mjs';
+import { futureKind } from './base.mjs';
 import { right } from '../right/create.mjs';
 
-const eitherFutureSuccessKind = createEitherKind("future-success");
+const futureSuccessKind = createEitherKind("future-success");
+/**
+ * @deprecated use futureSuccessKind
+ */
+const eitherFutureSuccessKind = futureSuccessKind;
 /**
  * {@include either/futureSuccess/index.md}
  */
 function futureSuccess(value) {
-    return eitherFutureKind.setTo(eitherFutureSuccessKind.setTo(right("future", value)));
+    return futureKind.setTo(futureSuccessKind.setTo(right("future", value)));
 }
 
-export { eitherFutureSuccessKind, futureSuccess };
+export { eitherFutureSuccessKind, futureSuccess, futureSuccessKind };

package/dist/either/hasInformation.cjs

@@ -8,8 +8,8 @@ function hasInformation(...args) {
         return (input) => hasInformation(input, information);
     }
     const [input, information] = args;
-    return kind.eitherInformationKind.has(input)
-        && kind.eitherInformationKind.getValue(input) === information;
+    return kind.informationKind.has(input)
+        && kind.informationKind.getValue(input) === information;
 }
 
 exports.hasInformation = hasInformation;