@duplojs/lang 0.0.1-beta.8 → 0.0.1-beta.9

package/dist/dataStructure/structure/defaults/type.d.ts

@@ -7,6 +7,6 @@ export declare const typeStructureKind: DKind.Handler<DKind.Definition<"@Duplojs
 export interface TypeStructureDefinition<GenericConstraints extends readonly Constraint[] = readonly Constraint[]> extends StructureDefinition<GenericConstraints> {
     readonly type: Type;
 }
-export interface TypeStructure<GenericType extends unknown = unknown, GenericConstraints extends readonly Constraint<GenericType>[] = readonly Constraint<GenericType>[]> extends DCommon.Forward<Structure<GenericType, TypeStructureDefinition<GenericConstraints>> & DKind.Kind<typeof typeStructureKind>> {
+export interface TypeStructure<out GenericType extends unknown = unknown, out GenericConstraints extends readonly Constraint<GenericType>[] = readonly Constraint<GenericType>[]> extends DCommon.Forward<Structure<GenericType, TypeStructureDefinition<GenericConstraints>> & DKind.Kind<typeof typeStructureKind>> {
 }
 export declare const TypeStructure: <GenericType extends Type, const GenericConstraints extends readonly Constraint<TypeValue<GenericType>>[]>(type: GenericType, constraints: GenericConstraints) => NoInfer<TypeStructure<TypeValue<GenericType>, readonly [...GenericConstraints]>>;

package/dist/dataStructure/structure/defaults/union.d.ts

@@ -7,6 +7,6 @@ export declare const unionStructureKind: DKind.Handler<DKind.Definition<"@Duploj
 export interface UnionStructureDefinition<GenericConstraints extends readonly Constraint[] = readonly Constraint[]> extends StructureDefinition<GenericConstraints> {
     readonly values: DCommon.Memoized<DCommon.AnyTuple<Structure>>;
 }
-export interface UnionStructure<GenericValue extends unknown = unknown, GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.Forward<Structure<GenericValue, UnionStructureDefinition<GenericConstraints>> & DKind.Kind<typeof unionStructureKind>> {
+export interface UnionStructure<out GenericValue extends unknown = unknown, out GenericConstraints extends readonly Constraint<GenericValue>[] = readonly Constraint<GenericValue>[]> extends DCommon.Forward<Structure<GenericValue, UnionStructureDefinition<GenericConstraints>> & DKind.Kind<typeof unionStructureKind>> {
 }
 export declare const UnionStructure: <GenericValues extends DCommon.AnyTuple<Structure>, const GenericConstraints extends readonly Constraint<StructureValue<GenericValues[number]>>[]>(values: GenericValues, constraints: GenericConstraints) => NoInfer<UnionStructure<StructureValue<GenericValues[number]>, readonly [...GenericConstraints]>>;

package/dist/either/index.cjs

@@ -4,23 +4,25 @@ const require_create = require("./left/create.cjs");
 const require_error = require("./left/error.cjs");
 const require_fail = require("./left/fail.cjs");
 const require_is = require("./left/is.cjs");
+const require_create$1 = require("./right/create.cjs");
+const require_none = require("./left/none.cjs");
+const require_unwrap = require("./left/unwrap.cjs");
+const require_unwrapOrThrow = require("./left/unwrapOrThrow.cjs");
 const require_when = require("./left/when.cjs");
 const require_whenOtherwise = require("./left/whenOtherwise.cjs");
-const require_unwrapOrThrow = require("./left/unwrapOrThrow.cjs");
-const require_unwrap = require("./left/unwrap.cjs");
-const require_create$1 = require("./right/create.cjs");
+const require_asyncGroup = require("./right/asyncGroup.cjs");
 const require_success = require("./right/success.cjs");
 const require_is$1 = require("./right/is.cjs");
 const require_asyncPipe = require("./right/asyncPipe.cjs");
+const require_when$1 = require("./right/when.cjs");
+const require_group = require("./right/group.cjs");
 const require_ok = require("./right/ok.cjs");
 const require_pipe = require("./right/pipe.cjs");
-const require_when$1 = require("./right/when.cjs");
-const require_whenOtherwise$1 = require("./right/whenOtherwise.cjs");
 const require_result = require("./right/result.cjs");
-const require_unwrapOrThrow$1 = require("./right/unwrapOrThrow.cjs");
+const require_some = require("./right/some.cjs");
 const require_unwrap$1 = require("./right/unwrap.cjs");
-const require_group = require("./right/group.cjs");
-const require_asyncGroup = require("./right/asyncGroup.cjs");
+const require_unwrapOrThrow$1 = require("./right/unwrapOrThrow.cjs");
+const require_whenOtherwise$1 = require("./right/whenOtherwise.cjs");
 const require_whenHasInformation = require("./whenHasInformation.cjs");
 const require_whenHasInformationOtherwise = require("./whenHasInformationOtherwise.cjs");
 const require_whenIsSelected = require("./whenIsSelected.cjs");
@@ -30,12 +32,16 @@ const require_asyncSafeCallback = require("./asyncSafeCallback.cjs");
 const require_expect = require("./expect.cjs");
 const require_matchInformation = require("./matchInformation.cjs");
 const require_matchInformationOtherwise = require("./matchInformationOtherwise.cjs");
+const require_rewriteInformation = require("./rewriteInformation.cjs");
+const require_toMaybe = require("./toMaybe.cjs");
 const require_unwrapSelection = require("./unwrapSelection.cjs");
 const require_unwrapSelectionOrThrow = require("./unwrapSelectionOrThrow.cjs");
 const require_forwardAssertsSelection = require("./forwardAssertsSelection.cjs");
 const require_hasInformation = require("./hasInformation.cjs");
 const require_unwrapByInformation = require("./unwrapByInformation.cjs");
 const require_unwrapByInformationOrThrow = require("./unwrapByInformationOrThrow.cjs");
+const require_unwrapOr = require("./unwrapOr.cjs");
+const require_unwrapOtherwise = require("./unwrapOtherwise.cjs");
 const require_keepAsRightByInformation = require("./keepAsRightByInformation.cjs");
 const require_keepAsRightSelection = require("./keepAsRightSelection.cjs");
 //#region scripts/either/index.ts
@@ -65,21 +71,29 @@ var either_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	leftKind: () => require_create.leftKind,
 	matchInformation: () => require_matchInformation.matchInformation,
 	matchInformationOtherwise: () => require_matchInformationOtherwise.matchInformationOtherwise,
+	none: () => require_none.none,
+	noneKind: () => require_none.noneKind,
 	ok: () => require_ok.ok,
 	okKind: () => require_ok.okKind,
 	result: () => require_result.result,
 	resultKind: () => require_result.resultKind,
+	rewriteInformation: () => require_rewriteInformation.rewriteInformation,
 	right: () => require_create$1.right,
 	rightAsyncPipe: () => require_asyncPipe.rightAsyncPipe,
 	rightKind: () => require_create$1.rightKind,
 	rightPipe: () => require_pipe.rightPipe,
 	safeCallback: () => require_safeCallback.safeCallback,
+	some: () => require_some.some,
+	someKind: () => require_some.someKind,
 	success: () => require_success.success,
 	successKind: () => require_success.successKind,
+	toMaybe: () => require_toMaybe.toMaybe,
 	unwrapByInformation: () => require_unwrapByInformation.unwrapByInformation,
 	unwrapByInformationOrThrow: () => require_unwrapByInformationOrThrow.unwrapByInformationOrThrow,
 	unwrapLeft: () => require_unwrap.unwrapLeft,
 	unwrapLeftOrThrow: () => require_unwrapOrThrow.unwrapLeftOrThrow,
+	unwrapOr: () => require_unwrapOr.unwrapOr,
+	unwrapOtherwise: () => require_unwrapOtherwise.unwrapOtherwise,
 	unwrapRight: () => require_unwrap$1.unwrapRight,
 	unwrapRightOrThrow: () => require_unwrapOrThrow$1.unwrapRightOrThrow,
 	unwrapSelection: () => require_unwrapSelection.unwrapSelection,
@@ -126,21 +140,29 @@ exports.left = require_create.left;
 exports.leftKind = require_create.leftKind;
 exports.matchInformation = require_matchInformation.matchInformation;
 exports.matchInformationOtherwise = require_matchInformationOtherwise.matchInformationOtherwise;
+exports.none = require_none.none;
+exports.noneKind = require_none.noneKind;
 exports.ok = require_ok.ok;
 exports.okKind = require_ok.okKind;
 exports.result = require_result.result;
 exports.resultKind = require_result.resultKind;
+exports.rewriteInformation = require_rewriteInformation.rewriteInformation;
 exports.right = require_create$1.right;
 exports.rightAsyncPipe = require_asyncPipe.rightAsyncPipe;
 exports.rightKind = require_create$1.rightKind;
 exports.rightPipe = require_pipe.rightPipe;
 exports.safeCallback = require_safeCallback.safeCallback;
+exports.some = require_some.some;
+exports.someKind = require_some.someKind;
 exports.success = require_success.success;
 exports.successKind = require_success.successKind;
+exports.toMaybe = require_toMaybe.toMaybe;
 exports.unwrapByInformation = require_unwrapByInformation.unwrapByInformation;
 exports.unwrapByInformationOrThrow = require_unwrapByInformationOrThrow.unwrapByInformationOrThrow;
 exports.unwrapLeft = require_unwrap.unwrapLeft;
 exports.unwrapLeftOrThrow = require_unwrapOrThrow.unwrapLeftOrThrow;
+exports.unwrapOr = require_unwrapOr.unwrapOr;
+exports.unwrapOtherwise = require_unwrapOtherwise.unwrapOtherwise;
 exports.unwrapRight = require_unwrap$1.unwrapRight;
 exports.unwrapRightOrThrow = require_unwrapOrThrow$1.unwrapRightOrThrow;
 exports.unwrapSelection = require_unwrapSelection.unwrapSelection;

package/dist/either/index.d.ts

@@ -11,11 +11,15 @@ export * from './asyncSafeCallback';
 export * from './expect';
 export * from './matchInformation';
 export * from './matchInformationOtherwise';
+export * from './rewriteInformation';
+export * from './toMaybe';
 export * from './unwrapSelection';
 export * from './unwrapSelectionOrThrow';
 export * from './forwardAssertsSelection';
 export * from './hasInformation';
 export * from './unwrapByInformation';
 export * from './unwrapByInformationOrThrow';
+export * from './unwrapOr';
+export * from './unwrapOtherwise';
 export * from './keepAsRightByInformation';
 export * from './keepAsRightSelection';

package/dist/either/index.mjs

@@ -4,23 +4,25 @@ import { left, leftKind } from "./left/create.mjs";
 import { error, errorKind } from "./left/error.mjs";
 import { fail, failKind } from "./left/fail.mjs";
 import { isLeft } from "./left/is.mjs";
+import { right, rightKind } from "./right/create.mjs";
+import { none, noneKind } from "./left/none.mjs";
+import { unwrapLeft } from "./left/unwrap.mjs";
+import { NotLeftError, unwrapLeftOrThrow } from "./left/unwrapOrThrow.mjs";
 import { whenIsLeft } from "./left/when.mjs";
 import { whenIsLeftOtherwise } from "./left/whenOtherwise.mjs";
-import { NotLeftError, unwrapLeftOrThrow } from "./left/unwrapOrThrow.mjs";
-import { unwrapLeft } from "./left/unwrap.mjs";
-import { right, rightKind } from "./right/create.mjs";
+import { asyncGroup } from "./right/asyncGroup.mjs";
 import { success, successKind } from "./right/success.mjs";
 import { isRight } from "./right/is.mjs";
 import { rightAsyncPipe } from "./right/asyncPipe.mjs";
+import { whenIsRight } from "./right/when.mjs";
+import { group } from "./right/group.mjs";
 import { ok, okKind } from "./right/ok.mjs";
 import { rightPipe } from "./right/pipe.mjs";
-import { whenIsRight } from "./right/when.mjs";
-import { whenIsRightOtherwise } from "./right/whenOtherwise.mjs";
 import { result, resultKind } from "./right/result.mjs";
-import { NotRightError, unwrapRightOrThrow } from "./right/unwrapOrThrow.mjs";
+import { some, someKind } from "./right/some.mjs";
 import { unwrapRight } from "./right/unwrap.mjs";
-import { group } from "./right/group.mjs";
-import { asyncGroup } from "./right/asyncGroup.mjs";
+import { NotRightError, unwrapRightOrThrow } from "./right/unwrapOrThrow.mjs";
+import { whenIsRightOtherwise } from "./right/whenOtherwise.mjs";
 import { whenHasInformation } from "./whenHasInformation.mjs";
 import { whenHasInformationOtherwise } from "./whenHasInformationOtherwise.mjs";
 import { whenIsSelected } from "./whenIsSelected.mjs";
@@ -30,12 +32,16 @@ import { asyncSafeCallback } from "./asyncSafeCallback.mjs";
 import { expect } from "./expect.mjs";
 import { matchInformation } from "./matchInformation.mjs";
 import { matchInformationOtherwise } from "./matchInformationOtherwise.mjs";
+import { rewriteInformation } from "./rewriteInformation.mjs";
+import { toMaybe } from "./toMaybe.mjs";
 import { unwrapSelection } from "./unwrapSelection.mjs";
 import { HasNotSelectedInformationError, unwrapSelectionOrThrow } from "./unwrapSelectionOrThrow.mjs";
 import { ForwardAssertsSelectionError, forwardAssertsSelection } from "./forwardAssertsSelection.mjs";
 import { hasInformation } from "./hasInformation.mjs";
 import { unwrapByInformation } from "./unwrapByInformation.mjs";
 import { HasNotInformationError, unwrapByInformationOrThrow } from "./unwrapByInformationOrThrow.mjs";
+import { unwrapOr } from "./unwrapOr.mjs";
+import { unwrapOtherwise } from "./unwrapOtherwise.mjs";
 import { keepAsRightByInformation } from "./keepAsRightByInformation.mjs";
 import { keepAsRightSelection } from "./keepAsRightSelection.mjs";
 //#region scripts/either/index.ts
@@ -65,21 +71,29 @@ var either_exports = /* @__PURE__ */ __exportAll({
 	leftKind: () => leftKind,
 	matchInformation: () => matchInformation,
 	matchInformationOtherwise: () => matchInformationOtherwise,
+	none: () => none,
+	noneKind: () => noneKind,
 	ok: () => ok,
 	okKind: () => okKind,
 	result: () => result,
 	resultKind: () => resultKind,
+	rewriteInformation: () => rewriteInformation,
 	right: () => right,
 	rightAsyncPipe: () => rightAsyncPipe,
 	rightKind: () => rightKind,
 	rightPipe: () => rightPipe,
 	safeCallback: () => safeCallback,
+	some: () => some,
+	someKind: () => someKind,
 	success: () => success,
 	successKind: () => successKind,
+	toMaybe: () => toMaybe,
 	unwrapByInformation: () => unwrapByInformation,
 	unwrapByInformationOrThrow: () => unwrapByInformationOrThrow,
 	unwrapLeft: () => unwrapLeft,
 	unwrapLeftOrThrow: () => unwrapLeftOrThrow,
+	unwrapOr: () => unwrapOr,
+	unwrapOtherwise: () => unwrapOtherwise,
 	unwrapRight: () => unwrapRight,
 	unwrapRightOrThrow: () => unwrapRightOrThrow,
 	unwrapSelection: () => unwrapSelection,
@@ -95,4 +109,4 @@ var either_exports = /* @__PURE__ */ __exportAll({
 	whenIsSelectedOtherwise: () => whenIsSelectedOtherwise
 });
 //#endregion
-export { ForwardAssertsSelectionError, HasNotInformationError, HasNotSelectedInformationError, NotLeftError, NotRightError, asyncGroup, asyncSafeCallback, createKind, either_exports, error, errorKind, expect, fail, failKind, forwardAssertsSelection, group, hasInformation, informationKind, isLeft, isRight, keepAsRightByInformation, keepAsRightSelection, left, leftKind, matchInformation, matchInformationOtherwise, ok, okKind, result, resultKind, right, rightAsyncPipe, rightKind, rightPipe, safeCallback, success, successKind, unwrapByInformation, unwrapByInformationOrThrow, unwrapLeft, unwrapLeftOrThrow, unwrapRight, unwrapRightOrThrow, unwrapSelection, unwrapSelectionOrThrow, valueKind, whenHasInformation, whenHasInformationOtherwise, whenIsLeft, whenIsLeftOtherwise, whenIsRight, whenIsRightOtherwise, whenIsSelected, whenIsSelectedOtherwise };
+export { ForwardAssertsSelectionError, HasNotInformationError, HasNotSelectedInformationError, NotLeftError, NotRightError, asyncGroup, asyncSafeCallback, createKind, either_exports, error, errorKind, expect, fail, failKind, forwardAssertsSelection, group, hasInformation, informationKind, isLeft, isRight, keepAsRightByInformation, keepAsRightSelection, left, leftKind, matchInformation, matchInformationOtherwise, none, noneKind, ok, okKind, result, resultKind, rewriteInformation, right, rightAsyncPipe, rightKind, rightPipe, safeCallback, some, someKind, success, successKind, toMaybe, unwrapByInformation, unwrapByInformationOrThrow, unwrapLeft, unwrapLeftOrThrow, unwrapOr, unwrapOtherwise, unwrapRight, unwrapRightOrThrow, unwrapSelection, unwrapSelectionOrThrow, valueKind, whenHasInformation, whenHasInformationOtherwise, whenIsLeft, whenIsLeftOtherwise, whenIsRight, whenIsRightOtherwise, whenIsSelected, whenIsSelectedOtherwise };

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

@@ -2,7 +2,8 @@ export * from './create';
 export * from './error';
 export * from './fail';
 export * from './is';
+export * from './none';
+export * from './unwrap';
+export * from './unwrapOrThrow';
 export * from './when';
 export * from './whenOtherwise';
-export * from './unwrapOrThrow';
-export * from './unwrap';

package/dist/either/left/none.cjs

@@ -0,0 +1,15 @@
+const require_kind = require("../kind.cjs");
+const require_create = require("../right/create.cjs");
+//#region scripts/either/left/none.ts
+const noneKind = require_kind.createKind("none");
+function none() {
+	return {
+		[require_create.rightKind.runTimeKey]: null,
+		[require_kind.informationKind.runTimeKey]: "none",
+		[require_kind.valueKind.runTimeKey]: null,
+		[noneKind.runTimeKey]: null
+	};
+}
+//#endregion
+exports.none = none;
+exports.noneKind = noneKind;

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

@@ -0,0 +1,7 @@
+import { Right } from '../right/create';
+import type * as DKind from '../../kind';
+import type * as DCommon from '../../common';
+export declare const noneKind: DKind.Handler<DKind.Definition<"@DuplojsLangEither/none", unknown>>;
+export interface None extends DCommon.Forward<DKind.Kind<typeof noneKind> & Right<"none", null>> {
+}
+export declare function none(): None;

package/dist/either/left/none.mjs

@@ -0,0 +1,14 @@
+import { createKind, informationKind, valueKind } from "../kind.mjs";
+import { rightKind } from "../right/create.mjs";
+//#region scripts/either/left/none.ts
+const noneKind = createKind("none");
+function none() {
+	return {
+		[rightKind.runTimeKey]: null,
+		[informationKind.runTimeKey]: "none",
+		[valueKind.runTimeKey]: null,
+		[noneKind.runTimeKey]: null
+	};
+}
+//#endregion
+export { none, noneKind };

package/dist/either/matchInformationOtherwise.d.ts

@@ -11,5 +11,5 @@ type ComputeMatcher<GenericEither extends Either> = Extract<{
 }, any>;
 type ForbiddenMoreKey<GenericInput extends unknown, GenericMatcher extends ComputeMatcher<Extract<GenericInput, Either>>> = DObject.ForbiddenKey<GenericMatcher, Extract<Exclude<keyof GenericMatcher, GetInformation<Extract<GenericInput, Either>>>, string>>;
 export declare function matchInformationOtherwise<GenericInput extends unknown, GenericMatcher extends ComputeMatcher<Extract<GenericInput, Either>>, GenericOutput extends unknown, GenericError extends ForbiddenMoreKey<GenericInput, GenericMatcher>>(matcher: (ComputeMatcher<Extract<NoInfer<GenericInput>, Either>> & GenericMatcher & NoInfer<GenericError>), otherwise: (value: Exclude<GenericInput, DKind.Kind<typeof informationKind, Extract<DObject.GetPropsWithValueExtends<GenericMatcher, DCommon.AnyFunction>, string>>>) => GenericOutput): (input: GenericInput) => (ReturnType<NoInfer<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>>> | GenericOutput);
-export declare function matchInformationOtherwise<GenericInput extends unknown, GenericMatcher extends ComputeMatcher<Extract<GenericInput, Either>>, GenericOutput extends unknown>(input: GenericInput, matcher: DCommon.FixDeepFunctionInfer<ComputeMatcher<Extract<GenericInput, Either>>, GenericMatcher> & ForbiddenMoreKey<GenericInput, GenericMatcher>, otherwise: (value: Exclude<GenericInput, DKind.Kind<typeof informationKind, Extract<DObject.GetPropsWithValueExtends<GenericMatcher, DCommon.AnyFunction>, string>>>) => GenericOutput): (ReturnType<NoInfer<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>>> | GenericOutput);
+export declare function matchInformationOtherwise<GenericInput extends unknown, GenericMatcher extends ComputeMatcher<Extract<GenericInput, Either>>, GenericOutput extends unknown>(input: GenericInput, matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<Extract<GenericInput, Either>>, GenericMatcher> & ForbiddenMoreKey<GenericInput, GenericMatcher> & DObject.ForbiddenUndefinedProps<GenericMatcher>), otherwise: (value: Exclude<GenericInput, DKind.Kind<typeof informationKind, Extract<DObject.GetPropsWithValueExtends<GenericMatcher, DCommon.AnyFunction>, string>>>) => GenericOutput): (ReturnType<NoInfer<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>>> | GenericOutput);
 export {};

package/dist/either/rewriteInformation.cjs

@@ -0,0 +1,22 @@
+const require_kind = require("./kind.cjs");
+const require_create = require("./left/create.cjs");
+const require_is = require("./left/is.cjs");
+const require_create$1 = require("./right/create.cjs");
+const require_is$1 = require("./right/is.cjs");
+//#region scripts/either/rewriteInformation.ts
+function rewriteInformation(...args) {
+	if (args.length === 1) {
+		const [matcher] = args;
+		return (input) => rewriteInformation(input, matcher);
+	}
+	const [input, matcher] = args;
+	const inputIsRight = require_is$1.isRight(input);
+	if (!inputIsRight && !require_is.isLeft(input)) return input;
+	const information = matcher[require_kind.informationKind.getValue(input)];
+	if (information === void 0) return input;
+	const value = require_kind.valueKind.getValue(input);
+	if (inputIsRight) return require_create$1.right(information, value);
+	return require_create.left(information, value);
+}
+//#endregion
+exports.rewriteInformation = rewriteInformation;

package/dist/either/rewriteInformation.d.ts

@@ -0,0 +1,14 @@
+import { Left } from './left';
+import { Right } from './right';
+import { GetInformation, GetValue } from './types';
+import type * as DCommon from '../common';
+import type * as DObject from '../object';
+type Either = Right | Left;
+type ComputeMatcher<GenericInput extends unknown> = {
+    [Prop in GetInformation<Extract<GenericInput, Either>>]?: string;
+};
+type ForbiddenMoreKey<GenericInput extends unknown, GenericMatcher extends ComputeMatcher<GenericInput>> = DObject.ForbiddenKey<GenericMatcher, Extract<Exclude<keyof GenericMatcher, GetInformation<Extract<GenericInput, Either>>>, string>>;
+type ComputeResult<GenericInput extends unknown, GenericMatcher extends ComputeMatcher<GenericInput>> = GenericInput extends Right ? GetInformation<GenericInput> extends keyof GenericMatcher ? Right<Extract<GenericMatcher[GetInformation<GenericInput>], string>, GetValue<GenericInput>> : GenericInput : GenericInput extends Left ? GetInformation<GenericInput> extends keyof GenericMatcher ? Left<Extract<GenericMatcher[GetInformation<GenericInput>], string>, GetValue<GenericInput>> : GenericInput : GenericInput;
+export declare function rewriteInformation<GenericInput extends Either | DCommon.AnyValue, const GenericMatcher extends ComputeMatcher<GenericInput>>(matcher: (GenericMatcher & ForbiddenMoreKey<GenericInput, GenericMatcher> & DObject.ForbiddenUndefinedProps<GenericMatcher>)): (input: GenericInput) => ComputeResult<GenericInput, GenericMatcher>;
+export declare function rewriteInformation<GenericInput extends Either | DCommon.AnyValue, const GenericMatcher extends ComputeMatcher<GenericInput>>(input: GenericInput, matcher: (GenericMatcher & ForbiddenMoreKey<GenericInput, GenericMatcher> & DObject.ForbiddenUndefinedProps<GenericMatcher>)): ComputeResult<GenericInput, GenericMatcher>;
+export {};

package/dist/either/rewriteInformation.mjs

@@ -0,0 +1,22 @@
+import { informationKind, valueKind } from "./kind.mjs";
+import { left } from "./left/create.mjs";
+import { isLeft } from "./left/is.mjs";
+import { right } from "./right/create.mjs";
+import { isRight } from "./right/is.mjs";
+//#region scripts/either/rewriteInformation.ts
+function rewriteInformation(...args) {
+	if (args.length === 1) {
+		const [matcher] = args;
+		return (input) => rewriteInformation(input, matcher);
+	}
+	const [input, matcher] = args;
+	const inputIsRight = isRight(input);
+	if (!inputIsRight && !isLeft(input)) return input;
+	const information = matcher[informationKind.getValue(input)];
+	if (information === void 0) return input;
+	const value = valueKind.getValue(input);
+	if (inputIsRight) return right(information, value);
+	return left(information, value);
+}
+//#endregion
+export { rewriteInformation };

package/dist/either/right/asyncGroup.cjs

@@ -1,10 +1,10 @@
 const require_asyncPipe = require("../../common/asyncPipe.cjs");
 const require_entries = require("../../object/entries.cjs");
 const require_is = require("../left/is.cjs");
-const require_success = require("./success.cjs");
-const require_when = require("./when.cjs");
 const require_reduce = require("../../generator/reduce.cjs");
 const require_asyncReduce = require("../../generator/asyncReduce.cjs");
+const require_success = require("./success.cjs");
+const require_when = require("./when.cjs");
 const require_isType = require("../../common/isType.cjs");
 const require_when$1 = require("../../common/when.cjs");
 const require_whenNot = require("../../common/whenNot.cjs");

package/dist/either/right/asyncGroup.mjs

@@ -1,10 +1,10 @@
 import { asyncPipe } from "../../common/asyncPipe.mjs";
 import { entries } from "../../object/entries.mjs";
 import { isLeft } from "../left/is.mjs";
-import { success } from "./success.mjs";
-import { whenIsRight } from "./when.mjs";
 import { reduceFrom } from "../../generator/reduce.mjs";
 import { asyncReduce } from "../../generator/asyncReduce.mjs";
+import { success } from "./success.mjs";
+import { whenIsRight } from "./when.mjs";
 import { isType } from "../../common/isType.mjs";
 import { when } from "../../common/when.mjs";
 import { whenNot } from "../../common/whenNot.mjs";

package/dist/either/right/group.cjs

@@ -1,8 +1,8 @@
 const require_entries = require("../../object/entries.cjs");
 const require_is = require("../left/is.cjs");
+const require_reduce = require("../../array/reduce.cjs");
 const require_success = require("./success.cjs");
 const require_when = require("./when.cjs");
-const require_reduce = require("../../array/reduce.cjs");
 const require_isType = require("../../common/isType.cjs");
 const require_pipe = require("../../common/pipe.cjs");
 const require_when$1 = require("../../common/when.cjs");

package/dist/either/right/group.mjs

@@ -1,8 +1,8 @@
 import { entries } from "../../object/entries.mjs";
 import { isLeft } from "../left/is.mjs";
+import { reduce, reduceFrom } from "../../array/reduce.mjs";
 import { success } from "./success.mjs";
 import { whenIsRight } from "./when.mjs";
-import { reduce, reduceFrom } from "../../array/reduce.mjs";
 import { isType } from "../../common/isType.mjs";
 import { pipe } from "../../common/pipe.mjs";
 import { when } from "../../common/when.mjs";

package/dist/either/right/index.d.ts

@@ -1,13 +1,14 @@
+export * from './asyncGroup';
 export * from './asyncPipe';
 export * from './create';
+export * from './group';
 export * from './is';
 export * from './ok';
 export * from './pipe';
+export * from './result';
+export * from './some';
 export * from './success';
+export * from './unwrap';
+export * from './unwrapOrThrow';
 export * from './when';
 export * from './whenOtherwise';
-export * from './result';
-export * from './unwrapOrThrow';
-export * from './unwrap';
-export * from './group';
-export * from './asyncGroup';

package/dist/either/right/some.cjs

@@ -0,0 +1,15 @@
+const require_kind = require("../kind.cjs");
+const require_create = require("./create.cjs");
+//#region scripts/either/right/some.ts
+const someKind = require_kind.createKind("some");
+function some(value) {
+	return {
+		[require_create.rightKind.runTimeKey]: null,
+		[require_kind.informationKind.runTimeKey]: "some",
+		[require_kind.valueKind.runTimeKey]: value,
+		[someKind.runTimeKey]: null
+	};
+}
+//#endregion
+exports.some = some;
+exports.someKind = someKind;

package/dist/either/right/some.d.ts

@@ -0,0 +1,7 @@
+import { Right } from './create';
+import type * as DKind from '../../kind';
+import type * as DCommon from '../../common';
+export declare const someKind: DKind.Handler<DKind.Definition<"@DuplojsLangEither/some", unknown>>;
+export interface Some<GenericValue extends unknown> extends DCommon.Forward<DKind.Kind<typeof someKind> & Right<"some", GenericValue>> {
+}
+export declare function some<GenericValue extends unknown>(value: GenericValue): Some<GenericValue>;

package/dist/either/right/some.mjs

@@ -0,0 +1,14 @@
+import { createKind, informationKind, valueKind } from "../kind.mjs";
+import { rightKind } from "./create.mjs";
+//#region scripts/either/right/some.ts
+const someKind = createKind("some");
+function some(value) {
+	return {
+		[rightKind.runTimeKey]: null,
+		[informationKind.runTimeKey]: "some",
+		[valueKind.runTimeKey]: value,
+		[someKind.runTimeKey]: null
+	};
+}
+//#endregion
+export { some, someKind };

package/dist/either/toMaybe.cjs

@@ -0,0 +1,12 @@
+const require_is = require("./left/is.cjs");
+const require_none = require("./left/none.cjs");
+const require_is$1 = require("./right/is.cjs");
+const require_some = require("./right/some.cjs");
+//#region scripts/either/toMaybe.ts
+function toMaybe(input) {
+	if (require_is$1.isRight(input) || require_is.isLeft(input)) return input;
+	if (input === null || input === void 0) return require_none.none();
+	return require_some.some(input);
+}
+//#endregion
+exports.toMaybe = toMaybe;

package/dist/either/toMaybe.d.ts

@@ -0,0 +1,5 @@
+import { Left, None } from './left';
+import { Some, Right } from './right';
+type Either = Right | Left;
+export declare function toMaybe<GenericInput extends unknown>(input: GenericInput): (GenericInput extends Either ? GenericInput : GenericInput extends null | undefined ? None : Some<GenericInput>);
+export {};

package/dist/either/toMaybe.mjs

@@ -0,0 +1,12 @@
+import { isLeft } from "./left/is.mjs";
+import { none } from "./left/none.mjs";
+import { isRight } from "./right/is.mjs";
+import { some } from "./right/some.mjs";
+//#region scripts/either/toMaybe.ts
+function toMaybe(input) {
+	if (isRight(input) || isLeft(input)) return input;
+	if (input === null || input === void 0) return none();
+	return some(input);
+}
+//#endregion
+export { toMaybe };

package/dist/either/types/mayBe.d.ts

@@ -0,0 +1,3 @@
+import { None } from '../left';
+import { Some } from '../right';
+export type MayBe<GenericValue extends unknown> = (Some<GenericValue> | None);

package/dist/either/unwrapOr.cjs

@@ -0,0 +1,14 @@
+const require_kind = require("./kind.cjs");
+const require_is = require("./right/is.cjs");
+//#region scripts/either/unwrapOr.ts
+function unwrapOr(...args) {
+	if (args.length === 1) {
+		const [value] = args;
+		return (input) => unwrapOr(input, value);
+	}
+	const [input, value] = args;
+	if (require_is.isRight(input)) return require_kind.valueKind.getValue(input);
+	return value;
+}
+//#endregion
+exports.unwrapOr = unwrapOr;

package/dist/either/unwrapOr.d.ts

@@ -0,0 +1,8 @@
+import { Left } from './left';
+import { Right } from './right';
+import { GetValue } from './types';
+import type * as DCommon from '../common';
+type Either = Right | Left;
+export declare function unwrapOr<GenericInput extends Either | DCommon.AnyValue, const GenericValue extends unknown>(input: GenericInput, value: GenericValue): (GetValue<Extract<GenericInput, Right>> | GenericValue);
+export declare function unwrapOr<GenericInput extends Either | DCommon.AnyValue, const GenericValue extends unknown>(value: GenericValue): (input: GenericInput) => (GetValue<Extract<GenericInput, Right>> | GenericValue);
+export {};

package/dist/either/unwrapOr.mjs

@@ -0,0 +1,14 @@
+import { valueKind } from "./kind.mjs";
+import { isRight } from "./right/is.mjs";
+//#region scripts/either/unwrapOr.ts
+function unwrapOr(...args) {
+	if (args.length === 1) {
+		const [value] = args;
+		return (input) => unwrapOr(input, value);
+	}
+	const [input, value] = args;
+	if (isRight(input)) return valueKind.getValue(input);
+	return value;
+}
+//#endregion
+export { unwrapOr };

package/dist/either/unwrapOtherwise.cjs

@@ -0,0 +1,14 @@
+const require_kind = require("./kind.cjs");
+const require_is = require("./right/is.cjs");
+//#region scripts/either/unwrapOtherwise.ts
+function unwrapOtherwise(...args) {
+	if (args.length === 1) {
+		const [value] = args;
+		return (input) => unwrapOtherwise(input, value);
+	}
+	const [input, value] = args;
+	if (require_is.isRight(input)) return require_kind.valueKind.getValue(input);
+	return value();
+}
+//#endregion
+exports.unwrapOtherwise = unwrapOtherwise;

package/dist/either/unwrapOtherwise.d.ts

@@ -0,0 +1,8 @@
+import { Left } from './left';
+import { Right } from './right';
+import { GetValue } from './types';
+import type * as DCommon from '../common';
+type Either = Right | Left;
+export declare function unwrapOtherwise<GenericInput extends Either | DCommon.AnyValue, const GenericValue extends unknown>(input: GenericInput, value: () => GenericValue): (GetValue<Extract<GenericInput, Right>> | GenericValue);
+export declare function unwrapOtherwise<GenericInput extends Either | DCommon.AnyValue, const GenericValue extends unknown>(value: () => GenericValue): (input: GenericInput) => (GetValue<Extract<GenericInput, Right>> | GenericValue);
+export {};

package/dist/either/unwrapOtherwise.mjs

@@ -0,0 +1,14 @@
+import { valueKind } from "./kind.mjs";
+import { isRight } from "./right/is.mjs";
+//#region scripts/either/unwrapOtherwise.ts
+function unwrapOtherwise(...args) {
+	if (args.length === 1) {
+		const [value] = args;
+		return (input) => unwrapOtherwise(input, value);
+	}
+	const [input, value] = args;
+	if (isRight(input)) return valueKind.getValue(input);
+	return value();
+}
+//#endregion
+export { unwrapOtherwise };

package/dist/generator/reduce.cjs

@@ -1,6 +1,7 @@
+const require_kind = require("./kind.cjs");
 const require_reduce = require("../array/reduce.cjs");
 //#region scripts/generator/reduce.ts
-const reduceKind = require("./kind.cjs").createKind("reduce");
+const reduceKind = require_kind.createKind("reduce");
 function reduceFrom(value) {
 	return { [reduceKind.runTimeKey]: value };
 }

package/dist/generator/reduce.mjs

@@ -1,5 +1,5 @@
-import { reduceTools } from "../array/reduce.mjs";
 import { createKind } from "./kind.mjs";
+import { reduceTools } from "../array/reduce.mjs";
 //#region scripts/generator/reduce.ts
 const reduceKind = createKind("reduce");
 function reduceFrom(value) {