typia 5.0.0-dev.20230822 → 5.0.0-dev.20230823-2

package/src/Resolved.ts

@@ -0,0 +1,116 @@
+/**
+ * Resolved type erased every methods.
+ *
+ * `Resolved` is a type of TMP (Type Meta Programming) type which converts
+ * its argument as a resolved type that erased every method properties.
+ *
+ * If the target argument is a built-in class which returns its origin primitive type
+ * through the `valueOf()` method like the `String` or `Number`, its return type would
+ * be the `string` or `number`. Otherwise, the built-in class does not have the
+ * `valueOf()` method, the return type would be same with the target argument.
+ *
+ * Otherwise, the target argument is a type of custom class, all of its custom methods
+ * would be erased and its prototype would be changed to the primitive `object`.
+ * Therefore, return type of the TMP type finally be the resolved object.
+ *
+ * Before                  | After
+ * ------------------------|----------------------------------------
+ * `Boolean`               | `boolean`
+ * `Number`                | `number`
+ * `BigInt`                | `bigint`
+ * `String`                | `string`
+ * `Class`                 | `interface`
+ * Native Claas or Others  | No change
+ *
+ * @template Instance Target argument type.
+ * @author Jenogho Nam - https://github.com/samchon
+ * @author Kyungsu Kang - https://github.com/kakasoo
+ */
+export type Resolved<T> = Equal<T, ResolvedMain<T>> extends true
+    ? T
+    : ResolvedMain<T>;
+
+type Equal<X, Y> = X extends Y ? (Y extends X ? true : false) : false;
+
+type ResolvedMain<Instance> = Instance extends [never]
+    ? never // (special trick for jsonable | null) type
+    : ValueOf<Instance> extends boolean | number | bigint | string
+    ? ValueOf<Instance>
+    : Instance extends Function
+    ? never
+    : Instance extends object
+    ? ResolvedObject<Instance>
+    : ValueOf<Instance>;
+
+type ResolvedObject<Instance extends object> = Instance extends Array<infer T>
+    ? IsTuple<Instance> extends true
+        ? ResolvedTuple<Instance>
+        : ResolvedMain<T>[]
+    : Instance extends Set<infer U>
+    ? Set<ResolvedMain<U>>
+    : Instance extends Map<infer K, infer V>
+    ? Map<ResolvedMain<K>, ResolvedMain<V>>
+    : Instance extends WeakSet<any> | WeakMap<any, any>
+    ? never
+    : Instance extends
+          | Date
+          | Uint8Array
+          | Uint8ClampedArray
+          | Uint16Array
+          | Uint32Array
+          | BigUint64Array
+          | Int8Array
+          | Int16Array
+          | Int32Array
+          | BigInt64Array
+          | Float32Array
+          | Float64Array
+          | ArrayBuffer
+          | SharedArrayBuffer
+          | DataView
+    ? Instance
+    : {
+          [P in keyof Instance]: ResolvedMain<Instance[P]>;
+      };
+
+type ResolvedTuple<T extends readonly any[]> = T extends []
+    ? []
+    : T extends [infer F]
+    ? [ResolvedMain<F>]
+    : T extends [infer F, ...infer Rest extends readonly any[]]
+    ? [ResolvedMain<F>, ...ResolvedTuple<Rest>]
+    : T extends [(infer F)?]
+    ? [ResolvedMain<F>?]
+    : T extends [(infer F)?, ...infer Rest extends readonly any[]]
+    ? [ResolvedMain<F>?, ...ResolvedTuple<Rest>]
+    : [];
+
+type ValueOf<Instance> = IsValueOf<Instance, Boolean> extends true
+    ? boolean
+    : IsValueOf<Instance, Number> extends true
+    ? number
+    : IsValueOf<Instance, String> extends true
+    ? string
+    : Instance;
+
+type IsTuple<T extends readonly any[] | { length: number }> = [T] extends [
+    never,
+]
+    ? false
+    : T extends readonly any[]
+    ? number extends T["length"]
+        ? false
+        : true
+    : false;
+
+type IsValueOf<Instance, Object extends IValueOf<any>> = Instance extends Object
+    ? Object extends IValueOf<infer Primitive>
+        ? Instance extends Primitive
+            ? false
+            : true // not Primitive, but Object
+        : false // cannot be
+    : false;
+
+interface IValueOf<T> {
+    valueOf(): T;
+}

package/src/factories/MetadataFactory.ts

@@ -9,7 +9,7 @@ import { MetadataCollection } from "./MetadataCollection";
 
 export namespace MetadataFactory {
     export interface IOptions {
-        resolve: boolean;
+        escape: boolean;
         constant: boolean;
         absorb: boolean;
         validate?: (meta: Metadata) => void;

package/src/factories/MetadataTagFactory.ts

@@ -318,8 +318,8 @@ const has_atomic =
             metadata.aliases.some((alias) =>
                 has_atomic(type)(visited)(alias.value),
             ) ||
-            (metadata.resolved !== null &&
-                has_atomic(type)(visited)(metadata.resolved.returns))
+            (metadata.escaped !== null &&
+                has_atomic(type)(visited)(metadata.escaped.returns))
         );
     };
 
@@ -341,8 +341,8 @@ const has_native =
             metadata.aliases.some((alias) =>
                 has_native(type)(visited)(alias.value),
             ) ||
-            (metadata.resolved !== null &&
-                has_native(type)(visited)(metadata.resolved.returns))
+            (metadata.escaped !== null &&
+                has_native(type)(visited)(metadata.escaped.returns))
         );
     };
 
@@ -358,7 +358,7 @@ const has_array =
             ) ||
             metadata.maps.some((map) => has_array(visited)(map.value)) ||
             metadata.aliases.some((alias) => has_array(visited)(alias.value)) ||
-            (metadata.resolved !== null &&
-                has_array(visited)(metadata.resolved.returns))
+            (metadata.escaped !== null &&
+                has_array(visited)(metadata.escaped.returns))
         );
     };

package/src/factories/ProtobufFactory.ts

@@ -18,7 +18,7 @@ export namespace ProtobufFactory {
         (type: ts.Type) => {
             // COMPOSE METADATA WITH INDIVIDUAL VALIDATIONS
             const top: Metadata = MetadataFactory.analyze(checker)({
-                resolve: false,
+                escape: false,
                 constant: true,
                 absorb: true,
                 validate: validate(method),
@@ -231,7 +231,7 @@ export namespace ProtobufFactory {
     };
 }
 
-const prefix = (method: string) => `Error on typia.protobuf.${method}():`;
+const prefix = (method: string) => `Error on ${method}():`;
 
 const notSupportedError = (p: { method: string }) => (title: string) =>
     new Error(

package/src/factories/internal/metadata/explore_metadata.ts

@@ -30,9 +30,9 @@ export const explore_metadata =
             aliased,
         );
         emend_metadata_atomics(meta);
-        if (meta.resolved) {
-            emend_metadata_atomics(meta.resolved.original);
-            emend_metadata_atomics(meta.resolved.returns);
+        if (meta.escaped) {
+            emend_metadata_atomics(meta.escaped.original);
+            emend_metadata_atomics(meta.escaped.returns);
         }
         return meta;
     };

package/src/factories/internal/metadata/iterate_metadata_collection.ts

@@ -58,8 +58,8 @@ const isArrayRecursive =
             ) ||
             meta.maps.some((m) => isArrayRecursive(visited)(array)(m.value)) ||
             meta.sets.some((s) => isArrayRecursive(visited)(array)(s)) ||
-            (meta.resolved !== null &&
-                isArrayRecursive(visited)(array)(meta.resolved.returns)) ||
+            (meta.escaped !== null &&
+                isArrayRecursive(visited)(array)(meta.escaped.returns)) ||
             (meta.rest !== null && isArrayRecursive(visited)(array)(meta.rest))
         );
     };
@@ -86,8 +86,8 @@ const isTupleRecursive =
             meta.aliases.some((alias) =>
                 isTupleRecursive(visited)(tuple)(alias.value),
             ) ||
-            (meta.resolved !== null &&
-                isTupleRecursive(visited)(tuple)(meta.resolved.returns)) ||
+            (meta.escaped !== null &&
+                isTupleRecursive(visited)(tuple)(meta.escaped.returns)) ||
             (meta.rest !== null && isTupleRecursive(visited)(tuple)(meta.rest))
         );
     };
@@ -126,8 +126,8 @@ const isObjectRecursive =
                 isObjectRecursive(visited)(obj)(map.value),
             ) ||
             meta.sets.some((value) => isObjectRecursive(visited)(obj)(value)) ||
-            (meta.resolved !== null &&
-                isObjectRecursive(visited)(obj)(meta.resolved.returns)) ||
+            (meta.escaped !== null &&
+                isObjectRecursive(visited)(obj)(meta.escaped.returns)) ||
             (meta.rest !== null && isObjectRecursive(visited)(obj)(meta.rest))
         );
     };

package/src/factories/internal/metadata/iterate_metadata_native.ts

@@ -21,12 +21,6 @@ export const iterate_metadata_native =
             return true;
         }
 
-        const complicate = COMPLICATES.get(name);
-        if (complicate && validator(complicate)) {
-            ArrayUtil.set(meta.natives, complicate.name ?? name, (str) => str);
-            return true;
-        }
-
         for (const generic of GENERICS)
             if (
                 name.substring(0, generic.name.length) === generic.name &&
@@ -190,9 +184,6 @@ const SIMPLES: Map<string, IClassInfo> = new Map([
         },
     ],
 ]);
-const COMPLICATES: Map<string, IClassInfo> = new Map([
-    [`'buffer'.global.Buffer`, getBinaryProps("Buffer")],
-]);
 const GENERICS: Array<IClassInfo & { name: string }> = [
     "WeakMap",
     "WeakSet",

package/src/factories/internal/metadata/iterate_metadata_resolve.ts

@@ -1,7 +1,7 @@
 import ts from "typescript";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataResolved } from "../../../schemas/metadata/MetadataResolved";
+import { MetadataEscaped } from "../../../schemas/metadata/MetadataEscaped";
 
 import { Writable } from "../../../typings/Writable";
 
@@ -22,25 +22,25 @@ export const iterate_metadata_resolve =
         resolved: boolean,
         aliased: boolean,
     ): boolean => {
-        if (options.resolve === false || resolved === true) return false;
+        if (options.escape === false || resolved === true) return false;
 
         const escaped: ts.Type | null = TypeFactory.resolve(checker)(type);
         if (escaped === null) return false;
 
-        if (meta.resolved === null) {
-            Writable(meta).resolved = MetadataResolved.create({
+        if (meta.escaped === null) {
+            Writable(meta).escaped = MetadataEscaped.create({
                 original: Metadata.initialize(),
                 returns: Metadata.initialize(),
             });
         }
         iterate_metadata(checker)(options)(collection)(
-            meta.resolved!.original,
+            meta.escaped!.original,
             type,
             true,
             aliased,
         );
         iterate_metadata(checker)(options)(collection)(
-            meta.resolved!.returns,
+            meta.escaped!.returns,
             escaped,
             true,
             aliased,

package/src/factories/internal/metadata/iterate_metadata_sort.ts

@@ -27,8 +27,8 @@ const iterate =
         // ITERATE CHILDREN
         for (const map of meta.maps) iterate(visited)(collection)(map.value);
         for (const set of meta.sets) iterate(visited)(collection)(set);
-        if (meta.resolved !== null)
-            iterate(visited)(collection)(meta.resolved.returns);
+        if (meta.escaped !== null)
+            iterate(visited)(collection)(meta.escaped.returns);
         if (meta.rest !== null) iterate(visited)(collection)(meta.rest);
 
         // SORT OBJECTS

package/src/functional/$ProtobufWriter.ts

@@ -130,8 +130,7 @@ export class $ProtobufWriter implements IProtobufWriter {
         val = BigInt.asUintN(64, val);
         while (val > NX7F) {
             this.buf[this.ptr++] = Number((val & NX7F) | NX80);
-            val = val >> ND07; // @todo
-            // (val / (128n) % 2n === 1n)
+            val = val >> ND07;
         }
         this.buf[this.ptr++] = Number(val);
     }

package/src/json.ts

@@ -340,7 +340,7 @@ export function isStringify<T>(input: T): string | null;
  * `typia.json.isStringify()` is a combination function of {@link is} and
  * {@link stringify}. Therefore, it converts an input value to JSON
  * (JavaScript Object Notation) string, with type checking.
- *f
+ *
  * In such reason, when `input` value is not matched with the type `T`, it returns
  * `null` value. Otherwise, there's no problem on the `input` value, JSON string
  * would be returned.
@@ -430,8 +430,8 @@ Object.assign(validateStringify, Namespace.json.stringify("validateStringify"));
 /**
  * Creates a reusable {@link isParse} function.
  *
- * @danger You have to specify the generic argument `T`
- * @return Nothing until specifying the generic argument `T`
+ * @danger You must configure the generic argument `T`
+ * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
@@ -459,8 +459,8 @@ Object.assign(createIsParse, isParse);
 /**
  * Creates a reusable {@link assertParse} function.
  *
- * @danger You have to specify the generic argument `T`
- * @return Nothing until specifying the generic argument `T`
+ * @danger You must configure the generic argument `T`
+ * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
@@ -488,8 +488,8 @@ Object.assign(createAssertParse, assertParse);
 /**
  * Creates a reusable {@link validateParse} function.
  *
- * @danger You have to specify the generic argument `T`
- * @return Nothing until specifying the generic argument `T`
+ * @danger You must configure the generic argument `T`
+ * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
@@ -521,8 +521,8 @@ Object.assign(createValidateParse, validateParse);
 /**
  * Creates a reusable {@link stringify} function.
  *
- * @danger You have to specify the generic argument `T`
- * @return Nothing until specifying the generic argument `T`
+ * @danger You must configure the generic argument `T`
+ * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
@@ -550,8 +550,8 @@ Object.assign(createStringify, stringify);
 /**
  * Creates a reusable {@link assertStringify} function.
  *
- * @danger You have to specify the generic argument `T`
- * @return Nothing until specifying the generic argument `T`
+ * @danger You must configure the generic argument `T`
+ * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
@@ -579,8 +579,8 @@ Object.assign(createAssertStringify, assertStringify);
 /**
  * Creates a reusable {@link isStringify} function.
  *
- * @danger You have to specify the generic argument `T`
- * @return Nothing until specifying the generic argument `T`
+ * @danger You must configure the generic argument `T`
+ * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
@@ -608,8 +608,8 @@ Object.assign(createIsStringify, isStringify);
 /**
  * Creates a reusable {@link validateStringify} function.
  *
- * @danger You have to specify the generic argument `T`
- * @return Nothing until specifying the generic argument `T`
+ * @danger You must configure the generic argument `T`
+ * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon

package/src/misc.ts

@@ -12,7 +12,7 @@ import { Namespace } from "./functional/Namespace";
 import { Atomic } from "./typings/Atomic";
 
 import { IValidation } from "./IValidation";
-import { Primitive } from "./Primitive";
+import { Resolved } from "./Resolved";
 
 /**
  * > You must configure the generic argument `T`.
@@ -62,8 +62,8 @@ export function literals(): never {
  * Clone a data.
  *
  * Clones an instance following type `T`. If the target *input* value or its member
- * variable contains a class instance that is having a `toJSON()` method, its return
- * value would be cloned.
+ * variable contains a class instance having methods, those methods would not be
+ * cloned.
  *
  * For reference, this `typia.misc.clone()` function does not validate the input value
  * type. It just believes that the input value is following the type `T`. Therefore,
@@ -76,7 +76,7 @@ export function literals(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function clone<T>(input: T): Primitive<T>;
+export function clone<T>(input: T): Resolved<T>;
 
 /**
  * @internal
@@ -90,8 +90,8 @@ Object.assign(clone, Namespace.misc.clone("clone"));
  * Clone a data with type assertion.
  *
  * Clones an instance following type `T`, with type assertion. If the target `input`
- * value or its member variable contains a class instance that is having a `toJSON()`
- * method, its return value would be cloned.
+ * value or its member variable contains a class instance having methods, those
+ * methods would not be cloned.
  *
  * In such reason, when `input` value is not matched with the type `T`, it throws an
  * {@link TypeGuardError}. Otherwise, there's no problem on the `input` value, cloned
@@ -103,14 +103,14 @@ Object.assign(clone, Namespace.misc.clone("clone"));
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function assertClone<T>(input: T): Primitive<T>;
+export function assertClone<T>(input: T): Resolved<T>;
 
 /**
  * Clone a data with type assertion.
  *
  * Clones an instance following type `T`, with type assertion. If the target `input`
- * value or its member variable contains a class instance that is having a `toJSON()`
- * method, its return value would be cloned.
+ * value or its member variable contains a class instance having methods, those
+ * methods would not be cloned.
  *
  * In such reason, when `input` value is not matched with the type `T`, it throws an
  * {@link TypeGuardError}. Otherwise, there's no problem on the `input` value, cloned
@@ -122,7 +122,7 @@ export function assertClone<T>(input: T): Primitive<T>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function assertClone<T>(input: unknown): Primitive<T>;
+export function assertClone<T>(input: unknown): Resolved<T>;
 
 /**
  * @internal
@@ -137,8 +137,8 @@ Object.assign(assertClone, Namespace.misc.clone("assertClone"));
  * Clone a data with type checking.
  *
  * Clones an instance following type `T`, with type checking. If the target `input`
- * value or its member variable contains a class instance that is having a `toJSON()`
- * method, its return value would be cloned.
+ * value or its member variable contains a class instance having methods, those
+ * methods would not be cloned.
  *
  * In such reason, when `input` value is not matched with the type `T`, it returns
  * `null` value instead. Otherwise, there's no problem on the `input` value, cloned
@@ -150,14 +150,14 @@ Object.assign(assertClone, Namespace.misc.clone("assertClone"));
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function isClone<T>(input: T): Primitive<T> | null;
+export function isClone<T>(input: T): Resolved<T> | null;
 
 /**
  * Clone a data with type checking.
  *
  * Clones an instance following type `T`, with type checking. If the target `input`
- * value or its member variable contains a class instance that is having a `toJSON()`
- * method, its return value would be cloned.
+ * value or its member variable contains a class instance having methods, those
+ * methods would not be cloned.
  *
  * In such reason, when `input` value is not matched with the type `T`, it returns
  * `null` value instead. Otherwise, there's no problem on the `input` value, cloned
@@ -169,7 +169,7 @@ export function isClone<T>(input: T): Primitive<T> | null;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function isClone<T>(input: unknown): Primitive<T> | null;
+export function isClone<T>(input: unknown): Resolved<T> | null;
 
 /**
  * @internal
@@ -184,8 +184,8 @@ Object.assign(isClone, Namespace.misc.clone("isClone"));
  * Clone a data with detailed type validation.
  *
  * Clones an instance following type `T`, with detailed type validation. If the target
- * `input` value or its member variable contains a class instance that is having a
- * `toJSON()` method, its return value would be cloned.
+ * `input` value or its member variable contains a class instance having methods,
+ * those methods would not be cloned.
  *
  * In such reason, when `input` value is not matched with the type `T`, it returns
  * {@link IValidation.Failure} value. Otherwise, there's no problem on the `input`
@@ -196,14 +196,14 @@ Object.assign(isClone, Namespace.misc.clone("isClone"));
  * @param input A value to be cloned
  * @returns Validation result with cloned value
  */
-export function validateClone<T>(input: T): IValidation<Primitive<T>>;
+export function validateClone<T>(input: T): IValidation<Resolved<T>>;
 
 /**
  * Clone a data with detailed type validation.
  *
  * Clones an instance following type `T`, with detailed type validation. If the target
- * `input` value or its member variable contains a class instance that is having a
- * `toJSON()` method, its return value would be cloned.
+ * `input` value or its member variable contains a class instance having methods,
+ * those methods would not be cloned.
  *
  * In such reason, when `input` value is not matched with the type `T`, it returns
  * {@link IValidation.Failure} value. Otherwise, there's no problem on the `input`
@@ -214,7 +214,7 @@ export function validateClone<T>(input: T): IValidation<Primitive<T>>;
  * @param input A value to be cloned
  * @returns Validation result with cloned value
  */
-export function validateClone<T>(input: unknown): IValidation<Primitive<T>>;
+export function validateClone<T>(input: unknown): IValidation<Resolved<T>>;
 
 /**
  * @internal
@@ -406,8 +406,8 @@ Object.assign(validatePrune, Namespace.validate());
 /**
  * Creates a reusable {@link clone} function.
  *
- * @danger You have to specify the generic argument `T`
- * @return Nothing until specifying the generic argument `T`
+ * @danger You must configure the generic argument `T`
+ * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
@@ -422,7 +422,7 @@ export function createClone(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createClone<T>(): (input: T) => Primitive<T>;
+export function createClone<T>(): (input: T) => Resolved<T>;
 
 /**
  * @internal
@@ -435,8 +435,8 @@ Object.assign(createClone, clone);
 /**
  * Creates a reusable {@link assertClone} function.
  *
- * @danger You have to specify the generic argument `T`
- * @return Nothing until specifying the generic argument `T`
+ * @danger You must configure the generic argument `T`
+ * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
@@ -451,7 +451,7 @@ export function createAssertClone(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createAssertClone<T>(): (input: unknown) => Primitive<T>;
+export function createAssertClone<T>(): (input: unknown) => Resolved<T>;
 
 /**
  * @internal
@@ -464,8 +464,8 @@ Object.assign(createAssertClone, assertClone);
 /**
  * Creates a reusable {@link isClone} function.
  *
- * @danger You have to specify the generic argument `T`
- * @return Nothing until specifying the generic argument `T`
+ * @danger You must configure the generic argument `T`
+ * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
@@ -480,7 +480,7 @@ export function createIsClone(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createIsClone<T>(): (input: unknown) => Primitive<T> | null;
+export function createIsClone<T>(): (input: unknown) => Resolved<T> | null;
 
 /**
  * @internal
@@ -493,8 +493,8 @@ Object.assign(createIsClone, isClone);
 /**
  * Creates a reusable {@link validateClone} function.
  *
- * @danger You have to specify the generic argument `T`
- * @return Nothing until specifying the generic argument `T`
+ * @danger You must configure the generic argument `T`
+ * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
@@ -511,7 +511,7 @@ export function createValidateClone(): never;
  */
 export function createValidateClone<T>(): (
     input: unknown,
-) => IValidation<Primitive<T>>;
+) => IValidation<Resolved<T>>;
 
 /**
  * @internal
@@ -524,8 +524,8 @@ Object.assign(createValidateClone, validateClone);
 /**
  * Creates a reusable {@link prune} function.
  *
- * @danger You have to specify the generic argument `T`
- * @return Nothing until specifying the generic argument `T`
+ * @danger You must configure the generic argument `T`
+ * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
@@ -553,8 +553,8 @@ Object.assign(createPrune, prune);
 /**
  * Creates a reusable {@link assertPrune} function.
  *
- * @danger You have to specify the generic argument `T`
- * @return Nothing until specifying the generic argument `T`
+ * @danger You must configure the generic argument `T`
+ * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
@@ -582,8 +582,8 @@ Object.assign(createAssertPrune, assertPrune);
 /**
  * Creates a reusable {@link isPrune} function.
  *
- * @danger You have to specify the generic argument `T`
- * @return Nothing until specifying the generic argument `T`
+ * @danger You must configure the generic argument `T`
+ * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
@@ -611,8 +611,8 @@ Object.assign(createIsPrune, isPrune);
 /**
  * Creates a reusable {@link validatePrune} function.
  *
- * @danger You have to specify the generic argument `T`
- * @return Nothing until specifying the generic argument `T`
+ * @danger You must configure the generic argument `T`
+ * @returns Nothing until you configure the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon