typia 9.7.1 → 9.7.2

package/src/functional.ts

@@ -15,42 +15,40 @@ import { TypeGuardError } from "./TypeGuardError";
  * Asserts a function.
  *
  * Asserts a function, by wrapping the function and checking its parameters and
- * return value through {@link assert} function. If some parameter or return value
- * does not match the expected type, it throws an {@link TypeGuardError} or a custom
- * error generated by the *errorFactory* parameter.
+ * return value through {@link assert} function. If some parameter or return
+ * value does not match the expected type, it throws an {@link TypeGuardError} or
+ * a custom error generated by the _errorFactory_ parameter.
  *
- * For reference, {@link TypeGuardError.path} would be a little bit different with
- * individual {@link assert} function. If the {@link TypeGuardError} occurs from
- * some parameter, the path would start from `$input.parameters[number]`. Otherwise
- * the path would start from `$input.return`.
+ * For reference, {@link TypeGuardError.path} would be a little bit different
+ * with individual {@link assert} function. If the {@link TypeGuardError} occurs
+ * from some parameter, the path would start from `$input.parameters[number]`.
+ * Otherwise the path would start from `$input.return`.
  *
  * - `$input.parameters[0].~`
  * - `$input.return.~`
  *
  * By the way, if what you want is not just finding the 1st type error through
- * assertion, but also finding every type errors, then use {@link validateFunction}
- * instead. Otherwise, what you want is just asserting parameters or return value
- * only, you can use {@link assertParameters} or {@link assertReturn} instead.
+ * assertion, but also finding every type errors, then use
+ * {@link validateFunction} instead. Otherwise, what you want is just asserting
+ * parameters or return value only, you can use {@link assertParameters} or
+ * {@link assertReturn} instead.
  *
  * On the other hand, if don't want to allow any superfluous properties, utilize
  * {@link assertEqualsFunction} or {@link validateEqualsFunction} instead.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Target function type
  * @param func Target function to assert
  * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns The wrapper function with type assertions
- * @throws A {@link TypeGuardError} or a custom error generated by *errorFactory*
- *
- * @author Jeongho Nam - https://github.com/samchon
+ * @throws A {@link TypeGuardError} or a custom error generated by _errorFactory_
  */
 export function assertFunction<T extends (...args: any[]) => any>(
   func: T,
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
 ): T;
 
-/**
- * @internal
- */
+/** @internal */
 export function assertFunction(): never {
   NoTransformConfigurationError("functional.assertFunction");
 }
@@ -58,39 +56,37 @@ export function assertFunction(): never {
 /**
  * Asserts parameters.
  *
- * Asserts a function, by wrapping the function and checking its parameters through
- * {@link assert} function. If some parameter does not match the expected type, it
- * throws an {@link TypeGuardError} or a custom error generated by the *errorFactory*
- * parameter.
+ * Asserts a function, by wrapping the function and checking its parameters
+ * through {@link assert} function. If some parameter does not match the expected
+ * type, it throws an {@link TypeGuardError} or a custom error generated by the
+ * _errorFactory_ parameter.
  *
- * For reference, {@link TypeGuardError.path} would be a little bit different with
- * individual {@link assert} function. If the {@link TypeGuardError} occurs from
- * some parameter, the path would start from `$input.parameters[number]`.
+ * For reference, {@link TypeGuardError.path} would be a little bit different
+ * with individual {@link assert} function. If the {@link TypeGuardError} occurs
+ * from some parameter, the path would start from `$input.parameters[number]`.
  *
  * By the way, if what you want is not just finding the 1st type error through
- * assertion, but also finding every type errors, then use {@link validateParameters}
- * instead. Otherwise, what you want is not only asserting parameters, but also
- * asserting return value, you can use {@link assertFunction} instead.
+ * assertion, but also finding every type errors, then use
+ * {@link validateParameters} instead. Otherwise, what you want is not only
+ * asserting parameters, but also asserting return value, you can use
+ * {@link assertFunction} instead.
  *
  * On the other hand, if don't want to allow any superfluous properties, utilize
  * {@link assertEqualsParameters} or {@link validateEqualsParameters} instead.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Target function type
  * @param func Target function to assert
  * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns The wrapper function with type assertions
- * @throws A {@link TypeGuardError} or a custom error generated by *errorFactory*
- *
- * @author Jeongho Nam - https://github.com/samchon
+ * @throws A {@link TypeGuardError} or a custom error generated by _errorFactory_
  */
 export function assertParameters<T extends (...args: any[]) => any>(
   func: T,
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
 ): T;
 
-/**
- * @internal
- */
+/** @internal */
 export function assertParameters(): never {
   NoTransformConfigurationError("functional.assertParameters");
 }
@@ -98,39 +94,36 @@ export function assertParameters(): never {
 /**
  * Asserts return value.
  *
- * Asserts a function, by wrapping the function and checking its return value through
- * {@link assert} function. If the return value does not match the expected type, it
- * throws an {@link TypeGuardError} or a custom error generated by the *errorFactory*
- * parameter.
+ * Asserts a function, by wrapping the function and checking its return value
+ * through {@link assert} function. If the return value does not match the
+ * expected type, it throws an {@link TypeGuardError} or a custom error generated
+ * by the _errorFactory_ parameter.
  *
- * For reference, {@link TypeGuardError.path} would be a little bit different with
- * individual {@link assert} function. If the {@link TypeGuardError} occurs from
- * the return value, the path would start from `$input.return`.
+ * For reference, {@link TypeGuardError.path} would be a little bit different
+ * with individual {@link assert} function. If the {@link TypeGuardError} occurs
+ * from the return value, the path would start from `$input.return`.
  *
  * By the way, if what you want is not just finding the 1st type error through
  * assertion, but also finding every type errors, then use {@link validateReturn}
- * instead. Otherwise, what you want is not only asserting return value, but also
- * asserting parameters, you can use {@link assertFunction} instead.
+ * instead. Otherwise, what you want is not only asserting return value, but
+ * also asserting parameters, you can use {@link assertFunction} instead.
  *
  * On the other hand, if don't want to allow any superfluous properties, utilize
  * {@link assertEqualsReturn} or {@link validateEqualsReturn} instead.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Target function type
  * @param func Target function to assert
  * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns The wrapper function with type assertions
- * @throws A {@link TypeGuardError} or a custom error generated by *errorFactory*
- *
- * @author Jeongho Nam - https://github.com/samchon
+ * @throws A {@link TypeGuardError} or a custom error generated by _errorFactory_
  */
 export function assertReturn<T extends (...args: any[]) => any>(
   func: T,
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
 ): T;
 
-/**
- * @internal
- */
+/** @internal */
 export function assertReturn(): never {
   NoTransformConfigurationError("functional.assertReturn");
 }
@@ -138,44 +131,43 @@ export function assertReturn(): never {
 /**
  * Asserts a function with strict equality.
  *
- * Asserts a function with strict equality, by wrapping the function and checking
- * its parameters and return value through {@link assertEquals} function. If some
- * parameter or return value does not match the expected type, it throws an
- * {@link TypeGuardError} or a custom error generated by the *errorFactory* parameter.
+ * Asserts a function with strict equality, by wrapping the function and
+ * checking its parameters and return value through {@link assertEquals}
+ * function. If some parameter or return value does not match the expected type,
+ * it throws an {@link TypeGuardError} or a custom error generated by the
+ * _errorFactory_ parameter.
  *
- * For reference, {@link TypeGuardError.path} would be a little bit different with
- * individual {@link assertEquals} function. If the {@link TypeGuardError} occurs from
- * some parameter, the path would start from `$input.parameters[number]`. Otherwise
- * the path would start from `$input.return`.
+ * For reference, {@link TypeGuardError.path} would be a little bit different
+ * with individual {@link assertEquals} function. If the {@link TypeGuardError}
+ * occurs from some parameter, the path would start from
+ * `$input.parameters[number]`. Otherwise the path would start from
+ * `$input.return`.
  *
  * - `$input.parameters[0].~`
  * - `$input.return.~`
  *
  * By the way, if what you want is not just finding the 1st type error through
  * assertion, but also finding every type errors, then use
- * {@link validateEqualsFunction} instead. Otherwise, what you want is just asserting
- * parameters or return value only, you can use {@link assertEqualsParameters} or
- * {@link assertEqualsReturn} instead.
+ * {@link validateEqualsFunction} instead. Otherwise, what you want is just
+ * asserting parameters or return value only, you can use
+ * {@link assertEqualsParameters} or {@link assertEqualsReturn} instead.
  *
  * On the other hand, if you want to allow any superfluous properties, utilize
  * {@link assertFunction} or {@link validateFunction} instead.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Target function type
  * @param func Target function to assert
  * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns The wrapper function with type assertions
- * @throws A {@link TypeGuardError} or a custom error generated by *errorFactory*
- *
- * @author Jeongho Nam - https://github.com/samchon
+ * @throws A {@link TypeGuardError} or a custom error generated by _errorFactory_
  */
 export function assertEqualsFunction<T extends (...args: any[]) => any>(
   func: T,
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
 ): T;
 
-/**
- * @internal
- */
+/** @internal */
 export function assertEqualsFunction(): never {
   NoTransformConfigurationError("functional.assertEqualsFunction");
 }
@@ -183,14 +175,15 @@ export function assertEqualsFunction(): never {
 /**
  * Asserts parameters with strict equality.
  *
- * Asserts a function, by wrapping the function and checking its parameters through
- * {@link assertEquals} function. If some parameter does not match the expected type,
- * it throws an {@link TypeGuardError} or a custom error generated by the *errorFactory*
- * parameter.
+ * Asserts a function, by wrapping the function and checking its parameters
+ * through {@link assertEquals} function. If some parameter does not match the
+ * expected type, it throws an {@link TypeGuardError} or a custom error generated
+ * by the _errorFactory_ parameter.
  *
- * For reference, {@link TypeGuardError.path} would be a little bit different with
- * individual {@link assertEquals} function. If the {@link TypeGuardError} occurs from
- * some parameter, the path would start from `$input.parameters[number]`.
+ * For reference, {@link TypeGuardError.path} would be a little bit different
+ * with individual {@link assertEquals} function. If the {@link TypeGuardError}
+ * occurs from some parameter, the path would start from
+ * `$input.parameters[number]`.
  *
  * By the way, if what you want is not just finding the 1st type error through
  * assertion, but also finding every type errors, then use
@@ -201,22 +194,19 @@ export function assertEqualsFunction(): never {
  * On the other hand, if you want to allow any superfluous properties, utilize
  * {@link assertParameters} or {@link validateParameters} instead.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Target function type
  * @param func Target function to assert
  * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns The wrapper function with type assertions
- * @throws A {@link TypeGuardError} or a custom error generated by *errorFactory*
- *
- * @author Jeongho Nam - https://github.com/samchon
+ * @throws A {@link TypeGuardError} or a custom error generated by _errorFactory_
  */
 export function assertEqualsParameters<T extends (...args: any[]) => any>(
   func: T,
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
 ): T;
 
-/**
- * @internal
- */
+/** @internal */
 export function assertEqualsParameters(): never {
   NoTransformConfigurationError("functional.assertEqualsParameters");
 }
@@ -224,39 +214,37 @@ export function assertEqualsParameters(): never {
 /**
  * Asserts return value with strict equality.
  *
- * Asserts a function, by wrapping the function and checking its return value through
- * {@link assertEquals} function. If the return value does not match the expected type,
- * it throws an {@link TypeGuardError} or a custom error generated by the *errorFactory*
- * parameter.
+ * Asserts a function, by wrapping the function and checking its return value
+ * through {@link assertEquals} function. If the return value does not match the
+ * expected type, it throws an {@link TypeGuardError} or a custom error generated
+ * by the _errorFactory_ parameter.
  *
- * For reference, {@link TypeGuardError.path} would be a little bit different with
- * individual {@link assertEquals} function. If the {@link TypeGuardError} occurs from
- * the return value, the path would start from `$input.return`.
+ * For reference, {@link TypeGuardError.path} would be a little bit different
+ * with individual {@link assertEquals} function. If the {@link TypeGuardError}
+ * occurs from the return value, the path would start from `$input.return`.
  *
  * By the way, if what you want is not just finding the 1st type error through
- * assertion, but also finding every type errors, then use {@link validateEqualsReturn}
- * instead. Otherwise, what you want is not only asserting return value, but also
- * asserting parameters, you can use {@link assertEqualsFunction} instead.
+ * assertion, but also finding every type errors, then use
+ * {@link validateEqualsReturn} instead. Otherwise, what you want is not only
+ * asserting return value, but also asserting parameters, you can use
+ * {@link assertEqualsFunction} instead.
  *
  * On the other hand, if you want to allow any superfluous properties, utilize
  * {@link assertReturn} or {@link validateReturn} instead.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Target function type
  * @param func Target function to assert
  * @param errorFactory Custom error factory. Default is `TypeGuardError`
  * @returns The wrapper function with type assertions
- * @throws A {@link TypeGuardError} or a custom error generated by *errorFactory*
- *
- * @author Jeongho Nam - https://github.com/samchon
+ * @throws A {@link TypeGuardError} or a custom error generated by _errorFactory_
  */
 export function assertEqualsReturn<T extends (...args: any[]) => any>(
   func: T,
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
 ): T;
 
-/**
- * @internal
- */
+/** @internal */
 export function assertEqualsReturn(): never {
   NoTransformConfigurationError("functional.assertEqualsReturn");
 }
@@ -280,11 +268,10 @@ export function assertEqualsReturn(): never {
  * utilize {@link equalsFunction}, {@link assertEqualsFunction} or
  * {@link validateEqualsFunction} instead.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Target function type
  * @param func Target function to test
  * @returns The wrapper function with type tests
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function isFunction<T extends (...args: any[]) => any>(
   func: T,
@@ -294,9 +281,7 @@ export function isFunction<T extends (...args: any[]) => any>(
     : (...args: Arguments) => Output | null
   : never;
 
-/**
- * @internal
- */
+/** @internal */
 export function isFunction(): never {
   NoTransformConfigurationError("functional.isFunction");
 }
@@ -304,10 +289,10 @@ export function isFunction(): never {
 /**
  * Tests parameters.
  *
- * Tests a function, by wrapping the function and checking its parameters through
- * {@link is} function. If some parameter does not match the expected type, it
- * returns `null`. Otherwise there's no type error, it returns the result of the
- * function.
+ * Tests a function, by wrapping the function and checking its parameters
+ * through {@link is} function. If some parameter does not match the expected
+ * type, it returns `null`. Otherwise there's no type error, it returns the
+ * result of the function.
  *
  * By the way, if you want is not just testing type checking, but also finding
  * detailed type error reason(s), then use {@link assertParameters} or
@@ -317,11 +302,10 @@ export function isFunction(): never {
  * utilize {@link equalsParameters}, {@link assertEqualsParameters} or
  * {@link validateEqualsParameters} instead.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Target function type
  * @param func Target function to test
  * @returns The wrapper function with type tests
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function isParameters<T extends (...args: any[]) => any>(
   func: T,
@@ -331,9 +315,7 @@ export function isParameters<T extends (...args: any[]) => any>(
     : (...args: Arguments) => Output | null
   : never;
 
-/**
- * @internal
- */
+/** @internal */
 export function isParameters(): never {
   NoTransformConfigurationError("functional.isParameters");
 }
@@ -341,10 +323,10 @@ export function isParameters(): never {
 /**
  * Tests return value.
  *
- * Tests a function, by wrapping the function and checking its return value through
- * {@link is} function. If the return value does not match the expected type, it
- * returns `null`. Otherwise there's no type error, it returns the result of the
- * function.
+ * Tests a function, by wrapping the function and checking its return value
+ * through {@link is} function. If the return value does not match the expected
+ * type, it returns `null`. Otherwise there's no type error, it returns the
+ * result of the function.
  *
  * By the way, if you want is not just testing type checking, but also finding
  * detailed type error reason(s), then use {@link assertReturn} or
@@ -354,11 +336,10 @@ export function isParameters(): never {
  * utilize {@link equalsReturn}, {@link assertEqualsReturn} or
  * {@link validateEqualsReturn} instead.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Target function type
  * @param func Target function to test
  * @returns The wrapper function with type tests
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function isReturn<T extends (...args: any[]) => any>(
   func: T,
@@ -368,9 +349,7 @@ export function isReturn<T extends (...args: any[]) => any>(
     : (...args: Arguments) => Output | null
   : never;
 
-/**
- * @internal
- */
+/** @internal */
 export function isReturn(): never {
   NoTransformConfigurationError("functional.isReturn");
 }
@@ -378,10 +357,11 @@ export function isReturn(): never {
 /**
  * Tests a function with strict equality.
  *
- * Tests a function with strict equality, by wrapping the function and checking its
- * parameters and return value through {@link isEquals} function. If some parameter
- * or return value does not match the expected type, it returns `null`. Otherwise
- * there's no type error, it returns the result of the function.
+ * Tests a function with strict equality, by wrapping the function and checking
+ * its parameters and return value through {@link isEquals} function. If some
+ * parameter or return value does not match the expected type, it returns
+ * `null`. Otherwise there's no type error, it returns the result of the
+ * function.
  *
  * By the way, if you want is not just testing type checking, but also finding
  * detailed type error reason(s), then use {@link assertEqualsFunction} or
@@ -390,11 +370,10 @@ export function isReturn(): never {
  * On the other hand, if you want to allow any superfluous properties, utilize
  * {@link isFunction}, {@link assertFunction} or {@link validateFunction} instead.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Target function type
  * @param func Target function to test
  * @returns The wrapper function with type tests
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function equalsFunction<T extends (...args: any[]) => any>(
   func: T,
@@ -404,9 +383,7 @@ export function equalsFunction<T extends (...args: any[]) => any>(
     : (...args: Arguments) => Output | null
   : never;
 
-/**
- * @internal
- */
+/** @internal */
 export function equalsFunction(): never {
   NoTransformConfigurationError("functional.equalsFunction");
 }
@@ -414,20 +391,19 @@ export function equalsFunction(): never {
 /**
  * Tests parameters with strict equality.
  *
- * Tests a function, by wrapping the function and checking its parameters through
- * {@link isEquals} function. If some parameter does not match the expected type,
- * it returns `null`. Otherwise there's no type error, it returns the result of the
- * function.
+ * Tests a function, by wrapping the function and checking its parameters
+ * through {@link isEquals} function. If some parameter does not match the
+ * expected type, it returns `null`. Otherwise there's no type error, it returns
+ * the result of the function.
  *
  * By the way, if you want is not just testing type checking, but also finding
  * detailed type error reason(s), then use {@link assertEqualsParameters} or
  * {@link validateEqualsParameters} instead.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Target function type
  * @param func Target function to test
  * @returns The wrapper function with type tests
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function equalsParameters<T extends (...args: any[]) => any>(
   func: T,
@@ -437,9 +413,7 @@ export function equalsParameters<T extends (...args: any[]) => any>(
     : (...args: Arguments) => Output | null
   : never;
 
-/**
- * @internal
- */
+/** @internal */
 export function equalsParameters(): never {
   NoTransformConfigurationError("functional.equalsParameters");
 }
@@ -447,10 +421,10 @@ export function equalsParameters(): never {
 /**
  * Tests return value with strict equality.
  *
- * Tests a function, by wrapping the function and checking its return value through
- * {@link isEquals} function. If the return value does not match the expected type,
- * it returns `null`. Otherwise there's no type error, it returns the result of the
- * function.
+ * Tests a function, by wrapping the function and checking its return value
+ * through {@link isEquals} function. If the return value does not match the
+ * expected type, it returns `null`. Otherwise there's no type error, it returns
+ * the result of the function.
  *
  * By the way, if you want is not just testing type checking, but also finding
  * detailed type error reason(s), then use {@link assertEqualsReturn} or
@@ -459,11 +433,10 @@ export function equalsParameters(): never {
  * On the other hand, if you want to allow any superfluous properties, utilize
  * {@link isReturn}, {@link assertReturn} or {@link validateReturn} instead.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Target function type
  * @param func Target function to test
  * @returns The wrapper function with type tests
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function equalsReturn<T extends (...args: any[]) => any>(
   func: T,
@@ -473,9 +446,7 @@ export function equalsReturn<T extends (...args: any[]) => any>(
     : (...args: Arguments) => Output | null
   : never;
 
-/**
- * @internal
- */
+/** @internal */
 export function equalsReturn(): never {
   NoTransformConfigurationError("functional.equalsReturn");
 }
@@ -486,33 +457,34 @@ export function equalsReturn(): never {
 /**
  * Validates a function.
  *
- * Validates a function, by wrapping the function and checking its parameters and
- * return value through {@link validate} function. If some parameter or return value
- * does not match the expected type, it returns {@link IValidation.IError} typed
- * object. Otherwise there's no type error, it returns {@link IValidation.ISuccess}
- * typed object instead.
+ * Validates a function, by wrapping the function and checking its parameters
+ * and return value through {@link validate} function. If some parameter or
+ * return value does not match the expected type, it returns
+ * {@link IValidation.IError} typed object. Otherwise there's no type error, it
+ * returns {@link IValidation.ISuccess} typed object instead.
  *
- * For reference, {@link IValidation.IError.path} would be a little bit different with
- * individual {@link validate} function. If the {@link IValidation.IError} occurs from
- * some parameter, the path would start from `$input.parameters[number]`. Otherwise
- * the path would start from `$input.return`.
+ * For reference, {@link IValidation.IError.path} would be a little bit different
+ * with individual {@link validate} function. If the {@link IValidation.IError}
+ * occurs from some parameter, the path would start from
+ * `$input.parameters[number]`. Otherwise the path would start from
+ * `$input.return`.
  *
  * - `$input.parameters[0].~`
  * - `$input.return.~`
  *
- * By the way, if what you want is not finding every type errors, but just finding
- * the 1st type error, then use {@link assertFunction} instead. Otherwise, what you
- * want is just validating parameters or return value only, you can use
- * {@link validateParameters} or {@link validateReturn} instead.
+ * By the way, if what you want is not finding every type errors, but just
+ * finding the 1st type error, then use {@link assertFunction} instead.
+ * Otherwise, what you want is just validating parameters or return value only,
+ * you can use {@link validateParameters} or {@link validateReturn} instead.
  *
- * On the other hand, if you don't want to allow any superfluous properties, utilize
- * {@link validateEqualsFunction} or {@link assertEqualsFunction} instead.
+ * On the other hand, if you don't want to allow any superfluous properties,
+ * utilize {@link validateEqualsFunction} or {@link assertEqualsFunction}
+ * instead.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Target function type
  * @param func Target function to validate
  * @returns The wrapper function with type validations
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function validateFunction<T extends (...args: any[]) => any>(
   func: T,
@@ -522,9 +494,7 @@ export function validateFunction<T extends (...args: any[]) => any>(
     : (...args: Arguments) => IValidation<Output>
   : never;
 
-/**
- * @internal
- */
+/** @internal */
 export function validateFunction(): never {
   NoTransformConfigurationError("functional.validateFunction");
 }
@@ -532,28 +502,30 @@ export function validateFunction(): never {
 /**
  * Validates parameters.
  *
- * Validates a function, by wrapping the function and checking its parameters through
- * {@link validate} function. If some parameter does not match the expected type, it
- * returns {@link IValidation.IError} typed object. Otherwise there's no type error,
- * it returns {@link IValidation.ISuccess} typed object instead.
+ * Validates a function, by wrapping the function and checking its parameters
+ * through {@link validate} function. If some parameter does not match the
+ * expected type, it returns {@link IValidation.IError} typed object. Otherwise
+ * there's no type error, it returns {@link IValidation.ISuccess} typed object
+ * instead.
  *
- * For reference, {@link IValidation.IError.path} would be a little bit different with
- * individual {@link validate} function. If the {@link IValidation.IError} occurs from
- * some parameter, the path would start from `$input.parameters[number]`.
+ * For reference, {@link IValidation.IError.path} would be a little bit different
+ * with individual {@link validate} function. If the {@link IValidation.IError}
+ * occurs from some parameter, the path would start from
+ * `$input.parameters[number]`.
  *
- * By the way, if what you want is not finding every type errors, but just finding
- * the 1st type error, then use {@link assertParameters} instead. Otherwise, what you
- * want is not only validating parameters, but also validating return value, you can
- * use {@link validateFunction} instead.
+ * By the way, if what you want is not finding every type errors, but just
+ * finding the 1st type error, then use {@link assertParameters} instead.
+ * Otherwise, what you want is not only validating parameters, but also
+ * validating return value, you can use {@link validateFunction} instead.
  *
- * On the other hand, if you don't want to allow any superfluous properties, utilize
- * {@link validateEqualsParameters} or {@link assertEqualsParameters} instead.
+ * On the other hand, if you don't want to allow any superfluous properties,
+ * utilize {@link validateEqualsParameters} or {@link assertEqualsParameters}
+ * instead.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Target function type
  * @param func Target function to validate
  * @returns The wrapper function with type validations
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function validateParameters<T extends (...args: any[]) => any>(
   func: T,
@@ -563,9 +535,7 @@ export function validateParameters<T extends (...args: any[]) => any>(
     : (...args: Arguments) => IValidation<Output>
   : never;
 
-/**
- * @internal
- */
+/** @internal */
 export function validateParameters(): never {
   NoTransformConfigurationError("functional.validateParameters");
 }
@@ -573,28 +543,28 @@ export function validateParameters(): never {
 /**
  * Validates return value.
  *
- * Validates a function, by wrapping the function and checking its return value through
- * {@link validate} function. If the return value does not match the expected type, it
- * returns {@link IValidation.IError} typed object. Otherwise there's no type error,
- * it returns {@link IValidation.ISuccess} typed object instead.
+ * Validates a function, by wrapping the function and checking its return value
+ * through {@link validate} function. If the return value does not match the
+ * expected type, it returns {@link IValidation.IError} typed object. Otherwise
+ * there's no type error, it returns {@link IValidation.ISuccess} typed object
+ * instead.
  *
- * For reference, {@link IValidation.IError.path} would be a little bit different with
- * individual {@link validate} function. If the {@link IValidation.IError} occurs from
- * the return value, the path would start from `$input.return`.
+ * For reference, {@link IValidation.IError.path} would be a little bit different
+ * with individual {@link validate} function. If the {@link IValidation.IError}
+ * occurs from the return value, the path would start from `$input.return`.
  *
- * By the way, if what you want is not finding every type errors, but just finding
- * the 1st type error, then use {@link assertReturn} instead. Otherwise, what you want
- * is not only validating return value, but also validating parameters, you can use
- * {@link validateFunction} instead.
+ * By the way, if what you want is not finding every type errors, but just
+ * finding the 1st type error, then use {@link assertReturn} instead. Otherwise,
+ * what you want is not only validating return value, but also validating
+ * parameters, you can use {@link validateFunction} instead.
  *
- * On the other hand, if you don't want to allow any superfluous properties, utilize
- * {@link validateEqualsReturn} or {@link assertEqualsReturn} instead.
+ * On the other hand, if you don't want to allow any superfluous properties,
+ * utilize {@link validateEqualsReturn} or {@link assertEqualsReturn} instead.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Target function type
  * @param func Target function to validate
  * @returns The wrapper function with type validations
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function validateReturn<T extends (...args: any[]) => any>(
   func: T,
@@ -604,9 +574,7 @@ export function validateReturn<T extends (...args: any[]) => any>(
     : (...args: Arguments) => IValidation<Output>
   : never;
 
-/**
- * @internal
- */
+/** @internal */
 export function validateReturn(): never {
   NoTransformConfigurationError("functional.validateReturn");
 }
@@ -614,33 +582,34 @@ export function validateReturn(): never {
 /**
  * Validates a function with strict equality.
  *
- * Validates a function with strict equality, by wrapping the function and checking
- * its parameters and return value through {@link validateEquals} function. If some
- * parameter or return value does not match the expected type, it returns
- * {@link IValidation.IError} typed object. Otherwise there's no type error, it
- * returns {@link IValidation.ISuccess} typed object instead.
+ * Validates a function with strict equality, by wrapping the function and
+ * checking its parameters and return value through {@link validateEquals}
+ * function. If some parameter or return value does not match the expected type,
+ * it returns {@link IValidation.IError} typed object. Otherwise there's no type
+ * error, it returns {@link IValidation.ISuccess} typed object instead.
  *
- * For reference, {@link IValidation.IError.path} would be a little bit different with
- * individual {@link validateEquals} function. If the {@link IValidation.IError} occurs
- * from some parameter, the path would start from `$input.parameters[number]`. Otherwise
- * the path would start from `$input.return`.
+ * For reference, {@link IValidation.IError.path} would be a little bit different
+ * with individual {@link validateEquals} function. If the
+ * {@link IValidation.IError} occurs from some parameter, the path would start
+ * from `$input.parameters[number]`. Otherwise the path would start from
+ * `$input.return`.
  *
  * - `$input.parameters[0].~`
  * - `$input.return.~`
  *
- * By the way, if what you want is not finding every type errors, but just finding
- * the 1st type error, then use {@link assertEqualsFunction} instead. Otherwise, what
- * you want is just validating parameters or return value only, you can use
- * {@link validateEqualsParameters} or {@link validateEqualsReturn} instead.
+ * By the way, if what you want is not finding every type errors, but just
+ * finding the 1st type error, then use {@link assertEqualsFunction} instead.
+ * Otherwise, what you want is just validating parameters or return value only,
+ * you can use {@link validateEqualsParameters} or {@link validateEqualsReturn}
+ * instead.
  *
  * On the other hand, if you want to allow any superfluous properties, utilize
  * {@link validateFunction} or {@link assertFunction} instead.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Target function type
  * @param func Target function to validate
  * @returns The wrapper function with type validations
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function validateEqualsFunction<T extends (...args: any[]) => any>(
   func: T,
@@ -650,9 +619,7 @@ export function validateEqualsFunction<T extends (...args: any[]) => any>(
     : (...args: Arguments) => IValidation<Output>
   : never;
 
-/**
- * @internal
- */
+/** @internal */
 export function validateEqualsFunction(): never {
   NoTransformConfigurationError("functional.validateEqualsFunction");
 }
@@ -660,28 +627,29 @@ export function validateEqualsFunction(): never {
 /**
  * Validates parameters with strict equality.
  *
- * Validates a function, by wrapping the function and checking its parameters through
- * {@link validateEquals} function. If some parameter does not match the expected type,
- * it returns {@link IValidation.IError} typed object. Otherwise there's no type error,
- * it returns {@link IValidation.ISuccess} typed object instead.
+ * Validates a function, by wrapping the function and checking its parameters
+ * through {@link validateEquals} function. If some parameter does not match the
+ * expected type, it returns {@link IValidation.IError} typed object. Otherwise
+ * there's no type error, it returns {@link IValidation.ISuccess} typed object
+ * instead.
  *
- * For reference, {@link IValidation.IError.path} would be a little bit different with
- * individual {@link validateEquals} function. If the {@link IValidation.IError} occurs
- * from some parameter, the path would start from `$input.parameters[number]`.
+ * For reference, {@link IValidation.IError.path} would be a little bit different
+ * with individual {@link validateEquals} function. If the
+ * {@link IValidation.IError} occurs from some parameter, the path would start
+ * from `$input.parameters[number]`.
  *
- * By the way, if what you want is not finding every type errors, but just finding
- * the 1st type error, then use {@link assertEqualsParameters} instead. Otherwise,
- * what you want is not only validating parameters, but also validating return value,
- * you can use {@link validateEqualsFunction} instead.
+ * By the way, if what you want is not finding every type errors, but just
+ * finding the 1st type error, then use {@link assertEqualsParameters} instead.
+ * Otherwise, what you want is not only validating parameters, but also
+ * validating return value, you can use {@link validateEqualsFunction} instead.
  *
  * On the other hand, if you want to allow any superfluous properties, utilize
  * {@link validateParameters} or {@link assertParameters} instead.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Target function type
  * @param func Target function to validate
  * @returns The wrapper function with type validations
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function validateEqualsParameters<T extends (...args: any[]) => any>(
   func: T,
@@ -691,9 +659,7 @@ export function validateEqualsParameters<T extends (...args: any[]) => any>(
     : (...args: Arguments) => IValidation<Output>
   : never;
 
-/**
- * @internal
- */
+/** @internal */
 export function validateEqualsParameters(): never {
   NoTransformConfigurationError("functional.validateEqualsParameters");
 }
@@ -701,28 +667,29 @@ export function validateEqualsParameters(): never {
 /**
  * Validates return value with strict equality.
  *
- * Validates a function, by wrapping the function and checking its return value through
- * {@link validateEquals} function. If the return value does not match the expected type,
- * it returns {@link IValidation.IError} typed object. Otherwise there's no type error,
- * it returns {@link IValidation.ISuccess} typed object instead.
+ * Validates a function, by wrapping the function and checking its return value
+ * through {@link validateEquals} function. If the return value does not match
+ * the expected type, it returns {@link IValidation.IError} typed object.
+ * Otherwise there's no type error, it returns {@link IValidation.ISuccess} typed
+ * object instead.
  *
- * For reference, {@link IValidation.IError.path} would be a little bit different with
- * individual {@link validateEquals} function. If the {@link IValidation.IError} occurs
- * from the return value, the path would start from `$input.return`.
+ * For reference, {@link IValidation.IError.path} would be a little bit different
+ * with individual {@link validateEquals} function. If the
+ * {@link IValidation.IError} occurs from the return value, the path would start
+ * from `$input.return`.
  *
- * By the way, if what you want is not finding every type errors, but just finding
- * the 1st type error, then use {@link assertEqualsReturn} instead. Otherwise, what you
- * want is not only validating return value, but also validating parameters, you can use
- * {@link validateEqualsFunction} instead.
+ * By the way, if what you want is not finding every type errors, but just
+ * finding the 1st type error, then use {@link assertEqualsReturn} instead.
+ * Otherwise, what you want is not only validating return value, but also
+ * validating parameters, you can use {@link validateEqualsFunction} instead.
  *
  * On the other hand, if you want to allow any superfluous properties, utilize
  * {@link validateReturn} or {@link assertReturn} instead.
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @template T Target function type
  * @param func Target function to validate
  * @returns The wrapper function with type validations
- *
- * @author Jeongho Nam - https://github.com/samchon
  */
 export function validateEqualsReturn<T extends (...args: any[]) => any>(
   func: T,
@@ -732,9 +699,7 @@ export function validateEqualsReturn<T extends (...args: any[]) => any>(
     : (...args: Arguments) => IValidation<Output>
   : never;
 
-/**
- * @internal
- */
+/** @internal */
 export function validateEqualsReturn(): never {
   NoTransformConfigurationError("functional.validateEqualsReturn");
 }