typia 3.8.0-dev.20230417 → 3.8.0-dev.20230420

package/lib/programmers/CheckerProgrammer.js

@@ -74,328 +74,355 @@ var check_union_tuple_1 = require("./internal/check_union_tuple");
 var decode_union_object_1 = require("./internal/decode_union_object");
 var CheckerProgrammer;
 (function (CheckerProgrammer) {
-    function generate(project, config, importer, addition) {
-        return FeatureProgrammer_1.FeatureProgrammer.generate(project, CONFIG(project, config, importer), importer, function () { return (addition ? (addition ? addition() : []) : undefined); });
-    }
-    CheckerProgrammer.generate = generate;
-    CheckerProgrammer.generate_functors = function (project, config, importer) {
-        return FeatureProgrammer_1.FeatureProgrammer.generate_functors(CONFIG(project, config, importer))(importer);
+    CheckerProgrammer.write = function (project) {
+        return function (config) {
+            return function (importer) {
+                return FeatureProgrammer_1.FeatureProgrammer.analyze(project)(configure(project)(config)(importer))(importer);
+            };
+        };
     };
-    CheckerProgrammer.generate_unioners = function (project, config, importer) {
-        return FeatureProgrammer_1.FeatureProgrammer.generate_unioners(CONFIG(project, __assign(__assign({}, config), { numeric: false }), importer))(importer);
+    CheckerProgrammer.write_functors = function (project) {
+        return function (config) {
+            return function (importer) {
+                return FeatureProgrammer_1.FeatureProgrammer.write_functors(configure(project)(config)(importer))(importer);
+            };
+        };
     };
-    function CONFIG(project, config, importer) {
-        var output = {
-            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(project.checker, type)));
-                },
-            },
-            trace: config.trace,
-            path: config.path,
-            functors: config.functors,
-            unioners: config.unioners,
-            initializer: function (_a, type) {
-                var checker = _a.checker;
-                var collection = new MetadataCollection_1.MetadataCollection();
-                var meta = MetadataFactory_1.MetadataFactory.generate(checker, collection, type, {
-                    resolve: false,
-                    constant: true,
-                });
-                return [collection, meta];
-            },
-            decoder: config.decoder || decode(project, config, importer),
-            objector: {
-                checker: config.decoder || decode(project, config, importer),
-                decoder: CheckerProgrammer.decode_object(config)(importer),
-                joiner: config.joiner.object,
-                unionizer: config.equals
-                    ? (0, decode_union_object_1.decode_union_object)(CheckerProgrammer.decode_object(config)(importer))(function (input, obj, explore) {
-                        return CheckerProgrammer.decode_object(config)(importer)(input, obj, __assign(__assign({}, explore), { tracable: true }));
-                    })(config.joiner.is || (function (expr) { return expr; }))(function (value, expected) {
-                        return typescript_1.default.factory.createReturnStatement(config.joiner.failure(value, expected));
-                    })
-                    : function (input, targets, explore) {
-                        return config.combiner(explore)("or")(input, targets.map(function (obj) { return ({
-                            expression: CheckerProgrammer.decode_object(config)(importer)(input, obj, explore),
-                            combined: true,
-                        }); }), "(".concat(targets.map(function (t) { return t.name; }).join(" | "), ")"));
+    CheckerProgrammer.write_unioners = function (project, config, importer) {
+        return FeatureProgrammer_1.FeatureProgrammer.write_unioners(configure(project)(__assign(__assign({}, config), { numeric: false }))(importer))(importer);
+    };
+    var configure = function (project) {
+        return function (config) {
+            return function (importer) {
+                var _a, _b, _c;
+                var output = {
+                    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(project.checker)(type)));
+                        },
                     },
-                failure: function (value, expected) {
-                    return typescript_1.default.factory.createReturnStatement(config.joiner.failure(value, expected));
-                },
-                is: config.joiner.is,
-                required: config.joiner.required,
-                full: config.joiner.full,
-                type: TypeFactory_1.TypeFactory.keyword("boolean"),
-            },
-        };
-        if (config.numeric === true)
-            output.generator = {
-                unioners: FeatureProgrammer_1.FeatureProgrammer.generate_unioners(CONFIG(project, __assign(__assign({}, config), { numeric: false }), importer))(importer),
-            };
-        return output;
-    }
-    function decode(project, config, importer) {
-        return function (input, meta, explore, metaTags, jsDocTags) {
-            var e_1, _a, e_2, _b, e_3, _c, e_4, _d;
-            if (meta.any)
-                return config.success;
-            var top = [];
-            var binaries = [];
-            var add = create_add(binaries)(input);
-            var getConstantValue = function (value) {
-                return typeof value === "string"
-                    ? typescript_1.default.factory.createStringLiteral(value)
-                    : typescript_1.default.factory.createIdentifier(value.toString());
+                    trace: config.trace,
+                    path: config.path,
+                    functors: config.functors,
+                    unioners: config.unioners,
+                    initializer: function (_a) {
+                        var checker = _a.checker;
+                        return function (type) {
+                            var collection = new MetadataCollection_1.MetadataCollection();
+                            var meta = MetadataFactory_1.MetadataFactory.analyze(checker)({
+                                resolve: false,
+                                constant: true,
+                            })(collection)(type);
+                            return [collection, meta];
+                        };
+                    },
+                    addition: config.addition,
+                    decoder: (_a = config.decoder) !== null && _a !== void 0 ? _a : CheckerProgrammer.decode(project)(config)(importer),
+                    objector: {
+                        checker: (_b = config.decoder) !== null && _b !== void 0 ? _b : CheckerProgrammer.decode(project)(config)(importer),
+                        decoder: CheckerProgrammer.decode_object(config)(importer),
+                        joiner: config.joiner.object,
+                        unionizer: config.equals
+                            ? (0, decode_union_object_1.decode_union_object)(CheckerProgrammer.decode_object(config)(importer))(function (input, obj, explore) {
+                                return CheckerProgrammer.decode_object(config)(importer)(input, obj, __assign(__assign({}, explore), { tracable: true }));
+                            })((_c = config.joiner.is) !== null && _c !== void 0 ? _c : (function (expr) { return expr; }))(function (value, expected) {
+                                return typescript_1.default.factory.createReturnStatement(config.joiner.failure(value, expected));
+                            })
+                            : function (input, targets, explore) {
+                                return config.combiner(explore)("or")(input, targets.map(function (obj) { return ({
+                                    expression: CheckerProgrammer.decode_object(config)(importer)(input, obj, explore),
+                                    combined: true,
+                                }); }), "(".concat(targets.map(function (t) { return t.name; }).join(" | "), ")"));
+                            },
+                        failure: function (value, expected) {
+                            return typescript_1.default.factory.createReturnStatement(config.joiner.failure(value, expected));
+                        },
+                        is: config.joiner.is,
+                        required: config.joiner.required,
+                        full: config.joiner.full,
+                        type: TypeFactory_1.TypeFactory.keyword("boolean"),
+                    },
+                };
+                if (config.numeric === true)
+                    output.generator = {
+                        unioners: FeatureProgrammer_1.FeatureProgrammer.write_unioners(configure(project)(__assign(__assign({}, config), { numeric: false }))(importer))(importer),
+                    };
+                return output;
             };
-            var checkOptional = meta.empty() || meta.isUnionBucket();
-            if (checkOptional ||
-                meta.nullable)
-                (meta.nullable ? add : create_add(top)(input))(meta.nullable, ValueFactory_1.ValueFactory.NULL());
-            if (checkOptional || !meta.required)
-                (meta.required ? create_add(top)(input) : add)(!meta.required, ValueFactory_1.ValueFactory.UNDEFINED());
-            if (meta.functional === true)
-                if (OptionPredicator_1.OptionPredicator.functional(project.options) ||
-                    meta.size() !== 1)
-                    add(true, typescript_1.default.factory.createStringLiteral("function"), ValueFactory_1.ValueFactory.TYPEOF(input));
-                else
-                    binaries.push({
-                        combined: false,
-                        expression: config.success,
-                    });
-            try {
-                for (var _e = __values(meta.constants), _f = _e.next(); !_f.done; _f = _e.next()) {
-                    var constant = _f.value;
-                    if (AtomicPredicator_1.AtomicPredicator.constant(meta)(constant.type))
+        };
+    };
+    CheckerProgrammer.decode = function (project) {
+        return function (config) {
+            return function (importer) {
+                return function (input, meta, explore, metaTags, jsDocTags) {
+                    var e_1, _a, e_2, _b, e_3, _c, e_4, _d;
+                    if (meta.any)
+                        return config.success;
+                    var top = [];
+                    var binaries = [];
+                    var add = create_add(binaries)(input);
+                    var getConstantValue = function (value) {
+                        return typeof value === "string"
+                            ? typescript_1.default.factory.createStringLiteral(value)
+                            : typescript_1.default.factory.createIdentifier(value.toString());
+                    };
+                    var checkOptional = meta.empty() || meta.isUnionBucket();
+                    if (checkOptional ||
+                        meta.nullable)
+                        (meta.nullable ? add : create_add(top)(input))(meta.nullable, ValueFactory_1.ValueFactory.NULL());
+                    if (checkOptional || !meta.required)
+                        (meta.required ? create_add(top)(input) : add)(!meta.required, ValueFactory_1.ValueFactory.UNDEFINED());
+                    if (meta.functional === true)
+                        if (OptionPredicator_1.OptionPredicator.functional(project.options) ||
+                            meta.size() !== 1)
+                            add(true, typescript_1.default.factory.createStringLiteral("function"), ValueFactory_1.ValueFactory.TYPEOF(input));
+                        else
+                            binaries.push({
+                                combined: false,
+                                expression: config.success,
+                            });
+                    try {
+                        for (var _e = __values(meta.constants), _f = _e.next(); !_f.done; _f = _e.next()) {
+                            var constant = _f.value;
+                            if (AtomicPredicator_1.AtomicPredicator.constant(meta)(constant.type))
+                                try {
+                                    for (var _g = (e_2 = void 0, __values(constant.values)), _h = _g.next(); !_h.done; _h = _g.next()) {
+                                        var val = _h.value;
+                                        add(true, getConstantValue(val));
+                                    }
+                                }
+                                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                                finally {
+                                    try {
+                                        if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+                                    }
+                                    finally { if (e_2) throw e_2.error; }
+                                }
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
                         try {
-                            for (var _g = (e_2 = void 0, __values(constant.values)), _h = _g.next(); !_h.done; _h = _g.next()) {
-                                var val = _h.value;
-                                add(true, getConstantValue(val));
-                            }
+                            if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
                         }
-                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                        finally {
-                            try {
-                                if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
-                            }
-                            finally { if (e_2) throw e_2.error; }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    try {
+                        for (var _j = __values(meta.atomics), _k = _j.next(); !_k.done; _k = _j.next()) {
+                            var type = _k.value;
+                            if (AtomicPredicator_1.AtomicPredicator.atomic(meta)(type) === false)
+                                continue;
+                            else if (type === "number")
+                                binaries.push({
+                                    expression: config.atomist(explore)((0, check_number_1.check_number)(project, config.numeric)(importer)(metaTags)(jsDocTags)(input))(input),
+                                    combined: false,
+                                });
+                            else if (type === "bigint")
+                                binaries.push({
+                                    expression: config.atomist(explore)((0, check_bigint_1.check_bigint)(importer)(metaTags)(jsDocTags)(input))(input),
+                                    combined: false,
+                                });
+                            else if (type === "string")
+                                binaries.push({
+                                    expression: config.atomist(explore)((0, check_string_1.check_string)(importer)(metaTags)(jsDocTags)(input))(input),
+                                    combined: false,
+                                });
+                            else
+                                add(true, typescript_1.default.factory.createStringLiteral(type), ValueFactory_1.ValueFactory.TYPEOF(input));
                         }
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            try {
-                for (var _j = __values(meta.atomics), _k = _j.next(); !_k.done; _k = _j.next()) {
-                    var type = _k.value;
-                    if (AtomicPredicator_1.AtomicPredicator.atomic(meta)(type) === false)
-                        continue;
-                    else if (type === "number")
-                        binaries.push({
-                            expression: config.atomist(explore)((0, check_number_1.check_number)(project, config.numeric)(importer)(metaTags)(jsDocTags)(input))(input),
-                            combined: false,
-                        });
-                    else if (type === "bigint")
-                        binaries.push({
-                            expression: config.atomist(explore)((0, check_bigint_1.check_bigint)(importer)(metaTags)(jsDocTags)(input))(input),
-                            combined: false,
-                        });
-                    else if (type === "string")
-                        binaries.push({
-                            expression: config.atomist(explore)((0, check_string_1.check_string)(importer)(metaTags)(jsDocTags)(input))(input),
-                            combined: false,
-                        });
-                    else
-                        add(true, typescript_1.default.factory.createStringLiteral(type), ValueFactory_1.ValueFactory.TYPEOF(input));
-                }
-            }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
-                try {
-                    if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
-                }
-                finally { if (e_3) throw e_3.error; }
-            }
-            if (meta.templates.length)
-                if (AtomicPredicator_1.AtomicPredicator.template(meta))
-                    binaries.push({
-                        expression: config.atomist(explore)((0, check_template_1.check_template)(importer)(metaTags)(jsDocTags)(meta.templates)(input))(input),
-                        combined: false,
-                    });
-            try {
-                for (var _l = __values(meta.natives), _m = _l.next(); !_m.done; _m = _l.next()) {
-                    var native = _m.value;
-                    binaries.push({
-                        expression: (0, check_native_1.check_native)(native)(input),
-                        combined: false,
-                    });
-                }
-            }
-            catch (e_4_1) { e_4 = { error: e_4_1 }; }
-            finally {
-                try {
-                    if (_m && !_m.done && (_d = _l.return)) _d.call(_l);
-                }
-                finally { if (e_4) throw e_4.error; }
-            }
-            var instances = [];
-            var prepare = function (pre, expected) {
-                return function (body) {
-                    return instances.push({
-                        pre: pre,
-                        expected: expected,
-                        body: body,
-                    });
+                    }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    finally {
+                        try {
+                            if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                    }
+                    if (meta.templates.length)
+                        if (AtomicPredicator_1.AtomicPredicator.template(meta))
+                            binaries.push({
+                                expression: config.atomist(explore)((0, check_template_1.check_template)(importer)(metaTags)(jsDocTags)(meta.templates)(input))(input),
+                                combined: false,
+                            });
+                    try {
+                        for (var _l = __values(meta.natives), _m = _l.next(); !_m.done; _m = _l.next()) {
+                            var native = _m.value;
+                            binaries.push({
+                                expression: (0, check_native_1.check_native)(native)(input),
+                                combined: false,
+                            });
+                        }
+                    }
+                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                    finally {
+                        try {
+                            if (_m && !_m.done && (_d = _l.return)) _d.call(_l);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                    }
+                    var instances = [];
+                    var prepare = function (pre, expected) {
+                        return function (body) {
+                            return instances.push({
+                                pre: pre,
+                                expected: expected,
+                                body: body,
+                            });
+                        };
+                    };
+                    if (meta.sets.length) {
+                        var install = prepare((0, check_native_1.check_native)("Set")(input), meta.sets
+                            .map(function (elem) { return "Set<".concat(elem.getName(), ">"); })
+                            .join(" | "));
+                        if (meta.sets.some(function (elem) { return elem.any; }))
+                            install(null);
+                        else
+                            install(explore_sets(project)(config)(importer)(input, meta.sets, __assign(__assign({}, explore), { from: "array" }), [], []));
+                    }
+                    if (meta.maps.length) {
+                        var install = prepare((0, check_native_1.check_native)("Map")(input), meta.maps
+                            .map(function (_a) {
+                            var key = _a.key, value = _a.value;
+                            return "Map<".concat(key, ", ").concat(value, ">");
+                        })
+                            .join(" | "));
+                        if (meta.maps.some(function (elem) { return elem.key.any && elem.value.any; }))
+                            install(null);
+                        else
+                            install(explore_maps(project)(config)(importer)(input, meta.maps.map(function (m) { return [m.key, m.value]; }), __assign(__assign({}, explore), { from: "array" }), [], []));
+                    }
+                    if (meta.tuples.length + meta.arrays.length > 0) {
+                        var install = prepare(config.atomist(explore)((0, check_array_1.check_array)(importer)(meta.tuples.length === 0 ? metaTags : [])(jsDocTags)(input))(input), __spreadArray(__spreadArray([], __read(meta.tuples), false), __read(meta.arrays), false).map(function (elem) {
+                            return Array.isArray(elem)
+                                ? "[".concat(elem
+                                    .map(function (elem) { return elem.getName(); })
+                                    .join(", "), "]")
+                                : "Array<".concat(elem.getName(), ">");
+                        })
+                            .join(" | "));
+                        if (meta.arrays.length === 0)
+                            install(explore_tuples(project)(config)(importer)(input, meta.tuples, __assign(__assign({}, explore), { from: "array" }), metaTags, jsDocTags));
+                        else if (meta.arrays.some(function (elem) { return elem.any; }))
+                            install(null);
+                        else if (meta.tuples.length === 0)
+                            install(explore_arrays(project, config, importer)(input, meta.arrays, __assign(__assign({}, explore), { from: "array" }), metaTags, jsDocTags));
+                        else
+                            install(explore_arrays_and_tuples(project, config, importer)(input, __spreadArray(__spreadArray([], __read(meta.tuples), false), __read(meta.arrays), false), explore, metaTags, jsDocTags));
+                    }
+                    if (meta.objects.length > 0)
+                        prepare(ExpressionFactory_1.ExpressionFactory.isObject({
+                            checkNull: true,
+                            checkArray: meta.objects.some(function (obj) {
+                                return obj.properties.every(function (prop) {
+                                    return !prop.key.isSoleLiteral() ||
+                                        !prop.value.required;
+                                });
+                            }),
+                        })(input), meta.objects.map(function (obj) { return obj.name; }).join(" | "))(explore_objects(config)(importer)(input, meta, __assign(__assign({}, explore), { from: "object" })));
+                    if (instances.length) {
+                        var transformer = function (merger) {
+                            return function (ins) {
+                                return ins.body
+                                    ? {
+                                        expression: merger(ins.pre, ins.body),
+                                        combined: true,
+                                    }
+                                    : {
+                                        expression: ins.pre,
+                                        combined: false,
+                                    };
+                            };
+                        };
+                        if (instances.length === 1)
+                            binaries.push(transformer(function (pre, body) {
+                                return config.combiner(explore)("and")(input, [pre, body].map(function (expression) { return ({
+                                    expression: expression,
+                                    combined: expression !== pre,
+                                }); }), meta.getName());
+                            })(instances[0]));
+                        else
+                            binaries.push({
+                                expression: config.combiner(explore)("or")(input, instances.map(transformer(typescript_1.default.factory.createLogicalAnd)), meta.getName()),
+                                combined: true,
+                            });
+                    }
+                    return top.length && binaries.length
+                        ? config.combiner(explore)("and")(input, __spreadArray(__spreadArray([], __read(top), false), [
+                            {
+                                expression: config.combiner(explore)("or")(input, binaries, meta.getName()),
+                                combined: true,
+                            },
+                        ], false), meta.getName())
+                        : binaries.length
+                            ? config.combiner(explore)("or")(input, binaries, meta.getName())
+                            : config.success;
                 };
             };
-            if (meta.sets.length) {
-                var install = prepare((0, check_native_1.check_native)("Set")(input), meta.sets
-                    .map(function (elem) { return "Set<".concat(elem.getName(), ">"); })
-                    .join(" | "));
-                if (meta.sets.some(function (elem) { return elem.any; }))
-                    install(null);
-                else
-                    install(explore_sets(project, config, importer)(input, meta.sets, __assign(__assign({}, explore), { from: "array" }), [], []));
-            }
-            if (meta.maps.length) {
-                var install = prepare((0, check_native_1.check_native)("Map")(input), meta.maps
-                    .map(function (_a) {
-                    var key = _a.key, value = _a.value;
-                    return "Map<".concat(key, ", ").concat(value, ">");
-                })
-                    .join(" | "));
-                if (meta.maps.some(function (elem) { return elem.key.any && elem.value.any; }))
-                    install(null);
-                else
-                    install(explore_maps(project, config, importer)(input, meta.maps.map(function (m) { return [m.key, m.value]; }), __assign(__assign({}, explore), { from: "array" }), [], []));
-            }
-            if (meta.tuples.length + meta.arrays.length > 0) {
-                var install = prepare(config.atomist(explore)((0, check_array_1.check_array)(importer)(meta.tuples.length === 0 ? metaTags : [])(jsDocTags)(input))(input), __spreadArray(__spreadArray([], __read(meta.tuples), false), __read(meta.arrays), false).map(function (elem) {
-                    return Array.isArray(elem)
-                        ? "[".concat(elem
-                            .map(function (elem) { return elem.getName(); })
-                            .join(", "), "]")
-                        : "Array<".concat(elem.getName(), ">");
-                })
-                    .join(" | "));
-                if (meta.arrays.length === 0)
-                    install(explore_tuples(project, config, importer)(input, meta.tuples, __assign(__assign({}, explore), { from: "array" }), metaTags, jsDocTags));
-                else if (meta.arrays.some(function (elem) { return elem.any; }))
-                    install(null);
-                else if (meta.tuples.length === 0)
-                    install(explore_arrays(project, config, importer)(input, meta.arrays, __assign(__assign({}, explore), { from: "array" }), metaTags, jsDocTags));
-                else
-                    install(explore_arrays_and_tuples(project, config, importer)(input, __spreadArray(__spreadArray([], __read(meta.tuples), false), __read(meta.arrays), false), explore, metaTags, jsDocTags));
-            }
-            if (meta.objects.length > 0)
-                prepare(ExpressionFactory_1.ExpressionFactory.isObject(input, {
-                    checkNull: true,
-                    checkArray: meta.objects.some(function (obj) {
-                        return obj.properties.every(function (prop) {
-                            return !prop.key.isSoleLiteral() ||
-                                !prop.value.required;
+        };
+    };
+    CheckerProgrammer.decode_tuple = function (project) {
+        return function (config) {
+            return function (importer) {
+                return function (checkLength) {
+                    return function (input, tuple, explore, tagList, jsDocTags) {
+                        var binaries = tuple
+                            .filter(function (meta) { return meta.rest === null; })
+                            .map(function (meta, index) {
+                            return CheckerProgrammer.decode(project)(config)(importer)(typescript_1.default.factory.createElementAccessExpression(input, index), meta, __assign(__assign({}, explore), { from: "array", postfix: explore.postfix.length
+                                    ? "".concat(explore.postfix.slice(0, -1), "[").concat(index, "]\"")
+                                    : "[".concat(index, "]") }), tagList, jsDocTags);
                         });
-                    }),
-                }), meta.objects.map(function (obj) { return "".concat(obj.name); }).join(" | "))(explore_objects(config)(importer)(input, meta, __assign(__assign({}, explore), { from: "object" })));
-            if (instances.length) {
-                var transformer = function (merger) {
-                    return function (ins) {
-                        return ins.body
-                            ? {
-                                expression: merger(ins.pre, ins.body),
+                        var rest = tuple.length && tuple[tuple.length - 1].rest !== null
+                            ? CheckerProgrammer.decode(project)(config)(importer)(typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.join(input)("slice"), undefined, [
+                                typescript_1.default.factory.createNumericLiteral(tuple.length - 1),
+                            ]), (function () {
+                                var wrapper = Metadata_1.Metadata.initialize();
+                                wrapper.arrays.push(tuple[tuple.length - 1].rest);
+                                return wrapper;
+                            })(), __assign(__assign({}, explore), { start: tuple.length - 1 }), tagList, jsDocTags)
+                            : null;
+                        return config.combiner(explore)("and")(input, __spreadArray(__spreadArray(__spreadArray([], __read((checkLength && rest === null
+                            ? [
+                                {
+                                    combined: false,
+                                    expression: typescript_1.default.factory.createStrictEquality(typescript_1.default.factory.createPropertyAccessExpression(input, "length"), typescript_1.default.factory.createNumericLiteral(tuple.length)),
+                                },
+                            ]
+                            : [])), false), __read((config.joiner.tuple
+                            ? [
+                                {
+                                    expression: config.joiner.tuple(binaries),
+                                    combined: true,
+                                },
+                            ]
+                            : binaries.map(function (expression) { return ({
+                                expression: expression,
                                 combined: true,
-                            }
-                            : {
-                                expression: ins.pre,
-                                combined: false,
-                            };
+                            }); }))), false), __read((rest !== null
+                            ? [
+                                {
+                                    expression: rest,
+                                    combined: true,
+                                },
+                            ]
+                            : [])), false), "[".concat(tuple.map(function (t) { return t.getName(); }).join(", "), "]"));
                     };
                 };
-                if (instances.length === 1)
-                    binaries.push(transformer(function (pre, body) {
-                        return config.combiner(explore)("and")(input, [pre, body].map(function (expression) { return ({
-                            expression: expression,
-                            combined: expression !== pre,
-                        }); }), meta.getName());
-                    })(instances[0]));
-                else
-                    binaries.push({
-                        expression: config.combiner(explore)("or")(input, instances.map(transformer(typescript_1.default.factory.createLogicalAnd)), meta.getName()),
-                        combined: true,
-                    });
-            }
-            return top.length && binaries.length
-                ? config.combiner(explore)("and")(input, __spreadArray(__spreadArray([], __read(top), false), [
-                    {
-                        expression: config.combiner(explore)("or")(input, binaries, meta.getName()),
-                        combined: true,
-                    },
-                ], false), meta.getName())
-                : binaries.length
-                    ? config.combiner(explore)("or")(input, binaries, meta.getName())
-                    : config.success;
+            };
         };
-    }
-    CheckerProgrammer.decode = decode;
-    function decode_tuple(project, config, importer, checkLength) {
-        return function (input, tuple, explore, tagList, jsDocTags) {
-            var binaries = tuple
-                .filter(function (meta) { return meta.rest === null; })
-                .map(function (meta, index) {
-                return decode(project, config, importer)(typescript_1.default.factory.createElementAccessExpression(input, index), meta, __assign(__assign({}, explore), { from: "array", postfix: explore.postfix.length
-                        ? "".concat(explore.postfix.slice(0, -1), "[").concat(index, "]\"")
-                        : "[".concat(index, "]") }), tagList, jsDocTags);
-            });
-            var rest = tuple.length && tuple[tuple.length - 1].rest !== null
-                ? decode(project, config, importer, false)(typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.join(input, "slice"), undefined, [
-                    typescript_1.default.factory.createNumericLiteral(tuple.length - 1),
-                ]), (function () {
-                    var wrapper = Metadata_1.Metadata.initialize();
-                    wrapper.arrays.push(tuple[tuple.length - 1].rest);
-                    return wrapper;
-                })(), __assign(__assign({}, explore), { start: tuple.length - 1 }), tagList, jsDocTags)
-                : null;
-            return config.combiner(explore)("and")(input, __spreadArray(__spreadArray(__spreadArray([], __read((checkLength && rest === null
-                ? [
-                    {
-                        combined: false,
-                        expression: typescript_1.default.factory.createStrictEquality(typescript_1.default.factory.createPropertyAccessExpression(input, "length"), typescript_1.default.factory.createNumericLiteral(tuple.length)),
-                    },
-                ]
-                : [])), false), __read((config.joiner.tuple
-                ? [
-                    {
-                        expression: config.joiner.tuple(binaries),
-                        combined: true,
-                    },
-                ]
-                : binaries.map(function (expression) { return ({
-                    expression: expression,
-                    combined: true,
-                }); }))), false), __read((rest !== null
-                ? [
-                    {
-                        expression: rest,
-                        combined: true,
-                    },
-                ]
-                : [])), false), "[".concat(tuple.map(function (t) { return t.getName(); }).join(", "), "]"));
+    };
+    var decode_array = function (project) {
+        return function (config) {
+            return function (importer) {
+                return FeatureProgrammer_1.FeatureProgrammer.decode_array({
+                    trace: config.trace,
+                    path: config.path,
+                    decoder: CheckerProgrammer.decode(project)(config)(importer),
+                })(importer)(config.joiner.array);
+            };
         };
-    }
-    CheckerProgrammer.decode_tuple = decode_tuple;
-    function decode_array(project, config, importer, checkTupleLength) {
-        return FeatureProgrammer_1.FeatureProgrammer.decode_array({
-            trace: config.trace,
-            path: config.path,
-            decoder: decode(project, config, importer, checkTupleLength),
-        }, importer, config.joiner.array);
-    }
+    };
     CheckerProgrammer.decode_object = function (config) { return function (importer) {
         var func = FeatureProgrammer_1.FeatureProgrammer.decode_object(config)(importer);
         return function (input, obj, explore) {
@@ -403,64 +430,76 @@ var CheckerProgrammer;
             return func(input, obj, explore);
         };
     }; };
-    var explore_sets = function (project, config, importer) {
-        return UnionExplorer_1.UnionExplorer.set({
-            checker: decode(project, config, importer),
-            decoder: decode_array(project, config, importer, true),
-            empty: config.success,
-            success: config.success,
-            failure: function (input, expected, explore) {
-                return typescript_1.default.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
-            },
-        });
+    var explore_sets = function (project) {
+        return function (config) {
+            return function (importer) {
+                return UnionExplorer_1.UnionExplorer.set({
+                    checker: CheckerProgrammer.decode(project)(config)(importer),
+                    decoder: decode_array(project)(config)(importer),
+                    empty: config.success,
+                    success: config.success,
+                    failure: function (input, expected, explore) {
+                        return typescript_1.default.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
+                    },
+                });
+            };
+        };
     };
-    var explore_maps = function (project, config, importer) {
-        return UnionExplorer_1.UnionExplorer.map({
-            checker: function (input, entry, explore) {
-                var func = decode(project, config, importer);
-                return typescript_1.default.factory.createLogicalAnd(func(typescript_1.default.factory.createElementAccessExpression(input, 0), entry[0], __assign(__assign({}, explore), { postfix: "".concat(explore.postfix, "[0]") }), [], []), func(typescript_1.default.factory.createElementAccessExpression(input, 1), entry[1], __assign(__assign({}, explore), { postfix: "".concat(explore.postfix, "[1]") }), [], []));
-            },
-            decoder: function (input, target, explore) {
-                return decode_array(project, config, importer, false)(input, Metadata_1.Metadata.create({
-                    any: false,
-                    nullable: false,
-                    required: true,
-                    functional: false,
-                    resolved: null,
-                    constants: [],
-                    atomics: [],
-                    templates: [],
-                    rest: null,
-                    arrays: [],
-                    tuples: [target],
-                    objects: [],
-                    natives: [],
-                    sets: [],
-                    maps: [],
-                }), explore, [], []);
-            },
-            empty: config.success,
-            success: config.success,
-            failure: function (input, expected, explore) {
-                return typescript_1.default.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
-            },
-        });
+    var explore_maps = function (project) {
+        return function (config) {
+            return function (importer) {
+                return UnionExplorer_1.UnionExplorer.map({
+                    checker: function (input, entry, explore) {
+                        var func = CheckerProgrammer.decode(project)(config)(importer);
+                        return typescript_1.default.factory.createLogicalAnd(func(typescript_1.default.factory.createElementAccessExpression(input, 0), entry[0], __assign(__assign({}, explore), { postfix: "".concat(explore.postfix, "[0]") }), [], []), func(typescript_1.default.factory.createElementAccessExpression(input, 1), entry[1], __assign(__assign({}, explore), { postfix: "".concat(explore.postfix, "[1]") }), [], []));
+                    },
+                    decoder: function (input, target, explore) {
+                        return decode_array(project)(config)(importer)(input, Metadata_1.Metadata.create({
+                            any: false,
+                            nullable: false,
+                            required: true,
+                            functional: false,
+                            resolved: null,
+                            constants: [],
+                            atomics: [],
+                            templates: [],
+                            rest: null,
+                            arrays: [],
+                            tuples: [target],
+                            objects: [],
+                            natives: [],
+                            sets: [],
+                            maps: [],
+                        }), explore, [], []);
+                    },
+                    empty: config.success,
+                    success: config.success,
+                    failure: function (input, expected, explore) {
+                        return typescript_1.default.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
+                    },
+                });
+            };
+        };
     };
-    var explore_tuples = function (project, config, importer) {
-        return UnionExplorer_1.UnionExplorer.tuple({
-            checker: (0, check_union_tuple_1.check_union_tuple)(project, config, importer),
-            decoder: decode_tuple(project, config, importer, true),
-            empty: config.success,
-            success: config.success,
-            failure: function (input, expected, explore) {
-                return typescript_1.default.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
-            },
-        });
+    var explore_tuples = function (project) {
+        return function (config) {
+            return function (importer) {
+                return UnionExplorer_1.UnionExplorer.tuple({
+                    checker: (0, check_union_tuple_1.check_union_tuple)(project)(config)(importer),
+                    decoder: CheckerProgrammer.decode_tuple(project)(config)(importer)(true),
+                    empty: config.success,
+                    success: config.success,
+                    failure: function (input, expected, explore) {
+                        return typescript_1.default.factory.createReturnStatement(config.joiner.failure(input, expected, explore));
+                    },
+                });
+            };
+        };
     };
     var explore_arrays = function (project, config, importer) {
         return UnionExplorer_1.UnionExplorer.array({
-            checker: decode(project, config, importer),
-            decoder: decode_array(project, config, importer, true),
+            checker: CheckerProgrammer.decode(project)(config)(importer),
+            decoder: decode_array(project)(config)(importer),
             empty: config.success,
             success: config.success,
             failure: function (input, expected, explore) {
@@ -472,16 +511,16 @@ var CheckerProgrammer;
         return UnionExplorer_1.UnionExplorer.array_or_tuple({
             checker: function (front, target, explore, tags, jsDocTags, array) {
                 return Array.isArray(target)
-                    ? (0, check_union_tuple_1.check_union_tuple)(project, config, importer)(front, target, explore, tags, jsDocTags, array)
+                    ? (0, check_union_tuple_1.check_union_tuple)(project)(config)(importer)(front, target, explore, tags, jsDocTags, array)
                     : config.atomist(explore)({
-                        expression: decode(project, config, importer)(front, target, explore, tags, jsDocTags),
+                        expression: CheckerProgrammer.decode(project)(config)(importer)(front, target, explore, tags, jsDocTags),
                         tags: (0, check_array_length_1.check_array_length)(tags)(array),
                     })(array);
             },
             decoder: function (input, target, explore, tags, jsDocTags) {
                 return Array.isArray(target)
-                    ? decode_tuple(project, config, importer, true)(input, target, explore, tags, jsDocTags)
-                    : decode_array(project, config, importer, true)(input, target, explore, tags, jsDocTags);
+                    ? CheckerProgrammer.decode_tuple(project)(config)(importer)(true)(input, target, explore, tags, jsDocTags)
+                    : decode_array(project)(config)(importer)(input, target, explore, tags, jsDocTags);
             },
             empty: config.success,
             success: config.success,