typia 6.10.2-dev.20240920 → 6.10.2

package/src/programmers/FeatureProgrammer.ts

@@ -1,549 +1,549 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../factories/IdentifierFactory";
-import { MetadataCollection } from "../factories/MetadataCollection";
-import { StatementFactory } from "../factories/StatementFactory";
-import { TypeFactory } from "../factories/TypeFactory";
-import { ValueFactory } from "../factories/ValueFactory";
-
-import { Metadata } from "../schemas/metadata/Metadata";
-import { MetadataArray } from "../schemas/metadata/MetadataArray";
-import { MetadataObject } from "../schemas/metadata/MetadataObject";
-
-import { IProject } from "../transformers/IProject";
-
-import { CheckerProgrammer } from "./CheckerProgrammer";
-import { FunctionImporter } from "./helpers/FunctionImporter";
-import { IExpressionEntry } from "./helpers/IExpressionEntry";
-import { UnionExplorer } from "./helpers/UnionExplorer";
-import { feature_object_entries } from "./internal/feature_object_entries";
-
-export namespace FeatureProgrammer {
-  /* -----------------------------------------------------------
-        PARAMETERS
-    ----------------------------------------------------------- */
-  export interface IConfig<Output extends ts.ConciseBody = ts.ConciseBody> {
-    types: IConfig.ITypes;
-
-    /**
-     * Prefix name of internal functions for specific types.
-     */
-    prefix: string;
-
-    /**
-     * Whether to archive access path or not.
-     */
-    path: boolean;
-
-    /**
-     * Whether to trace exception or not.
-     */
-    trace: boolean;
-
-    addition?: undefined | ((collection: MetadataCollection) => ts.Statement[]);
-
-    /**
-     * Initializer of metadata.
-     */
-    initializer: (
-      project: IProject,
-    ) => (
-      importer: FunctionImporter,
-    ) => (type: ts.Type) => [MetadataCollection, Metadata];
-
-    /**
-     * Decoder, station of every types.
-     */
-    decoder: () => Decoder<Metadata, Output>;
-
-    /**
-     * Object configurator.
-     */
-    objector: IConfig.IObjector<Output>;
-
-    /**
-     * Generator of functions for object types.
-     */
-    generator: IConfig.IGenerator;
-  }
-  export namespace IConfig {
-    export interface ITypes {
-      input: (type: ts.Type, name?: undefined | string) => ts.TypeNode;
-      output: (type: ts.Type, name?: undefined | string) => ts.TypeNode;
-    }
-
-    export interface IObjector<Output extends ts.ConciseBody = ts.ConciseBody> {
-      /**
-       * Type checker when union object type comes.
-       */
-      checker: () => Decoder<Metadata, ts.Expression>;
-
-      /**
-       * Decoder, function call expression generator of specific typed objects.
-       */
-      decoder: () => Decoder<MetadataObject, ts.Expression>;
-
-      /**
-       * Joiner of expressions from properties.
-       */
-      joiner(
-        input: ts.Expression,
-        entries: IExpressionEntry<Output>[],
-        parent: MetadataObject,
-      ): ts.ConciseBody;
-
-      /**
-       * Union type specificator.
-       *
-       * Expression of an algorithm specifying object type and calling
-       * the `decoder` function of the specified object type.
-       */
-      unionizer: Decoder<MetadataObject[], ts.Expression>;
-
-      /**
-       * Handler of union type specification failure.
-       *
-       * @param value Expression of input parameter
-       * @param expected Expected type name
-       * @param explore Exploration info
-       * @returns Statement of failure
-       */
-      failure(
-        value: ts.Expression,
-        expected: string,
-        explore?: undefined | IExplore,
-      ): ts.Statement;
-
-      /**
-       * Transformer of type checking expression by discrimination.
-       *
-       * When an object type has been specified by a discrimination without full
-       * iteration, the `unionizer` will decode the object instance after
-       * the last type checking.
-       *
-       * In such circumtance, you can transform the last type checking function.
-       *
-       * @param exp Current expression about type checking
-       * @returns Transformed expression
-       * @deprecated
-       */
-      is?: undefined | ((exp: ts.Expression) => ts.Expression);
-
-      /**
-       * Transformer of non-undefined type checking by discrimination.
-       *
-       * When specifying an union type of objects, `typia` tries to find
-       * descrimination way just by checking only one property type.
-       * If succeeded to find the discrimination way, `typia` will check the target
-       * property type and in the checking, non-undefined type checking would be
-       * done.
-       *
-       * In such process, you can transform the non-undefined type checking.
-       *
-       * @param exp
-       * @returns Transformed expression
-       * @deprecated
-       */
-      required?: undefined | ((exp: ts.Expression) => ts.Expression);
-
-      /**
-       * Conditon wrapper when unable to specify any object type.
-       *
-       * When failed to specify an object type through discrimination, full
-       * iteration type checking would be happend. In such circumstance, you
-       * can wrap the condition with additional function.
-       *
-       * @param condition Current condition
-       * @returns A function wrapped current condition
-       */
-      full?:
-        | undefined
-        | ((
-            condition: ts.Expression,
-          ) => (
-            input: ts.Expression,
-            expected: string,
-            explore: IExplore,
-          ) => ts.Expression);
-
-      /**
-       * Return type.
-       */
-      type?: undefined | ts.TypeNode;
-    }
-    export interface IGenerator {
-      objects?:
-        | undefined
-        | (() => (col: MetadataCollection) => ts.VariableStatement[]);
-      unions?:
-        | undefined
-        | (() => (col: MetadataCollection) => ts.VariableStatement[]);
-      arrays(): (col: MetadataCollection) => ts.VariableStatement[];
-      tuples(): (col: MetadataCollection) => ts.VariableStatement[];
-    }
-  }
-
-  export interface IExplore {
-    tracable: boolean;
-    source: "top" | "function";
-    from: "top" | "array" | "object";
-    postfix: string;
-    start?: undefined | number;
-  }
-
-  export interface Decoder<T, Output extends ts.ConciseBody = ts.ConciseBody> {
-    (input: ts.Expression, target: T, explore: IExplore): Output;
-  }
-
-  /* -----------------------------------------------------------
-    GENERATORS
-  ----------------------------------------------------------- */
-  export interface IComposed {
-    body: ts.ConciseBody;
-    parameters: ts.ParameterDeclaration[];
-    functions: Record<string, ts.VariableStatement>;
-    statements: ts.Statement[];
-    response: ts.TypeNode;
-  }
-  export interface IDecomposed {
-    functions: Record<string, ts.VariableStatement>;
-    statements: ts.Statement[];
-    arrow: ts.ArrowFunction;
-  }
-
-  export const compose = (props: {
-    project: IProject;
-    config: IConfig;
-    importer: FunctionImporter;
-    type: ts.Type;
-    name: string | undefined;
-  }): IComposed => {
-    const [collection, meta] = props.config.initializer(props.project)(
-      props.importer,
-    )(props.type);
-    return {
-      body: props.config.decoder()(ValueFactory.INPUT(), meta, {
-        tracable: props.config.path || props.config.trace,
-        source: "top",
-        from: "top",
-        postfix: '""',
-      }),
-      statements: props.config.addition
-        ? props.config.addition(collection)
-        : [],
-      functions: {
-        ...Object.fromEntries(
-          (
-            props.config.generator.objects?.() ??
-            write_object_functions(props.config)(props.importer)
-          )(collection).map((v, i) => [`${props.config.prefix}o${i}`, v]),
-        ),
-        ...Object.fromEntries(
-          (
-            props.config.generator.unions?.() ??
-            write_union_functions(props.config)
-          )(collection).map((v, i) => [`${props.config.prefix}u${i}`, v]),
-        ),
-        ...Object.fromEntries(
-          props.config.generator
-            .arrays()(collection)
-            .map((v, i) => [`${props.config.prefix}a${i}`, v]),
-        ),
-        ...Object.fromEntries(
-          props.config.generator
-            .tuples()(collection)
-            .map((v, i) => [`${props.config.prefix}t${i}`, v]),
-        ),
-      },
-      parameters: parameterDeclarations(props.config)(
-        props.config.types.input(props.type, props.name),
-      )(ValueFactory.INPUT()),
-      response: props.config.types.output(props.type, props.name),
-    };
-  };
-
-  export const writeDecomposed = (props: {
-    modulo: ts.LeftHandSideExpression;
-    importer: FunctionImporter;
-    result: IDecomposed;
-  }): ts.CallExpression =>
-    ts.factory.createCallExpression(
-      ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [],
-        undefined,
-        undefined,
-        ts.factory.createBlock([
-          ...props.importer.declare(props.modulo),
-          ...Object.entries(props.result.functions)
-            .filter(([k]) => props.importer.hasLocal(k))
-            .map(([_k, v]) => v),
-          ...props.result.statements,
-          ts.factory.createReturnStatement(props.result.arrow),
-        ]),
-      ),
-      undefined,
-      undefined,
-    );
-
-  export const write =
-    (project: IProject) =>
-    (config: IConfig) =>
-    (importer: FunctionImporter) =>
-    (type: ts.Type, name?: string): ts.ArrowFunction => {
-      const [collection, meta] = config.initializer(project)(importer)(type);
-
-      // ITERATE OVER ALL METADATA
-      const output: ts.ConciseBody = config.decoder()(
-        ValueFactory.INPUT(),
-        meta,
-        {
-          tracable: config.path || config.trace,
-          source: "top",
-          from: "top",
-          postfix: '""',
-        },
-      );
-
-      // RETURNS THE OPTIMAL ARROW FUNCTION
-      const functions = {
-        objects: (
-          config.generator.objects?.() ??
-          write_object_functions(config)(importer)
-        )(collection),
-        unions: (config.generator.unions?.() ?? write_union_functions(config))(
-          collection,
-        ),
-        arrays: config.generator.arrays()(collection),
-        tuples: config.generator.tuples()(collection),
-      };
-      const added: ts.Statement[] = (config.addition ?? (() => []))(collection);
-
-      return ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        parameterDeclarations(config)(config.types.input(type, name))(
-          ValueFactory.INPUT(),
-        ),
-        config.types.output(type, name),
-        undefined,
-        ts.factory.createBlock(
-          [
-            ...added,
-            ...functions.objects.filter((_, i) =>
-              importer.hasLocal(`${config.prefix}o${i}`),
-            ),
-            ...functions.unions.filter((_, i) =>
-              importer.hasLocal(`${config.prefix}u${i}`),
-            ),
-            ...functions.arrays.filter((_, i) =>
-              importer.hasLocal(`${config.prefix}a${i}`),
-            ),
-            ...functions.tuples.filter((_, i) =>
-              importer.hasLocal(`${config.prefix}t${i}`),
-            ),
-            ...(ts.isBlock(output)
-              ? output.statements
-              : [ts.factory.createReturnStatement(output)]),
-          ],
-          true,
-        ),
-      );
-    };
-
-  export const write_object_functions =
-    (config: IConfig) =>
-    (importer: FunctionImporter) =>
-    (collection: MetadataCollection) =>
-      collection
-        .objects()
-        .map((obj) =>
-          StatementFactory.constant(
-            `${config.prefix}o${obj.index}`,
-            ts.factory.createArrowFunction(
-              undefined,
-              undefined,
-              parameterDeclarations(config)(TypeFactory.keyword("any"))(
-                ValueFactory.INPUT(),
-              ),
-              config.objector.type ?? TypeFactory.keyword("any"),
-              undefined,
-              config.objector.joiner(
-                ts.factory.createIdentifier("input"),
-                feature_object_entries(config)(importer)(obj)(
-                  ts.factory.createIdentifier("input"),
-                ),
-                obj,
-              ),
-            ),
-          ),
-        );
-
-  export const write_union_functions =
-    (config: IConfig) => (collection: MetadataCollection) =>
-      collection
-        .unions()
-        .map((union, i) =>
-          StatementFactory.constant(
-            `${config.prefix}u${i}`,
-            write_union(config)(union),
-          ),
-        );
-
-  const write_union = (config: IConfig) => {
-    const explorer = UnionExplorer.object(config);
-    const input = ValueFactory.INPUT();
-
-    return (meta: MetadataObject[]) =>
-      ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        parameterDeclarations(config)(TypeFactory.keyword("any"))(
-          ValueFactory.INPUT(),
-        ),
-        TypeFactory.keyword("any"),
-        undefined,
-        explorer(input, meta, {
-          tracable: config.path || config.trace,
-          source: "function",
-          from: "object",
-          postfix: "",
-        }),
-      );
-  };
-
-  /* -----------------------------------------------------------
-        DECODERS
-    ----------------------------------------------------------- */
-  export const decode_array =
-    (config: Pick<IConfig, "trace" | "path" | "decoder" | "prefix">) =>
-    (importer: FunctionImporter) =>
-    (
-      combiner: (
-        input: ts.Expression,
-        arrow: ts.ArrowFunction,
-      ) => ts.Expression,
-    ) => {
-      const rand: string = importer.increment().toString();
-      const tail =
-        config.path || config.trace
-          ? [
-              IdentifierFactory.parameter(
-                "_index" + rand,
-                TypeFactory.keyword("number"),
-              ),
-            ]
-          : [];
-
-      return (
-        input: ts.Expression,
-        array: MetadataArray,
-        explore: IExplore,
-      ) => {
-        const arrow: ts.ArrowFunction = ts.factory.createArrowFunction(
-          undefined,
-          undefined,
-          [
-            IdentifierFactory.parameter("elem", TypeFactory.keyword("any")),
-            ...tail,
-          ],
-          undefined,
-          undefined,
-          config.decoder()(ValueFactory.INPUT("elem"), array.type.value, {
-            tracable: explore.tracable,
-            source: explore.source,
-            from: "array",
-            postfix: index(explore.start ?? null)(explore.postfix)(rand),
-          }),
-        );
-        return combiner(input, arrow);
-      };
-    };
-
-  export const decode_object =
-    (config: Pick<IConfig, "trace" | "path" | "prefix">) =>
-    (importer: FunctionImporter) =>
-    (input: ts.Expression, obj: MetadataObject, explore: IExplore) =>
-      ts.factory.createCallExpression(
-        ts.factory.createIdentifier(
-          importer.useLocal(`${config.prefix}o${obj.index}`),
-        ),
-        undefined,
-        argumentsArray(config)(explore)(input),
-      );
-
-  /* -----------------------------------------------------------
-        UTILITIES FOR INTERNAL FUNCTIONS
-    ----------------------------------------------------------- */
-  export const index =
-    (start: number | null) => (prev: string) => (rand: string) => {
-      const tail: string =
-        start !== null
-          ? `"[" + (${start} + _index${rand}) + "]"`
-          : `"[" + _index${rand} + "]"`;
-      if (prev === "") return tail;
-      else if (prev[prev.length - 1] === `"`)
-        return prev.substring(0, prev.length - 1) + tail.substring(1);
-      return prev + ` + ${tail}`;
-    };
-
-  export const argumentsArray =
-    (config: Pick<IConfig, "path" | "trace">) =>
-    (explore: FeatureProgrammer.IExplore) => {
-      const tail: ts.Expression[] =
-        config.path === false && config.trace === false
-          ? []
-          : config.path === true && config.trace === true
-            ? [
-                ts.factory.createIdentifier(
-                  explore.postfix ? `_path + ${explore.postfix}` : "_path",
-                ),
-                explore.source === "function"
-                  ? ts.factory.createIdentifier(
-                      `${explore.tracable} && _exceptionable`,
-                    )
-                  : explore.tracable
-                    ? ts.factory.createTrue()
-                    : ts.factory.createFalse(),
-              ]
-            : config.path === true
-              ? [
-                  ts.factory.createIdentifier(
-                    explore.postfix ? `_path + ${explore.postfix}` : "_path",
-                  ),
-                ]
-              : [
-                  explore.source === "function"
-                    ? ts.factory.createIdentifier(
-                        `${explore.tracable} && _exceptionable`,
-                      )
-                    : explore.tracable
-                      ? ts.factory.createTrue()
-                      : ts.factory.createFalse(),
-                ];
-      return (input: ts.Expression) => [input, ...tail];
-    };
-
-  export const parameterDeclarations =
-    (props: Pick<CheckerProgrammer.IConfig, "path" | "trace">) =>
-    (type: ts.TypeNode) => {
-      const tail: ts.ParameterDeclaration[] = [];
-      if (props.path)
-        tail.push(
-          IdentifierFactory.parameter("_path", TypeFactory.keyword("string")),
-        );
-      if (props.trace)
-        tail.push(
-          IdentifierFactory.parameter(
-            "_exceptionable",
-            TypeFactory.keyword("boolean"),
-            ts.factory.createTrue(),
-          ),
-        );
-      return (input: ts.Identifier): ts.ParameterDeclaration[] => [
-        IdentifierFactory.parameter(input, type),
-        ...tail,
-      ];
-    };
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { MetadataCollection } from "../factories/MetadataCollection";
+import { StatementFactory } from "../factories/StatementFactory";
+import { TypeFactory } from "../factories/TypeFactory";
+import { ValueFactory } from "../factories/ValueFactory";
+
+import { Metadata } from "../schemas/metadata/Metadata";
+import { MetadataArray } from "../schemas/metadata/MetadataArray";
+import { MetadataObject } from "../schemas/metadata/MetadataObject";
+
+import { IProject } from "../transformers/IProject";
+
+import { CheckerProgrammer } from "./CheckerProgrammer";
+import { FunctionImporter } from "./helpers/FunctionImporter";
+import { IExpressionEntry } from "./helpers/IExpressionEntry";
+import { UnionExplorer } from "./helpers/UnionExplorer";
+import { feature_object_entries } from "./internal/feature_object_entries";
+
+export namespace FeatureProgrammer {
+  /* -----------------------------------------------------------
+        PARAMETERS
+    ----------------------------------------------------------- */
+  export interface IConfig<Output extends ts.ConciseBody = ts.ConciseBody> {
+    types: IConfig.ITypes;
+
+    /**
+     * Prefix name of internal functions for specific types.
+     */
+    prefix: string;
+
+    /**
+     * Whether to archive access path or not.
+     */
+    path: boolean;
+
+    /**
+     * Whether to trace exception or not.
+     */
+    trace: boolean;
+
+    addition?: undefined | ((collection: MetadataCollection) => ts.Statement[]);
+
+    /**
+     * Initializer of metadata.
+     */
+    initializer: (
+      project: IProject,
+    ) => (
+      importer: FunctionImporter,
+    ) => (type: ts.Type) => [MetadataCollection, Metadata];
+
+    /**
+     * Decoder, station of every types.
+     */
+    decoder: () => Decoder<Metadata, Output>;
+
+    /**
+     * Object configurator.
+     */
+    objector: IConfig.IObjector<Output>;
+
+    /**
+     * Generator of functions for object types.
+     */
+    generator: IConfig.IGenerator;
+  }
+  export namespace IConfig {
+    export interface ITypes {
+      input: (type: ts.Type, name?: undefined | string) => ts.TypeNode;
+      output: (type: ts.Type, name?: undefined | string) => ts.TypeNode;
+    }
+
+    export interface IObjector<Output extends ts.ConciseBody = ts.ConciseBody> {
+      /**
+       * Type checker when union object type comes.
+       */
+      checker: () => Decoder<Metadata, ts.Expression>;
+
+      /**
+       * Decoder, function call expression generator of specific typed objects.
+       */
+      decoder: () => Decoder<MetadataObject, ts.Expression>;
+
+      /**
+       * Joiner of expressions from properties.
+       */
+      joiner(
+        input: ts.Expression,
+        entries: IExpressionEntry<Output>[],
+        parent: MetadataObject,
+      ): ts.ConciseBody;
+
+      /**
+       * Union type specificator.
+       *
+       * Expression of an algorithm specifying object type and calling
+       * the `decoder` function of the specified object type.
+       */
+      unionizer: Decoder<MetadataObject[], ts.Expression>;
+
+      /**
+       * Handler of union type specification failure.
+       *
+       * @param value Expression of input parameter
+       * @param expected Expected type name
+       * @param explore Exploration info
+       * @returns Statement of failure
+       */
+      failure(
+        value: ts.Expression,
+        expected: string,
+        explore?: undefined | IExplore,
+      ): ts.Statement;
+
+      /**
+       * Transformer of type checking expression by discrimination.
+       *
+       * When an object type has been specified by a discrimination without full
+       * iteration, the `unionizer` will decode the object instance after
+       * the last type checking.
+       *
+       * In such circumtance, you can transform the last type checking function.
+       *
+       * @param exp Current expression about type checking
+       * @returns Transformed expression
+       * @deprecated
+       */
+      is?: undefined | ((exp: ts.Expression) => ts.Expression);
+
+      /**
+       * Transformer of non-undefined type checking by discrimination.
+       *
+       * When specifying an union type of objects, `typia` tries to find
+       * descrimination way just by checking only one property type.
+       * If succeeded to find the discrimination way, `typia` will check the target
+       * property type and in the checking, non-undefined type checking would be
+       * done.
+       *
+       * In such process, you can transform the non-undefined type checking.
+       *
+       * @param exp
+       * @returns Transformed expression
+       * @deprecated
+       */
+      required?: undefined | ((exp: ts.Expression) => ts.Expression);
+
+      /**
+       * Conditon wrapper when unable to specify any object type.
+       *
+       * When failed to specify an object type through discrimination, full
+       * iteration type checking would be happend. In such circumstance, you
+       * can wrap the condition with additional function.
+       *
+       * @param condition Current condition
+       * @returns A function wrapped current condition
+       */
+      full?:
+        | undefined
+        | ((
+            condition: ts.Expression,
+          ) => (
+            input: ts.Expression,
+            expected: string,
+            explore: IExplore,
+          ) => ts.Expression);
+
+      /**
+       * Return type.
+       */
+      type?: undefined | ts.TypeNode;
+    }
+    export interface IGenerator {
+      objects?:
+        | undefined
+        | (() => (col: MetadataCollection) => ts.VariableStatement[]);
+      unions?:
+        | undefined
+        | (() => (col: MetadataCollection) => ts.VariableStatement[]);
+      arrays(): (col: MetadataCollection) => ts.VariableStatement[];
+      tuples(): (col: MetadataCollection) => ts.VariableStatement[];
+    }
+  }
+
+  export interface IExplore {
+    tracable: boolean;
+    source: "top" | "function";
+    from: "top" | "array" | "object";
+    postfix: string;
+    start?: undefined | number;
+  }
+
+  export interface Decoder<T, Output extends ts.ConciseBody = ts.ConciseBody> {
+    (input: ts.Expression, target: T, explore: IExplore): Output;
+  }
+
+  /* -----------------------------------------------------------
+    GENERATORS
+  ----------------------------------------------------------- */
+  export interface IComposed {
+    body: ts.ConciseBody;
+    parameters: ts.ParameterDeclaration[];
+    functions: Record<string, ts.VariableStatement>;
+    statements: ts.Statement[];
+    response: ts.TypeNode;
+  }
+  export interface IDecomposed {
+    functions: Record<string, ts.VariableStatement>;
+    statements: ts.Statement[];
+    arrow: ts.ArrowFunction;
+  }
+
+  export const compose = (props: {
+    project: IProject;
+    config: IConfig;
+    importer: FunctionImporter;
+    type: ts.Type;
+    name: string | undefined;
+  }): IComposed => {
+    const [collection, meta] = props.config.initializer(props.project)(
+      props.importer,
+    )(props.type);
+    return {
+      body: props.config.decoder()(ValueFactory.INPUT(), meta, {
+        tracable: props.config.path || props.config.trace,
+        source: "top",
+        from: "top",
+        postfix: '""',
+      }),
+      statements: props.config.addition
+        ? props.config.addition(collection)
+        : [],
+      functions: {
+        ...Object.fromEntries(
+          (
+            props.config.generator.objects?.() ??
+            write_object_functions(props.config)(props.importer)
+          )(collection).map((v, i) => [`${props.config.prefix}o${i}`, v]),
+        ),
+        ...Object.fromEntries(
+          (
+            props.config.generator.unions?.() ??
+            write_union_functions(props.config)
+          )(collection).map((v, i) => [`${props.config.prefix}u${i}`, v]),
+        ),
+        ...Object.fromEntries(
+          props.config.generator
+            .arrays()(collection)
+            .map((v, i) => [`${props.config.prefix}a${i}`, v]),
+        ),
+        ...Object.fromEntries(
+          props.config.generator
+            .tuples()(collection)
+            .map((v, i) => [`${props.config.prefix}t${i}`, v]),
+        ),
+      },
+      parameters: parameterDeclarations(props.config)(
+        props.config.types.input(props.type, props.name),
+      )(ValueFactory.INPUT()),
+      response: props.config.types.output(props.type, props.name),
+    };
+  };
+
+  export const writeDecomposed = (props: {
+    modulo: ts.LeftHandSideExpression;
+    importer: FunctionImporter;
+    result: IDecomposed;
+  }): ts.CallExpression =>
+    ts.factory.createCallExpression(
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [],
+        undefined,
+        undefined,
+        ts.factory.createBlock([
+          ...props.importer.declare(props.modulo),
+          ...Object.entries(props.result.functions)
+            .filter(([k]) => props.importer.hasLocal(k))
+            .map(([_k, v]) => v),
+          ...props.result.statements,
+          ts.factory.createReturnStatement(props.result.arrow),
+        ]),
+      ),
+      undefined,
+      undefined,
+    );
+
+  export const write =
+    (project: IProject) =>
+    (config: IConfig) =>
+    (importer: FunctionImporter) =>
+    (type: ts.Type, name?: string): ts.ArrowFunction => {
+      const [collection, meta] = config.initializer(project)(importer)(type);
+
+      // ITERATE OVER ALL METADATA
+      const output: ts.ConciseBody = config.decoder()(
+        ValueFactory.INPUT(),
+        meta,
+        {
+          tracable: config.path || config.trace,
+          source: "top",
+          from: "top",
+          postfix: '""',
+        },
+      );
+
+      // RETURNS THE OPTIMAL ARROW FUNCTION
+      const functions = {
+        objects: (
+          config.generator.objects?.() ??
+          write_object_functions(config)(importer)
+        )(collection),
+        unions: (config.generator.unions?.() ?? write_union_functions(config))(
+          collection,
+        ),
+        arrays: config.generator.arrays()(collection),
+        tuples: config.generator.tuples()(collection),
+      };
+      const added: ts.Statement[] = (config.addition ?? (() => []))(collection);
+
+      return ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        parameterDeclarations(config)(config.types.input(type, name))(
+          ValueFactory.INPUT(),
+        ),
+        config.types.output(type, name),
+        undefined,
+        ts.factory.createBlock(
+          [
+            ...added,
+            ...functions.objects.filter((_, i) =>
+              importer.hasLocal(`${config.prefix}o${i}`),
+            ),
+            ...functions.unions.filter((_, i) =>
+              importer.hasLocal(`${config.prefix}u${i}`),
+            ),
+            ...functions.arrays.filter((_, i) =>
+              importer.hasLocal(`${config.prefix}a${i}`),
+            ),
+            ...functions.tuples.filter((_, i) =>
+              importer.hasLocal(`${config.prefix}t${i}`),
+            ),
+            ...(ts.isBlock(output)
+              ? output.statements
+              : [ts.factory.createReturnStatement(output)]),
+          ],
+          true,
+        ),
+      );
+    };
+
+  export const write_object_functions =
+    (config: IConfig) =>
+    (importer: FunctionImporter) =>
+    (collection: MetadataCollection) =>
+      collection
+        .objects()
+        .map((obj) =>
+          StatementFactory.constant(
+            `${config.prefix}o${obj.index}`,
+            ts.factory.createArrowFunction(
+              undefined,
+              undefined,
+              parameterDeclarations(config)(TypeFactory.keyword("any"))(
+                ValueFactory.INPUT(),
+              ),
+              config.objector.type ?? TypeFactory.keyword("any"),
+              undefined,
+              config.objector.joiner(
+                ts.factory.createIdentifier("input"),
+                feature_object_entries(config)(importer)(obj)(
+                  ts.factory.createIdentifier("input"),
+                ),
+                obj,
+              ),
+            ),
+          ),
+        );
+
+  export const write_union_functions =
+    (config: IConfig) => (collection: MetadataCollection) =>
+      collection
+        .unions()
+        .map((union, i) =>
+          StatementFactory.constant(
+            `${config.prefix}u${i}`,
+            write_union(config)(union),
+          ),
+        );
+
+  const write_union = (config: IConfig) => {
+    const explorer = UnionExplorer.object(config);
+    const input = ValueFactory.INPUT();
+
+    return (meta: MetadataObject[]) =>
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        parameterDeclarations(config)(TypeFactory.keyword("any"))(
+          ValueFactory.INPUT(),
+        ),
+        TypeFactory.keyword("any"),
+        undefined,
+        explorer(input, meta, {
+          tracable: config.path || config.trace,
+          source: "function",
+          from: "object",
+          postfix: "",
+        }),
+      );
+  };
+
+  /* -----------------------------------------------------------
+        DECODERS
+    ----------------------------------------------------------- */
+  export const decode_array =
+    (config: Pick<IConfig, "trace" | "path" | "decoder" | "prefix">) =>
+    (importer: FunctionImporter) =>
+    (
+      combiner: (
+        input: ts.Expression,
+        arrow: ts.ArrowFunction,
+      ) => ts.Expression,
+    ) => {
+      const rand: string = importer.increment().toString();
+      const tail =
+        config.path || config.trace
+          ? [
+              IdentifierFactory.parameter(
+                "_index" + rand,
+                TypeFactory.keyword("number"),
+              ),
+            ]
+          : [];
+
+      return (
+        input: ts.Expression,
+        array: MetadataArray,
+        explore: IExplore,
+      ) => {
+        const arrow: ts.ArrowFunction = ts.factory.createArrowFunction(
+          undefined,
+          undefined,
+          [
+            IdentifierFactory.parameter("elem", TypeFactory.keyword("any")),
+            ...tail,
+          ],
+          undefined,
+          undefined,
+          config.decoder()(ValueFactory.INPUT("elem"), array.type.value, {
+            tracable: explore.tracable,
+            source: explore.source,
+            from: "array",
+            postfix: index(explore.start ?? null)(explore.postfix)(rand),
+          }),
+        );
+        return combiner(input, arrow);
+      };
+    };
+
+  export const decode_object =
+    (config: Pick<IConfig, "trace" | "path" | "prefix">) =>
+    (importer: FunctionImporter) =>
+    (input: ts.Expression, obj: MetadataObject, explore: IExplore) =>
+      ts.factory.createCallExpression(
+        ts.factory.createIdentifier(
+          importer.useLocal(`${config.prefix}o${obj.index}`),
+        ),
+        undefined,
+        argumentsArray(config)(explore)(input),
+      );
+
+  /* -----------------------------------------------------------
+        UTILITIES FOR INTERNAL FUNCTIONS
+    ----------------------------------------------------------- */
+  export const index =
+    (start: number | null) => (prev: string) => (rand: string) => {
+      const tail: string =
+        start !== null
+          ? `"[" + (${start} + _index${rand}) + "]"`
+          : `"[" + _index${rand} + "]"`;
+      if (prev === "") return tail;
+      else if (prev[prev.length - 1] === `"`)
+        return prev.substring(0, prev.length - 1) + tail.substring(1);
+      return prev + ` + ${tail}`;
+    };
+
+  export const argumentsArray =
+    (config: Pick<IConfig, "path" | "trace">) =>
+    (explore: FeatureProgrammer.IExplore) => {
+      const tail: ts.Expression[] =
+        config.path === false && config.trace === false
+          ? []
+          : config.path === true && config.trace === true
+            ? [
+                ts.factory.createIdentifier(
+                  explore.postfix ? `_path + ${explore.postfix}` : "_path",
+                ),
+                explore.source === "function"
+                  ? ts.factory.createIdentifier(
+                      `${explore.tracable} && _exceptionable`,
+                    )
+                  : explore.tracable
+                    ? ts.factory.createTrue()
+                    : ts.factory.createFalse(),
+              ]
+            : config.path === true
+              ? [
+                  ts.factory.createIdentifier(
+                    explore.postfix ? `_path + ${explore.postfix}` : "_path",
+                  ),
+                ]
+              : [
+                  explore.source === "function"
+                    ? ts.factory.createIdentifier(
+                        `${explore.tracable} && _exceptionable`,
+                      )
+                    : explore.tracable
+                      ? ts.factory.createTrue()
+                      : ts.factory.createFalse(),
+                ];
+      return (input: ts.Expression) => [input, ...tail];
+    };
+
+  export const parameterDeclarations =
+    (props: Pick<CheckerProgrammer.IConfig, "path" | "trace">) =>
+    (type: ts.TypeNode) => {
+      const tail: ts.ParameterDeclaration[] = [];
+      if (props.path)
+        tail.push(
+          IdentifierFactory.parameter("_path", TypeFactory.keyword("string")),
+        );
+      if (props.trace)
+        tail.push(
+          IdentifierFactory.parameter(
+            "_exceptionable",
+            TypeFactory.keyword("boolean"),
+            ts.factory.createTrue(),
+          ),
+        );
+      return (input: ts.Identifier): ts.ParameterDeclaration[] => [
+        IdentifierFactory.parameter(input, type),
+        ...tail,
+      ];
+    };
+}