Typia Guide Documents

`assertFunction()`

export namespace functional {
  export function assertFunction<T extends Function>(func: T): T;
  export function assertParameters<T extends Function>(func: T): T;
  export function assertReturn<T extends Function>(func: T): T;
 
  export function assertEqualsFunction<T extends Function>(func: T): T;
  export function assertEqualsParameters<T extends Function>(func: T): T;
  export function assertEqualsReturn<T extends Function>(func: T): T;
}

Asserts a function.

typia.functional.assertFunction<T>() asserts a function, by wrapping the parameter function and checking its parametrs and return value through typia.assert<T>() function. If some parameter or return value does not match the expected type, it throws a TypeGuardError error.

For reference, TypeGuardError.path would be a little bit different with individual typia.assert<T>() function. If TypeGuardError occurs from some parameter, the path wouold start from $input.parameters[<index>]. Otherwise the path would start from $input.return.

$input.parameters[0].~
$input.return.~

By the way, if you don’t want to assert both paramters and return value, but one of them, you can use typia.functional.assertParameters<T>() or typia.functional.assertReturn<T>() instead. Otherwise, if you want to prohibit superfluous properties, typia.functional.assertEqualsFunction<T>() would be helpful.

Also, if what you want is not just finding the first type error through assertion, but also finding every type errors, utilize typia.functional.validateFunction<T>() function instead. Otherwise, you don’t need the reason why, but just want to know whether the function is valid or not, use typia.functional.isFunction<T>() function.

examples/src/assertFunction.ts

import typia from "typia";
 
const func = typia.functional.assertFunction(
  (x: number, y: number): number => x + y,
);
func(3, 4);
func(4, 5);

examples/bin/assertFunction.js

import * as __typia_transform__functionalTypeGuardErrorFactory from "typia/lib/internal/_functionalTypeGuardErrorFactory.js";
import * as __typia_transform__assertGuard from "typia/lib/internal/_assertGuard.js";
import typia from "typia";
const func = (() => {
  const errorFactoryWrapper =
    __typia_transform__functionalTypeGuardErrorFactory._functionalTypeGuardErrorFactory;
  const __assert_param_0 = (() => {
    const __is = (input) => "number" === typeof input;
    let _errorFactory;
    return (
      input,
      errorFactory = (p) =>
        errorFactoryWrapper({
          ...p,
          path: p.path
            ? p.path.replace("$input", "$input.parameters[0]")
            : undefined,
        }),
    ) => {
      if (false === __is(input)) {
        _errorFactory = errorFactory;
        ((input, _path, _exceptionable = true) =>
          "number" === typeof input ||
          __typia_transform__assertGuard._assertGuard(
            true,
            {
              method: "typia.functional.assertFunction",
              path: _path + "",
              expected: "number",
              value: input,
            },
            _errorFactory,
          ))(input, "$input", true);
      }
      return input;
    };
  })();
  const __assert_param_1 = (() => {
    const __is = (input) => "number" === typeof input;
    let _errorFactory;
    return (
      input,
      errorFactory = (p) =>
        errorFactoryWrapper({
          ...p,
          path: p.path
            ? p.path.replace("$input", "$input.parameters[1]")
            : undefined,
        }),
    ) => {
      if (false === __is(input)) {
        _errorFactory = errorFactory;
        ((input, _path, _exceptionable = true) =>
          "number" === typeof input ||
          __typia_transform__assertGuard._assertGuard(
            true,
            {
              method: "typia.functional.assertFunction",
              path: _path + "",
              expected: "number",
              value: input,
            },
            _errorFactory,
          ))(input, "$input", true);
      }
      return input;
    };
  })();
  const __assert_return = (() => {
    const __is = (input) => "number" === typeof input;
    let _errorFactory;
    return (
      input,
      errorFactory = (p) =>
        errorFactoryWrapper({
          ...p,
          path: p.path ? p.path.replace("$input", "$input.return") : undefined,
        }),
    ) => {
      if (false === __is(input)) {
        _errorFactory = errorFactory;
        ((input, _path, _exceptionable = true) =>
          "number" === typeof input ||
          __typia_transform__assertGuard._assertGuard(
            true,
            {
              method: "typia.functional.assertFunction",
              path: _path + "",
              expected: "number",
              value: input,
            },
            _errorFactory,
          ))(input, "$input", true);
      }
      return input;
    };
  })();
  return (x, y) => {
    __assert_param_0(x);
    __assert_param_1(y);
    return __assert_return(((x, y) => x + y)(x, y));
  };
})();
func(3, 4);
func(4, 5);

`isFunction()`

typia

export namespace functional {
  export function isFunction<T extends (...args: any[]) => any>(
    func: T,
  ): T extends (...args: infer Arguments) => infer Output
    ? Output extends Promise<infer R>
      ? (...args: Arguments) => Promise<R | null>
      : (...args: Arguments) => Output | null
    : never;
  export function isParameters;
  export function isReturn;
 
  export function isEqualsFunction;
  export function isEqualsParameters;
  export function isEqualsReturn;
}

Tests a function.

typia.functional.isFunction<T>() tests a function, by wrapping the parameter function and checking its paramters and return value through typia.is<T>() function. If some parameter or return value does not match the expected type, it returns null. Otherwise, it returns the return value of the parameter function.

By the way, if you don’t want to test both paramters and return value, but one of them, you can use typia.functional.isParameters<T>() or typia.functional.isReturn<T>() instead. Otherwise, if you want to prohibit superfluous properties, typia.functional.equalsFunction<T>() would be helpful.

Also, if what you want is not just type checking, but want to know the detailed reason(s) why, utilize typia.functional.assertFunction<T>() or typia.functional.validateFunction<T>() instead.

examples/src/isFunction.ts

import typia from "typia";
 
const func = typia.functional.isFunction(
  (x: number, y: number): number => x + y,
);
func(3, 4);
func(4, 5);

Validates a function.

typia.functional.validateFunction<T>() validates a function, by wrapping the parameter function and checking its paramters and return value through typia.validate<T>() function. If some parameter or return value does not match the expected type, it returns a IValidation.IFailure typed object. Otherwise, it returns a IValidation.ISuccess typed object instead.

For reference, IValidation.IError.path would be a little bit different with individual typia.validate<T>() function. If IValidation.IError occurs from some parameter, the path wouold start from $input.parameters[<index>]. Otherwise the path would start from $input.return.

$input.parameters[0].~
$input.return.~

By the way, if you don’t want to validate both paramters and return value, but one of them, you can use typia.functional.validateParameters<T>() or typia.functional.validateReturn<T>() instead. Otherwise, if you want to prohibit superfluous properties, typia.functional.validateEqualsFunction<T>() would be helpful.

Also, if what you want is not retrieving every type errors, but just finding the first type error, utilize typia.functional.assertFunction<T>() function instead. Otherwise, you don’t need the reason why, but just want to know whether the function is valid or not, use typia.functional.isFunction<T>() function.

examples/src/validateFunction.ts

import typia from "typia";
 
const func = typia.functional.validateFunction(
  (x: number, y: number): number => x + y,
);
func(3, 4);
func(4, 5);

examples/bin/validateFunction.js

import * as __typia_transform__validateReport from "typia/lib/internal/_validateReport.js";
import typia from "typia";
const func = (() => {
  const __validate_param_0 = (() => {
    const __is = (input) => "number" === typeof input;
    let errors;
    let $report;
    return (input) => {
      if (false === __is(input)) {
        errors = [];
        $report = __typia_transform__validateReport._validateReport(errors);
        ((input, _path, _exceptionable = true) =>
          "number" === typeof input ||
          $report(true, {
            path: _path + "",
            expected: "number",
            value: input,
          }))(input, "$input", true);
        const success = 0 === errors.length;
        return {
          success,
          errors,
          data: success ? input : undefined,
        };
      }
      return {
        success: true,
        errors: [],
        data: input,
      };
    };
  })();
  const __validate_param_1 = (() => {
    const __is = (input) => "number" === typeof input;
    let errors;
    let $report;
    return (input) => {
      if (false === __is(input)) {
        errors = [];
        $report = __typia_transform__validateReport._validateReport(errors);
        ((input, _path, _exceptionable = true) =>
          "number" === typeof input ||
          $report(true, {
            path: _path + "",
            expected: "number",
            value: input,
          }))(input, "$input", true);
        const success = 0 === errors.length;
        return {
          success,
          errors,
          data: success ? input : undefined,
        };
      }
      return {
        success: true,
        errors: [],
        data: input,
      };
    };
  })();
  const __validate_return = (() => {
    const __is = (input) => "number" === typeof input;
    let errors;
    let $report;
    return (input) => {
      if (false === __is(input)) {
        errors = [];
        $report = __typia_transform__validateReport._validateReport(errors);
        ((input, _path, _exceptionable = true) =>
          "number" === typeof input ||
          $report(true, {
            path: _path + "",
            expected: "number",
            value: input,
          }))(input, "$input", true);
        const success = 0 === errors.length;
        return {
          success,
          errors,
          data: success ? input : undefined,
        };
      }
      return {
        success: true,
        errors: [],
        data: input,
      };
    };
  })();
  return (x, y) => {
    const paramErrorResults = [__validate_param_0(x), __validate_param_1(y)]
      .map((r, i) =>
        true === r.success
          ? r
          : {
              ...r,
              errors: r.errors.map((error) => ({
                ...error,
                path: error.path.replace("$input", `$input.parameters[${i}]`),
              })),
            },
      )
      .filter((r) => false === r.success);
    if (0 !== paramErrorResults.length)
      return {
        success: false,
        errors: paramErrorResults.map((r) => r.errors).flat(),
      };
    const result = __validate_return(((x, y) => x + y)(x, y));
    if (false === result.success)
      result.errors = result.errors.map((error) => ({
        ...error,
        path: error.path.replace("$input", "$input.return"),
      }));
    return result;
  };
})();
func(3, 4);
func(4, 5);

validate() function Special Tags