@duplojs/utils 1.4.44 → 1.4.46

package/dist/either/hasInformation.d.ts

@@ -1,8 +1,8 @@
 import { type Kind } from "../common";
-import { type EitherLeft } from "./left";
-import { type EitherRight } from "./right";
-import { eitherInformationKind } from "./kind";
-type Either = EitherRight | EitherLeft;
+import { type Left } from "./left";
+import { type Right } from "./right";
+import { informationKind } from "./kind";
+type Either = Right | Left;
 /**
  * Type guard based on the literal information stored in the Either. Lets you precisely target a business case without extra introspection.
  * 
@@ -20,10 +20,10 @@ type Either = EitherRight | EitherLeft;
  * 	: E.left("left-3", 3);
  * 
  * if (E.isLeft(result)) {
- * 	// type: E.EitherLeft<"left-2", 2> | E.EitherLeft<"left-3", 3>
+ * 	// type: E.Left<"left-2", 2> | E.Left<"left-3", 3>
  * 
  * 	if (E.hasInformation(result, "left-2")) {
- * 		// type: E.EitherLeft<"left-2", 2>
+ * 		// type: E.Left<"left-2", 2>
  * 	}
  * }
  * ```
@@ -33,6 +33,6 @@ type Either = EitherRight | EitherLeft;
  * @namespace E
  * 
  */
-export declare function hasInformation<const GenericInput extends unknown, GenericInformation extends (GenericInput extends Either ? ReturnType<typeof eitherInformationKind.getValue<GenericInput>> : never)>(information: GenericInformation): (input: GenericInput) => input is Extract<GenericInput, Kind<typeof eitherInformationKind.definition, GenericInformation>>;
-export declare function hasInformation<const GenericInput extends unknown, GenericInformation extends (GenericInput extends Either ? ReturnType<typeof eitherInformationKind.getValue<GenericInput>> : never)>(input: GenericInput, information: GenericInformation): input is Extract<GenericInput, Kind<typeof eitherInformationKind.definition, GenericInformation>>;
+export declare function hasInformation<const GenericInput extends unknown, GenericInformation extends (GenericInput extends Either ? ReturnType<typeof informationKind.getValue<GenericInput>> : never)>(information: GenericInformation): (input: GenericInput) => input is Extract<GenericInput, Kind<typeof informationKind.definition, GenericInformation>>;
+export declare function hasInformation<const GenericInput extends unknown, GenericInformation extends (GenericInput extends Either ? ReturnType<typeof informationKind.getValue<GenericInput>> : never)>(input: GenericInput, information: GenericInformation): input is Extract<GenericInput, Kind<typeof informationKind.definition, GenericInformation>>;
 export {};

package/dist/either/hasInformation.mjs

@@ -1,4 +1,4 @@
-import { eitherInformationKind } from './kind.mjs';
+import { informationKind } from './kind.mjs';
 
 function hasInformation(...args) {
     if (args.length === 1) {
@@ -6,8 +6,8 @@ function hasInformation(...args) {
         return (input) => hasInformation(input, information);
     }
     const [input, information] = args;
-    return eitherInformationKind.has(input)
-        && eitherInformationKind.getValue(input) === information;
+    return informationKind.has(input)
+        && informationKind.getValue(input) === information;
 }
 
 export { hasInformation };

package/dist/either/index.cjs

@@ -47,75 +47,99 @@ exports.hasInformation = hasInformation.hasInformation;
 exports.whenHasInformation = whenHasInformation.whenHasInformation;
 exports.createEitherKind = kind.createEitherKind;
 exports.eitherInformationKind = kind.eitherInformationKind;
+exports.informationKind = kind.informationKind;
 exports.callbackError = safeCallback.callbackError;
+exports.callbackErrorKind = safeCallback.callbackErrorKind;
 exports.callbackSuccess = safeCallback.callbackSuccess;
+exports.callbackSuccessKind = safeCallback.callbackSuccessKind;
 exports.eitherCallbackErrorKind = safeCallback.eitherCallbackErrorKind;
 exports.eitherCallbackSuccessKind = safeCallback.eitherCallbackSuccessKind;
 exports.safeCallback = safeCallback.safeCallback;
 exports.bool = create.bool;
 exports.boolFalsy = falsy.boolFalsy;
+exports.boolFalsyKind = falsy.boolFalsyKind;
 exports.eitherBoolFalsyKind = falsy.eitherBoolFalsyKind;
 exports.isBoolFalsy = falsy.isBoolFalsy;
 exports.whenIsBoolFalsy = falsy.whenIsBoolFalsy;
 exports.boolTruthy = truthy.boolTruthy;
+exports.boolTruthyKind = truthy.boolTruthyKind;
 exports.eitherBoolTruthyKind = truthy.eitherBoolTruthyKind;
 exports.isBoolTruthy = truthy.isBoolTruthy;
 exports.whenIsBoolTruthy = truthy.whenIsBoolTruthy;
+exports.boolKind = base.boolKind;
 exports.eitherBoolKind = base.eitherBoolKind;
 exports.Future = create$1.Future;
 exports.future = create$1.future;
 exports.eitherFutureErrorKind = error.eitherFutureErrorKind;
 exports.futureError = error.futureError;
+exports.futureErrorKind = error.futureErrorKind;
 exports.eitherFutureSuccessKind = success.eitherFutureSuccessKind;
 exports.futureSuccess = success.futureSuccess;
+exports.futureSuccessKind = success.futureSuccessKind;
 exports.eitherFutureKind = base$1.eitherFutureKind;
+exports.futureKind = base$1.futureKind;
 exports.eitherLeftKind = create$2.eitherLeftKind;
 exports.left = create$2.left;
+exports.leftKind = create$2.leftKind;
 exports.eitherErrorKind = error$1.eitherErrorKind;
 exports.error = error$1.error;
+exports.errorKind = error$1.errorKind;
 exports.eitherFailKind = fail.eitherFailKind;
 exports.fail = fail.fail;
+exports.failKind = fail.failKind;
 exports.isLeft = is.isLeft;
 exports.whenIsLeft = when.whenIsLeft;
 exports.nullable = create$3.nullable;
 exports.eitherNullableEmptyKind = empty.eitherNullableEmptyKind;
 exports.isNullableEmpty = empty.isNullableEmpty;
 exports.nullableEmpty = empty.nullableEmpty;
+exports.nullableEmptyKind = empty.nullableEmptyKind;
 exports.whenIsNullableEmpty = empty.whenIsNullableEmpty;
 exports.eitherNullableFilledKind = filled.eitherNullableFilledKind;
 exports.isNullableFilled = filled.isNullableFilled;
 exports.nullableFilled = filled.nullableFilled;
+exports.nullableFilledKind = filled.nullableFilledKind;
 exports.whenIsNullableFilled = filled.whenIsNullableFilled;
 exports.eitherNullableKind = base$2.eitherNullableKind;
+exports.nullableKind = base$2.nullableKind;
 exports.nullish = create$4.nullish;
 exports.eitherNullishEmptyKind = empty$1.eitherNullishEmptyKind;
 exports.isNullishEmpty = empty$1.isNullishEmpty;
 exports.nullishEmpty = empty$1.nullishEmpty;
+exports.nullishEmptyKind = empty$1.nullishEmptyKind;
 exports.whenIsNullishEmpty = empty$1.whenIsNullishEmpty;
 exports.eitherNullishFilledKind = filled$1.eitherNullishFilledKind;
 exports.isNullishFilled = filled$1.isNullishFilled;
 exports.nullishFilled = filled$1.nullishFilled;
+exports.nullishFilledKind = filled$1.nullishFilledKind;
 exports.whenIsNullishFilled = filled$1.whenIsNullishFilled;
 exports.eitherNullishKind = base$3.eitherNullishKind;
+exports.nullishKind = base$3.nullishKind;
 exports.optional = create$5.optional;
 exports.eitherOptionalEmptyKind = empty$2.eitherOptionalEmptyKind;
 exports.isOptionalEmpty = empty$2.isOptionalEmpty;
 exports.optionalEmpty = empty$2.optionalEmpty;
+exports.optionalEmptyKind = empty$2.optionalEmptyKind;
 exports.whenIsOptionalEmpty = empty$2.whenIsOptionalEmpty;
 exports.eitherOptionalFilledKind = filled$2.eitherOptionalFilledKind;
 exports.isOptionalFilled = filled$2.isOptionalFilled;
 exports.optionalFilled = filled$2.optionalFilled;
+exports.optionalFilledKind = filled$2.optionalFilledKind;
 exports.whenIsOptionalFilled = filled$2.whenIsOptionalFilled;
 exports.eitherOptionalKind = base$4.eitherOptionalKind;
+exports.optionalKind = base$4.optionalKind;
 exports.rightAsyncPipe = asyncPipe.rightAsyncPipe;
 exports.eitherRightKind = create$6.eitherRightKind;
 exports.right = create$6.right;
+exports.rightKind = create$6.rightKind;
 exports.isRight = is$1.isRight;
 exports.eitherOkKind = ok.eitherOkKind;
 exports.ok = ok.ok;
+exports.okKind = ok.okKind;
 exports.rightPipe = pipe.rightPipe;
 exports.eitherSuccessKind = success$1.eitherSuccessKind;
 exports.success = success$1.success;
+exports.successKind = success$1.successKind;
 exports.whenIsRight = when$1.whenIsRight;
 exports.group = group.group;
 exports.asyncGroup = asyncGroup.asyncGroup;

package/dist/either/index.mjs

@@ -1,38 +1,38 @@
 export { hasInformation } from './hasInformation.mjs';
 export { whenHasInformation } from './whenHasInformation.mjs';
-export { createEitherKind, eitherInformationKind } from './kind.mjs';
-export { callbackError, callbackSuccess, eitherCallbackErrorKind, eitherCallbackSuccessKind, safeCallback } from './safeCallback.mjs';
+export { createEitherKind, eitherInformationKind, informationKind } from './kind.mjs';
+export { callbackError, callbackErrorKind, callbackSuccess, callbackSuccessKind, eitherCallbackErrorKind, eitherCallbackSuccessKind, safeCallback } from './safeCallback.mjs';
 export { bool } from './bool/create.mjs';
-export { boolFalsy, eitherBoolFalsyKind, isBoolFalsy, whenIsBoolFalsy } from './bool/falsy.mjs';
-export { boolTruthy, eitherBoolTruthyKind, isBoolTruthy, whenIsBoolTruthy } from './bool/truthy.mjs';
-export { eitherBoolKind } from './bool/base.mjs';
+export { boolFalsy, boolFalsyKind, eitherBoolFalsyKind, isBoolFalsy, whenIsBoolFalsy } from './bool/falsy.mjs';
+export { boolTruthy, boolTruthyKind, eitherBoolTruthyKind, isBoolTruthy, whenIsBoolTruthy } from './bool/truthy.mjs';
+export { boolKind, eitherBoolKind } from './bool/base.mjs';
 export { Future, future } from './future/create.mjs';
-export { eitherFutureErrorKind, futureError } from './future/error.mjs';
-export { eitherFutureSuccessKind, futureSuccess } from './future/success.mjs';
-export { eitherFutureKind } from './future/base.mjs';
-export { eitherLeftKind, left } from './left/create.mjs';
-export { eitherErrorKind, error } from './left/error.mjs';
-export { eitherFailKind, fail } from './left/fail.mjs';
+export { eitherFutureErrorKind, futureError, futureErrorKind } from './future/error.mjs';
+export { eitherFutureSuccessKind, futureSuccess, futureSuccessKind } from './future/success.mjs';
+export { eitherFutureKind, futureKind } from './future/base.mjs';
+export { eitherLeftKind, left, leftKind } from './left/create.mjs';
+export { eitherErrorKind, error, errorKind } from './left/error.mjs';
+export { eitherFailKind, fail, failKind } from './left/fail.mjs';
 export { isLeft } from './left/is.mjs';
 export { whenIsLeft } from './left/when.mjs';
 export { nullable } from './nullable/create.mjs';
-export { eitherNullableEmptyKind, isNullableEmpty, nullableEmpty, whenIsNullableEmpty } from './nullable/empty.mjs';
-export { eitherNullableFilledKind, isNullableFilled, nullableFilled, whenIsNullableFilled } from './nullable/filled.mjs';
-export { eitherNullableKind } from './nullable/base.mjs';
+export { eitherNullableEmptyKind, isNullableEmpty, nullableEmpty, nullableEmptyKind, whenIsNullableEmpty } from './nullable/empty.mjs';
+export { eitherNullableFilledKind, isNullableFilled, nullableFilled, nullableFilledKind, whenIsNullableFilled } from './nullable/filled.mjs';
+export { eitherNullableKind, nullableKind } from './nullable/base.mjs';
 export { nullish } from './nullish/create.mjs';
-export { eitherNullishEmptyKind, isNullishEmpty, nullishEmpty, whenIsNullishEmpty } from './nullish/empty.mjs';
-export { eitherNullishFilledKind, isNullishFilled, nullishFilled, whenIsNullishFilled } from './nullish/filled.mjs';
-export { eitherNullishKind } from './nullish/base.mjs';
+export { eitherNullishEmptyKind, isNullishEmpty, nullishEmpty, nullishEmptyKind, whenIsNullishEmpty } from './nullish/empty.mjs';
+export { eitherNullishFilledKind, isNullishFilled, nullishFilled, nullishFilledKind, whenIsNullishFilled } from './nullish/filled.mjs';
+export { eitherNullishKind, nullishKind } from './nullish/base.mjs';
 export { optional } from './optional/create.mjs';
-export { eitherOptionalEmptyKind, isOptionalEmpty, optionalEmpty, whenIsOptionalEmpty } from './optional/empty.mjs';
-export { eitherOptionalFilledKind, isOptionalFilled, optionalFilled, whenIsOptionalFilled } from './optional/filled.mjs';
-export { eitherOptionalKind } from './optional/base.mjs';
+export { eitherOptionalEmptyKind, isOptionalEmpty, optionalEmpty, optionalEmptyKind, whenIsOptionalEmpty } from './optional/empty.mjs';
+export { eitherOptionalFilledKind, isOptionalFilled, optionalFilled, optionalFilledKind, whenIsOptionalFilled } from './optional/filled.mjs';
+export { eitherOptionalKind, optionalKind } from './optional/base.mjs';
 export { rightAsyncPipe } from './right/asyncPipe.mjs';
-export { eitherRightKind, right } from './right/create.mjs';
+export { eitherRightKind, right, rightKind } from './right/create.mjs';
 export { isRight } from './right/is.mjs';
-export { eitherOkKind, ok } from './right/ok.mjs';
+export { eitherOkKind, ok, okKind } from './right/ok.mjs';
 export { rightPipe } from './right/pipe.mjs';
-export { eitherSuccessKind, success } from './right/success.mjs';
+export { eitherSuccessKind, success, successKind } from './right/success.mjs';
 export { whenIsRight } from './right/when.mjs';
 export { group } from './right/group.mjs';
 export { asyncGroup } from './right/asyncGroup.mjs';

package/dist/either/kind.cjs

@@ -5,7 +5,12 @@ var kind = require('../common/kind.cjs');
 const createEitherKind = kind.createKindNamespace(
 // @ts-expect-error reserved kind namespace
 "DuplojsUtilsEither");
-const eitherInformationKind = createEitherKind("information");
+const informationKind = createEitherKind("information");
+/**
+ * @deprecated use informationKind
+ */
+const eitherInformationKind = informationKind;
 
 exports.createEitherKind = createEitherKind;
 exports.eitherInformationKind = eitherInformationKind;
+exports.informationKind = informationKind;

package/dist/either/kind.d.ts

@@ -1,2 +1,6 @@
 export declare const createEitherKind: <GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName & import("../string").ForbiddenString<GenericName, "@" | "/">) => import("../common").KindHandler<import("../common").KindDefinition<`@DuplojsUtilsEither/${GenericName}`, GenericKindValue>>;
+export declare const informationKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsEither/information", string>>;
+/**
+ * @deprecated use informationKind
+ */
 export declare const eitherInformationKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsEither/information", string>>;

package/dist/either/kind.mjs

@@ -3,6 +3,10 @@ import { createKindNamespace } from '../common/kind.mjs';
 const createEitherKind = createKindNamespace(
 // @ts-expect-error reserved kind namespace
 "DuplojsUtilsEither");
-const eitherInformationKind = createEitherKind("information");
+const informationKind = createEitherKind("information");
+/**
+ * @deprecated use informationKind
+ */
+const eitherInformationKind = informationKind;
 
-export { createEitherKind, eitherInformationKind };
+export { createEitherKind, eitherInformationKind, informationKind };

package/dist/either/left/create.cjs

@@ -3,13 +3,18 @@
 var wrapValue = require('../../common/wrapValue.cjs');
 var kind = require('../kind.cjs');
 
-const eitherLeftKind = kind.createEitherKind("left");
+const leftKind = kind.createEitherKind("left");
+/**
+ * @deprecated use leftKind
+ */
+const eitherLeftKind = leftKind;
 /**
  * {@include either/left/index.md}
  */
 function left(information, value = undefined) {
-    return eitherLeftKind.setTo(kind.eitherInformationKind.setTo(wrapValue.wrapValue(value), information));
+    return leftKind.setTo(kind.informationKind.setTo(wrapValue.wrapValue(value), information));
 }
 
 exports.eitherLeftKind = eitherLeftKind;
 exports.left = left;
+exports.leftKind = leftKind;

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

@@ -1,12 +1,20 @@
 import { type Kind } from "../../common/kind";
 import { type WrappedValue } from "../../common/wrapValue";
-import { eitherInformationKind } from "../kind";
+import { informationKind } from "../kind";
+export declare const leftKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/left", unknown>>;
+/**
+ * @deprecated use leftKind
+ */
 export declare const eitherLeftKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/left", unknown>>;
-type _EitherLeft<GenericInformation extends string = string, GenericValue extends unknown = unknown> = (Kind<typeof eitherLeftKind.definition> & Kind<typeof eitherInformationKind.definition, GenericInformation> & WrappedValue<GenericValue>);
-export interface EitherLeft<GenericInformation extends string = string, GenericValue extends unknown = unknown> extends _EitherLeft<GenericInformation, GenericValue> {
+type _Left<GenericInformation extends string = string, GenericValue extends unknown = unknown> = (Kind<typeof leftKind.definition> & Kind<typeof informationKind.definition, GenericInformation> & WrappedValue<GenericValue>);
+export interface Left<GenericInformation extends string = string, GenericValue extends unknown = unknown> extends _Left<GenericInformation, GenericValue> {
 }
 /**
- * Builds an EitherLeft by associating mandatory business information (literal string) with a value representing the error. This is the fundamental brick to signal a contextualized failure.
+ * @deprecated use Left
+ */
+export type EitherLeft<GenericInformation extends string = string, GenericValue extends unknown = unknown> = Left<GenericInformation, GenericValue>;
+/**
+ * Builds an Left by associating mandatory business information (literal string) with a value representing the error. This is the fundamental brick to signal a contextualized failure.
  * 
  * Signature: `left(information, value)` → returns a value
  * 
@@ -26,7 +34,7 @@ export interface EitherLeft<GenericInformation extends string = string, GenericV
  * 	),
  * );
  * 
- * // type: E.EitherRight<"number.positive", number> | E.EitherLeft<"number.notPositive", number>
+ * // type: E.Right<"number.positive", number> | E.Left<"number.notPositive", number>
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/left
@@ -34,5 +42,5 @@ export interface EitherLeft<GenericInformation extends string = string, GenericV
  * @namespace E
  * 
  */
-export declare function left<GenericInformation extends string, const GenericValue extends unknown = undefined>(information: GenericInformation, value?: GenericValue): EitherLeft<GenericInformation, GenericValue>;
+export declare function left<GenericInformation extends string, const GenericValue extends unknown = undefined>(information: GenericInformation, value?: GenericValue): Left<GenericInformation, GenericValue>;
 export {};

package/dist/either/left/create.mjs

@@ -1,12 +1,16 @@
 import { wrapValue } from '../../common/wrapValue.mjs';
-import { createEitherKind, eitherInformationKind } from '../kind.mjs';
+import { createEitherKind, informationKind } from '../kind.mjs';
 
-const eitherLeftKind = createEitherKind("left");
+const leftKind = createEitherKind("left");
+/**
+ * @deprecated use leftKind
+ */
+const eitherLeftKind = leftKind;
 /**
  * {@include either/left/index.md}
  */
 function left(information, value = undefined) {
-    return eitherLeftKind.setTo(eitherInformationKind.setTo(wrapValue(value), information));
+    return leftKind.setTo(informationKind.setTo(wrapValue(value), information));
 }
 
-export { eitherLeftKind, left };
+export { eitherLeftKind, left, leftKind };

package/dist/either/left/error.cjs

@@ -3,13 +3,18 @@
 var kind = require('../kind.cjs');
 var create = require('./create.cjs');
 
-const eitherErrorKind = kind.createEitherKind("error");
+const errorKind = kind.createEitherKind("error");
+/**
+ * @deprecated use errorKind
+ */
+const eitherErrorKind = errorKind;
 /**
  * {@include either/error/index.md}
  */
 function error(value) {
-    return eitherErrorKind.setTo(create.left("error", value));
+    return errorKind.setTo(create.left("error", value));
 }
 
 exports.eitherErrorKind = eitherErrorKind;
 exports.error = error;
+exports.errorKind = errorKind;

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

@@ -1,11 +1,19 @@
 import { type Kind } from "../../common/kind";
-import { type EitherLeft } from "./create";
+import { type Left } from "./create";
+export declare const errorKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/error", unknown>>;
+/**
+ * @deprecated use errorKind
+ */
 export declare const eitherErrorKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/error", unknown>>;
-type _EitherError<GenericValue extends unknown = unknown> = (EitherLeft<"error", GenericValue> & Kind<typeof eitherErrorKind.definition>);
-export interface EitherError<GenericValue extends unknown = unknown> extends _EitherError<GenericValue> {
+type _Error<GenericValue extends unknown = unknown> = (Left<"error", GenericValue> & Kind<typeof errorKind.definition>);
+export interface Error<GenericValue extends unknown = unknown> extends _Error<GenericValue> {
 }
 /**
- * Handy alias to create an EitherLeft with the info fixed to "error". Useful to signal a generic error without manually providing the info.
+ * @deprecated use Error
+ */
+export type EitherError<GenericValue extends unknown = unknown> = Error<GenericValue>;
+/**
+ * Handy alias to create an Left with the info fixed to "error". Useful to signal a generic error without manually providing the info.
  * 
  * Signature: `error(value)` → returns a value
  * 
@@ -24,7 +32,7 @@ export interface EitherError<GenericValue extends unknown = unknown> extends _Ei
  * 	),
  * );
  * 
- * // type: E.EitherError<string> | E.EitherSuccess<string>
+ * // type: E.Error<string> | E.Success<string>
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/error
@@ -32,5 +40,5 @@ export interface EitherError<GenericValue extends unknown = unknown> extends _Ei
  * @namespace E
  * 
  */
-export declare function error<const GenericValue extends unknown>(value: GenericValue): EitherError<GenericValue>;
+export declare function error<const GenericValue extends unknown>(value: GenericValue): Error<GenericValue>;
 export {};

package/dist/either/left/error.mjs

@@ -1,12 +1,16 @@
 import { createEitherKind } from '../kind.mjs';
 import { left } from './create.mjs';
 
-const eitherErrorKind = createEitherKind("error");
+const errorKind = createEitherKind("error");
+/**
+ * @deprecated use errorKind
+ */
+const eitherErrorKind = errorKind;
 /**
  * {@include either/error/index.md}
  */
 function error(value) {
-    return eitherErrorKind.setTo(left("error", value));
+    return errorKind.setTo(left("error", value));
 }
 
-export { eitherErrorKind, error };
+export { eitherErrorKind, error, errorKind };

package/dist/either/left/fail.cjs

@@ -3,13 +3,18 @@
 var kind = require('../kind.cjs');
 var create = require('./create.cjs');
 
-const eitherFailKind = kind.createEitherKind("fail");
+const failKind = kind.createEitherKind("fail");
+/**
+ * @deprecated use failKind
+ */
+const eitherFailKind = failKind;
 /**
  * {@include either/fail/index.md}
  */
 function fail() {
-    return eitherFailKind.setTo(create.left("fail", undefined));
+    return failKind.setTo(create.left("fail", undefined));
 }
 
 exports.eitherFailKind = eitherFailKind;
 exports.fail = fail;
+exports.failKind = failKind;

package/dist/either/left/fail.d.ts

@@ -1,11 +1,19 @@
 import { type Kind } from "../../common/kind";
-import { type EitherLeft } from "./create";
+import { type Left } from "./create";
+export declare const failKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/fail", unknown>>;
+/**
+ * @deprecated use failKind
+ */
 export declare const eitherFailKind: import("../../common/kind").KindHandler<import("../../common/kind").KindDefinition<"@DuplojsUtilsEither/fail", unknown>>;
-type _EitherFail = (EitherLeft<"fail", never> & Kind<typeof eitherFailKind.definition>);
-export interface EitherFail extends _EitherFail {
+type _Fail = (Left<"fail", never> & Kind<typeof failKind.definition>);
+export interface Fail extends _Fail {
 }
 /**
- * Returns an EitherLeft<"fail", never>: perfect to signal a failure without carrying extra data.
+ * @deprecated use Fail
+ */
+export type EitherFail = Fail;
+/**
+ * Returns an Left<"fail", never>: perfect to signal a failure without carrying extra data.
  * 
  * Signature: `fail()` → returns a value
  * 
@@ -25,7 +33,7 @@ export interface EitherFail extends _EitherFail {
  * 	),
  * );
  * 
- * // type: E.EitherSuccess<number> | E.EitherFail
+ * // type: E.Success<number> | E.Fail
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/either/fail
@@ -33,5 +41,5 @@ export interface EitherFail extends _EitherFail {
  * @namespace E
  * 
  */
-export declare function fail(): EitherFail;
+export declare function fail(): Fail;
 export {};

package/dist/either/left/fail.mjs

@@ -1,12 +1,16 @@
 import { createEitherKind } from '../kind.mjs';
 import { left } from './create.mjs';
 
-const eitherFailKind = createEitherKind("fail");
+const failKind = createEitherKind("fail");
+/**
+ * @deprecated use failKind
+ */
+const eitherFailKind = failKind;
 /**
  * {@include either/fail/index.md}
  */
 function fail() {
-    return eitherFailKind.setTo(left("fail", undefined));
+    return failKind.setTo(left("fail", undefined));
 }
 
-export { eitherFailKind, fail };
+export { eitherFailKind, fail, failKind };

package/dist/either/left/is.cjs

@@ -8,8 +8,8 @@ var kind = require('../kind.cjs');
  * {@include either/isLeft/index.md}
  */
 function isLeft(input) {
-    return create.eitherLeftKind.has(input)
-        && kind.eitherInformationKind.has(input)
+    return create.leftKind.has(input)
+        && kind.informationKind.has(input)
         && wrapValue.isWrappedValue(input);
 }
 

package/dist/either/left/is.d.ts

@@ -1,6 +1,6 @@
-import { type EitherLeft } from "./create";
+import { type Left } from "./create";
 /**
- * Type guard that checks whether a value is an EitherLeft. Ideal to secure an unwrap or trigger an error branch.
+ * Type guard that checks whether a value is an Left. Ideal to secure an unwrap or trigger an error branch.
  * 
  * Signature: `isLeft(input)` → returns a value
  * 
@@ -12,7 +12,7 @@ import { type EitherLeft } from "./create";
  * 	: E.fail();
  * 
  * if (E.isLeft(result)) {
- * 	// type: E.EitherFail
+ * 	// type: E.Fail
  * }
  * ```
  * 
@@ -21,4 +21,4 @@ import { type EitherLeft } from "./create";
  * @namespace E
  * 
  */
-export declare function isLeft<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherLeft>;
+export declare function isLeft<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, Left>;

package/dist/either/left/is.mjs

@@ -1,13 +1,13 @@
-import { eitherLeftKind } from './create.mjs';
+import { leftKind } from './create.mjs';
 import { isWrappedValue } from '../../common/wrapValue.mjs';
-import { eitherInformationKind } from '../kind.mjs';
+import { informationKind } from '../kind.mjs';
 
 /**
  * {@include either/isLeft/index.md}
  */
 function isLeft(input) {
-    return eitherLeftKind.has(input)
-        && eitherInformationKind.has(input)
+    return leftKind.has(input)
+        && informationKind.has(input)
         && isWrappedValue(input);
 }
 

package/dist/either/left/when.d.ts

@@ -1,7 +1,7 @@
 import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
-import { type EitherLeft } from "./create";
+import { type Left } from "./create";
 /**
- * Executes a function only when the input is an EitherLeft. Otherwise, the original value is returned as-is.
+ * Executes a function only when the input is an Left. Otherwise, the original value is returned as-is.
  * 
  * **Supported call styles:**
  * - Classic: `whenIsLeft(input, theFunction)` → returns a value
@@ -26,5 +26,5 @@ import { type EitherLeft } from "./create";
  * @namespace E
  * 
  */
-export declare function whenIsLeft<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<BreakGenericLink<GenericInput>, EitherLeft>>) => GenericOutput): (input: GenericInput) => Exclude<BreakGenericLink<GenericInput>, EitherLeft> | GenericOutput;
-export declare function whenIsLeft<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<BreakGenericLink<GenericInput>, EitherLeft>>) => GenericOutput): Exclude<GenericInput, EitherLeft> | GenericOutput;
+export declare function whenIsLeft<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(theFunction: (eitherValue: Unwrap<Extract<BreakGenericLink<GenericInput>, Left>>) => GenericOutput): (input: GenericInput) => Exclude<BreakGenericLink<GenericInput>, Left> | GenericOutput;
+export declare function whenIsLeft<const GenericInput extends unknown, const GenericOutput extends AnyValue | EscapeVoid>(input: GenericInput, theFunction: (eitherValue: Unwrap<Extract<BreakGenericLink<GenericInput>, Left>>) => GenericOutput): Exclude<GenericInput, Left> | GenericOutput;

package/dist/either/nullable/base.cjs

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

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

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

package/dist/either/nullable/base.mjs

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