typia 3.8.9 → 3.9.0-dev.20230604

package/lib/programmers/CheckerProgrammer.js

@@ -56,9 +56,10 @@ var ExpressionFactory_1 = require("../factories/ExpressionFactory");
 var IdentifierFactory_1 = require("../factories/IdentifierFactory");
 var MetadataCollection_1 = require("../factories/MetadataCollection");
 var MetadataFactory_1 = require("../factories/MetadataFactory");
+var StatementFactory_1 = require("../factories/StatementFactory");
 var TypeFactory_1 = require("../factories/TypeFactory");
 var ValueFactory_1 = require("../factories/ValueFactory");
-var Metadata_1 = require("../metadata/Metadata");
+var MetadataTuple_1 = require("../metadata/MetadataTuple");
 var FeatureProgrammer_1 = require("./FeatureProgrammer");
 var AtomicPredicator_1 = require("./helpers/AtomicPredicator");
 var OptionPredicator_1 = require("./helpers/OptionPredicator");
@@ -70,32 +71,74 @@ var check_native_1 = require("./internal/check_native");
 var check_number_1 = require("./internal/check_number");
 var check_string_1 = require("./internal/check_string");
 var check_template_1 = require("./internal/check_template");
-var check_union_tuple_1 = require("./internal/check_union_tuple");
 var decode_union_object_1 = require("./internal/decode_union_object");
+var wrap_metadata_rest_tuple_1 = require("./internal/wrap_metadata_rest_tuple");
 var CheckerProgrammer;
 (function (CheckerProgrammer) {
     CheckerProgrammer.write = function (project) {
         return function (config) {
             return function (importer) {
-                return FeatureProgrammer_1.FeatureProgrammer.analyze(project)(configure(project)(config)(importer))(importer);
+                return FeatureProgrammer_1.FeatureProgrammer.write(project)(configure(project)(config)(importer))(importer);
             };
         };
     };
-    CheckerProgrammer.write_functors = function (project) {
+    CheckerProgrammer.write_object_functions = function (project) {
         return function (config) {
             return function (importer) {
-                return FeatureProgrammer_1.FeatureProgrammer.write_functors(configure(project)(config)(importer))(importer);
+                return FeatureProgrammer_1.FeatureProgrammer.write_object_functions(configure(project)(config)(importer))(importer);
             };
         };
     };
-    CheckerProgrammer.write_unioners = function (project, config, importer) {
-        return FeatureProgrammer_1.FeatureProgrammer.write_unioners(configure(project)(__assign(__assign({}, config), { numeric: false }))(importer))(importer);
+    CheckerProgrammer.write_union_functions = function (project) {
+        return function (config) {
+            return function (importer) {
+                return FeatureProgrammer_1.FeatureProgrammer.write_union_functions(configure(project)(__assign(__assign({}, config), { numeric: false }))(importer));
+            };
+        };
+    };
+    CheckerProgrammer.write_array_functions = function (project) {
+        return function (config) {
+            return function (importer) {
+                return function (collection) {
+                    return collection
+                        .arrays()
+                        .filter(function (a) { return a.recursive; })
+                        .map(function (array, i) {
+                        return StatementFactory_1.StatementFactory.constant("".concat(config.prefix, "a").concat(i), typescript_1.default.factory.createArrowFunction(undefined, undefined, FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations(config)(TypeFactory_1.TypeFactory.keyword("any"))(typescript_1.default.factory.createIdentifier("input")), TypeFactory_1.TypeFactory.keyword("any"), undefined, decode_array_inline(project)(config)(importer)(typescript_1.default.factory.createIdentifier("input"), array, {
+                            tracable: config.trace,
+                            source: "function",
+                            from: "array",
+                            postfix: "",
+                        }, [], [])));
+                    });
+                };
+            };
+        };
+    };
+    CheckerProgrammer.write_tuple_functions = function (project) {
+        return function (config) {
+            return function (importer) {
+                return function (collection) {
+                    return collection
+                        .tuples()
+                        .filter(function (t) { return t.recursive; })
+                        .map(function (tuple, i) {
+                        return StatementFactory_1.StatementFactory.constant("".concat(config.prefix, "t").concat(i), typescript_1.default.factory.createArrowFunction(undefined, undefined, FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations(config)(TypeFactory_1.TypeFactory.keyword("any"))(typescript_1.default.factory.createIdentifier("input")), TypeFactory_1.TypeFactory.keyword("any"), undefined, decode_tuple_inline(project)(config)(importer)(typescript_1.default.factory.createIdentifier("input"), tuple, {
+                            tracable: config.trace,
+                            source: "function",
+                            from: "array",
+                            postfix: "",
+                        }, [], [])));
+                    });
+                };
+            };
+        };
     };
     var configure = function (project) {
         return function (config) {
             return function (importer) {
-                var _a, _b, _c;
-                var output = {
+                var _a;
+                return ({
                     types: {
                         input: function () { return TypeFactory_1.TypeFactory.keyword("any"); },
                         output: function (type, name) {
@@ -104,8 +147,7 @@ var CheckerProgrammer;
                     },
                     trace: config.trace,
                     path: config.path,
-                    functors: config.functors,
-                    unioners: config.unioners,
+                    prefix: config.prefix,
                     initializer: function (_a) {
                         var checker = _a.checker;
                         return function (type) {
@@ -113,20 +155,26 @@ var CheckerProgrammer;
                             var meta = MetadataFactory_1.MetadataFactory.analyze(checker)({
                                 resolve: false,
                                 constant: true,
+                                absorb: true,
+                                validate: function (meta) {
+                                    if (meta.arrays.length > 1 &&
+                                        meta.arrays.some(function (a) { return a.recursive; }))
+                                        throw new Error("Repeated union array types are not supported yet.");
+                                },
                             })(collection)(type);
                             return [collection, meta];
                         };
                     },
                     addition: config.addition,
-                    decoder: (_a = config.decoder) !== null && _a !== void 0 ? _a : CheckerProgrammer.decode(project)(config)(importer),
+                    decoder: function () { var _a, _b; return (_b = (_a = config.decoder) === null || _a === void 0 ? void 0 : _a.call(config)) !== null && _b !== void 0 ? _b : CheckerProgrammer.decode(project)(config)(importer); },
                     objector: {
-                        checker: (_b = config.decoder) !== null && _b !== void 0 ? _b : CheckerProgrammer.decode(project)(config)(importer),
-                        decoder: CheckerProgrammer.decode_object(config)(importer),
+                        checker: function () { var _a, _b; return (_b = (_a = config.decoder) === null || _a === void 0 ? void 0 : _a.call(config)) !== null && _b !== void 0 ? _b : CheckerProgrammer.decode(project)(config)(importer); },
+                        decoder: function () { return CheckerProgrammer.decode_object(config)(importer); },
                         joiner: config.joiner.object,
                         unionizer: config.equals
                             ? (0, decode_union_object_1.decode_union_object)(CheckerProgrammer.decode_object(config)(importer))(function (input, obj, explore) {
                                 return CheckerProgrammer.decode_object(config)(importer)(input, obj, __assign(__assign({}, explore), { tracable: true }));
-                            })((_c = config.joiner.is) !== null && _c !== void 0 ? _c : (function (expr) { return expr; }))(function (value, expected) {
+                            })((_a = config.joiner.is) !== null && _a !== void 0 ? _a : (function (expr) { return expr; }))(function (value, expected) {
                                 return typescript_1.default.factory.createReturnStatement(config.joiner.failure(value, expected));
                             })
                             : function (input, targets, explore) {
@@ -143,12 +191,16 @@ var CheckerProgrammer;
                         full: config.joiner.full,
                         type: TypeFactory_1.TypeFactory.keyword("boolean"),
                     },
-                };
-                if (config.numeric === true)
-                    output.generator = {
-                        unioners: FeatureProgrammer_1.FeatureProgrammer.write_unioners(configure(project)(__assign(__assign({}, config), { numeric: false }))(importer))(importer),
-                    };
-                return output;
+                    generator: {
+                        unions: config.numeric
+                            ? function () {
+                                return FeatureProgrammer_1.FeatureProgrammer.write_union_functions(configure(project)(__assign(__assign({}, config), { numeric: false }))(importer));
+                            }
+                            : undefined,
+                        arrays: function () { return CheckerProgrammer.write_array_functions(project)(config)(importer); },
+                        tuples: function () { return CheckerProgrammer.write_tuple_functions(project)(config)(importer); },
+                    },
+                });
             };
         };
     };
@@ -168,8 +220,7 @@ var CheckerProgrammer;
                             : typescript_1.default.factory.createIdentifier(value.toString());
                     };
                     var checkOptional = meta.empty() || meta.isUnionBucket();
-                    if (checkOptional ||
-                        meta.nullable)
+                    if (checkOptional || meta.nullable)
                         (meta.nullable ? add : create_add(top)(input))(meta.nullable, ValueFactory_1.ValueFactory.NULL());
                     if (checkOptional || !meta.required)
                         (meta.required ? create_add(top)(input) : add)(!meta.required, ValueFactory_1.ValueFactory.UNDEFINED());
@@ -290,25 +341,25 @@ var CheckerProgrammer;
                         if (meta.maps.some(function (elem) { return elem.key.any && elem.value.any; }))
                             install(null);
                         else
-                            install(explore_maps(project)(config)(importer)(input, meta.maps.map(function (m) { return [m.key, m.value]; }), __assign(__assign({}, explore), { from: "array" }), [], []));
+                            install(explore_maps(project)(config)(importer)(input, meta.maps, __assign(__assign({}, explore), { from: "array" }), [], []));
                     }
                     if (meta.tuples.length + meta.arrays.length > 0) {
-                        var install = prepare(config.atomist(explore)((0, check_array_1.check_array)(importer)(meta.tuples.length === 0 ? metaTags : [])(jsDocTags)(input))(input), __spreadArray(__spreadArray([], __read(meta.tuples), false), __read(meta.arrays), false).map(function (elem) {
-                            return Array.isArray(elem)
-                                ? "[".concat(elem
-                                    .map(function (elem) { return elem.getName(); })
-                                    .join(", "), "]")
-                                : "Array<".concat(elem.getName(), ">");
-                        })
+                        var install = prepare(config.atomist(explore)((0, check_array_1.check_array)(importer)(meta.tuples.length === 0 ? metaTags : [])(jsDocTags)(input))(input), __spreadArray(__spreadArray([], __read(meta.tuples), false), __read(meta.arrays), false).map(function (elem) { return elem.name; })
                             .join(" | "));
                         if (meta.arrays.length === 0)
-                            install(explore_tuples(project)(config)(importer)(input, meta.tuples, __assign(__assign({}, explore), { from: "array" }), metaTags, jsDocTags));
-                        else if (meta.arrays.some(function (elem) { return elem.any; }))
+                            if (meta.tuples.length === 1)
+                                install(decode_tuple(project)(config)(importer)(input, meta.tuples[0], __assign(__assign({}, explore), { from: "array" }), metaTags, jsDocTags));
+                            else
+                                install(explore_tuples(project)(config)(importer)(input, meta.tuples, __assign(__assign({}, explore), { from: "array" }), metaTags, jsDocTags));
+                        else if (meta.arrays.some(function (elem) { return elem.value.any; }))
                             install(null);
                         else if (meta.tuples.length === 0)
-                            install(explore_arrays(project, config, importer)(input, meta.arrays, __assign(__assign({}, explore), { from: "array" }), metaTags, jsDocTags));
+                            if (meta.arrays.length === 1)
+                                install(decode_array(project)(config)(importer)(input, meta.arrays[0], __assign(__assign({}, explore), { from: "array" }), metaTags, jsDocTags));
+                            else
+                                install(explore_arrays(project)(config)(importer)(input, meta.arrays, __assign(__assign({}, explore), { from: "array" }), metaTags, jsDocTags));
                         else
-                            install(explore_arrays_and_tuples(project, config, importer)(input, __spreadArray(__spreadArray([], __read(meta.tuples), false), __read(meta.arrays), false), explore, metaTags, jsDocTags));
+                            install(explore_arrays_and_tuples(project)(config)(importer)(input, __spreadArray(__spreadArray([], __read(meta.tuples), false), __read(meta.arrays), false), explore, metaTags, jsDocTags));
                     }
                     if (meta.objects.length > 0)
                         prepare(ExpressionFactory_1.ExpressionFactory.isObject({
@@ -361,193 +412,233 @@ var CheckerProgrammer;
             };
         };
     };
-    CheckerProgrammer.decode_tuple = function (project) {
+    CheckerProgrammer.decode_object = function (config) { return function (importer) {
+        var func = FeatureProgrammer_1.FeatureProgrammer.decode_object(config)(importer);
+        return function (input, obj, explore) {
+            obj.validated = true;
+            return func(input, obj, explore);
+        };
+    }; };
+    var decode_array = function (project) {
         return function (config) {
             return function (importer) {
-                return function (checkLength) {
-                    return function (input, tuple, explore, tagList, jsDocTags) {
-                        var binaries = tuple
-                            .filter(function (meta) { return meta.rest === null; })
-                            .map(function (meta, index) {
-                            return CheckerProgrammer.decode(project)(config)(importer)(typescript_1.default.factory.createElementAccessExpression(input, index), meta, __assign(__assign({}, explore), { from: "array", postfix: explore.postfix.length
-                                    ? "".concat(explore.postfix.slice(0, -1), "[").concat(index, "]\"")
-                                    : "[".concat(index, "]") }), tagList, jsDocTags);
-                        });
-                        var rest = tuple.length && tuple[tuple.length - 1].rest !== null
-                            ? CheckerProgrammer.decode(project)(config)(importer)(typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(input)("slice"), undefined, [
-                                typescript_1.default.factory.createNumericLiteral(tuple.length - 1),
-                            ]), (function () {
-                                var wrapper = Metadata_1.Metadata.initialize();
-                                wrapper.arrays.push(tuple[tuple.length - 1].rest);
-                                return wrapper;
-                            })(), __assign(__assign({}, explore), { start: tuple.length - 1 }), tagList, jsDocTags)
-                            : null;
-                        var arrayLength = typescript_1.default.factory.createPropertyAccessExpression(input, "length");
-                        return config.combiner(explore)("and")(input, __spreadArray(__spreadArray(__spreadArray([], __read((checkLength && rest === null
-                            ? tuple.every(function (t) { return t.optional === false; })
-                                ? [
-                                    {
-                                        combined: false,
-                                        expression: typescript_1.default.factory.createStrictEquality(arrayLength, typescript_1.default.factory.createNumericLiteral(tuple.length)),
-                                    },
-                                ]
-                                : [
-                                    {
-                                        combined: false,
-                                        expression: typescript_1.default.factory.createLogicalAnd(typescript_1.default.factory.createLessThanEquals(typescript_1.default.factory.createNumericLiteral(tuple.filter(function (t) {
-                                            return t.optional === false;
-                                        }).length), arrayLength), typescript_1.default.factory.createGreaterThanEquals(typescript_1.default.factory.createNumericLiteral(tuple.length), arrayLength)),
-                                    },
-                                ]
-                            : [])), false), __read((config.joiner.tuple
-                            ? [
-                                {
-                                    expression: config.joiner.tuple(binaries),
-                                    combined: true,
-                                },
-                            ]
-                            : binaries.map(function (expression) { return ({
-                                expression: expression,
-                                combined: true,
-                            }); }))), false), __read((rest !== null
-                            ? [
-                                {
-                                    expression: rest,
-                                    combined: true,
-                                },
-                            ]
-                            : [])), false), "[".concat(tuple.map(function (t) { return t.getName(); }).join(", "), "]"));
-                    };
+                return function (input, array, explore, metaTags, jsDocTags) {
+                    if (array.recursive === false)
+                        return decode_array_inline(project)(config)(importer)(input, array, explore, metaTags, jsDocTags);
+                    explore = __assign(__assign({}, explore), { source: "function", from: "array" });
+                    return typescript_1.default.factory.createLogicalOr(typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(importer.useLocal("".concat(config.prefix, "a").concat(array.index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(config)(__assign(__assign({}, explore), { source: "function", from: "array" }))(input)), config.joiner.failure(input, array.name, explore));
                 };
             };
         };
     };
-    var decode_array = function (project) {
+    var decode_array_inline = function (project) {
         return function (config) {
             return function (importer) {
                 return FeatureProgrammer_1.FeatureProgrammer.decode_array({
+                    prefix: config.prefix,
                     trace: config.trace,
                     path: config.path,
-                    decoder: CheckerProgrammer.decode(project)(config)(importer),
+                    decoder: function () { return CheckerProgrammer.decode(project)(config)(importer); },
                 })(importer)(config.joiner.array);
             };
         };
     };
-    CheckerProgrammer.decode_object = function (config) { return function (importer) {
-        var func = FeatureProgrammer_1.FeatureProgrammer.decode_object(config)(importer);
-        return function (input, obj, explore) {
-            obj.validated = true;
-            return func(input, obj, explore);
+    var decode_tuple = function (project) {
+        return function (config) {
+            return function (importer) {
+                return function (input, tuple, explore, tagList, jsDocTags) {
+                    if (tuple.recursive === false)
+                        return decode_tuple_inline(project)(config)(importer)(input, tuple, explore, tagList, jsDocTags);
+                    explore = __assign(__assign({}, explore), { source: "function", from: "array" });
+                    return typescript_1.default.factory.createLogicalOr(typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(importer.useLocal("".concat(config.prefix, "t").concat(tuple.index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(config)(__assign(__assign({}, explore), { source: "function" }))(input)), config.joiner.failure(input, tuple.name, explore));
+                };
+            };
         };
-    }; };
+    };
+    var decode_tuple_inline = function (project) {
+        return function (config) {
+            return function (importer) {
+                return function (input, tuple, explore, tagList, jsDocTags) {
+                    var binaries = tuple.elements
+                        .filter(function (meta) { return meta.rest === null; })
+                        .map(function (meta, index) {
+                        return CheckerProgrammer.decode(project)(config)(importer)(typescript_1.default.factory.createElementAccessExpression(input, index), meta, __assign(__assign({}, explore), { from: "array", postfix: explore.postfix.length
+                                ? "".concat(explore.postfix.slice(0, -1), "[").concat(index, "]\"")
+                                : "\"[".concat(index, "]\"") }), tagList, jsDocTags);
+                    });
+                    var rest = tuple.elements.length && tuple.elements.at(-1).rest !== null
+                        ? CheckerProgrammer.decode(project)(config)(importer)(typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(input)("slice"), undefined, [
+                            typescript_1.default.factory.createNumericLiteral(tuple.elements.length - 1),
+                        ]), (0, wrap_metadata_rest_tuple_1.wrap_metadata_rest_tuple)(tuple.elements.at(-1).rest), __assign(__assign({}, explore), { start: tuple.elements.length - 1 }), tagList, jsDocTags)
+                        : null;
+                    var arrayLength = typescript_1.default.factory.createPropertyAccessExpression(input, "length");
+                    return config.combiner(explore)("and")(input, __spreadArray(__spreadArray(__spreadArray([], __read((rest === null
+                        ? tuple.elements.every(function (t) { return t.optional === false; })
+                            ? [
+                                {
+                                    combined: false,
+                                    expression: typescript_1.default.factory.createStrictEquality(arrayLength, typescript_1.default.factory.createNumericLiteral(tuple.elements.length)),
+                                },
+                            ]
+                            : [
+                                {
+                                    combined: false,
+                                    expression: typescript_1.default.factory.createLogicalAnd(typescript_1.default.factory.createLessThanEquals(typescript_1.default.factory.createNumericLiteral(tuple.elements.filter(function (t) {
+                                        return t.optional === false;
+                                    }).length), arrayLength), typescript_1.default.factory.createGreaterThanEquals(typescript_1.default.factory.createNumericLiteral(tuple.elements.length), arrayLength)),
+                                },
+                            ]
+                        : [])), false), __read((config.joiner.tuple
+                        ? [
+                            {
+                                expression: config.joiner.tuple(binaries),
+                                combined: true,
+                            },
+                        ]
+                        : binaries.map(function (expression) { return ({
+                            expression: expression,
+                            combined: true,
+                        }); }))), false), __read((rest !== null
+                        ? [
+                            {
+                                expression: rest,
+                                combined: true,
+                            },
+                        ]
+                        : [])), false), "[".concat(tuple.elements.map(function (t) { return t.getName(); }).join(", "), "]"));
+                };
+            };
+        };
+    };
     var explore_sets = function (project) {
         return function (config) {
             return function (importer) {
-                return UnionExplorer_1.UnionExplorer.set({
-                    checker: CheckerProgrammer.decode(project)(config)(importer),
-                    decoder: decode_array(project)(config)(importer),
-                    empty: config.success,
-                    success: config.success,
-                    failure: function (input, expected, explore) {
-                        return typescript_1.default.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
-                    },
-                });
+                return function (input, sets, explore, tags, jsDocTags) {
+                    return typescript_1.default.factory.createCallExpression(UnionExplorer_1.UnionExplorer.set({
+                        checker: CheckerProgrammer.decode(project)(config)(importer),
+                        decoder: decode_array(project)(config)(importer),
+                        empty: config.success,
+                        success: config.success,
+                        failure: function (input, expected, explore) {
+                            return typescript_1.default.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
+                        },
+                    })([])(input, sets, explore, tags, jsDocTags), undefined, undefined);
+                };
             };
         };
     };
     var explore_maps = function (project) {
         return function (config) {
             return function (importer) {
-                return UnionExplorer_1.UnionExplorer.map({
-                    checker: function (input, entry, explore) {
-                        var func = CheckerProgrammer.decode(project)(config)(importer);
-                        return typescript_1.default.factory.createLogicalAnd(func(typescript_1.default.factory.createElementAccessExpression(input, 0), entry[0], __assign(__assign({}, explore), { postfix: "".concat(explore.postfix, "[0]") }), [], []), func(typescript_1.default.factory.createElementAccessExpression(input, 1), entry[1], __assign(__assign({}, explore), { postfix: "".concat(explore.postfix, "[1]") }), [], []));
-                    },
-                    decoder: function (input, target, explore) {
-                        return decode_array(project)(config)(importer)(input, Metadata_1.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: function (input, expected, explore) {
-                        return typescript_1.default.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
-                    },
-                });
+                return function (input, maps, explore, tags, jsDocTags) {
+                    return typescript_1.default.factory.createCallExpression(UnionExplorer_1.UnionExplorer.map({
+                        checker: function (input, entry, explore) {
+                            var func = CheckerProgrammer.decode(project)(config)(importer);
+                            return typescript_1.default.factory.createLogicalAnd(func(typescript_1.default.factory.createElementAccessExpression(input, 0), entry[0], __assign(__assign({}, explore), { postfix: "".concat(explore.postfix, "[0]") }), [], []), func(typescript_1.default.factory.createElementAccessExpression(input, 1), entry[1], __assign(__assign({}, explore), { postfix: "".concat(explore.postfix, "[1]") }), [], []));
+                        },
+                        decoder: decode_array(project)(config)(importer),
+                        empty: config.success,
+                        success: config.success,
+                        failure: function (input, expected, explore) {
+                            return typescript_1.default.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
+                        },
+                    })([])(input, maps, explore, tags, jsDocTags), undefined, undefined);
+                };
             };
         };
     };
     var explore_tuples = function (project) {
         return function (config) {
             return function (importer) {
-                return UnionExplorer_1.UnionExplorer.tuple({
-                    checker: (0, check_union_tuple_1.check_union_tuple)(project)(config)(importer),
-                    decoder: CheckerProgrammer.decode_tuple(project)(config)(importer)(true),
-                    empty: config.success,
-                    success: config.success,
-                    failure: function (input, expected, explore) {
-                        return typescript_1.default.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
-                    },
-                });
+                return function (input, tuples, explore, tags, jsDocTags) {
+                    return explore_array_like_union_types(config)(importer)(UnionExplorer_1.UnionExplorer.tuple({
+                        checker: decode_tuple(project)(config)(importer),
+                        decoder: decode_tuple(project)(config)(importer),
+                        empty: config.success,
+                        success: config.success,
+                        failure: function (input, expected, explore) {
+                            return typescript_1.default.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
+                        },
+                    }))(input, tuples, explore, tags, jsDocTags);
+                };
             };
         };
     };
-    var explore_arrays = function (project, config, importer) {
-        return UnionExplorer_1.UnionExplorer.array({
-            checker: CheckerProgrammer.decode(project)(config)(importer),
-            decoder: decode_array(project)(config)(importer),
-            empty: config.success,
-            success: config.success,
-            failure: function (input, expected, explore) {
-                return typescript_1.default.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
-            },
-        });
+    var explore_arrays = function (project) {
+        return function (config) {
+            return function (importer) {
+                return function (input, arrays, explore, tags, jsDocTags) {
+                    return explore_array_like_union_types(config)(importer)(UnionExplorer_1.UnionExplorer.array({
+                        checker: CheckerProgrammer.decode(project)(config)(importer),
+                        decoder: decode_array(project)(config)(importer),
+                        empty: config.success,
+                        success: config.success,
+                        failure: function (input, expected, explore) {
+                            return typescript_1.default.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
+                        },
+                    }))(input, arrays, explore, tags, jsDocTags);
+                };
+            };
+        };
     };
-    var explore_arrays_and_tuples = function (project, config, importer) {
-        return UnionExplorer_1.UnionExplorer.array_or_tuple({
-            checker: function (front, target, explore, tags, jsDocTags, array) {
-                return Array.isArray(target)
-                    ? (0, check_union_tuple_1.check_union_tuple)(project)(config)(importer)(front, target, explore, tags, jsDocTags, array)
-                    : config.atomist(explore)({
-                        expression: CheckerProgrammer.decode(project)(config)(importer)(front, target, explore, tags, jsDocTags),
-                        tags: (0, check_array_length_1.check_array_length)(tags)(array),
-                    })(array);
-            },
-            decoder: function (input, target, explore, tags, jsDocTags) {
-                return Array.isArray(target)
-                    ? CheckerProgrammer.decode_tuple(project)(config)(importer)(true)(input, target, explore, tags, jsDocTags)
-                    : decode_array(project)(config)(importer)(input, target, explore, tags, jsDocTags);
-            },
-            empty: config.success,
-            success: config.success,
-            failure: function (input, expected, explore) {
-                return typescript_1.default.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
-            },
-        });
+    var explore_arrays_and_tuples = function (project) {
+        return function (config) {
+            return function (importer) {
+                return function (input, elements, explore, tags, jsDocTags) {
+                    return explore_array_like_union_types(config)(importer)(UnionExplorer_1.UnionExplorer.array_or_tuple({
+                        checker: function (front, target, explore, tags, jsDocTags, array) {
+                            return target instanceof MetadataTuple_1.MetadataTuple
+                                ? decode_tuple(project)(config)(importer)(front, target, explore, tags, jsDocTags)
+                                : config.atomist(explore)({
+                                    expression: CheckerProgrammer.decode(project)(config)(importer)(front, target, explore, tags, jsDocTags),
+                                    tags: (0, check_array_length_1.check_array_length)(tags)(array),
+                                })(array);
+                        },
+                        decoder: function (input, target, explore, tags, jsDocTags) {
+                            return target instanceof MetadataTuple_1.MetadataTuple
+                                ? decode_tuple(project)(config)(importer)(input, target, explore, tags, jsDocTags)
+                                : decode_array(project)(config)(importer)(input, target, explore, tags, jsDocTags);
+                        },
+                        empty: config.success,
+                        success: config.success,
+                        failure: function (input, expected, explore) {
+                            return typescript_1.default.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
+                        },
+                    }))(input, elements, explore, tags, jsDocTags);
+                };
+            };
+        };
+    };
+    var explore_array_like_union_types = function (config) {
+        return function (importer) {
+            return function (factory) {
+                return function (input, elements, explore, tags, jsDocTags) {
+                    var arrow = function (parameters) {
+                        return function (explore) {
+                            return function (input) {
+                                return factory(parameters)(input, elements, explore, tags, jsDocTags);
+                            };
+                        };
+                    };
+                    if (elements.every(function (e) { return e.recursive === false; }))
+                        typescript_1.default.factory.createCallExpression(arrow([])(explore)(input), undefined, []);
+                    explore = __assign(__assign({}, explore), { source: "function", from: "array" });
+                    return typescript_1.default.factory.createLogicalOr(typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(importer.emplaceUnion(config.prefix, elements.map(function (e) { return e.name; }).join(" | "), function () {
+                        return arrow(FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations(config)(TypeFactory_1.TypeFactory.keyword("any"))(typescript_1.default.factory.createIdentifier("input")))(__assign(__assign({}, explore), { postfix: "" }))(typescript_1.default.factory.createIdentifier("input"));
+                    })), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(config)(explore)(input)), config.joiner.failure(input, elements.map(function (e) { return e.name; }).join(" | "), explore));
+                };
+            };
+        };
     };
-    var explore_objects = function (config) { return function (importer) {
-        var objector = CheckerProgrammer.decode_object(config)(importer);
-        return function (input, meta, explore) {
-            if (meta.objects.length === 1)
-                return objector(input, meta.objects[0], explore);
-            return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(importer.useLocal("".concat(config.unioners).concat(meta.union_index))), undefined, FeatureProgrammer_1.FeatureProgrammer.get_object_arguments(config)(explore)(input));
+    var explore_objects = function (config) {
+        return function (importer) {
+            return function (input, meta, explore) {
+                return meta.objects.length === 1
+                    ? CheckerProgrammer.decode_object(config)(importer)(input, meta.objects[0], explore)
+                    : typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(importer.useLocal("".concat(config.prefix, "u").concat(meta.union_index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(config)(explore)(input));
+            };
         };
-    }; };
+    };
 })(CheckerProgrammer = exports.CheckerProgrammer || (exports.CheckerProgrammer = {}));
 var create_add = function (binaries) {
     return function (defaultInput) {