typia 7.0.0-dev.20240929 → 7.0.0-dev.20241001

package/lib/programmers/CheckerProgrammer.js

@@ -85,7 +85,13 @@ var CheckerProgrammer;
         return FeatureProgrammer_1.FeatureProgrammer.compose(__assign(__assign({}, props), { config: configure(props) }));
     };
     CheckerProgrammer.write = function (props) {
-        return FeatureProgrammer_1.FeatureProgrammer.write(props.context)(configure(props))(props.importer)(props.type, props.name);
+        return FeatureProgrammer_1.FeatureProgrammer.write({
+            config: configure(props),
+            context: props.context,
+            importer: props.importer,
+            type: props.type,
+            name: props.name,
+        });
     };
     CheckerProgrammer.write_object_functions = function (props) {
         return FeatureProgrammer_1.FeatureProgrammer.write_object_functions({
@@ -95,18 +101,25 @@ var CheckerProgrammer;
         });
     };
     CheckerProgrammer.write_union_functions = function (props) {
-        return FeatureProgrammer_1.FeatureProgrammer.write_union_functions(configure({
-            context: props.context,
-            config: __assign(__assign({}, props.config), { numeric: false }),
-            importer: props.importer,
-        }))(props.collection);
+        return FeatureProgrammer_1.FeatureProgrammer.write_union_functions({
+            config: configure({
+                context: props.context,
+                config: __assign(__assign({}, props.config), { numeric: false }),
+                importer: props.importer,
+            }),
+            collection: props.collection,
+        });
     };
     CheckerProgrammer.write_array_functions = function (props) {
         return props.collection
             .arrays()
             .filter(function (a) { return a.recursive; })
             .map(function (type, i) {
-            return StatementFactory_1.StatementFactory.constant("".concat(props.config.prefix, "a").concat(i), typescript_1.default.factory.createArrowFunction(undefined, undefined, FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations(props.config)(TypeFactory_1.TypeFactory.keyword("any"))(typescript_1.default.factory.createIdentifier("input")), TypeFactory_1.TypeFactory.keyword("any"), undefined, decode_array_inline(__assign(__assign({}, props), { input: typescript_1.default.factory.createIdentifier("input"), array: MetadataArray_1.MetadataArray.create({
+            return StatementFactory_1.StatementFactory.constant("".concat(props.config.prefix, "a").concat(i), typescript_1.default.factory.createArrowFunction(undefined, undefined, FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations({
+                config: props.config,
+                type: TypeFactory_1.TypeFactory.keyword("any"),
+                input: typescript_1.default.factory.createIdentifier("input"),
+            }), TypeFactory_1.TypeFactory.keyword("any"), undefined, decode_array_inline(__assign(__assign({}, props), { input: typescript_1.default.factory.createIdentifier("input"), array: MetadataArray_1.MetadataArray.create({
                     type: type,
                     tags: [],
                 }), explore: {
@@ -122,7 +135,11 @@ var CheckerProgrammer;
             .tuples()
             .filter(function (t) { return t.recursive; })
             .map(function (tuple, i) {
-            return StatementFactory_1.StatementFactory.constant("".concat(props.config.prefix, "t").concat(i), typescript_1.default.factory.createArrowFunction(undefined, undefined, FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations(props.config)(TypeFactory_1.TypeFactory.keyword("any"))(typescript_1.default.factory.createIdentifier("input")), TypeFactory_1.TypeFactory.keyword("any"), undefined, decode_tuple_inline({
+            return StatementFactory_1.StatementFactory.constant("".concat(props.config.prefix, "t").concat(i), typescript_1.default.factory.createArrowFunction(undefined, undefined, FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations({
+                config: props.config,
+                type: TypeFactory_1.TypeFactory.keyword("any"),
+                input: typescript_1.default.factory.createIdentifier("input"),
+            }), TypeFactory_1.TypeFactory.keyword("any"), undefined, decode_tuple_inline({
                 config: props.config,
                 context: props.context,
                 importer: props.importer,
@@ -137,150 +154,145 @@ var CheckerProgrammer;
             })));
         });
     };
-    var configure = function (props) {
-        var _a;
-        return ({
-            types: {
-                input: function () { return TypeFactory_1.TypeFactory.keyword("any"); },
-                output: function (type, name) {
-                    return typescript_1.default.factory.createTypePredicateNode(undefined, "input", typescript_1.default.factory.createTypeReferenceNode(name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName(props.context.checker)(type)));
-                },
+    var configure = function (props) { return ({
+        types: {
+            input: function () { return TypeFactory_1.TypeFactory.keyword("any"); },
+            output: function (type, name) {
+                return typescript_1.default.factory.createTypePredicateNode(undefined, "input", typescript_1.default.factory.createTypeReferenceNode(name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName(props.context.checker)(type)));
             },
-            trace: props.config.trace,
-            path: props.config.path,
-            prefix: props.config.prefix,
-            initializer: function (context) { return function (importer) { return function (type) {
-                var collection = new MetadataCollection_1.MetadataCollection();
-                var result = MetadataFactory_1.MetadataFactory.analyze({
-                    checker: context.checker,
-                    transformer: context.transformer,
-                    options: {
-                        escape: false,
-                        constant: true,
-                        absorb: true,
-                    },
-                    collection: collection,
-                    type: type,
+        },
+        trace: props.config.trace,
+        path: props.config.path,
+        prefix: props.config.prefix,
+        initializer: function (next) {
+            var collection = new MetadataCollection_1.MetadataCollection();
+            var result = MetadataFactory_1.MetadataFactory.analyze({
+                checker: next.context.checker,
+                transformer: next.context.transformer,
+                options: {
+                    escape: false,
+                    constant: true,
+                    absorb: true,
+                },
+                collection: collection,
+                type: next.type,
+            });
+            if (result.success === false)
+                throw TransformerError_1.TransformerError.from("typia.".concat(next.importer.method))(result.errors);
+            return [collection, result.data];
+        },
+        addition: props.config.addition,
+        decoder: props.config.decoder
+            ? function (next) { return props.config.decoder(next); }
+            : function (next) {
+                return CheckerProgrammer.decode({
+                    context: props.context,
+                    config: props.config,
+                    importer: props.importer,
+                    input: next.input,
+                    metadata: next.metadata,
+                    explore: next.explore,
                 });
-                if (result.success === false)
-                    throw TransformerError_1.TransformerError.from("typia.".concat(importer.method))(result.errors);
-                return [collection, result.data];
-            }; }; },
-            addition: props.config.addition,
-            decoder: function () {
-                return props.config.decoder
-                    ? function (input, metadata, explore) {
-                        return props.config.decoder()(input, metadata, explore);
-                    }
-                    : function (input, metadata, explore) {
-                        return CheckerProgrammer.decode({
-                            context: props.context,
-                            config: props.config,
-                            importer: props.importer,
-                            input: input,
-                            metadata: metadata,
-                            explore: explore,
-                        });
-                    };
             },
-            objector: {
-                checker: function () { return function (input, metadata, explore) {
-                    var _a, _b, _c;
-                    return (_c = (_b = (_a = props.config).decoder) === null || _b === void 0 ? void 0 : _b.call(_a)(input, metadata, explore)) !== null && _c !== void 0 ? _c : CheckerProgrammer.decode({
+        objector: {
+            checker: props.config.decoder
+                ? function (next) { return props.config.decoder(next); }
+                : function (next) {
+                    return CheckerProgrammer.decode({
                         context: props.context,
                         config: props.config,
                         importer: props.importer,
-                        input: input,
-                        metadata: metadata,
-                        explore: explore,
+                        input: next.input,
+                        metadata: next.metadata,
+                        explore: next.explore,
                     });
-                }; },
-                decoder: function () { return function (input, object, explore) {
-                    return CheckerProgrammer.decode_object({
-                        config: props.config,
-                        importer: props.importer,
-                        input: input,
-                        object: object,
-                        explore: explore,
+                },
+            decoder: function (next) {
+                return CheckerProgrammer.decode_object({
+                    config: props.config,
+                    importer: props.importer,
+                    input: next.input,
+                    object: next.object,
+                    explore: next.explore,
+                });
+            },
+            joiner: props.config.joiner.object,
+            unionizer: props.config.equals
+                ? function (next) {
+                    var _a;
+                    return (0, decode_union_object_1.decode_union_object)({
+                        checker: function (v) {
+                            return CheckerProgrammer.decode_object({
+                                config: props.config,
+                                importer: props.importer,
+                                object: v.object,
+                                input: v.input,
+                                explore: v.explore,
+                            });
+                        },
+                        decoder: function (v) {
+                            return CheckerProgrammer.decode_object({
+                                config: props.config,
+                                importer: props.importer,
+                                input: v.input,
+                                object: v.object,
+                                explore: __assign(__assign({}, v.explore), { tracable: true }),
+                            });
+                        },
+                        success: (_a = props.config.joiner.is) !== null && _a !== void 0 ? _a : (function (expr) { return expr; }),
+                        escaper: function (v) {
+                            return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure(v));
+                        },
+                        input: next.input,
+                        objects: next.objects,
+                        explore: next.explore,
+                    });
+                }
+                : function (next) {
+                    return props.config.combiner({
+                        logic: "or",
+                        explore: next.explore,
+                        input: next.input,
+                        binaries: next.objects.map(function (object) { return ({
+                            expression: CheckerProgrammer.decode_object({
+                                config: props.config,
+                                importer: props.importer,
+                                object: object,
+                                input: next.input,
+                                explore: next.explore,
+                            }),
+                            combined: true,
+                        }); }),
+                        expected: "(".concat(next.objects.map(function (t) { return t.name; }).join(" | "), ")"),
                     });
-                }; },
-                joiner: props.config.joiner.object,
-                unionizer: props.config.equals
-                    ? (0, decode_union_object_1.decode_union_object)(function (input, object, explore) {
-                        return CheckerProgrammer.decode_object({
-                            config: props.config,
-                            importer: props.importer,
-                            object: object,
-                            input: input,
-                            explore: explore,
-                        });
-                    })(function (input, object, explore) {
-                        return CheckerProgrammer.decode_object({
-                            config: props.config,
-                            importer: props.importer,
-                            input: input,
-                            object: object,
-                            explore: __assign(__assign({}, explore), { tracable: true }),
-                        });
-                    })((_a = props.config.joiner.is) !== null && _a !== void 0 ? _a : (function (expr) { return expr; }))(function (input, expected) {
-                        return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure({
-                            input: input,
-                            expected: expected,
-                        }));
-                    })
-                    : function (input, targets, explore) {
-                        return props.config.combiner({
-                            explore: explore,
-                            logic: "or",
-                            input: input,
-                            binaries: targets.map(function (object) { return ({
-                                expression: CheckerProgrammer.decode_object({
-                                    config: props.config,
-                                    importer: props.importer,
-                                    input: input,
-                                    object: object,
-                                    explore: explore,
-                                }),
-                                combined: true,
-                            }); }),
-                            expected: "(".concat(targets.map(function (t) { return t.name; }).join(" | "), ")"),
-                        });
-                    },
-                failure: function (input, expected) {
-                    return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure({
-                        input: input,
-                        expected: expected,
-                    }));
                 },
-                is: props.config.joiner.is,
-                required: props.config.joiner.required,
-                full: props.config.joiner.full
-                    ? function (condition) { return function (input, expected, explore) {
-                        return props.config.joiner.full({
-                            condition: condition,
-                            input: input,
-                            expected: expected,
-                            explore: explore,
-                        });
-                    }; }
-                    : undefined,
-                type: TypeFactory_1.TypeFactory.keyword("boolean"),
+            failure: function (next) {
+                return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure(next));
             },
-            generator: {
-                unions: props.config.numeric
-                    ? function () {
-                        return FeatureProgrammer_1.FeatureProgrammer.write_union_functions(configure(__assign(__assign({}, props), { config: __assign(__assign({}, props.config), { numeric: false }) })));
-                    }
-                    : undefined,
-                arrays: function () { return function (collection) {
-                    return CheckerProgrammer.write_array_functions(__assign(__assign({}, props), { collection: collection }));
-                }; },
-                tuples: function () { return function (collection) {
-                    return CheckerProgrammer.write_tuple_functions(__assign(__assign({}, props), { collection: collection }));
-                }; },
+            is: props.config.joiner.is,
+            required: props.config.joiner.required,
+            full: props.config.joiner.full
+                ? function (next) { return props.config.joiner.full(next); }
+                : undefined,
+            type: TypeFactory_1.TypeFactory.keyword("boolean"),
+        },
+        generator: {
+            unions: props.config.numeric
+                ? function (collection) {
+                    return FeatureProgrammer_1.FeatureProgrammer.write_union_functions({
+                        config: configure(__assign(__assign({}, props), { config: __assign(__assign({}, props.config), { numeric: false }) })),
+                        collection: collection,
+                    });
+                }
+                : undefined,
+            arrays: function (collection) {
+                return CheckerProgrammer.write_array_functions(__assign(__assign({}, props), { collection: collection }));
             },
-        });
-    };
+            tuples: function (collection) {
+                return CheckerProgrammer.write_tuple_functions(__assign(__assign({}, props), { collection: collection }));
+            },
+        },
+    }); };
     /* -----------------------------------------------------------
           DECODERS
       ----------------------------------------------------------- */
@@ -434,7 +446,12 @@ var CheckerProgrammer;
                     binaries.push({
                         expression: props.config.atomist({
                             explore: props.explore,
-                            entry: (0, check_number_1.check_number)(props.context, props.config.numeric)(atom)(props.input),
+                            entry: (0, check_number_1.check_number)({
+                                context: props.context,
+                                numeric: props.config.numeric,
+                                atomic: atom,
+                                input: props.input,
+                            }),
                             input: props.input,
                         }),
                         combined: false,
@@ -443,7 +460,11 @@ var CheckerProgrammer;
                     binaries.push({
                         expression: props.config.atomist({
                             explore: props.explore,
-                            entry: (0, check_bigint_1.check_bigint)(props.context)(atom)(props.input),
+                            entry: (0, check_bigint_1.check_bigint)({
+                                context: props.context,
+                                atomic: atom,
+                                input: props.input,
+                            }),
                             input: props.input,
                         }),
                         combined: false,
@@ -452,7 +473,11 @@ var CheckerProgrammer;
                     binaries.push({
                         expression: props.config.atomist({
                             explore: props.explore,
-                            entry: (0, check_string_1.check_string)(props.context)(atom)(props.input),
+                            entry: (0, check_string_1.check_string)({
+                                context: props.context,
+                                atomic: atom,
+                                input: props.input,
+                            }),
                             input: props.input,
                         }),
                         combined: false,
@@ -478,7 +503,10 @@ var CheckerProgrammer;
                 binaries.push({
                     expression: props.config.atomist({
                         explore: props.explore,
-                        entry: (0, check_template_1.check_template)(props.metadata.templates)(props.input),
+                        entry: (0, check_template_1.check_template)({
+                            templates: props.metadata.templates,
+                            input: props.input,
+                        }),
                         input: props.input,
                     }),
                     combined: false,
@@ -488,7 +516,10 @@ var CheckerProgrammer;
             for (var _j = __values(props.metadata.natives), _k = _j.next(); !_k.done; _k = _j.next()) {
                 var native = _k.value;
                 binaries.push({
-                    expression: (0, check_native_1.check_native)(native)(props.input),
+                    expression: (0, check_native_1.check_native)({
+                        type: native,
+                        input: props.input,
+                    }),
                     combined: false,
                 });
             }
@@ -506,7 +537,10 @@ var CheckerProgrammer;
         if (props.metadata.sets.length) {
             var install = function (body) {
                 return prepare({
-                    knock: (0, check_native_1.check_native)("Set")(props.input),
+                    head: (0, check_native_1.check_native)({
+                        type: "Set",
+                        input: props.input,
+                    }),
                     expected: props.metadata.sets
                         .map(function (elem) { return "Set<".concat(elem.getName(), ">"); })
                         .join(" | "),
@@ -529,7 +563,10 @@ var CheckerProgrammer;
         if (props.metadata.maps.length) {
             var install = function (body) {
                 return prepare({
-                    knock: (0, check_native_1.check_native)("Map")(props.input),
+                    head: (0, check_native_1.check_native)({
+                        type: "Map",
+                        input: props.input,
+                    }),
                     expected: props.metadata.maps
                         .map(function (_a) {
                         var key = _a.key, value = _a.value;
@@ -555,7 +592,7 @@ var CheckerProgrammer;
         if (props.metadata.tuples.length + props.metadata.arrays.length > 0) {
             var install = function (body) {
                 return prepare({
-                    knock: props.config.atomist({
+                    head: props.config.atomist({
                         explore: props.explore,
                         entry: {
                             expected: __spreadArray(__spreadArray([], __read(props.metadata.tuples.map(function (t) { return t.type.name; })), false), __read(props.metadata.arrays.map(function (a) { return a.getName(); })), false).join(" | "),
@@ -624,7 +661,7 @@ var CheckerProgrammer;
         // OBJECT
         if (props.metadata.objects.length > 0)
             prepare({
-                knock: ExpressionFactory_1.ExpressionFactory.isObject({
+                head: ExpressionFactory_1.ExpressionFactory.isObject({
                     checkNull: true,
                     checkArray: props.metadata.objects.some(function (obj) {
                         return obj.properties.every(function (prop) { return !prop.key.isSoleLiteral() || !prop.value.isRequired(); });
@@ -644,24 +681,24 @@ var CheckerProgrammer;
                 return function (ins) {
                     return ins.body
                         ? {
-                            expression: merger(ins.knock, ins.body),
+                            expression: merger(ins.head, ins.body),
                             combined: true,
                         }
                         : {
-                            expression: ins.knock,
+                            expression: ins.head,
                             combined: false,
                         };
                 };
             };
             if (instances.length === 1)
-                binaries.push(transformer(function (pre, body) {
+                binaries.push(transformer(function (head, body) {
                     return props.config.combiner({
                         explore: props.explore,
                         logic: "and",
                         input: props.input,
-                        binaries: [pre, body].map(function (expression) { return ({
+                        binaries: [head, body].map(function (expression) { return ({
                             expression: expression,
-                            combined: expression !== pre,
+                            combined: expression !== head,
                         }); }),
                         expected: props.metadata.getName(),
                     });
@@ -684,7 +721,10 @@ var CheckerProgrammer;
                 combined: false,
                 expression: props.metadata.escaped.original.size() === 1 &&
                     props.metadata.escaped.original.natives.length === 1
-                    ? (0, check_native_1.check_native)(props.metadata.escaped.original.natives[0])(props.input)
+                    ? (0, check_native_1.check_native)({
+                        type: props.metadata.escaped.original.natives[0],
+                        input: props.input,
+                    })
                     : typescript_1.default.factory.createLogicalAnd(CheckerProgrammer.decode({
                         context: props.context,
                         config: props.config,
@@ -739,28 +779,43 @@ var CheckerProgrammer;
     CheckerProgrammer.decode_object = function (props) {
         var _a;
         (_a = props.object).validated || (_a.validated = true);
-        return FeatureProgrammer_1.FeatureProgrammer.decode_object(props.config)(props.importer)(props.input, props.object, props.explore);
+        return FeatureProgrammer_1.FeatureProgrammer.decode_object(props);
     };
     var decode_array = function (props) {
         if (props.array.type.recursive === false)
             return decode_array_inline(props);
         var arrayExplore = __assign(__assign({}, props.explore), { source: "function", from: "array" });
-        return typescript_1.default.factory.createLogicalOr(typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.importer.useLocal("".concat(props.config.prefix, "a").concat(props.array.type.index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props.config)(__assign(__assign({}, arrayExplore), { source: "function", from: "array" }))(props.input)), props.config.joiner.failure({
+        return typescript_1.default.factory.createLogicalOr(typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.importer.useLocal("".concat(props.config.prefix, "a").concat(props.array.type.index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray({
+            config: props.config,
+            explore: __assign(__assign({}, arrayExplore), { source: "function", from: "array" }),
+            input: props.input,
+        })), props.config.joiner.failure({
             input: props.input,
             expected: props.array.type.name,
             explore: arrayExplore,
         }));
     };
     var decode_array_inline = function (props) {
-        var length = (0, check_array_length_1.check_array_length)(props.context)(props.array)(props.input);
+        var length = (0, check_array_length_1.check_array_length)({
+            context: props.context,
+            array: props.array,
+            input: props.input,
+        });
         var main = FeatureProgrammer_1.FeatureProgrammer.decode_array({
-            prefix: props.config.prefix,
-            trace: props.config.trace,
-            path: props.config.path,
-            decoder: function () { return function (input, metadata, explore) {
-                return CheckerProgrammer.decode(__assign(__assign({}, props), { input: input, metadata: metadata, explore: explore }));
-            }; },
-        })(props.importer)(props.config.joiner.array)(props.input, props.array, props.explore);
+            config: {
+                prefix: props.config.prefix,
+                trace: props.config.trace,
+                path: props.config.path,
+                decoder: function (next) {
+                    return CheckerProgrammer.decode(__assign(__assign({}, props), next));
+                },
+            },
+            importer: props.importer,
+            combiner: props.config.joiner.array,
+            array: props.array,
+            input: props.input,
+            explore: props.explore,
+        });
         return length.expression === null && length.conditions.length === 0
             ? main
             : typescript_1.default.factory.createLogicalAnd(props.config.atomist({
@@ -773,7 +828,11 @@ var CheckerProgrammer;
         if (props.tuple.type.recursive === false)
             return decode_tuple_inline(__assign(__assign({}, props), { tuple: props.tuple.type }));
         var arrayExplore = __assign(__assign({}, props.explore), { source: "function", from: "array" });
-        return typescript_1.default.factory.createLogicalOr(typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.importer.useLocal("".concat(props.config.prefix, "t").concat(props.tuple.type.index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props.config)(__assign(__assign({}, arrayExplore), { source: "function" }))(props.input)), props.config.joiner.failure({
+        return typescript_1.default.factory.createLogicalOr(typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.importer.useLocal("".concat(props.config.prefix, "t").concat(props.tuple.type.index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray({
+            config: props.config,
+            explore: __assign(__assign({}, arrayExplore), { source: "function" }),
+            input: props.input,
+        })), props.config.joiner.failure({
             input: props.input,
             expected: props.tuple.type.name,
             explore: arrayExplore,
@@ -855,152 +914,164 @@ var CheckerProgrammer;
       ----------------------------------------------------------- */
     var explore_sets = function (props) {
         return typescript_1.default.factory.createCallExpression(UnionExplorer_1.UnionExplorer.set({
-            checker: function (input, metadata, explore, _container) {
-                return CheckerProgrammer.decode({
-                    context: props.context,
-                    config: props.config,
-                    importer: props.importer,
-                    input: input,
-                    metadata: metadata,
-                    explore: explore,
-                });
-            },
-            decoder: function (input, array, explore) {
-                return decode_array({
-                    config: props.config,
-                    context: props.context,
-                    importer: props.importer,
-                    array: array,
-                    input: input,
-                    explore: explore,
-                });
-            },
-            empty: props.config.success,
-            success: props.config.success,
-            failure: function (input, expected, explore) {
-                return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure({
-                    input: input,
-                    expected: expected,
-                    explore: explore,
-                }));
-            },
-        })([])(props.input, props.sets, props.explore), undefined, undefined);
-    };
-    var explore_maps = function (props) {
-        return typescript_1.default.factory.createCallExpression(UnionExplorer_1.UnionExplorer.map({
-            checker: function (input, entry, explore) {
-                return typescript_1.default.factory.createLogicalAnd(CheckerProgrammer.decode({
-                    config: props.config,
-                    context: props.context,
-                    importer: props.importer,
-                    input: typescript_1.default.factory.createElementAccessExpression(input, 0),
-                    metadata: entry[0],
-                    explore: __assign(__assign({}, explore), { postfix: "".concat(explore.postfix, "[0]") }),
-                }), CheckerProgrammer.decode({
-                    config: props.config,
-                    context: props.context,
-                    importer: props.importer,
-                    input: typescript_1.default.factory.createElementAccessExpression(input, 1),
-                    metadata: entry[1],
-                    explore: __assign(__assign({}, explore), { postfix: "".concat(explore.postfix, "[1]") }),
-                }));
-            },
-            decoder: function (input, array, explore) {
-                return decode_array({
-                    context: props.context,
-                    config: props.config,
-                    importer: props.importer,
-                    array: array,
-                    input: input,
-                    explore: explore,
-                });
-            },
-            empty: props.config.success,
-            success: props.config.success,
-            failure: function (input, expected, explore) {
-                return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure({
-                    input: input,
-                    expected: expected,
-                    explore: explore,
-                }));
-            },
-        })([])(props.input, props.maps, props.explore), undefined, undefined);
-    };
-    var explore_tuples = function (props) {
-        return explore_array_like_union_types({
-            config: props.config,
-            importer: props.importer,
-            factory: UnionExplorer_1.UnionExplorer.tuple({
-                checker: function (input, tuple, explore) {
-                    return decode_tuple({
+            config: {
+                checker: function (v) {
+                    return CheckerProgrammer.decode({
                         context: props.context,
                         config: props.config,
                         importer: props.importer,
-                        input: input,
-                        tuple: tuple,
-                        explore: explore,
+                        input: v.input,
+                        metadata: v.definition,
+                        explore: v.explore,
                     });
                 },
-                decoder: function (input, tuple, explore) {
-                    return decode_tuple({
-                        context: props.context,
+                decoder: function (v) {
+                    return decode_array({
                         config: props.config,
+                        context: props.context,
                         importer: props.importer,
-                        tuple: tuple,
-                        input: input,
-                        explore: explore,
+                        array: v.definition,
+                        input: v.input,
+                        explore: v.explore,
                     });
                 },
                 empty: props.config.success,
                 success: props.config.success,
-                failure: function (input, expected, explore) {
-                    return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure({
-                        input: input,
-                        expected: expected,
-                        explore: explore,
-                    }));
+                failure: function (v) {
+                    return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure(v));
                 },
-            }),
-            definitions: props.tuples,
+            },
+            parameters: [],
             input: props.input,
+            sets: props.sets,
             explore: props.explore,
-        });
+        }), undefined, undefined);
     };
-    var explore_arrays = function (props) {
-        return explore_array_like_union_types({
-            config: props.config,
-            importer: props.importer,
-            factory: UnionExplorer_1.UnionExplorer.array({
-                checker: function (input, metadata, explore) {
-                    return CheckerProgrammer.decode({
+    var explore_maps = function (props) {
+        return typescript_1.default.factory.createCallExpression(UnionExplorer_1.UnionExplorer.map({
+            config: {
+                checker: function (v) {
+                    return typescript_1.default.factory.createLogicalAnd(CheckerProgrammer.decode({
+                        config: props.config,
                         context: props.context,
+                        importer: props.importer,
+                        input: typescript_1.default.factory.createElementAccessExpression(v.input, 0),
+                        metadata: v.definition[0],
+                        explore: __assign(__assign({}, v.explore), { postfix: "".concat(v.explore.postfix, "[0]") }),
+                    }), CheckerProgrammer.decode({
                         config: props.config,
+                        context: props.context,
                         importer: props.importer,
-                        metadata: metadata,
-                        input: input,
-                        explore: explore,
-                    });
+                        input: typescript_1.default.factory.createElementAccessExpression(v.input, 1),
+                        metadata: v.definition[1],
+                        explore: __assign(__assign({}, v.explore), { postfix: "".concat(v.explore.postfix, "[1]") }),
+                    }));
                 },
-                decoder: function (input, array, explore) {
+                decoder: function (v) {
                     return decode_array({
                         context: props.context,
                         config: props.config,
                         importer: props.importer,
-                        array: array,
-                        input: input,
-                        explore: explore,
+                        array: v.definition,
+                        input: v.input,
+                        explore: v.explore,
                     });
                 },
                 empty: props.config.success,
                 success: props.config.success,
-                failure: function (input, expected, explore) {
-                    return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure({
-                        input: input,
-                        expected: expected,
-                        explore: explore,
-                    }));
+                failure: function (v) {
+                    return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure(v));
                 },
-            }),
+            },
+            parameters: [],
+            input: props.input,
+            maps: props.maps,
+            explore: props.explore,
+        }), undefined, undefined);
+    };
+    var explore_tuples = function (props) {
+        return explore_array_like_union_types({
+            config: props.config,
+            importer: props.importer,
+            factory: function (next) {
+                return UnionExplorer_1.UnionExplorer.tuple({
+                    config: {
+                        checker: function (v) {
+                            return decode_tuple({
+                                context: props.context,
+                                config: props.config,
+                                importer: props.importer,
+                                input: v.input,
+                                tuple: v.definition,
+                                explore: v.explore,
+                            });
+                        },
+                        decoder: function (v) {
+                            return decode_tuple({
+                                context: props.context,
+                                config: props.config,
+                                importer: props.importer,
+                                tuple: v.definition,
+                                input: v.input,
+                                explore: v.explore,
+                            });
+                        },
+                        empty: props.config.success,
+                        success: props.config.success,
+                        failure: function (v) {
+                            return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure(v));
+                        },
+                    },
+                    parameters: next.parameters,
+                    tuples: next.definitions,
+                    input: next.input,
+                    explore: next.explore,
+                });
+            },
+            definitions: props.tuples,
+            input: props.input,
+            explore: props.explore,
+        });
+    };
+    var explore_arrays = function (props) {
+        return explore_array_like_union_types({
+            config: props.config,
+            importer: props.importer,
+            factory: function (next) {
+                return UnionExplorer_1.UnionExplorer.array({
+                    config: {
+                        checker: function (v) {
+                            return CheckerProgrammer.decode({
+                                context: props.context,
+                                config: props.config,
+                                importer: props.importer,
+                                metadata: v.definition,
+                                input: v.input,
+                                explore: v.explore,
+                            });
+                        },
+                        decoder: function (v) {
+                            return decode_array({
+                                context: props.context,
+                                config: props.config,
+                                importer: props.importer,
+                                array: v.definition,
+                                input: v.input,
+                                explore: v.explore,
+                            });
+                        },
+                        empty: props.config.success,
+                        success: props.config.success,
+                        failure: function (v) {
+                            return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure(v));
+                        },
+                    },
+                    parameters: next.parameters,
+                    arrays: next.definitions,
+                    input: next.input,
+                    explore: next.explore,
+                });
+            },
             definitions: props.arrays,
             input: props.input,
             explore: props.explore,
@@ -1010,69 +1081,73 @@ var CheckerProgrammer;
         return explore_array_like_union_types({
             config: props.config,
             importer: props.importer,
-            factory: UnionExplorer_1.UnionExplorer.array_or_tuple({
-                checker: function (input, definition, explore, array) {
-                    return definition instanceof MetadataTuple_1.MetadataTuple
-                        ? decode_tuple({
-                            config: props.config,
-                            context: props.context,
-                            importer: props.importer,
-                            input: input,
-                            tuple: definition,
-                            explore: explore,
-                        })
-                        : props.config.atomist({
-                            explore: explore,
-                            entry: {
-                                expected: props.definitions
-                                    .map(function (elem) {
-                                    return elem instanceof MetadataArray_1.MetadataArray
-                                        ? elem.getName()
-                                        : elem.type.name;
+            factory: function (next) {
+                return UnionExplorer_1.UnionExplorer.array_or_tuple({
+                    config: {
+                        checker: function (v) {
+                            return v.definition instanceof MetadataTuple_1.MetadataTuple
+                                ? decode_tuple({
+                                    config: props.config,
+                                    context: props.context,
+                                    importer: props.importer,
+                                    input: v.input,
+                                    tuple: v.definition,
+                                    explore: v.explore,
                                 })
-                                    .join(" | "),
-                                expression: CheckerProgrammer.decode({
+                                : props.config.atomist({
+                                    explore: v.explore,
+                                    entry: {
+                                        expected: props.definitions
+                                            .map(function (elem) {
+                                            return elem instanceof MetadataArray_1.MetadataArray
+                                                ? elem.getName()
+                                                : elem.type.name;
+                                        })
+                                            .join(" | "),
+                                        expression: CheckerProgrammer.decode({
+                                            importer: props.importer,
+                                            context: props.context,
+                                            config: props.config,
+                                            metadata: v.definition,
+                                            input: v.input,
+                                            explore: v.explore,
+                                        }),
+                                        conditions: [],
+                                    },
+                                    input: v.container,
+                                });
+                        },
+                        decoder: function (v) {
+                            return v.definition instanceof MetadataTuple_1.MetadataTuple
+                                ? decode_tuple({
+                                    context: props.context,
+                                    config: props.config,
                                     importer: props.importer,
+                                    input: v.input,
+                                    tuple: v.definition,
+                                    explore: v.explore,
+                                })
+                                : decode_array({
                                     context: props.context,
                                     config: props.config,
-                                    input: input,
-                                    metadata: definition,
-                                    explore: explore,
-                                }),
-                                conditions: [],
-                            },
-                            input: array,
-                        });
-                },
-                decoder: function (input, definition, explore) {
-                    return definition instanceof MetadataTuple_1.MetadataTuple
-                        ? decode_tuple({
-                            context: props.context,
-                            config: props.config,
-                            importer: props.importer,
-                            input: input,
-                            tuple: definition,
-                            explore: explore,
-                        })
-                        : decode_array({
-                            context: props.context,
-                            config: props.config,
-                            importer: props.importer,
-                            input: input,
-                            array: definition,
-                            explore: explore,
-                        });
-                },
-                empty: props.config.success,
-                success: props.config.success,
-                failure: function (input, expected, explore) {
-                    return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure({
-                        input: input,
-                        expected: expected,
-                        explore: explore,
-                    }));
-                },
-            }),
+                                    importer: props.importer,
+                                    input: v.input,
+                                    array: v.definition,
+                                    explore: v.explore,
+                                });
+                        },
+                        empty: props.config.success,
+                        success: props.config.success,
+                        failure: function (v) {
+                            return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure(v));
+                        },
+                    },
+                    parameters: next.parameters,
+                    definitions: next.definitions,
+                    input: next.input,
+                    explore: next.explore,
+                });
+            },
             input: props.input,
             definitions: props.definitions,
             explore: props.explore,
@@ -1080,7 +1155,12 @@ var CheckerProgrammer;
     };
     var explore_array_like_union_types = function (props) {
         var arrow = function (next) {
-            return props.factory(next.parameters)(next.input, props.definitions, next.explore);
+            return props.factory({
+                parameters: next.parameters,
+                definitions: props.definitions,
+                input: next.input,
+                explore: next.explore,
+            });
         };
         if (props.definitions.every(function (e) { return e.type.recursive === false; }))
             typescript_1.default.factory.createCallExpression(arrow({
@@ -1091,11 +1171,15 @@ var CheckerProgrammer;
         var arrayExplore = __assign(__assign({}, props.explore), { source: "function", from: "array" });
         return typescript_1.default.factory.createLogicalOr(typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.importer.emplaceUnion(props.config.prefix, props.definitions.map(function (e) { return e.type.name; }).join(" | "), function () {
             return arrow({
-                parameters: FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations(props.config)(TypeFactory_1.TypeFactory.keyword("any"))(typescript_1.default.factory.createIdentifier("input")),
+                parameters: FeatureProgrammer_1.FeatureProgrammer.parameterDeclarations({
+                    config: props.config,
+                    type: TypeFactory_1.TypeFactory.keyword("any"),
+                    input: typescript_1.default.factory.createIdentifier("input"),
+                }),
                 explore: __assign(__assign({}, arrayExplore), { postfix: "" }),
                 input: typescript_1.default.factory.createIdentifier("input"),
             });
-        })), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props.config)(arrayExplore)(props.input)), props.config.joiner.failure({
+        })), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props)), props.config.joiner.failure({
             input: props.input,
             expected: props.definitions.map(function (e) { return e.type.name; }).join(" | "),
             explore: arrayExplore,
@@ -1110,7 +1194,7 @@ var CheckerProgrammer;
                 input: props.input,
                 explore: props.explore,
             })
-            : typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.importer.useLocal("".concat(props.config.prefix, "u").concat(props.metadata.union_index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props.config)(props.explore)(props.input));
+            : typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.importer.useLocal("".concat(props.config.prefix, "u").concat(props.metadata.union_index))), undefined, FeatureProgrammer_1.FeatureProgrammer.argumentsArray(props));
     };
 })(CheckerProgrammer || (exports.CheckerProgrammer = CheckerProgrammer = {}));
 var create_add = function (props) {