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

package/src/programmers/CheckerProgrammer.ts

@@ -44,7 +44,11 @@ export namespace CheckerProgrammer {
     equals: boolean;
     numeric: boolean;
     addition?: () => ts.Statement[];
-    decoder?: () => FeatureProgrammer.Decoder<Metadata, ts.Expression>;
+    decoder?: (props: {
+      metadata: Metadata;
+      input: ts.Expression;
+      explore: IExplore;
+    }) => ts.Expression;
     combiner: IConfig.Combiner;
     atomist: (props: {
       entry: ICheckEntry;
@@ -121,10 +125,13 @@ export namespace CheckerProgrammer {
     type: ts.Type;
     name?: string;
   }): ts.ArrowFunction =>
-    FeatureProgrammer.write(props.context)(configure(props))(props.importer)(
-      props.type,
-      props.name,
-    );
+    FeatureProgrammer.write({
+      config: configure(props),
+      context: props.context,
+      importer: props.importer,
+      type: props.type,
+      name: props.name,
+    });
 
   export const write_object_functions = (props: {
     context: ITypiaContext;
@@ -144,8 +151,8 @@ export namespace CheckerProgrammer {
     importer: FunctionImporter;
     collection: MetadataCollection;
   }): ts.VariableStatement[] =>
-    FeatureProgrammer.write_union_functions(
-      configure({
+    FeatureProgrammer.write_union_functions({
+      config: configure({
         context: props.context,
         config: {
           ...props.config,
@@ -153,7 +160,8 @@ export namespace CheckerProgrammer {
         },
         importer: props.importer,
       }),
-    )(props.collection);
+      collection: props.collection,
+    });
 
   export const write_array_functions = (props: {
     context: ITypiaContext;
@@ -170,9 +178,11 @@ export namespace CheckerProgrammer {
           ts.factory.createArrowFunction(
             undefined,
             undefined,
-            FeatureProgrammer.parameterDeclarations(props.config)(
-              TypeFactory.keyword("any"),
-            )(ts.factory.createIdentifier("input")),
+            FeatureProgrammer.parameterDeclarations({
+              config: props.config,
+              type: TypeFactory.keyword("any"),
+              input: ts.factory.createIdentifier("input"),
+            }),
             TypeFactory.keyword("any"),
             undefined,
             decode_array_inline({
@@ -208,9 +218,11 @@ export namespace CheckerProgrammer {
           ts.factory.createArrowFunction(
             undefined,
             undefined,
-            FeatureProgrammer.parameterDeclarations(props.config)(
-              TypeFactory.keyword("any"),
-            )(ts.factory.createIdentifier("input")),
+            FeatureProgrammer.parameterDeclarations({
+              config: props.config,
+              type: TypeFactory.keyword("any"),
+              input: ts.factory.createIdentifier("input"),
+            }),
             TypeFactory.keyword("any"),
             undefined,
             decode_tuple_inline({
@@ -249,141 +261,135 @@ export namespace CheckerProgrammer {
     trace: props.config.trace,
     path: props.config.path,
     prefix: props.config.prefix,
-    initializer: (context) => (importer) => (type) => {
+    initializer: (next) => {
       const collection: MetadataCollection = new MetadataCollection();
       const result = MetadataFactory.analyze({
-        checker: context.checker,
-        transformer: context.transformer,
+        checker: next.context.checker,
+        transformer: next.context.transformer,
         options: {
           escape: false,
           constant: true,
           absorb: true,
         },
         collection,
-        type,
+        type: next.type,
       });
       if (result.success === false)
-        throw TransformerError.from(`typia.${importer.method}`)(result.errors);
+        throw TransformerError.from(`typia.${next.importer.method}`)(
+          result.errors,
+        );
       return [collection, result.data];
     },
     addition: props.config.addition,
-    decoder: () =>
-      props.config.decoder
-        ? (input, metadata, explore) =>
-            props.config.decoder!()(input, metadata, explore)
-        : (input, metadata, explore) =>
+    decoder: props.config.decoder
+      ? (next) => props.config.decoder!(next)
+      : (next) =>
+          decode({
+            context: props.context,
+            config: props.config,
+            importer: props.importer,
+            input: next.input,
+            metadata: next.metadata,
+            explore: next.explore,
+          }),
+    objector: {
+      checker: props.config.decoder
+        ? (next) => props.config.decoder!(next)
+        : (next) =>
             decode({
               context: props.context,
               config: props.config,
               importer: props.importer,
-              input,
-              metadata,
-              explore,
+              input: next.input,
+              metadata: next.metadata,
+              explore: next.explore,
             }),
-    objector: {
-      checker: () => (input, metadata, explore) =>
-        props.config.decoder?.()(input, metadata, explore) ??
-        decode({
-          context: props.context,
-          config: props.config,
-          importer: props.importer,
-          input,
-          metadata,
-          explore,
-        }),
-      decoder: () => (input, object, explore) =>
+      decoder: (next) =>
         decode_object({
           config: props.config,
           importer: props.importer,
-          input,
-          object,
-          explore,
+          input: next.input,
+          object: next.object,
+          explore: next.explore,
         }),
       joiner: props.config.joiner.object,
       unionizer: props.config.equals
-        ? decode_union_object((input, object, explore) =>
-            decode_object({
-              config: props.config,
-              importer: props.importer,
-              object,
-              input,
-              explore,
-            }),
-          )((input, object, explore) =>
-            decode_object({
-              config: props.config,
-              importer: props.importer,
-              input,
-              object,
-              explore: {
-                ...explore,
-                tracable: true,
-              },
-            }),
-          )(props.config.joiner.is ?? ((expr) => expr))((input, expected) =>
-            ts.factory.createReturnStatement(
-              props.config.joiner.failure({
-                input,
-                expected,
-              }),
-            ),
-          )
-        : (input, targets, explore) =>
+        ? (next) =>
+            decode_union_object({
+              checker: (v) =>
+                decode_object({
+                  config: props.config,
+                  importer: props.importer,
+                  object: v.object,
+                  input: v.input,
+                  explore: v.explore,
+                }),
+              decoder: (v) =>
+                decode_object({
+                  config: props.config,
+                  importer: props.importer,
+                  input: v.input,
+                  object: v.object,
+                  explore: {
+                    ...v.explore,
+                    tracable: true,
+                  },
+                }),
+              success: props.config.joiner.is ?? ((expr) => expr),
+              escaper: (v) =>
+                ts.factory.createReturnStatement(
+                  props.config.joiner.failure(v),
+                ),
+              input: next.input,
+              objects: next.objects,
+              explore: next.explore,
+            })
+        : (next) =>
             props.config.combiner({
-              explore,
               logic: "or",
-              input,
-              binaries: targets.map((object) => ({
+              explore: next.explore,
+              input: next.input,
+              binaries: next.objects.map((object) => ({
                 expression: decode_object({
                   config: props.config,
                   importer: props.importer,
-                  input,
                   object,
-                  explore,
+                  input: next.input,
+                  explore: next.explore,
                 }),
                 combined: true,
               })),
-              expected: `(${targets.map((t) => t.name).join(" | ")})`,
+              expected: `(${next.objects.map((t) => t.name).join(" | ")})`,
             }),
-      failure: (input, expected) =>
-        ts.factory.createReturnStatement(
-          props.config.joiner.failure({
-            input,
-            expected,
-          }),
-        ),
+      failure: (next) =>
+        ts.factory.createReturnStatement(props.config.joiner.failure(next)),
       is: props.config.joiner.is,
       required: props.config.joiner.required,
       full: props.config.joiner.full
-        ? (condition) => (input, expected, explore) =>
-            props.config.joiner.full!({
-              condition,
-              input,
-              expected,
-              explore,
-            })
+        ? (next) => props.config.joiner.full!(next)
         : undefined,
       type: TypeFactory.keyword("boolean"),
     },
     generator: {
       unions: props.config.numeric
-        ? () =>
-            FeatureProgrammer.write_union_functions(
-              configure({
+        ? (collection) =>
+            FeatureProgrammer.write_union_functions({
+              config: configure({
                 ...props,
                 config: {
                   ...props.config,
                   numeric: false,
                 },
               }),
-            )
+              collection,
+            })
         : undefined,
-      arrays: () => (collection) =>
+      arrays: (collection) =>
         write_array_functions({
           ...props,
           collection,
         }),
-      tuples: () => (collection) =>
+      tuples: (collection) =>
         write_tuple_functions({
           ...props,
           collection,
@@ -556,9 +562,12 @@ export namespace CheckerProgrammer {
         binaries.push({
           expression: props.config.atomist({
             explore: props.explore,
-            entry: check_number(props.context, props.config.numeric)(atom)(
-              props.input,
-            ),
+            entry: check_number({
+              context: props.context,
+              numeric: props.config.numeric,
+              atomic: atom,
+              input: props.input,
+            }),
             input: props.input,
           }),
           combined: false,
@@ -567,7 +576,11 @@ export namespace CheckerProgrammer {
         binaries.push({
           expression: props.config.atomist({
             explore: props.explore,
-            entry: check_bigint(props.context)(atom)(props.input),
+            entry: check_bigint({
+              context: props.context,
+              atomic: atom,
+              input: props.input,
+            }),
             input: props.input,
           }),
           combined: false,
@@ -576,7 +589,11 @@ export namespace CheckerProgrammer {
         binaries.push({
           expression: props.config.atomist({
             explore: props.explore,
-            entry: check_string(props.context)(atom)(props.input),
+            entry: check_string({
+              context: props.context,
+              atomic: atom,
+              input: props.input,
+            }),
             input: props.input,
           }),
           combined: false,
@@ -594,7 +611,10 @@ export namespace CheckerProgrammer {
         binaries.push({
           expression: props.config.atomist({
             explore: props.explore,
-            entry: check_template(props.metadata.templates)(props.input),
+            entry: check_template({
+              templates: props.metadata.templates,
+              input: props.input,
+            }),
             input: props.input,
           }),
           combined: false,
@@ -603,7 +623,10 @@ export namespace CheckerProgrammer {
     // NATIVE CLASSES
     for (const native of props.metadata.natives)
       binaries.push({
-        expression: check_native(native)(props.input),
+        expression: check_native({
+          type: native,
+          input: props.input,
+        }),
         combined: false,
       });
 
@@ -611,7 +634,7 @@ export namespace CheckerProgrammer {
     // INSTANCES
     //----
     interface IInstance {
-      knock: ts.Expression;
+      head: ts.Expression;
       body: ts.Expression | null;
       expected: string;
     }
@@ -622,7 +645,10 @@ export namespace CheckerProgrammer {
     if (props.metadata.sets.length) {
       const install = (body: ts.Expression | null) =>
         prepare({
-          knock: check_native("Set")(props.input),
+          head: check_native({
+            type: "Set",
+            input: props.input,
+          }),
           expected: props.metadata.sets
             .map((elem) => `Set<${elem.getName()}>`)
             .join(" | "),
@@ -649,7 +675,10 @@ export namespace CheckerProgrammer {
     if (props.metadata.maps.length) {
       const install = (body: ts.Expression | null) =>
         prepare({
-          knock: check_native("Map")(props.input),
+          head: check_native({
+            type: "Map",
+            input: props.input,
+          }),
           expected: props.metadata.maps
             .map(({ key, value }) => `Map<${key}, ${value}>`)
             .join(" | "),
@@ -677,7 +706,7 @@ export namespace CheckerProgrammer {
     if (props.metadata.tuples.length + props.metadata.arrays.length > 0) {
       const install = (body: ts.Expression | null) =>
         prepare({
-          knock: props.config.atomist({
+          head: props.config.atomist({
             explore: props.explore,
             entry: {
               expected: [
@@ -772,7 +801,7 @@ export namespace CheckerProgrammer {
     // OBJECT
     if (props.metadata.objects.length > 0)
       prepare({
-        knock: ExpressionFactory.isObject({
+        head: ExpressionFactory.isObject({
           checkNull: true,
           checkArray: props.metadata.objects.some((obj) =>
             obj.properties.every(
@@ -799,23 +828,23 @@ export namespace CheckerProgrammer {
         (ins: IInstance) =>
           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((pre, body) =>
+          transformer((head, body) =>
             props.config.combiner({
               explore: props.explore,
               logic: "and",
               input: props.input,
-              binaries: [pre, body].map((expression) => ({
+              binaries: [head, body].map((expression) => ({
                 expression,
-                combined: expression !== pre,
+                combined: expression !== head,
               })),
               expected: props.metadata.getName(),
             }),
@@ -841,9 +870,10 @@ export namespace CheckerProgrammer {
         expression:
           props.metadata.escaped.original.size() === 1 &&
           props.metadata.escaped.original.natives.length === 1
-            ? check_native(props.metadata.escaped.original.natives[0]!)(
-                props.input,
-              )
+            ? check_native({
+                type: props.metadata.escaped.original.natives[0]!,
+                input: props.input,
+              })
             : ts.factory.createLogicalAnd(
                 decode({
                   context: props.context,
@@ -912,11 +942,7 @@ export namespace CheckerProgrammer {
     explore: IExplore;
   }) => {
     props.object.validated ||= true;
-    return FeatureProgrammer.decode_object(props.config)(props.importer)(
-      props.input,
-      props.object,
-      props.explore,
-    );
+    return FeatureProgrammer.decode_object(props);
   };
 
   const decode_array = (props: {
@@ -942,11 +968,15 @@ export namespace CheckerProgrammer {
           ),
         ),
         undefined,
-        FeatureProgrammer.argumentsArray(props.config)({
-          ...arrayExplore,
-          source: "function",
-          from: "array",
-        })(props.input),
+        FeatureProgrammer.argumentsArray({
+          config: props.config,
+          explore: {
+            ...arrayExplore,
+            source: "function",
+            from: "array",
+          },
+          input: props.input,
+        }),
       ),
       props.config.joiner.failure({
         input: props.input,
@@ -964,25 +994,28 @@ export namespace CheckerProgrammer {
     input: ts.Expression;
     explore: IExplore;
   }): ts.Expression => {
-    const length: ICheckEntry = check_array_length(props.context)(props.array)(
-      props.input,
-    );
+    const length: ICheckEntry = check_array_length({
+      context: props.context,
+      array: props.array,
+      input: props.input,
+    });
     const main: ts.Expression = FeatureProgrammer.decode_array({
-      prefix: props.config.prefix,
-      trace: props.config.trace,
-      path: props.config.path,
-      decoder: () => (input, metadata, explore) =>
-        decode({
-          ...props,
-          input,
-          metadata,
-          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: (next) =>
+          decode({
+            ...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
       : ts.factory.createLogicalAnd(
@@ -1021,10 +1054,14 @@ export namespace CheckerProgrammer {
           ),
         ),
         undefined,
-        FeatureProgrammer.argumentsArray(props.config)({
-          ...arrayExplore,
-          source: "function",
-        })(props.input),
+        FeatureProgrammer.argumentsArray({
+          config: props.config,
+          explore: {
+            ...arrayExplore,
+            source: "function",
+          },
+          input: props.input,
+        }),
       ),
       props.config.joiner.failure({
         input: props.input,
@@ -1188,35 +1225,35 @@ export namespace CheckerProgrammer {
   }): ts.Expression =>
     ts.factory.createCallExpression(
       UnionExplorer.set({
-        checker: (input, metadata, explore, _container) =>
-          decode({
-            context: props.context,
-            config: props.config,
-            importer: props.importer,
-            input,
-            metadata,
-            explore,
-          }),
-        decoder: (input, array, explore) =>
-          decode_array({
-            config: props.config,
-            context: props.context,
-            importer: props.importer,
-            array,
-            input,
-            explore,
-          }),
-        empty: props.config.success,
-        success: props.config.success,
-        failure: (input, expected, explore) =>
-          ts.factory.createReturnStatement(
-            props.config.joiner.failure({
-              input,
-              expected,
-              explore,
+        config: {
+          checker: (v) =>
+            decode({
+              context: props.context,
+              config: props.config,
+              importer: props.importer,
+              input: v.input,
+              metadata: v.definition,
+              explore: v.explore,
             }),
-          ),
-      })([])(props.input, props.sets, props.explore),
+          decoder: (v) =>
+            decode_array({
+              config: props.config,
+              context: props.context,
+              importer: props.importer,
+              array: v.definition,
+              input: v.input,
+              explore: v.explore,
+            }),
+          empty: props.config.success,
+          success: props.config.success,
+          failure: (v) =>
+            ts.factory.createReturnStatement(props.config.joiner.failure(v)),
+        },
+        parameters: [],
+        input: props.input,
+        sets: props.sets,
+        explore: props.explore,
+      }),
       undefined,
       undefined,
     );
@@ -1231,51 +1268,51 @@ export namespace CheckerProgrammer {
   }): ts.Expression =>
     ts.factory.createCallExpression(
       UnionExplorer.map({
-        checker: (input, entry, explore) =>
-          ts.factory.createLogicalAnd(
-            decode({
-              config: props.config,
+        config: {
+          checker: (v) =>
+            ts.factory.createLogicalAnd(
+              decode({
+                config: props.config,
+                context: props.context,
+                importer: props.importer,
+                input: ts.factory.createElementAccessExpression(v.input, 0),
+                metadata: v.definition[0],
+                explore: {
+                  ...v.explore,
+                  postfix: `${v.explore.postfix}[0]`,
+                },
+              }),
+              decode({
+                config: props.config,
+                context: props.context,
+                importer: props.importer,
+                input: ts.factory.createElementAccessExpression(v.input, 1),
+                metadata: v.definition[1],
+                explore: {
+                  ...v.explore,
+                  postfix: `${v.explore.postfix}[1]`,
+                },
+              }),
+            ),
+          decoder: (v) =>
+            decode_array({
               context: props.context,
-              importer: props.importer,
-              input: ts.factory.createElementAccessExpression(input, 0),
-              metadata: entry[0],
-              explore: {
-                ...explore,
-                postfix: `${explore.postfix}[0]`,
-              },
-            }),
-            decode({
               config: props.config,
-              context: props.context,
               importer: props.importer,
-              input: ts.factory.createElementAccessExpression(input, 1),
-              metadata: entry[1],
-              explore: {
-                ...explore,
-                postfix: `${explore.postfix}[1]`,
-              },
-            }),
-          ),
-        decoder: (input, array, explore) =>
-          decode_array({
-            context: props.context,
-            config: props.config,
-            importer: props.importer,
-            array,
-            input,
-            explore,
-          }),
-        empty: props.config.success,
-        success: props.config.success,
-        failure: (input, expected, explore) =>
-          ts.factory.createReturnStatement(
-            props.config.joiner.failure({
-              input,
-              expected,
-              explore,
+              array: v.definition,
+              input: v.input,
+              explore: v.explore,
             }),
-          ),
-      })([])(props.input, props.maps, props.explore),
+          empty: props.config.success,
+          success: props.config.success,
+          failure: (v) =>
+            ts.factory.createReturnStatement(props.config.joiner.failure(v)),
+        },
+        parameters: [],
+        input: props.input,
+        maps: props.maps,
+        explore: props.explore,
+      }),
       undefined,
       undefined,
     );
@@ -1291,36 +1328,37 @@ export namespace CheckerProgrammer {
     explore_array_like_union_types<MetadataTuple>({
       config: props.config,
       importer: props.importer,
-      factory: UnionExplorer.tuple({
-        checker: (input, tuple, explore) =>
-          decode_tuple({
-            context: props.context,
-            config: props.config,
-            importer: props.importer,
-            input,
-            tuple,
-            explore,
-          }),
-        decoder: (input, tuple, explore) =>
-          decode_tuple({
-            context: props.context,
-            config: props.config,
-            importer: props.importer,
-            tuple,
-            input,
-            explore,
-          }),
-        empty: props.config.success,
-        success: props.config.success,
-        failure: (input, expected, explore) =>
-          ts.factory.createReturnStatement(
-            props.config.joiner.failure({
-              input,
-              expected,
-              explore,
-            }),
-          ),
-      }),
+      factory: (next) =>
+        UnionExplorer.tuple({
+          config: {
+            checker: (v) =>
+              decode_tuple({
+                context: props.context,
+                config: props.config,
+                importer: props.importer,
+                input: v.input,
+                tuple: v.definition,
+                explore: v.explore,
+              }),
+            decoder: (v) =>
+              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: (v) =>
+              ts.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,
@@ -1337,36 +1375,37 @@ export namespace CheckerProgrammer {
     explore_array_like_union_types<MetadataArray>({
       config: props.config,
       importer: props.importer,
-      factory: UnionExplorer.array({
-        checker: (input, metadata, explore) =>
-          decode({
-            context: props.context,
-            config: props.config,
-            importer: props.importer,
-            metadata,
-            input,
-            explore,
-          }),
-        decoder: (input, array, explore) =>
-          decode_array({
-            context: props.context,
-            config: props.config,
-            importer: props.importer,
-            array,
-            input,
-            explore,
-          }),
-        empty: props.config.success,
-        success: props.config.success,
-        failure: (input, expected, explore) =>
-          ts.factory.createReturnStatement(
-            props.config.joiner.failure({
-              input,
-              expected,
-              explore,
-            }),
-          ),
-      }),
+      factory: (next) =>
+        UnionExplorer.array({
+          config: {
+            checker: (v) =>
+              decode({
+                context: props.context,
+                config: props.config,
+                importer: props.importer,
+                metadata: v.definition,
+                input: v.input,
+                explore: v.explore,
+              }),
+            decoder: (v) =>
+              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: (v) =>
+              ts.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,
@@ -1383,68 +1422,69 @@ export namespace CheckerProgrammer {
     explore_array_like_union_types<MetadataArray | MetadataTuple>({
       config: props.config,
       importer: props.importer,
-      factory: UnionExplorer.array_or_tuple({
-        checker: (input, definition, explore, array) =>
-          definition instanceof MetadataTuple
-            ? decode_tuple({
-                config: props.config,
-                context: props.context,
-                importer: props.importer,
-                input,
-                tuple: definition,
-                explore,
-              })
-            : props.config.atomist({
-                explore,
-                entry: {
-                  expected: props.definitions
-                    .map((elem) =>
-                      elem instanceof MetadataArray
-                        ? elem.getName()
-                        : elem.type.name,
-                    )
-                    .join(" | "),
-                  expression: decode({
+      factory: (next) =>
+        UnionExplorer.array_or_tuple({
+          config: {
+            checker: (v) =>
+              v.definition instanceof MetadataTuple
+                ? decode_tuple({
+                    config: props.config,
+                    context: props.context,
                     importer: props.importer,
+                    input: v.input,
+                    tuple: v.definition,
+                    explore: v.explore,
+                  })
+                : props.config.atomist({
+                    explore: v.explore,
+                    entry: {
+                      expected: props.definitions
+                        .map((elem) =>
+                          elem instanceof MetadataArray
+                            ? elem.getName()
+                            : elem.type.name,
+                        )
+                        .join(" | "),
+                      expression: decode({
+                        importer: props.importer,
+                        context: props.context,
+                        config: props.config,
+                        metadata: v.definition,
+                        input: v.input,
+                        explore: v.explore,
+                      }),
+                      conditions: [],
+                    },
+                    input: v.container,
+                  }),
+            decoder: (v) =>
+              v.definition instanceof 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,
-                    metadata: definition,
-                    explore,
+                    importer: props.importer,
+                    input: v.input,
+                    array: v.definition,
+                    explore: v.explore,
                   }),
-                  conditions: [],
-                },
-                input: array,
-              }),
-        decoder: (input, definition, explore) =>
-          definition instanceof MetadataTuple
-            ? decode_tuple({
-                context: props.context,
-                config: props.config,
-                importer: props.importer,
-                input,
-                tuple: definition,
-                explore,
-              })
-            : decode_array({
-                context: props.context,
-                config: props.config,
-                importer: props.importer,
-                input,
-                array: definition,
-                explore,
-              }),
-        empty: props.config.success,
-        success: props.config.success,
-        failure: (input, expected, explore) =>
-          ts.factory.createReturnStatement(
-            props.config.joiner.failure({
-              input,
-              expected,
-              explore,
-            }),
-          ),
-      }),
+            empty: props.config.success,
+            success: props.config.success,
+            failure: (v) =>
+              ts.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,
@@ -1455,13 +1495,12 @@ export namespace CheckerProgrammer {
   >(props: {
     config: IConfig;
     importer: FunctionImporter;
-    factory: (
-      parameters: ts.ParameterDeclaration[],
-    ) => (
-      input: ts.Expression,
-      elements: T[],
-      explore: IExplore,
-    ) => ts.ArrowFunction;
+    factory: (next: {
+      parameters: ts.ParameterDeclaration[];
+      definitions: T[];
+      input: ts.Expression;
+      explore: IExplore;
+    }) => ts.ArrowFunction;
     input: ts.Expression;
     definitions: T[];
     explore: IExplore;
@@ -1471,11 +1510,12 @@ export namespace CheckerProgrammer {
       explore: IExplore;
       input: ts.Expression;
     }): ts.ArrowFunction =>
-      props.factory(next.parameters)(
-        next.input,
-        props.definitions,
-        next.explore,
-      );
+      props.factory({
+        parameters: next.parameters,
+        definitions: props.definitions,
+        input: next.input,
+        explore: next.explore,
+      });
     if (props.definitions.every((e) => e.type.recursive === false))
       ts.factory.createCallExpression(
         arrow({
@@ -1499,11 +1539,11 @@ export namespace CheckerProgrammer {
             props.definitions.map((e) => e.type.name).join(" | "),
             () =>
               arrow({
-                parameters: FeatureProgrammer.parameterDeclarations(
-                  props.config,
-                )(TypeFactory.keyword("any"))(
-                  ts.factory.createIdentifier("input"),
-                ),
+                parameters: FeatureProgrammer.parameterDeclarations({
+                  config: props.config,
+                  type: TypeFactory.keyword("any"),
+                  input: ts.factory.createIdentifier("input"),
+                }),
                 explore: {
                   ...arrayExplore,
                   postfix: "",
@@ -1513,9 +1553,7 @@ export namespace CheckerProgrammer {
           ),
         ),
         undefined,
-        FeatureProgrammer.argumentsArray(props.config)(arrayExplore)(
-          props.input,
-        ),
+        FeatureProgrammer.argumentsArray(props),
       ),
       props.config.joiner.failure({
         input: props.input,
@@ -1547,9 +1585,7 @@ export namespace CheckerProgrammer {
             ),
           ),
           undefined,
-          FeatureProgrammer.argumentsArray(props.config)(props.explore)(
-            props.input,
-          ),
+          FeatureProgrammer.argumentsArray(props),
         );
 }