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

package/src/programmers/CheckerProgrammer.ts

@@ -1,16 +1,19 @@
-import { JSDocTagInfo } from "typescript";
-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";
 
@@ -28,19 +31,18 @@ import { check_native } from "./internal/check_native";
 import { check_number } from "./internal/check_number";
 import { check_string } from "./internal/check_string";
 import { check_template } from "./internal/check_template";
-import { check_union_tuple } from "./internal/check_union_tuple";
 import { decode_union_object } from "./internal/decode_union_object";
+import { wrap_metadata_rest_tuple } from "./internal/wrap_metadata_rest_tuple";
 
 export namespace CheckerProgrammer {
     export interface IConfig {
-        functors: string;
-        unioners: string;
+        prefix: string;
         path: boolean;
         trace: boolean;
         equals: boolean;
         numeric: boolean;
         addition?: () => ts.Statement[];
-        decoder?: FeatureProgrammer.Decoder<Metadata, ts.Expression>;
+        decoder?: () => FeatureProgrammer.Decoder<Metadata, ts.Expression>;
         combiner: IConfig.Combiner;
         atomist: (
             explore: IExplore,
@@ -98,107 +100,192 @@ export namespace CheckerProgrammer {
         (project: IProject) =>
         (config: IConfig) =>
         (importer: FunctionImporter) =>
-            FeatureProgrammer.analyze(project)(
+            FeatureProgrammer.write(project)(
                 configure(project)(config)(importer),
             )(importer);
 
-    export const write_functors =
-        (p: IProject) => (config: IConfig) => (importer: FunctionImporter) =>
-            FeatureProgrammer.write_functors(p.tsc)(
-                configure(p)(config)(importer),
+    export const write_object_functions =
+        (project: IProject) =>
+        (config: IConfig) =>
+        (importer: FunctionImporter) =>
+            FeatureProgrammer.write_object_functions(
+                configure(project)(config)(importer),
             )(importer);
 
-    export const write_unioners = (
-        p: IProject,
-        config: IConfig,
-        importer: FunctionImporter,
-    ) =>
-        FeatureProgrammer.write_unioners(p.tsc)(
-            configure(p)({ ...config, numeric: false })(importer),
-        )(importer);
+    export const write_union_functions =
+        (project: IProject) =>
+        (config: IConfig) =>
+        (importer: FunctionImporter) =>
+            FeatureProgrammer.write_union_functions(
+                configure(project)({ ...config, numeric: false })(importer),
+            );
 
-    const configure =
-        (p: IProject) =>
+    export const write_array_functions =
+        (project: IProject) =>
         (config: IConfig) =>
-        (importer: FunctionImporter): FeatureProgrammer.IConfig => {
-            const output: FeatureProgrammer.IConfig = {
-                types: {
-                    input: () => TypeFactory.keyword(p.tsc)("any"),
-                    output: (type, name) =>
-                        p.tsc.factory.createTypePredicateNode(
+        (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,
-                            "input",
-                            p.tsc.factory.createTypeReferenceNode(
-                                name ?? TypeFactory.getFullName(p)(type),
+                            FeatureProgrammer.parameterDeclarations(config)(
+                                TypeFactory.keyword("any"),
+                            )(ts.factory.createIdentifier("input")),
+                            TypeFactory.keyword("any"),
+                            undefined,
+                            decode_array_inline(project)(config)(importer)(
+                                ts.factory.createIdentifier("input"),
+                                array,
+                                {
+                                    tracable: config.trace,
+                                    source: "function",
+                                    from: "array",
+                                    postfix: "",
+                                },
+                                [],
+                                [],
                             ),
                         ),
-                },
-                trace: config.trace,
-                path: config.path,
-                functors: config.functors,
-                unioners: config.unioners,
-                initializer: (p) => (type) => {
+                    ),
+                );
+
+    export const write_tuple_functions =
+        (project: IProject) =>
+        (config: 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: "",
+                                },
+                                [],
+                                [],
+                            ),
+                        ),
+                    ),
+                );
+
+    const configure =
+        (project: IProject) =>
+        (config: IConfig) =>
+        (importer: FunctionImporter): FeatureProgrammer.IConfig => ({
+            types: {
+                input: () => TypeFactory.keyword("any"),
+                output: (type, name) =>
+                    ts.factory.createTypePredicateNode(
+                        undefined,
+                        "input",
+                        ts.factory.createTypeReferenceNode(
+                            name ??
+                                TypeFactory.getFullName(project.checker)(type),
+                        ),
+                    ),
+            },
+            trace: config.trace,
+            path: config.path,
+            prefix: config.prefix,
+            initializer:
+                ({ checker }) =>
+                (type) => {
                     const collection: MetadataCollection =
                         new MetadataCollection();
-                    const meta: Metadata = MetadataFactory.analyze(p)({
+                    const meta: Metadata = MetadataFactory.analyze(checker)({
                         resolve: false,
                         constant: true,
+                        absorb: true,
+                        validate: (meta) => {
+                            if (
+                                meta.arrays.length > 1 &&
+                                meta.arrays.some((a) => a.recursive)
+                            )
+                                throw new Error(
+                                    `Repeated union array types are not supported yet.`,
+                                );
+                        },
                     })(collection)(type);
                     return [collection, meta];
                 },
-                addition: config.addition,
-                decoder: config.decoder ?? decode(p)(config)(importer),
-                objector: {
-                    checker: config.decoder ?? decode(p)(config)(importer),
-                    decoder: decode_object(p.tsc)(config)(importer),
-                    joiner: config.joiner.object,
-                    unionizer: config.equals
-                        ? decode_union_object(p.tsc)(
-                              decode_object(p.tsc)(config)(importer),
-                          )((input, obj, explore) =>
-                              decode_object(p.tsc)(config)(importer)(
-                                  input,
-                                  obj,
-                                  {
-                                      ...explore,
-                                      tracable: true,
-                                  },
+            addition: config.addition,
+            decoder: () =>
+                config.decoder?.() ?? decode(project)(config)(importer),
+            objector: {
+                checker: () =>
+                    config.decoder?.() ?? decode(project)(config)(importer),
+                decoder: () => decode_object(config)(importer),
+                joiner: config.joiner.object,
+                unionizer: config.equals
+                    ? decode_union_object(decode_object(config)(importer))(
+                          (input, obj, explore) =>
+                              decode_object(config)(importer)(input, obj, {
+                                  ...explore,
+                                  tracable: true,
+                              }),
+                      )(config.joiner.is ?? ((expr) => expr))(
+                          (value, expected) =>
+                              ts.factory.createReturnStatement(
+                                  config.joiner.failure(value, expected),
                               ),
-                          )(config.joiner.is ?? ((expr) => expr))(
-                              (value, expected) =>
-                                  p.tsc.factory.createReturnStatement(
-                                      config.joiner.failure(value, expected),
+                      )
+                    : (input, targets, explore) =>
+                          config.combiner(explore)("or")(
+                              input,
+                              targets.map((obj) => ({
+                                  expression: decode_object(config)(importer)(
+                                      input,
+                                      obj,
+                                      explore,
                                   ),
-                          )
-                        : (input, targets, explore) =>
-                              config.combiner(explore)("or")(
-                                  input,
-                                  targets.map((obj) => ({
-                                      expression: decode_object(p.tsc)(config)(
-                                          importer,
-                                      )(input, obj, explore),
-                                      combined: true,
-                                  })),
-                                  `(${targets.map((t) => t.name).join(" | ")})`,
+                                  combined: true,
+                              })),
+                              `(${targets.map((t) => t.name).join(" | ")})`,
+                          ),
+                failure: (value, expected) =>
+                    ts.factory.createReturnStatement(
+                        config.joiner.failure(value, expected),
+                    ),
+                is: config.joiner.is,
+                required: config.joiner.required,
+                full: config.joiner.full,
+                type: TypeFactory.keyword("boolean"),
+            },
+            generator: {
+                unions: config.numeric
+                    ? () =>
+                          FeatureProgrammer.write_union_functions(
+                              configure(project)({ ...config, numeric: false })(
+                                  importer,
                               ),
-                    failure: (value, expected) =>
-                        p.tsc.factory.createReturnStatement(
-                            config.joiner.failure(value, expected),
-                        ),
-                    is: config.joiner.is,
-                    required: config.joiner.required,
-                    full: config.joiner.full,
-                    type: TypeFactory.keyword(p.tsc)("boolean"),
-                },
-            };
-            if (config.numeric === true)
-                output.generator = {
-                    unioners: FeatureProgrammer.write_unioners(p.tsc)(
-                        configure(p)({ ...config, numeric: false })(importer),
-                    )(importer),
-                };
-            return output;
-        };
+                          )
+                    : undefined,
+                arrays: () => write_array_functions(project)(config)(importer),
+                tuples: () => write_tuple_functions(project)(config)(importer),
+            },
+        });
 
     /* -----------------------------------------------------------
         DECODERS
@@ -207,7 +294,7 @@ export namespace CheckerProgrammer {
      * @internal
      */
     export const decode =
-        (p: IProject) =>
+        (project: IProject) =>
         (config: IConfig) =>
         (importer: FunctionImporter) =>
         (
@@ -215,19 +302,19 @@ export namespace CheckerProgrammer {
             meta: Metadata,
             explore: IExplore,
             metaTags: IMetadataTag[],
-            jsDocTags: JSDocTagInfo[],
+            jsDocTags: ts.JSDocTagInfo[],
         ): ts.Expression => {
             if (meta.any) return config.success;
 
             const top: IBinary[] = [];
             const binaries: IBinary[] = [];
-            const add = create_add(p.tsc)(binaries)(input);
+            const add = create_add(binaries)(input);
             const getConstantValue = (
                 value: number | string | bigint | boolean,
             ) =>
                 typeof value === "string"
-                    ? p.tsc.factory.createStringLiteral(value)
-                    : p.tsc.factory.createIdentifier(value.toString());
+                    ? ts.factory.createStringLiteral(value)
+                    : ts.factory.createIdentifier(value.toString());
 
             //----
             // CHECK OPTIONAL
@@ -236,30 +323,29 @@ export namespace CheckerProgrammer {
             const checkOptional: boolean = meta.empty() || meta.isUnionBucket();
 
             // NULLABLE
-            if (
-                checkOptional ||
-                meta.nullable
-                // || (meta.objects.length && meta.size() !== meta.objects.length)
-            )
-                (meta.nullable ? add : create_add(p.tsc)(top)(input))(
+            if (checkOptional || meta.nullable)
+                (meta.nullable ? add : create_add(top)(input))(
                     meta.nullable,
-                    ValueFactory.NULL(p.tsc),
+                    ValueFactory.NULL(),
                 );
 
             // UNDEFINDABLE
             if (checkOptional || !meta.required)
-                (meta.required ? create_add(p.tsc)(top)(input) : add)(
+                (meta.required ? create_add(top)(input) : add)(
                     !meta.required,
-                    ValueFactory.UNDEFINED(p.tsc),
+                    ValueFactory.UNDEFINED(),
                 );
 
             // FUNCTIONAL
             if (meta.functional === true)
-                if (OptionPredicator.functional(p.options) || meta.size() !== 1)
+                if (
+                    OptionPredicator.functional(project.options) ||
+                    meta.size() !== 1
+                )
                     add(
                         true,
-                        p.tsc.factory.createStringLiteral("function"),
-                        ValueFactory.TYPEOF(p.tsc)(input),
+                        ts.factory.createStringLiteral("function"),
+                        ValueFactory.TYPEOF(input),
                     );
                 else
                     binaries.push({
@@ -282,35 +368,31 @@ export namespace CheckerProgrammer {
                 else if (type === "number")
                     binaries.push({
                         expression: config.atomist(explore)(
-                            check_number(p, config.numeric)(importer)(metaTags)(
-                                jsDocTags,
-                            )(input),
+                            check_number(project, config.numeric)(importer)(
+                                metaTags,
+                            )(jsDocTags)(input),
                         )(input),
                         combined: false,
                     });
                 else if (type === "bigint")
                     binaries.push({
                         expression: config.atomist(explore)(
-                            check_bigint(p.tsc)(importer)(metaTags)(jsDocTags)(
-                                input,
-                            ),
+                            check_bigint(importer)(metaTags)(jsDocTags)(input),
                         )(input),
                         combined: false,
                     });
                 else if (type === "string")
                     binaries.push({
                         expression: config.atomist(explore)(
-                            check_string(p.tsc)(importer)(metaTags)(jsDocTags)(
-                                input,
-                            ),
+                            check_string(importer)(metaTags)(jsDocTags)(input),
                         )(input),
                         combined: false,
                     });
                 else
                     add(
                         true,
-                        p.tsc.factory.createStringLiteral(type),
-                        ValueFactory.TYPEOF(p.tsc)(input),
+                        ts.factory.createStringLiteral(type),
+                        ValueFactory.TYPEOF(input),
                     );
 
             // TEMPLATE LITERAL VALUES
@@ -318,9 +400,9 @@ export namespace CheckerProgrammer {
                 if (AtomicPredicator.template(meta))
                     binaries.push({
                         expression: config.atomist(explore)(
-                            check_template(p.tsc)(importer)(metaTags)(
-                                jsDocTags,
-                            )(meta.templates)(input),
+                            check_template(importer)(metaTags)(jsDocTags)(
+                                meta.templates,
+                            )(input),
                         )(input),
                         combined: false,
                     });
@@ -328,7 +410,7 @@ export namespace CheckerProgrammer {
             // NATIVE CLASSES
             for (const native of meta.natives)
                 binaries.push({
-                    expression: check_native(p.tsc)(native)(input),
+                    expression: check_native(native)(input),
                     combined: false,
                 });
 
@@ -353,7 +435,7 @@ export namespace CheckerProgrammer {
             // SETS
             if (meta.sets.length) {
                 const install = prepare(
-                    check_native(p.tsc)("Set")(input),
+                    check_native("Set")(input),
                     meta.sets
                         .map((elem) => `Set<${elem.getName()}>`)
                         .join(" | "),
@@ -361,7 +443,7 @@ export namespace CheckerProgrammer {
                 if (meta.sets.some((elem) => elem.any)) install(null);
                 else
                     install(
-                        explore_sets(p)(config)(importer)(
+                        explore_sets(project)(config)(importer)(
                             input,
                             meta.sets,
                             {
@@ -377,7 +459,7 @@ export namespace CheckerProgrammer {
             // MAPS
             if (meta.maps.length) {
                 const install = prepare(
-                    check_native(p.tsc)("Map")(input),
+                    check_native("Map")(input),
                     meta.maps
                         .map(({ key, value }) => `Map<${key}, ${value}>`)
                         .join(" | "),
@@ -386,9 +468,9 @@ export namespace CheckerProgrammer {
                     install(null);
                 else
                     install(
-                        explore_maps(p)(config)(importer)(
+                        explore_maps(project)(config)(importer)(
                             input,
-                            meta.maps.map((m) => [m.key, m.value]),
+                            meta.maps,
                             {
                                 ...explore,
                                 from: "array",
@@ -403,51 +485,75 @@ export namespace CheckerProgrammer {
             if (meta.tuples.length + meta.arrays.length > 0) {
                 const install = prepare(
                     config.atomist(explore)(
-                        check_array(p.tsc)(importer)(
+                        check_array(importer)(
                             meta.tuples.length === 0 ? metaTags : [],
                         )(jsDocTags)(input),
                     )(input),
                     [...meta.tuples, ...meta.arrays]
-                        .map((elem) =>
-                            Array.isArray(elem)
-                                ? `[${elem
-                                      .map((elem) => elem.getName())
-                                      .join(", ")}]`
-                                : `Array<${elem.getName()}>`,
-                        )
+                        .map((elem) => elem.name)
                         .join(" | "),
                 );
                 if (meta.arrays.length === 0)
-                    install(
-                        explore_tuples(p)(config)(importer)(
-                            input,
-                            meta.tuples,
-                            {
-                                ...explore,
-                                from: "array",
-                            },
-                            metaTags,
-                            jsDocTags,
-                        ),
-                    );
-                else if (meta.arrays.some((elem) => elem.any)) install(null);
+                    if (meta.tuples.length === 1)
+                        install(
+                            decode_tuple(project)(config)(importer)(
+                                input,
+                                meta.tuples[0]!,
+                                {
+                                    ...explore,
+                                    from: "array",
+                                },
+                                metaTags,
+                                jsDocTags,
+                            ),
+                        );
+                    // TUPLE ONLY
+                    else
+                        install(
+                            explore_tuples(project)(config)(importer)(
+                                input,
+                                meta.tuples,
+                                {
+                                    ...explore,
+                                    from: "array",
+                                },
+                                metaTags,
+                                jsDocTags,
+                            ),
+                        );
+                else if (meta.arrays.some((elem) => elem.value.any))
+                    install(null);
                 else if (meta.tuples.length === 0)
-                    // ARRAY ONLY
-                    install(
-                        explore_arrays(p)(config)(importer)(
-                            input,
-                            meta.arrays,
-                            {
-                                ...explore,
-                                from: "array",
-                            },
-                            metaTags,
-                            jsDocTags,
-                        ),
-                    );
+                    if (meta.arrays.length === 1)
+                        // ARRAY ONLY
+                        install(
+                            decode_array(project)(config)(importer)(
+                                input,
+                                meta.arrays[0]!,
+                                {
+                                    ...explore,
+                                    from: "array",
+                                },
+                                metaTags,
+                                jsDocTags,
+                            ),
+                        );
+                    else
+                        install(
+                            explore_arrays(project)(config)(importer)(
+                                input,
+                                meta.arrays,
+                                {
+                                    ...explore,
+                                    from: "array",
+                                },
+                                metaTags,
+                                jsDocTags,
+                            ),
+                        );
                 else
                     install(
-                        explore_arrays_and_tuples(p)(config)(importer)(
+                        explore_arrays_and_tuples(project)(config)(importer)(
                             input,
                             [...meta.tuples, ...meta.arrays],
                             explore,
@@ -460,7 +566,7 @@ export namespace CheckerProgrammer {
             // OBJECT
             if (meta.objects.length > 0)
                 prepare(
-                    ExpressionFactory.isObject(p.tsc)({
+                    ExpressionFactory.isObject({
                         checkNull: true,
                         checkArray: meta.objects.some((obj) =>
                             obj.properties.every(
@@ -472,7 +578,7 @@ export namespace CheckerProgrammer {
                     })(input),
                     meta.objects.map((obj) => obj.name).join(" | "),
                 )(
-                    explore_objects(p.tsc)(config)(importer)(input, meta, {
+                    explore_objects(config)(importer)(input, meta, {
                         ...explore,
                         from: "object",
                     }),
@@ -514,7 +620,7 @@ export namespace CheckerProgrammer {
                         expression: config.combiner(explore)("or")(
                             input,
                             instances.map(
-                                transformer(p.tsc.factory.createLogicalAnd),
+                                transformer(ts.factory.createLogicalAnd),
                             ),
                             meta.getName(),
                         ),
@@ -550,83 +656,179 @@ export namespace CheckerProgrammer {
                 : config.success;
         };
 
-    export const decode_tuple =
-        (p: IProject) =>
+    export const decode_object =
+        (config: IConfig) => (importer: FunctionImporter) => {
+            const func = FeatureProgrammer.decode_object(config)(importer);
+            return (
+                input: ts.Expression,
+                obj: MetadataObject,
+                explore: IExplore,
+            ) => {
+                obj.validated = true;
+                return func(input, obj, explore);
+            };
+        };
+
+    const decode_array =
+        (project: IProject) =>
+        (config: IConfig) =>
+        (importer: FunctionImporter) =>
+        (
+            input: ts.Expression,
+            array: MetadataArray,
+            explore: IExplore,
+            metaTags: IMetadataTag[],
+            jsDocTags: IJsDocTagInfo[],
+        ) => {
+            if (array.recursive === false)
+                return decode_array_inline(project)(config)(importer)(
+                    input,
+                    array,
+                    explore,
+                    metaTags,
+                    jsDocTags,
+                );
+
+            explore = {
+                ...explore,
+                source: "function",
+                from: "array",
+            };
+            return ts.factory.createLogicalOr(
+                ts.factory.createCallExpression(
+                    ts.factory.createIdentifier(
+                        importer.useLocal(`${config.prefix}a${array.index}`),
+                    ),
+                    undefined,
+                    FeatureProgrammer.argumentsArray(config)({
+                        ...explore,
+                        source: "function",
+                        from: "array",
+                    })(input),
+                ),
+                config.joiner.failure(input, array.name, explore),
+            );
+        };
+
+    const decode_array_inline =
+        (project: IProject) =>
+        (config: IConfig) =>
+        (importer: FunctionImporter) =>
+            FeatureProgrammer.decode_array({
+                prefix: config.prefix,
+                trace: config.trace,
+                path: config.path,
+                decoder: () => decode(project)(config)(importer),
+            })(importer)(config.joiner.array);
+
+    const decode_tuple =
+        (project: IProject) =>
         (config: IConfig) =>
         (importer: FunctionImporter) =>
-        (checkLength: boolean) =>
         (
             input: ts.Expression,
-            tuple: Array<Metadata>,
+            tuple: MetadataTuple,
             explore: IExplore,
             tagList: IMetadataTag[],
-            jsDocTags: JSDocTagInfo[],
+            jsDocTags: ts.JSDocTagInfo[],
         ): ts.Expression => {
-            const binaries: ts.Expression[] = tuple
+            if (tuple.recursive === false)
+                return decode_tuple_inline(project)(config)(importer)(
+                    input,
+                    tuple,
+                    explore,
+                    tagList,
+                    jsDocTags,
+                );
+            explore = {
+                ...explore,
+                source: "function",
+                from: "array",
+            };
+            return ts.factory.createLogicalOr(
+                ts.factory.createCallExpression(
+                    ts.factory.createIdentifier(
+                        importer.useLocal(`${config.prefix}t${tuple.index}`),
+                    ),
+                    undefined,
+                    FeatureProgrammer.argumentsArray(config)({
+                        ...explore,
+                        source: "function",
+                    })(input),
+                ),
+                config.joiner.failure(input, tuple.name, explore),
+            );
+        };
+
+    const decode_tuple_inline =
+        (project: IProject) =>
+        (config: IConfig) =>
+        (importer: FunctionImporter) =>
+        (
+            input: ts.Expression,
+            tuple: MetadataTuple,
+            explore: IExplore,
+            tagList: IMetadataTag[],
+            jsDocTags: ts.JSDocTagInfo[],
+        ): ts.Expression => {
+            const binaries: ts.Expression[] = tuple.elements
                 .filter((meta) => meta.rest === null)
                 .map((meta, index) =>
-                    decode(p)(config)(importer)(
-                        p.tsc.factory.createElementAccessExpression(
-                            input,
-                            index,
-                        ),
+                    decode(project)(config)(importer)(
+                        ts.factory.createElementAccessExpression(input, index),
                         meta,
                         {
                             ...explore,
                             from: "array",
                             postfix: explore.postfix.length
                                 ? `${explore.postfix.slice(0, -1)}[${index}]"`
-                                : `[${index}]`,
+                                : `"[${index}]"`,
                         },
                         tagList,
                         jsDocTags,
                     ),
                 );
             const rest: ts.Expression | null =
-                tuple.length && tuple[tuple.length - 1]!.rest !== null
-                    ? decode(p)(config)(importer)(
-                          p.tsc.factory.createCallExpression(
-                              IdentifierFactory.access(p.tsc)(input)("slice"),
+                tuple.elements.length && tuple.elements.at(-1)!.rest !== null
+                    ? 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,
                           },
                           tagList,
                           jsDocTags,
                       )
                     : null;
 
-            const arrayLength = p.tsc.factory.createPropertyAccessExpression(
+            const arrayLength = ts.factory.createPropertyAccessExpression(
                 input,
                 "length",
             );
             return config.combiner(explore)("and")(
                 input,
                 [
-                    ...(checkLength && rest === null
-                        ? tuple.every((t) => t.optional === false)
+                    ...(rest === null
+                        ? tuple.elements.every((t) => t.optional === false)
                             ? [
                                   {
                                       combined: false,
                                       expression:
-                                          p.tsc.factory.createStrictEquality(
+                                          ts.factory.createStrictEquality(
                                               arrayLength,
-                                              p.tsc.factory.createNumericLiteral(
-                                                  tuple.length,
+                                              ts.factory.createNumericLiteral(
+                                                  tuple.elements.length,
                                               ),
                                           ),
                                   },
@@ -634,25 +836,23 @@ export namespace CheckerProgrammer {
                             : [
                                   {
                                       combined: false,
-                                      expression:
-                                          p.tsc.factory.createLogicalAnd(
-                                              p.tsc.factory.createLessThanEquals(
-                                                  p.tsc.factory.createNumericLiteral(
-                                                      tuple.filter(
-                                                          (t) =>
-                                                              t.optional ===
-                                                              false,
-                                                      ).length,
-                                                  ),
-                                                  arrayLength,
+                                      expression: ts.factory.createLogicalAnd(
+                                          ts.factory.createLessThanEquals(
+                                              ts.factory.createNumericLiteral(
+                                                  tuple.elements.filter(
+                                                      (t) =>
+                                                          t.optional === false,
+                                                  ).length,
                                               ),
-                                              p.tsc.factory.createGreaterThanEquals(
-                                                  p.tsc.factory.createNumericLiteral(
-                                                      tuple.length,
-                                                  ),
-                                                  arrayLength,
+                                              arrayLength,
+                                          ),
+                                          ts.factory.createGreaterThanEquals(
+                                              ts.factory.createNumericLiteral(
+                                                  tuple.elements.length,
                                               ),
+                                              arrayLength,
                                           ),
+                                      ),
                                   },
                               ]
                         : []),
@@ -676,210 +876,295 @@ export namespace CheckerProgrammer {
                           ]
                         : []),
                 ],
-                `[${tuple.map((t) => t.getName()).join(", ")}]`,
+                `[${tuple.elements.map((t) => t.getName()).join(", ")}]`,
             );
         };
 
-    const decode_array =
-        (p: IProject) => (config: IConfig) => (importer: FunctionImporter) =>
-            FeatureProgrammer.decode_array(p.tsc)({
-                trace: config.trace,
-                path: config.path,
-                decoder: decode(p)(config)(importer),
-            })(importer)(config.joiner.array);
-
-    export const decode_object =
-        (tsc: typeof ts) =>
-        (config: IConfig) =>
-        (importer: FunctionImporter) => {
-            const func = FeatureProgrammer.decode_object(tsc)(config)(importer);
-            return (
-                input: ts.Expression,
-                obj: MetadataObject,
-                explore: IExplore,
-            ) => {
-                obj.validated = true;
-                return func(input, obj, explore);
-            };
-        };
-
+    /* -----------------------------------------------------------
+        UNION TYPE EXPLORERS
+    ----------------------------------------------------------- */
     const explore_sets =
-        (p: IProject) => (config: IConfig) => (importer: FunctionImporter) =>
-            UnionExplorer.set(p.tsc)({
-                checker: decode(p)(config)(importer),
-                decoder: decode_array(p)(config)(importer),
-                empty: config.success,
-                success: config.success,
-                failure: (input, expected, explore) =>
-                    p.tsc.factory.createReturnStatement(
-                        config.joiner.failure(input, expected, explore),
-                    ),
-            });
+        (project: IProject) =>
+        (config: IConfig) =>
+        (importer: FunctionImporter) =>
+        (
+            input: ts.Expression,
+            sets: Metadata[],
+            explore: IExplore,
+            tags: IMetadataTag[],
+            jsDocTags: IJsDocTagInfo[],
+        ): ts.Expression =>
+            ts.factory.createCallExpression(
+                UnionExplorer.set({
+                    checker: decode(project)(config)(importer),
+                    decoder: decode_array(project)(config)(importer),
+                    empty: config.success,
+                    success: config.success,
+                    failure: (input, expected, explore) =>
+                        ts.factory.createReturnStatement(
+                            config.joiner.failure(input, expected, explore),
+                        ),
+                })([])(input, sets, explore, tags, jsDocTags),
+                undefined,
+                undefined,
+            );
 
     const explore_maps =
-        (p: IProject) => (config: IConfig) => (importer: FunctionImporter) =>
-            UnionExplorer.map(p.tsc)({
-                checker: (input, entry, explore) => {
-                    const func = decode(p)(config)(importer);
-                    return p.tsc.factory.createLogicalAnd(
-                        func(
-                            p.tsc.factory.createElementAccessExpression(
-                                input,
-                                0,
+        (project: IProject) =>
+        (config: IConfig) =>
+        (importer: FunctionImporter) =>
+        (
+            input: ts.Expression,
+            maps: Metadata.Entry[],
+            explore: IExplore,
+            tags: IMetadataTag[],
+            jsDocTags: IJsDocTagInfo[],
+        ): ts.Expression =>
+            ts.factory.createCallExpression(
+                UnionExplorer.map({
+                    checker: (input, entry, explore) => {
+                        const func = decode(project)(config)(importer);
+                        return ts.factory.createLogicalAnd(
+                            func(
+                                ts.factory.createElementAccessExpression(
+                                    input,
+                                    0,
+                                ),
+                                entry[0],
+                                {
+                                    ...explore,
+                                    postfix: `${explore.postfix}[0]`,
+                                },
+                                [],
+                                [],
                             ),
-                            entry[0],
-                            { ...explore, postfix: `${explore.postfix}[0]` },
-                            [],
-                            [],
-                        ),
-                        func(
-                            p.tsc.factory.createElementAccessExpression(
-                                input,
-                                1,
+                            func(
+                                ts.factory.createElementAccessExpression(
+                                    input,
+                                    1,
+                                ),
+                                entry[1],
+                                {
+                                    ...explore,
+                                    postfix: `${explore.postfix}[1]`,
+                                },
+                                [],
+                                [],
                             ),
-                            entry[1],
-                            { ...explore, postfix: `${explore.postfix}[1]` },
-                            [],
-                            [],
+                        );
+                    },
+                    decoder: decode_array(project)(config)(importer),
+                    empty: config.success,
+                    success: config.success,
+                    failure: (input, expected, explore) =>
+                        ts.factory.createReturnStatement(
+                            config.joiner.failure(input, expected, explore),
                         ),
-                    );
-                },
-                decoder: (input, target, explore) =>
-                    decode_array(p)(config)(importer)(
-                        input,
-                        Metadata.create({
-                            any: false,
-                            nullable: false,
-                            required: true,
-                            optional: false,
-                            functional: false,
-                            resolved: null,
-                            constants: [],
-                            atomics: [],
-                            templates: [],
-                            rest: null,
-                            arrays: [],
-                            tuples: [target],
-                            objects: [],
-                            natives: [],
-                            sets: [],
-                            maps: [],
-                        }),
-                        explore,
-                        [],
-                        [],
-                    ),
-                empty: config.success,
-                success: config.success,
-                failure: (input, expected, explore) =>
-                    p.tsc.factory.createReturnStatement(
-                        config.joiner.failure(input, expected, explore),
-                    ),
-            });
+                })([])(input, maps, explore, tags, jsDocTags),
+                undefined,
+                undefined,
+            );
 
     const explore_tuples =
-        (p: IProject) => (config: IConfig) => (importer: FunctionImporter) =>
-            UnionExplorer.tuple(p.tsc)({
-                checker: check_union_tuple(p)(config)(importer),
-                decoder: decode_tuple(p)(config)(importer)(true),
-                empty: config.success,
-                success: config.success,
-                failure: (input, expected, explore) =>
-                    p.tsc.factory.createReturnStatement(
-                        config.joiner.failure(input, expected, explore),
-                    ),
-            });
+        (project: IProject) =>
+        (config: IConfig) =>
+        (importer: FunctionImporter) =>
+        (
+            input: ts.Expression,
+            tuples: MetadataTuple[],
+            explore: IExplore,
+            tags: IMetadataTag[],
+            jsDocTags: IJsDocTagInfo[],
+        ): ts.Expression =>
+            explore_array_like_union_types(config)(importer)(
+                UnionExplorer.tuple({
+                    checker: decode_tuple(project)(config)(importer),
+                    decoder: decode_tuple(project)(config)(importer),
+                    empty: config.success,
+                    success: config.success,
+                    failure: (input, expected, explore) =>
+                        ts.factory.createReturnStatement(
+                            config.joiner.failure(input, expected, explore),
+                        ),
+                }),
+            )(input, tuples, explore, tags, jsDocTags);
 
     const explore_arrays =
-        (p: IProject) => (config: IConfig) => (importer: FunctionImporter) =>
-            UnionExplorer.array(p.tsc)({
-                checker: decode(p)(config)(importer),
-                decoder: decode_array(p)(config)(importer),
-                empty: config.success,
-                success: config.success,
-                failure: (input, expected, explore) =>
-                    p.tsc.factory.createReturnStatement(
-                        config.joiner.failure(input, expected, explore),
-                    ),
-            });
+        (project: IProject) =>
+        (config: IConfig) =>
+        (importer: FunctionImporter) =>
+        (
+            input: ts.Expression,
+            arrays: MetadataArray[],
+            explore: IExplore,
+            tags: IMetadataTag[],
+            jsDocTags: IJsDocTagInfo[],
+        ): ts.Expression =>
+            explore_array_like_union_types(config)(importer)(
+                UnionExplorer.array({
+                    checker: decode(project)(config)(importer),
+                    decoder: decode_array(project)(config)(importer),
+                    empty: config.success,
+                    success: config.success,
+                    failure: (input, expected, explore) =>
+                        ts.factory.createReturnStatement(
+                            config.joiner.failure(input, expected, explore),
+                        ),
+                }),
+            )(input, arrays, explore, tags, jsDocTags);
 
     const explore_arrays_and_tuples =
-        (p: IProject) => (config: IConfig) => (importer: FunctionImporter) =>
-            UnionExplorer.array_or_tuple(p.tsc)({
-                checker: (front, target, explore, tags, jsDocTags, array) =>
-                    Array.isArray(target)
-                        ? check_union_tuple(p)(config)(importer)(
-                              front,
-                              target,
-                              explore,
-                              tags,
-                              jsDocTags,
-                              array,
-                          )
-                        : config.atomist(explore)({
-                              expression: decode(p)(config)(importer)(
+        (project: IProject) =>
+        (config: IConfig) =>
+        (importer: FunctionImporter) =>
+        (
+            input: ts.Expression,
+            elements: Array<MetadataArray | MetadataTuple>,
+            explore: IExplore,
+            tags: IMetadataTag[],
+            jsDocTags: IJsDocTagInfo[],
+        ): ts.Expression =>
+            explore_array_like_union_types(config)(importer)(
+                UnionExplorer.array_or_tuple({
+                    checker: (front, target, explore, tags, jsDocTags, array) =>
+                        target instanceof MetadataTuple
+                            ? decode_tuple(project)(config)(importer)(
                                   front,
                                   target,
                                   explore,
                                   tags,
                                   jsDocTags,
+                              )
+                            : config.atomist(explore)({
+                                  expression: decode(project)(config)(importer)(
+                                      front,
+                                      target,
+                                      explore,
+                                      tags,
+                                      jsDocTags,
+                                  ),
+                                  tags: check_array_length(tags)(array),
+                              })(array),
+                    decoder: (input, target, explore, tags, jsDocTags) =>
+                        target instanceof MetadataTuple
+                            ? decode_tuple(project)(config)(importer)(
+                                  input,
+                                  target,
+                                  explore,
+                                  tags,
+                                  jsDocTags,
+                              )
+                            : decode_array(project)(config)(importer)(
+                                  input,
+                                  target,
+                                  explore,
+                                  tags,
+                                  jsDocTags,
                               ),
-                              tags: check_array_length(p.tsc)(tags)(array),
-                          })(array),
-                decoder: (input, target, explore, tags, jsDocTags) =>
-                    Array.isArray(target)
-                        ? decode_tuple(p)(config)(importer)(true)(
-                              input,
-                              target,
-                              explore,
-                              tags,
-                              jsDocTags,
-                          )
-                        : decode_array(p)(config)(importer)(
-                              input,
-                              target,
-                              explore,
-                              tags,
-                              jsDocTags,
-                          ),
-                empty: config.success,
-                success: config.success,
-                failure: (input, expected, explore) =>
-                    p.tsc.factory.createReturnStatement(
-                        config.joiner.failure(input, expected, explore),
-                    ),
-            });
+                    empty: config.success,
+                    success: config.success,
+                    failure: (input, expected, explore) =>
+                        ts.factory.createReturnStatement(
+                            config.joiner.failure(input, expected, explore),
+                        ),
+                }),
+            )(input, elements, explore, tags, jsDocTags);
 
-    const explore_objects =
-        (tsc: typeof ts) =>
+    const explore_array_like_union_types =
         (config: IConfig) =>
-        (importer: FunctionImporter) => {
-            const objector = decode_object(tsc)(config)(importer);
-            return (
+        (importer: FunctionImporter) =>
+        <T extends MetadataArray | MetadataTuple>(
+            factory: (
+                parameters: ts.ParameterDeclaration[],
+            ) => (
                 input: ts.Expression,
-                meta: Metadata,
+                elements: T[],
                 explore: IExplore,
-            ) => {
-                if (meta.objects.length === 1)
-                    return objector(input, meta.objects[0]!, explore);
-
-                return tsc.factory.createCallExpression(
-                    tsc.factory.createIdentifier(
-                        importer.useLocal(
-                            `${config.unioners}${meta.union_index!}`,
-                        ),
-                    ),
-                    undefined,
-                    FeatureProgrammer.get_object_arguments(tsc)(config)(
+                tags: IMetadataTag[],
+                jsDocTags: IJsDocTagInfo[],
+            ) => ts.ArrowFunction,
+        ) =>
+        (
+            input: ts.Expression,
+            elements: T[],
+            explore: IExplore,
+            tags: IMetadataTag[],
+            jsDocTags: IJsDocTagInfo[],
+        ): ts.Expression => {
+            const arrow =
+                (parameters: ts.ParameterDeclaration[]) =>
+                (explore: IExplore) =>
+                (input: ts.Expression): ts.ArrowFunction =>
+                    factory(parameters)(
+                        input,
+                        elements,
                         explore,
-                    )(input),
+                        tags,
+                        jsDocTags,
+                    );
+            if (elements.every((e) => e.recursive === false))
+                ts.factory.createCallExpression(
+                    arrow([])(explore)(input),
+                    undefined,
+                    [],
                 );
+            explore = {
+                ...explore,
+                source: "function",
+                from: "array",
             };
+            return ts.factory.createLogicalOr(
+                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,
+                    FeatureProgrammer.argumentsArray(config)(explore)(input),
+                ),
+                config.joiner.failure(
+                    input,
+                    elements.map((e) => e.name).join(" | "),
+                    explore,
+                ),
+            );
         };
+
+    const explore_objects =
+        (config: IConfig) =>
+        (importer: FunctionImporter) =>
+        (input: ts.Expression, meta: Metadata, explore: IExplore) =>
+            meta.objects.length === 1
+                ? decode_object(config)(importer)(
+                      input,
+                      meta.objects[0]!,
+                      explore,
+                  )
+                : ts.factory.createCallExpression(
+                      ts.factory.createIdentifier(
+                          importer.useLocal(
+                              `${config.prefix}u${meta.union_index!}`,
+                          ),
+                      ),
+                      undefined,
+                      FeatureProgrammer.argumentsArray(config)(explore)(input),
+                  );
 }
 
 const create_add =
-    (tsc: typeof ts) =>
     (binaries: CheckerProgrammer.IBinary[]) =>
     (defaultInput: ts.Expression) =>
     (
@@ -888,8 +1173,8 @@ const create_add =
         right: ts.Expression = defaultInput,
     ) => {
         const factory = exact
-            ? tsc.factory.createStrictEquality
-            : tsc.factory.createStrictInequality;
+            ? ts.factory.createStrictEquality
+            : ts.factory.createStrictInequality;
         binaries.push({
             expression: factory(left, right),
             combined: false,