typia 4.0.0-dev.20230520 → 4.0.0-dev.20230603

package/src/programmers/StringifyProgrammer.ts

@@ -1,15 +1,19 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { ExpressionFactory } from "../factories/ExpressionFactory";
 import { IdentifierFactory } from "../factories/IdentifierFactory";
 import { MetadataCollection } from "../factories/MetadataCollection";
 import { MetadataFactory } from "../factories/MetadataFactory";
+import { StatementFactory } from "../factories/StatementFactory";
 import { TypeFactory } from "../factories/TypeFactory";
 import { ValueFactory } from "../factories/ValueFactory";
 
+import { IJsDocTagInfo } from "../metadata/IJsDocTagInfo";
 import { IMetadataTag } from "../metadata/IMetadataTag";
 import { Metadata } from "../metadata/Metadata";
+import { MetadataArray } from "../metadata/MetadataArray";
 import { MetadataObject } from "../metadata/MetadataObject";
+import { MetadataTuple } from "../metadata/MetadataTuple";
 
 import { IProject } from "../transformers/IProject";
 
@@ -29,53 +33,128 @@ import { UnionExplorer } from "./helpers/UnionExplorer";
 import { check_native } from "./internal/check_native";
 import { decode_union_object } from "./internal/decode_union_object";
 import { feature_object_entries } from "./internal/feature_object_entries";
+import { wrap_metadata_rest_tuple } from "./internal/wrap_metadata_rest_tuple";
 
 export namespace StringifyProgrammer {
     /* -----------------------------------------------------------
         WRITER
     ----------------------------------------------------------- */
+    /**
+     * @deprecated Use `write()` function instead
+     */
+    export const generate =
+        (project: IProject, modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string) =>
+            write(project)(modulo)(type, name);
+
     export const write =
-        (p: IProject) => (modulo: ts.LeftHandSideExpression) => {
-            const importer: FunctionImporter = new FunctionImporter(p.tsc);
-            return FeatureProgrammer.analyze(p)({
-                ...configure(p)(importer),
-                addition: (collection) => {
-                    const isFunctors =
-                        IsProgrammer.write_functors(p)(importer)(collection);
-                    const isUnioners =
-                        IsProgrammer.write_unioners(p)(importer)(collection);
-
-                    return [
-                        ...importer.declare(modulo),
-                        ...isFunctors.filter((_, i) =>
-                            importer.hasLocal(`$io${i}`),
-                        ),
-                        ...isUnioners.filter((_, i) =>
-                            importer.hasLocal(`$iu${i}`),
-                        ),
-                    ];
-                },
+        (project: IProject) => (modulo: ts.LeftHandSideExpression) => {
+            const importer: FunctionImporter = new FunctionImporter();
+            const config: FeatureProgrammer.IConfig =
+                configure(project)(importer);
+
+            return FeatureProgrammer.write(project)({
+                ...config,
+                addition: (collection) => [
+                    ...IsProgrammer.write_function_statements(project)(
+                        importer,
+                    )(collection),
+                    ...importer.declare(modulo),
+                ],
             })(importer);
         };
 
+    const write_array_functions =
+        (config: FeatureProgrammer.IConfig) =>
+        (importer: FunctionImporter) =>
+        (collection: MetadataCollection): ts.VariableStatement[] =>
+            collection
+                .arrays()
+                .filter((a) => a.recursive)
+                .map((array, i) =>
+                    StatementFactory.constant(
+                        `${config.prefix}a${i}`,
+                        ts.factory.createArrowFunction(
+                            undefined,
+                            undefined,
+                            FeatureProgrammer.parameterDeclarations(config)(
+                                TypeFactory.keyword("any"),
+                            )(ts.factory.createIdentifier("input")),
+                            TypeFactory.keyword("any"),
+                            undefined,
+                            decode_array_inline(config)(importer)(
+                                ts.factory.createIdentifier("input"),
+                                array,
+                                {
+                                    tracable: config.trace,
+                                    source: "function",
+                                    from: "array",
+                                    postfix: "",
+                                },
+                            ),
+                        ),
+                    ),
+                );
+
+    const write_tuple_functions =
+        (project: IProject) =>
+        (config: FeatureProgrammer.IConfig) =>
+        (importer: FunctionImporter) =>
+        (collection: MetadataCollection): ts.VariableStatement[] =>
+            collection
+                .tuples()
+                .filter((t) => t.recursive)
+                .map((tuple, i) =>
+                    StatementFactory.constant(
+                        `${config.prefix}t${i}`,
+                        ts.factory.createArrowFunction(
+                            undefined,
+                            undefined,
+                            FeatureProgrammer.parameterDeclarations(config)(
+                                TypeFactory.keyword("any"),
+                            )(ts.factory.createIdentifier("input")),
+                            TypeFactory.keyword("any"),
+                            undefined,
+                            decode_tuple_inline(project)(config)(importer)(
+                                ts.factory.createIdentifier("input"),
+                                tuple,
+                                {
+                                    tracable: config.trace,
+                                    source: "function",
+                                    from: "array",
+                                    postfix: "",
+                                },
+                            ),
+                        ),
+                    ),
+                );
+
     /* -----------------------------------------------------------
         DECODERS
     ----------------------------------------------------------- */
     const decode =
-        (p: IProject) =>
+        (project: IProject) =>
+        (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
             meta: Metadata,
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
         ): ts.Expression => {
             // ANY TYPE
             if (meta.any === true)
-                return wrap_required(p.tsc)(input, meta, explore)(
-                    wrap_functional(p.tsc)(input, meta, explore)(
-                        p.tsc.factory.createCallExpression(
-                            p.tsc.factory.createIdentifier("JSON.stringify"),
+                return wrap_required(
+                    input,
+                    meta,
+                    explore,
+                )(
+                    wrap_functional(
+                        input,
+                        meta,
+                        explore,
+                    )(
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("JSON.stringify"),
                             undefined,
                             [input],
                         ),
@@ -90,22 +169,22 @@ export namespace StringifyProgrammer {
             ) {
                 if (meta.required === false && meta.nullable === true)
                     return explore.from === "array"
-                        ? p.tsc.factory.createStringLiteral("null")
-                        : p.tsc.factory.createConditionalExpression(
-                              p.tsc.factory.createStrictEquality(
-                                  p.tsc.factory.createNull(),
+                        ? ts.factory.createStringLiteral("null")
+                        : ts.factory.createConditionalExpression(
+                              ts.factory.createStrictEquality(
+                                  ts.factory.createNull(),
                                   input,
                               ),
                               undefined,
-                              p.tsc.factory.createStringLiteral("null"),
+                              ts.factory.createStringLiteral("null"),
                               undefined,
-                              p.tsc.factory.createIdentifier("undefined"),
+                              ts.factory.createIdentifier("undefined"),
                           );
                 else if (meta.required === false)
                     return explore.from === "array"
-                        ? p.tsc.factory.createStringLiteral("null")
-                        : p.tsc.factory.createIdentifier("undefined");
-                else return p.tsc.factory.createStringLiteral("null");
+                        ? ts.factory.createStringLiteral("null")
+                        : ts.factory.createIdentifier("undefined");
+                else return ts.factory.createStringLiteral("null");
             }
 
             //----
@@ -116,30 +195,27 @@ export namespace StringifyProgrammer {
             // toJSON() METHOD
             if (meta.resolved !== null)
                 if (size === 1)
-                    return decode_to_json(p)(importer)(
+                    return decode_to_json(project)(config)(importer)(
                         input,
                         meta.resolved,
                         explore,
-                        tags,
                     );
                 else
                     unions.push({
                         type: "resolved",
-                        is: () =>
-                            IsProgrammer.decode_to_json(p.tsc)(false)(input),
+                        is: () => IsProgrammer.decode_to_json(false)(input),
                         value: () =>
-                            decode_to_json(p)(importer)(
+                            decode_to_json(project)(config)(importer)(
                                 input,
                                 meta.resolved!,
                                 explore,
-                                tags,
                             ),
                     });
             else if (meta.functional === true)
                 unions.push({
                     type: "functional",
-                    is: () => IsProgrammer.decode_functional(p.tsc)(input),
-                    value: () => decode_functional(p.tsc)(explore),
+                    is: () => IsProgrammer.decode_functional(input),
+                    value: () => decode_functional(explore),
                 });
 
             // TEMPLATES
@@ -153,7 +229,7 @@ export namespace StringifyProgrammer {
                         unions.push({
                             type: "template literal",
                             is: () =>
-                                IsProgrammer.decode(p)(importer)(
+                                IsProgrammer.decode(project)(importer)(
                                     input,
                                     partial,
                                     explore,
@@ -161,7 +237,7 @@ export namespace StringifyProgrammer {
                                     [],
                                 ),
                             value: () =>
-                                decode_atomic(p)(importer)(
+                                decode_atomic(project)(importer)(
                                     input,
                                     "string",
                                     explore,
@@ -177,7 +253,7 @@ export namespace StringifyProgrammer {
                     unions.push({
                         type: "atomic",
                         is: () =>
-                            IsProgrammer.decode(p)(importer)(
+                            IsProgrammer.decode(project)(importer)(
                                 input,
                                 (() => {
                                     const partial = Metadata.initialize();
@@ -189,7 +265,7 @@ export namespace StringifyProgrammer {
                                 [],
                             ),
                         value: () =>
-                            decode_atomic(p)(importer)(
+                            decode_atomic(project)(importer)(
                                 input,
                                 constant.type,
                                 explore,
@@ -199,7 +275,7 @@ export namespace StringifyProgrammer {
                     unions.push({
                         type: "const string",
                         is: () =>
-                            IsProgrammer.decode(p)(importer)(
+                            IsProgrammer.decode(project)(importer)(
                                 input,
                                 (() => {
                                     const partial = Metadata.initialize();
@@ -211,7 +287,7 @@ export namespace StringifyProgrammer {
                                 [],
                             ),
                         value: () =>
-                            decode_constant_string(p)(importer)(
+                            decode_constant_string(project)(importer)(
                                 input,
                                 [...constant.values] as string[],
                                 explore,
@@ -224,7 +300,7 @@ export namespace StringifyProgrammer {
                     unions.push({
                         type: "atomic",
                         is: () =>
-                            IsProgrammer.decode(p)(importer)(
+                            IsProgrammer.decode(project)(importer)(
                                 input,
                                 (() => {
                                     const partial = Metadata.initialize();
@@ -236,12 +312,16 @@ export namespace StringifyProgrammer {
                                 [],
                             ),
                         value: () =>
-                            decode_atomic(p)(importer)(input, type, explore),
+                            decode_atomic(project)(importer)(
+                                input,
+                                type,
+                                explore,
+                            ),
                     });
 
             // TUPLES
             for (const tuple of meta.tuples) {
-                for (const child of tuple)
+                for (const child of tuple.elements)
                     if (StringifyPredicator.undefindable(meta))
                         throw new Error(
                             `Error on typia.stringify(): tuple cannot contain undefined value - (${child.getName()}).`,
@@ -249,7 +329,7 @@ export namespace StringifyProgrammer {
                 unions.push({
                     type: "tuple",
                     is: () =>
-                        IsProgrammer.decode(p)(importer)(
+                        IsProgrammer.decode(project)(importer)(
                             input,
                             (() => {
                                 const partial = Metadata.initialize();
@@ -261,41 +341,52 @@ export namespace StringifyProgrammer {
                             [],
                         ),
                     value: () =>
-                        decode_tuple(p)(importer)(input, tuple, explore, tags),
+                        decode_tuple(project)(config)(importer)(
+                            input,
+                            tuple,
+                            explore,
+                        ),
                 });
             }
 
             // ARRAYS
             if (meta.arrays.length) {
                 for (const child of meta.arrays)
-                    if (StringifyPredicator.undefindable(child))
+                    if (StringifyPredicator.undefindable(child.value))
                         throw new Error(
-                            `Error on typia.stringify(): array cannot contain undefined value (${child.getName()}).`,
+                            `Error on typia.stringify(): array cannot contain undefined value (${child.value.getName()}).`,
                         );
-                const value: () => ts.Expression = meta.arrays.some(
-                    (elem) => elem.any,
-                )
-                    ? () =>
-                          p.tsc.factory.createCallExpression(
-                              p.tsc.factory.createIdentifier("JSON.stringify"),
-                              undefined,
-                              [input],
-                          )
-                    : () =>
-                          explore_arrays(p)(importer)(
-                              input,
-                              meta.arrays,
-                              {
-                                  ...explore,
-                                  from: "array",
-                              },
-                              [],
-                              [],
-                          );
+                const value: () => ts.Expression =
+                    meta.arrays.length === 1
+                        ? () =>
+                              decode_array(config)(importer)(
+                                  input,
+                                  meta.arrays[0]!,
+                                  {
+                                      ...explore,
+                                      from: "array",
+                                  },
+                              )
+                        : meta.arrays.some((elem) => elem.value.any)
+                        ? () =>
+                              ts.factory.createCallExpression(
+                                  ts.factory.createIdentifier("JSON.stringify"),
+                                  undefined,
+                                  [input],
+                              )
+                        : () =>
+                              explore_arrays(project)(config)(importer)(
+                                  input,
+                                  meta.arrays,
+                                  {
+                                      ...explore,
+                                      from: "array",
+                                  },
+                              );
 
                 unions.push({
                     type: "array",
-                    is: () => ExpressionFactory.isArray(p.tsc)(input),
+                    is: () => ExpressionFactory.isArray(input),
                     value,
                 });
             }
@@ -305,33 +396,31 @@ export namespace StringifyProgrammer {
                 for (const native of meta.natives)
                     unions.push({
                         type: "object",
-                        is: () => check_native(p.tsc)(native)(input),
+                        is: () => check_native(native)(input),
                         value: () =>
                             AtomicPredicator.native(native)
-                                ? decode_atomic(p)(importer)(
+                                ? decode_atomic(project)(importer)(
                                       input,
                                       native.toLowerCase() as Atomic.Literal,
                                       explore,
                                   )
-                                : p.tsc.factory.createStringLiteral("{}"),
+                                : ts.factory.createStringLiteral("{}"),
                     });
 
             // SETS
             if (meta.sets.length)
                 unions.push({
                     type: "object",
-                    is: () =>
-                        ExpressionFactory.isInstanceOf(p.tsc)("Set")(input),
-                    value: () => p.tsc.factory.createStringLiteral("{}"),
+                    is: () => ExpressionFactory.isInstanceOf("Set")(input),
+                    value: () => ts.factory.createStringLiteral("{}"),
                 });
 
             // MAPS
             if (meta.maps.length)
                 unions.push({
                     type: "object",
-                    is: () =>
-                        ExpressionFactory.isInstanceOf(p.tsc)("Map")(input),
-                    value: () => p.tsc.factory.createStringLiteral("{}"),
+                    is: () => ExpressionFactory.isInstanceOf("Map")(input),
+                    value: () => ts.factory.createStringLiteral("{}"),
                 });
 
             // OBJECTS
@@ -339,7 +428,7 @@ export namespace StringifyProgrammer {
                 unions.push({
                     type: "object",
                     is: () =>
-                        ExpressionFactory.isObject(p.tsc)({
+                        ExpressionFactory.isObject({
                             checkNull: true,
                             checkArray: meta.objects.some((obj) =>
                                 obj.properties.every(
@@ -356,18 +445,26 @@ export namespace StringifyProgrammer {
                             ? (() => {
                                   const obj: MetadataObject = meta.objects[0]!;
                                   const entries: IExpressionEntry<ts.Expression>[] =
-                                      feature_object_entries(
-                                          p.tsc,
-                                      )<ts.Expression>({
-                                          decoder: decode(p)(importer),
+                                      feature_object_entries({
+                                          decoder: () =>
+                                              decode(project)(config)(importer),
                                           trace: false,
                                           path: false,
-                                      })(importer)(obj)(input);
-                                  return StringifyJoiner.object(p.tsc)(
-                                      importer,
-                                  )(input, entries);
+                                      })(importer)(obj)(
+                                          ts.factory.createAsExpression(
+                                              input,
+                                              TypeFactory.keyword("any"),
+                                          ),
+                                      );
+                                  return StringifyJoiner.object(importer)(
+                                      ts.factory.createAsExpression(
+                                          input,
+                                          TypeFactory.keyword("any"),
+                                      ),
+                                      entries,
+                                  );
                               })()
-                            : explore_objects(p.tsc)(importer)(input, meta, {
+                            : explore_objects(config)(importer)(input, meta, {
                                   ...explore,
                                   from: "object",
                               }),
@@ -378,14 +475,16 @@ export namespace StringifyProgrammer {
             //----
             // CHECK NULL AND UNDEFINED
             const wrapper = (output: ts.Expression) =>
-                wrap_required(p.tsc)(input, meta, explore)(
-                    wrap_nullable(p.tsc)(input, meta)(output),
-                );
+                wrap_required(
+                    input,
+                    meta,
+                    explore,
+                )(wrap_nullable(input, meta)(output));
 
             // DIRECT RETURN
             if (unions.length === 0)
-                return p.tsc.factory.createCallExpression(
-                    p.tsc.factory.createIdentifier("JSON.stringify"),
+                return ts.factory.createCallExpression(
+                    ts.factory.createIdentifier("JSON.stringify"),
                     undefined,
                     [input],
                 );
@@ -393,14 +492,14 @@ export namespace StringifyProgrammer {
 
             // RETURN WITH TYPE CHECKING
             return wrapper(
-                p.tsc.factory.createCallExpression(
-                    p.tsc.factory.createArrowFunction(
+                ts.factory.createCallExpression(
+                    ts.factory.createArrowFunction(
                         undefined,
                         undefined,
                         [],
                         undefined,
                         undefined,
-                        iterate(p.tsc)(importer)(input, unions, meta.getName()),
+                        iterate(importer, input, unions, meta.getName()),
                     ),
                     undefined,
                     undefined,
@@ -408,76 +507,129 @@ export namespace StringifyProgrammer {
             );
         };
 
-    const decode_array = (p: IProject) => (importer: FunctionImporter) =>
-        FeatureProgrammer.decode_array(p.tsc)(configure(p)(importer))(importer)(
-            StringifyJoiner.array(p.tsc),
-        );
-
-    const decode_object = (tsc: typeof ts) => (importer: FunctionImporter) =>
-        FeatureProgrammer.decode_object(tsc)({
+    const decode_object = (importer: FunctionImporter) =>
+        FeatureProgrammer.decode_object({
             trace: false,
             path: false,
-            functors: FUNCTORS,
+            prefix: PREFIX,
         })(importer);
 
+    const decode_array =
+        (config: FeatureProgrammer.IConfig) =>
+        (importer: FunctionImporter) =>
+        (
+            input: ts.Expression,
+            array: MetadataArray,
+            explore: FeatureProgrammer.IExplore,
+        ) =>
+            array.recursive
+                ? ts.factory.createCallExpression(
+                      ts.factory.createIdentifier(
+                          importer.useLocal(`${config.prefix}a${array.index}`),
+                      ),
+                      undefined,
+                      FeatureProgrammer.argumentsArray(config)({
+                          ...explore,
+                          source: "function",
+                          from: "array",
+                      })(input),
+                  )
+                : decode_array_inline(config)(importer)(input, array, explore);
+
+    const decode_array_inline =
+        (config: FeatureProgrammer.IConfig) =>
+        (importer: FunctionImporter) =>
+        (
+            input: ts.Expression,
+            array: MetadataArray,
+            explore: FeatureProgrammer.IExplore,
+        ) =>
+            FeatureProgrammer.decode_array(config)(importer)(
+                StringifyJoiner.array,
+            )(input, array, explore, [], []);
+
     const decode_tuple =
-        (p: IProject) =>
+        (project: IProject) =>
+        (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
-            tuple: Metadata[],
+            tuple: MetadataTuple,
+            explore: FeatureProgrammer.IExplore,
+        ): ts.Expression =>
+            tuple.recursive
+                ? ts.factory.createCallExpression(
+                      ts.factory.createIdentifier(
+                          importer.useLocal(`${config.prefix}t${tuple.index}`),
+                      ),
+                      undefined,
+                      FeatureProgrammer.argumentsArray(config)({
+                          ...explore,
+                          source: "function",
+                      })(input),
+                  )
+                : decode_tuple_inline(project)(config)(importer)(
+                      input,
+                      tuple,
+                      explore,
+                  );
+
+    const decode_tuple_inline =
+        (project: IProject) =>
+        (config: FeatureProgrammer.IConfig) =>
+        (importer: FunctionImporter) =>
+        (
+            input: ts.Expression,
+            tuple: MetadataTuple,
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
         ): ts.Expression => {
-            const children: ts.Expression[] = tuple
+            const children: ts.Expression[] = tuple.elements
                 .filter((elem) => elem.rest === null)
                 .map((elem, index) =>
-                    decode(p)(importer)(
-                        p.tsc.factory.createElementAccessExpression(
-                            input,
-                            index,
-                        ),
+                    decode(project)(config)(importer)(
+                        ts.factory.createElementAccessExpression(input, index),
                         elem,
                         {
                             ...explore,
                             from: "array",
+                            postfix: explore.postfix.length
+                                ? `${explore.postfix.slice(0, -1)}[${index}]"`
+                                : `"[${index}]"`,
                         },
-                        tags,
                     ),
                 );
             const rest = (() => {
-                if (tuple.length === 0) return null;
-                const last = tuple[tuple.length - 1]!;
+                if (tuple.elements.length === 0) return null;
+                const last = tuple.elements.at(-1)!;
                 if (last.rest === null) return null;
 
-                const code = decode(p)(importer)(
-                    p.tsc.factory.createCallExpression(
-                        IdentifierFactory.access(p.tsc)(input)("slice"),
+                const code = decode(project)(config)(importer)(
+                    ts.factory.createCallExpression(
+                        IdentifierFactory.access(input)("slice"),
                         undefined,
-                        [p.tsc.factory.createNumericLiteral(tuple.length - 1)],
+                        [
+                            ts.factory.createNumericLiteral(
+                                tuple.elements.length - 1,
+                            ),
+                        ],
                     ),
-                    (() => {
-                        const wrapper: Metadata = Metadata.initialize();
-                        wrapper.arrays.push(tuple[tuple.length - 1]!.rest!);
-                        return wrapper;
-                    })(),
+                    wrap_metadata_rest_tuple(tuple.elements.at(-1)!.rest!),
                     {
                         ...explore,
-                        start: tuple.length - 1,
+                        start: tuple.elements.length - 1,
                     },
-                    tags,
                 );
-                return p.tsc.factory.createCallExpression(
+                return ts.factory.createCallExpression(
                     importer.use("rest"),
                     undefined,
                     [code],
                 );
             })();
-            return StringifyJoiner.tuple(p.tsc)(children, rest);
+            return StringifyJoiner.tuple(children, rest);
         };
 
     const decode_atomic =
-        (p: IProject) =>
+        (project: IProject) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
@@ -485,28 +637,32 @@ export namespace StringifyProgrammer {
             explore: FeatureProgrammer.IExplore,
         ) => {
             if (type === "string")
-                return p.tsc.factory.createCallExpression(
+                return ts.factory.createCallExpression(
                     importer.use("string"),
                     undefined,
                     [input],
                 );
-            else if (type === "number" && OptionPredicator.numeric(p.options))
-                input = p.tsc.factory.createCallExpression(
+            else if (
+                type === "number" &&
+                OptionPredicator.numeric(project.options)
+            )
+                input = ts.factory.createCallExpression(
                     importer.use("number"),
                     undefined,
                     [input],
                 );
+
             return explore.from !== "top"
                 ? input
-                : p.tsc.factory.createCallExpression(
-                      IdentifierFactory.access(p.tsc)(input)("toString"),
+                : ts.factory.createCallExpression(
+                      IdentifierFactory.access(input)("toString"),
                       undefined,
                       undefined,
                   );
         };
 
     const decode_constant_string =
-        (p: IProject) =>
+        (project: IProject) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
@@ -515,191 +671,281 @@ export namespace StringifyProgrammer {
         ): ts.Expression => {
             if (values.every((v) => !StringifyPredicator.require_escape(v)))
                 return [
-                    p.tsc.factory.createStringLiteral('"'),
+                    ts.factory.createStringLiteral('"'),
+                    input,
+                    ts.factory.createStringLiteral('"'),
+                ].reduce((x, y) => ts.factory.createAdd(x, y));
+            else
+                return decode_atomic(project)(importer)(
                     input,
-                    p.tsc.factory.createStringLiteral('"'),
-                ].reduce((x, y) => p.tsc.factory.createAdd(x, y));
-            else return decode_atomic(p)(importer)(input, "string", explore);
+                    "string",
+                    explore,
+                );
         };
 
     const decode_to_json =
-        (p: IProject) =>
+        (project: IProject) =>
+        (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
             resolved: Metadata,
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
         ): ts.Expression => {
-            return decode(p)(importer)(
-                p.tsc.factory.createCallExpression(
-                    IdentifierFactory.access(p.tsc)(input)("toJSON"),
+            return decode(project)(config)(importer)(
+                ts.factory.createCallExpression(
+                    IdentifierFactory.access(input)("toJSON"),
                     undefined,
                     [],
                 ),
                 resolved,
                 explore,
-                tags,
             );
         };
 
-    const decode_functional =
-        (tsc: typeof ts) => (explore: FeatureProgrammer.IExplore) =>
-            explore.from === "array"
-                ? tsc.factory.createStringLiteral("null")
-                : tsc.factory.createIdentifier("undefined");
+    const decode_functional = (explore: FeatureProgrammer.IExplore) =>
+        explore.from === "array"
+            ? ts.factory.createStringLiteral("null")
+            : ts.factory.createIdentifier("undefined");
 
     /* -----------------------------------------------------------
         EXPLORERS
     ----------------------------------------------------------- */
-    const explore_arrays = (p: IProject) => (importer: FunctionImporter) =>
-        UnionExplorer.array(p.tsc)({
-            checker: IsProgrammer.decode(p)(importer),
-            decoder: decode_array(p)(importer),
-            empty: p.tsc.factory.createStringLiteral("[]"),
-            success: p.tsc.factory.createTrue(),
-            failure: (input, expected) =>
-                create_throw_error(p.tsc)(importer, input, expected),
-        });
-
     const explore_objects =
-        (tsc: typeof ts) =>
+        (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
             meta: Metadata,
             explore: FeatureProgrammer.IExplore,
-        ) => {
-            if (meta.objects.length === 1)
-                return decode_object(tsc)(importer)(
-                    input,
-                    meta.objects[0]!,
-                    explore,
-                );
-
-            return tsc.factory.createCallExpression(
-                tsc.factory.createIdentifier(`${UNIONERS}${meta.union_index!}`),
-                undefined,
-                [input],
-            );
-        };
+        ) =>
+            meta.objects.length === 1
+                ? decode_object(importer)(input, meta.objects[0]!, explore)
+                : ts.factory.createCallExpression(
+                      ts.factory.createIdentifier(
+                          importer.useLocal(`${PREFIX}u${meta.union_index!}`),
+                      ),
+                      undefined,
+                      FeatureProgrammer.argumentsArray(config)(explore)(input),
+                  );
 
-    /* -----------------------------------------------------------
-        RETURN SCRIPTS
-    ----------------------------------------------------------- */
-    const wrap_required =
-        (tsc: typeof ts) =>
+    const explore_arrays =
+        (project: IProject) =>
+        (config: FeatureProgrammer.IConfig) =>
+        (importer: FunctionImporter) =>
         (
             input: ts.Expression,
-            meta: Metadata,
+            elements: MetadataArray[],
             explore: FeatureProgrammer.IExplore,
-        ): ((expression: ts.Expression) => ts.Expression) => {
-            if (meta.required === true && meta.any === false)
-                return (expression) => expression;
-            return (expression) =>
-                tsc.factory.createConditionalExpression(
-                    tsc.factory.createStrictInequality(
-                        tsc.factory.createIdentifier("undefined"),
-                        input,
-                    ),
-                    undefined,
-                    expression,
-                    undefined,
-                    explore.from === "array"
-                        ? tsc.factory.createStringLiteral("null")
-                        : tsc.factory.createIdentifier("undefined"),
-                );
-        };
-
-    const wrap_nullable =
-        (tsc: typeof ts) =>
+        ): ts.Expression =>
+            explore_array_like_union_types(config)(importer)(
+                UnionExplorer.array({
+                    checker: IsProgrammer.decode(project)(importer),
+                    decoder: decode_array(config)(importer),
+                    empty: ts.factory.createStringLiteral("[]"),
+                    success: ts.factory.createTrue(),
+                    failure: (input, expected) =>
+                        create_throw_error(importer)(expected)(input),
+                }),
+            )(input, elements, explore);
+
+    const explore_array_like_union_types =
+        (config: FeatureProgrammer.IConfig) =>
+        (importer: FunctionImporter) =>
+        <T extends MetadataArray | MetadataTuple>(
+            factory: (
+                parameters: ts.ParameterDeclaration[],
+            ) => (
+                input: ts.Expression,
+                elements: T[],
+                explore: FeatureProgrammer.IExplore,
+                tags: IMetadataTag[],
+                jsDocTags: IJsDocTagInfo[],
+            ) => ts.ArrowFunction,
+        ) =>
         (
             input: ts.Expression,
-            meta: Metadata,
-        ): ((expression: ts.Expression) => ts.Expression) => {
-            if (meta.nullable === false) return (expression) => expression;
-            return (expression) =>
-                tsc.factory.createConditionalExpression(
-                    tsc.factory.createStrictInequality(
-                        tsc.factory.createNull(),
-                        input,
-                    ),
-                    undefined,
-                    expression,
+            elements: T[],
+            explore: FeatureProgrammer.IExplore,
+        ): ts.Expression => {
+            const arrow =
+                (parameters: ts.ParameterDeclaration[]) =>
+                (explore: FeatureProgrammer.IExplore) =>
+                (input: ts.Expression): ts.ArrowFunction =>
+                    factory(parameters)(input, elements, explore, [], []);
+            if (elements.every((e) => e.recursive === false))
+                ts.factory.createCallExpression(
+                    arrow([])(explore)(input),
                     undefined,
-                    tsc.factory.createStringLiteral("null"),
+                    [],
                 );
-        };
 
-    const wrap_functional =
-        (tsc: typeof ts) =>
-        (
-            input: ts.Expression,
-            meta: Metadata,
-            explore: FeatureProgrammer.IExplore,
-        ): ((expression: ts.Expression) => ts.Expression) => {
-            if (meta.functional === false) return (expression) => expression;
-            return (expression) =>
-                tsc.factory.createConditionalExpression(
-                    tsc.factory.createStrictInequality(
-                        tsc.factory.createStringLiteral("function"),
-                        ValueFactory.TYPEOF(tsc)(input),
+            explore = {
+                ...explore,
+                source: "function",
+                from: "array",
+            };
+            return ts.factory.createCallExpression(
+                ts.factory.createIdentifier(
+                    importer.emplaceUnion(
+                        config.prefix,
+                        elements.map((e) => e.name).join(" | "),
+                        () =>
+                            arrow(
+                                FeatureProgrammer.parameterDeclarations(config)(
+                                    TypeFactory.keyword("any"),
+                                )(ts.factory.createIdentifier("input")),
+                            )({
+                                ...explore,
+                                postfix: "",
+                            })(ts.factory.createIdentifier("input")),
                     ),
-                    undefined,
-                    expression,
-                    undefined,
-                    decode_functional(tsc)(explore),
-                );
+                ),
+                undefined,
+                FeatureProgrammer.argumentsArray(config)(explore)(input),
+            );
         };
 
-    const iterate =
-        (tsc: typeof ts) =>
-        (importer: FunctionImporter) =>
-        (input: ts.Expression, unions: IUnion[], expected: string) =>
-            tsc.factory.createBlock(
-                [
-                    ...unions.map((u) =>
-                        tsc.factory.createIfStatement(
-                            u.is(),
-                            tsc.factory.createReturnStatement(u.value()),
-                        ),
-                    ),
-                    create_throw_error(tsc)(importer, input, expected),
-                ],
-                true,
+    /* -----------------------------------------------------------
+        RETURN SCRIPTS
+    ----------------------------------------------------------- */
+    const wrap_required = (
+        input: ts.Expression,
+        meta: Metadata,
+        explore: FeatureProgrammer.IExplore,
+    ): ((expression: ts.Expression) => ts.Expression) => {
+        if (meta.required === true && meta.any === false)
+            return (expression) => expression;
+        return (expression) =>
+            ts.factory.createConditionalExpression(
+                ts.factory.createStrictInequality(
+                    ts.factory.createIdentifier("undefined"),
+                    input,
+                ),
+                undefined,
+                expression,
+                undefined,
+                explore.from === "array"
+                    ? ts.factory.createStringLiteral("null")
+                    : ts.factory.createIdentifier("undefined"),
             );
+    };
+
+    const wrap_nullable = (
+        input: ts.Expression,
+        meta: Metadata,
+    ): ((expression: ts.Expression) => ts.Expression) => {
+        if (meta.nullable === false) return (expression) => expression;
+        return (expression) =>
+            ts.factory.createConditionalExpression(
+                ts.factory.createStrictInequality(
+                    ts.factory.createNull(),
+                    input,
+                ),
+                undefined,
+                expression,
+                undefined,
+                ts.factory.createStringLiteral("null"),
+            );
+    };
+
+    const wrap_functional = (
+        input: ts.Expression,
+        meta: Metadata,
+        explore: FeatureProgrammer.IExplore,
+    ): ((expression: ts.Expression) => ts.Expression) => {
+        if (meta.functional === false) return (expression) => expression;
+        return (expression) =>
+            ts.factory.createConditionalExpression(
+                ts.factory.createStrictInequality(
+                    ts.factory.createStringLiteral("function"),
+                    ValueFactory.TYPEOF(input),
+                ),
+                undefined,
+                expression,
+                undefined,
+                decode_functional(explore),
+            );
+    };
+
+    const iterate = (
+        importer: FunctionImporter,
+        input: ts.Expression,
+        unions: IUnion[],
+        expected: string,
+    ) =>
+        ts.factory.createBlock(
+            [
+                ...unions.map((u) =>
+                    ts.factory.createIfStatement(
+                        u.is(),
+                        ts.factory.createReturnStatement(u.value()),
+                    ),
+                ),
+                create_throw_error(importer)(expected)(input),
+            ],
+            true,
+        );
 
     /* -----------------------------------------------------------
         CONFIGURATIONS
     ----------------------------------------------------------- */
-    const FUNCTORS = "$so";
-    const UNIONERS = "$su";
+    const PREFIX = "$s";
 
     const configure =
-        (p: IProject) =>
-        (importer: FunctionImporter): FeatureProgrammer.IConfig => ({
-            types: {
-                input: (type, name) =>
-                    p.tsc.factory.createTypeReferenceNode(
-                        name ?? TypeFactory.getFullName(p)(type),
+        (project: IProject) =>
+        (importer: FunctionImporter): FeatureProgrammer.IConfig => {
+            const config: FeatureProgrammer.IConfig = {
+                types: {
+                    input: (type, name) =>
+                        ts.factory.createTypeReferenceNode(
+                            name ??
+                                TypeFactory.getFullName(project.checker)(type),
+                        ),
+                    output: () => TypeFactory.keyword("string"),
+                },
+                prefix: PREFIX,
+                trace: false,
+                path: false,
+                initializer,
+                decoder: () => decode(project)(config)(importer),
+                objector: {
+                    checker: () => (input, meta, explore) =>
+                        IsProgrammer.decode(project)(importer)(
+                            input,
+                            meta,
+                            explore,
+                            [],
+                            [],
+                        ),
+                    decoder: () => decode_object(importer),
+                    joiner: StringifyJoiner.object(importer),
+                    unionizer: decode_union_object(
+                        IsProgrammer.decode_object(importer),
+                    )(decode_object(importer))((exp) => exp)(
+                        (value, expected) =>
+                            create_throw_error(importer)(expected)(value),
                     ),
-                output: () => TypeFactory.keyword(p.tsc)("string"),
-            },
-            functors: FUNCTORS,
-            unioners: UNIONERS,
-            trace: false,
-            path: false,
-            initializer,
-            decoder: decode(p)(importer),
-            objector: OBJECTOR(p)(importer),
-        });
+                    failure: (input, expected) =>
+                        create_throw_error(importer)(expected)(input),
+                },
+                generator: {
+                    arrays: () => write_array_functions(config)(importer),
+                    tuples: () =>
+                        write_tuple_functions(project)(config)(importer),
+                },
+            };
+            return config;
+        };
 
     const initializer: FeatureProgrammer.IConfig["initializer"] =
-        (p) => (type) => {
+        ({ checker }) =>
+        (type) => {
             const collection: MetadataCollection = new MetadataCollection();
-            const meta: Metadata = MetadataFactory.analyze(p)({
+            const meta: Metadata = MetadataFactory.analyze(checker)({
                 resolve: true,
                 constant: true,
+                absorb: true,
                 validate: (meta) => {
                     if (meta.atomics.find((str) => str === "bigint"))
                         throw new Error(NO_BIGINT);
@@ -708,36 +954,22 @@ export namespace StringifyProgrammer {
             return [collection, meta];
         };
 
-    const OBJECTOR =
-        (p: IProject) =>
-        (importer: FunctionImporter): FeatureProgrammer.IConfig.IObjector => ({
-            checker: IsProgrammer.decode(p)(importer),
-            decoder: decode_object(p.tsc)(importer),
-            joiner: StringifyJoiner.object(p.tsc)(importer),
-            unionizer: decode_union_object(p.tsc)(
-                IsProgrammer.decode_object(p.tsc)(importer),
-            )(decode_object(p.tsc)(importer))((exp) => exp)((value, expected) =>
-                create_throw_error(p.tsc)(importer, value, expected),
-            ),
-            failure: (input, expected) =>
-                create_throw_error(p.tsc)(importer, input, expected),
-        });
-
     const create_throw_error =
-        (tsc: typeof ts) =>
-        (importer: FunctionImporter, value: ts.Expression, expected: string) =>
-            tsc.factory.createExpressionStatement(
-                tsc.factory.createCallExpression(
+        (importer: FunctionImporter) =>
+        (expected: string) =>
+        (value: ts.Expression) =>
+            ts.factory.createExpressionStatement(
+                ts.factory.createCallExpression(
                     importer.use("throws"),
                     [],
                     [
-                        tsc.factory.createObjectLiteralExpression(
+                        ts.factory.createObjectLiteralExpression(
                             [
-                                tsc.factory.createPropertyAssignment(
+                                ts.factory.createPropertyAssignment(
                                     "expected",
-                                    tsc.factory.createStringLiteral(expected),
+                                    ts.factory.createStringLiteral(expected),
                                 ),
-                                tsc.factory.createPropertyAssignment(
+                                ts.factory.createPropertyAssignment(
                                     "value",
                                     value,
                                 ),