typia 7.0.0-dev.20240930 → 7.0.0-dev.20241002

package/lib/programmers/CheckerProgrammer.js

@@ -115,19 +115,22 @@ var CheckerProgrammer;
             .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({
-                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: {
-                    tracable: props.config.trace,
-                    source: "function",
-                    from: "array",
-                    postfix: "",
-                } }))));
+            return StatementFactory_1.StatementFactory.constant({
+                name: "".concat(props.config.prefix, "a").concat(i),
+                value: 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: {
+                        tracable: props.config.trace,
+                        source: "function",
+                        from: "array",
+                        postfix: "",
+                    } }))),
+            });
         });
     };
     CheckerProgrammer.write_tuple_functions = function (props) {
@@ -135,30 +138,33 @@ 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({
-                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,
-                input: typescript_1.default.factory.createIdentifier("input"),
-                tuple: tuple,
-                explore: {
-                    tracable: props.config.trace,
-                    source: "function",
-                    from: "array",
-                    postfix: "",
-                },
-            })));
+            return StatementFactory_1.StatementFactory.constant({
+                name: "".concat(props.config.prefix, "t").concat(i),
+                value: 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,
+                    input: typescript_1.default.factory.createIdentifier("input"),
+                    tuple: tuple,
+                    explore: {
+                        tracable: props.config.trace,
+                        source: "function",
+                        from: "array",
+                        postfix: "",
+                    },
+                })),
+            });
         });
     };
     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)));
+                return typescript_1.default.factory.createTypePredicateNode(undefined, "input", typescript_1.default.factory.createTypeReferenceNode(name !== null && name !== void 0 ? name : TypeFactory_1.TypeFactory.getFullName({ checker: props.context.checker, type: type })));
             },
         },
         trace: props.config.trace,
@@ -220,28 +226,33 @@ var CheckerProgrammer;
             unionizer: props.config.equals
                 ? function (next) {
                     var _a;
-                    return (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,
-                        }));
-                    })(next.input, next.objects, next.explore);
+                    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({
@@ -392,7 +403,7 @@ var CheckerProgrammer;
                                     ? ExpressionFactory_1.ExpressionFactory.number(v)
                                     : typescript_1.default.factory.createStringLiteral(v.toString());
                     })),
-                ])))("has"), undefined, [props.input]),
+                ])), "has"), undefined, [props.input]),
             });
         }
         else
@@ -441,7 +452,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,
@@ -450,7 +466,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,
@@ -459,7 +479,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,
@@ -485,7 +509,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,
@@ -495,7 +522,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,
                 });
             }
@@ -513,7 +543,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(" | "),
@@ -536,7 +569,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;
@@ -562,7 +598,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(" | "),
@@ -631,12 +667,13 @@ 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(); });
                     }),
-                })(props.input),
+                    input: props.input,
+                }),
                 expected: props.metadata.objects.map(function (obj) { return obj.name; }).join(" | "),
                 body: explore_objects({
                     config: props.config,
@@ -651,24 +688,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(),
                     });
@@ -691,7 +728,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,
@@ -763,7 +803,11 @@ var CheckerProgrammer;
         }));
     };
     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({
             config: {
                 prefix: props.config.prefix,
@@ -821,7 +865,7 @@ var CheckerProgrammer;
                 config: props.config,
                 context: props.context,
                 importer: props.importer,
-                input: typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(props.input)("slice"), undefined, [ExpressionFactory_1.ExpressionFactory.number(props.tuple.elements.length - 1)]),
+                input: typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(props.input, "slice"), undefined, [ExpressionFactory_1.ExpressionFactory.number(props.tuple.elements.length - 1)]),
                 metadata: (0, wrap_metadata_rest_tuple_1.wrap_metadata_rest_tuple)(props.tuple.elements.at(-1).rest),
                 explore: __assign(__assign({}, props.explore), { start: props.tuple.elements.length - 1 }),
             })
@@ -869,7 +913,7 @@ var CheckerProgrammer;
     };
     var decode_escaped = function (props) {
         return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createParenthesizedExpression(typescript_1.default.factory.createArrowFunction(undefined, undefined, [IdentifierFactory_1.IdentifierFactory.parameter("input", TypeFactory_1.TypeFactory.keyword("any"))], undefined, undefined, CheckerProgrammer.decode(__assign(__assign({}, props), { input: typescript_1.default.factory.createIdentifier("input") })))), undefined, [
-            typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(props.input)("toJSON"), undefined, []),
+            typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(props.input, "toJSON"), undefined, []),
         ]);
     };
     /* -----------------------------------------------------------
@@ -877,152 +921,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,
@@ -1032,69 +1088,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,
@@ -1102,7 +1162,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({