typia 13.1.1 → 13.1.19

package/native/core/programmers/helpers/UnionExplorer.go

@@ -79,11 +79,12 @@ type UnionExplorer_ObjectProps struct {
 }
 
 type UnionExplorer_ArrayLikeConfig struct {
-  Checker func(props UnionExplorer_ArrayLikeCheckerProps) *shimast.Node
-  Decoder func(props UnionExplorer_ArrayLikeDecoderProps) *shimast.Node
-  Empty   *shimast.Node
-  Success *shimast.Expression
-  Failure func(props UnionExplorer_ArrayLikeFailureProps) *shimast.Node
+  Checker   func(props UnionExplorer_ArrayLikeCheckerProps) *shimast.Node
+  Candidate func(props UnionExplorer_ArrayLikeCandidateProps) *shimast.Node
+  Decoder   func(props UnionExplorer_ArrayLikeDecoderProps) *shimast.Node
+  Empty     *shimast.Node
+  Success   *shimast.Expression
+  Failure   func(props UnionExplorer_ArrayLikeFailureProps) *shimast.Node
 }
 
 type UnionExplorer_ArrayLikeCheckerProps struct {
@@ -99,6 +100,12 @@ type UnionExplorer_ArrayLikeDecoderProps struct {
   Explore    any
 }
 
+type UnionExplorer_ArrayLikeCandidateProps struct {
+  Input      *shimast.Expression
+  Definition any
+  Explore    any
+}
+
 type UnionExplorer_ArrayLikeFailureProps struct {
   Input    *shimast.Expression
   Expected string
@@ -622,46 +629,69 @@ func unionExplorer_check_union_array_like(props unionExplorer_check_union_array_
       inputType = nativefactories.TypeFactory.Keyword("any", props.Emit)
       postfix = "\"[0]\""
     }
-    return f.NewAsExpression(
-      f.NewArrayLiteralExpression(
+    entries := []*shimast.Node{
+      f.NewArrowFunction(
+        nil,
+        nil,
         f.NewNodeList([]*shimast.Node{
-          f.NewArrowFunction(
-            nil,
-            nil,
-            f.NewNodeList([]*shimast.Node{
-              nativefactories.IdentifierFactory.Parameter("top", inputType, nil, props.Emit),
-            }),
-            nativefactories.TypeFactory.Keyword("any", props.Emit),
+          nativefactories.IdentifierFactory.Parameter("top", inputType, nil, props.Emit),
+        }),
+        nativefactories.TypeFactory.Keyword("any", props.Emit),
+        nil,
+        f.NewToken(shimast.KindEqualsGreaterThanToken),
+        props.Config.Checker(UnionExplorer_ArrayLikeCheckerProps{
+          Input:      f.NewIdentifier("top"),
+          Definition: props.Accessor.Element(meta),
+          Explore:    unionExplorer_with_postfix(props.Explore, false, postfix),
+          Container:  array,
+        }),
+      ),
+      f.NewArrowFunction(
+        nil,
+        nil,
+        f.NewNodeList([]*shimast.Node{
+          nativefactories.IdentifierFactory.Parameter(
+            "entire",
+            f.NewTypeReferenceNode(f.NewIdentifier("any[]"), nil),
             nil,
-            f.NewToken(shimast.KindEqualsGreaterThanToken),
-            props.Config.Checker(UnionExplorer_ArrayLikeCheckerProps{
-              Input:      f.NewIdentifier("top"),
-              Definition: props.Accessor.Element(meta),
-              Explore:    unionExplorer_with_postfix(props.Explore, false, postfix),
-              Container:  array,
-            }),
+            props.Emit,
           ),
-          f.NewArrowFunction(
-            nil,
-            nil,
-            f.NewNodeList([]*shimast.Node{
-              nativefactories.IdentifierFactory.Parameter(
-                "entire",
-                f.NewTypeReferenceNode(f.NewIdentifier("any[]"), nil),
-                nil,
-                props.Emit,
-              ),
-            }),
-            nativefactories.TypeFactory.Keyword("any", props.Emit),
+        }),
+        nativefactories.TypeFactory.Keyword("any", props.Emit),
+        nil,
+        f.NewToken(shimast.KindEqualsGreaterThanToken),
+        props.Config.Decoder(UnionExplorer_ArrayLikeDecoderProps{
+          Input:      f.NewIdentifier("entire"),
+          Definition: meta,
+          Explore:    unionExplorer_with_tracable(props.Explore, true),
+        }),
+      ),
+    }
+    if props.Config.Candidate != nil {
+      entries = append(entries, f.NewArrowFunction(
+        nil,
+        nil,
+        f.NewNodeList([]*shimast.Node{
+          nativefactories.IdentifierFactory.Parameter(
+            "entire",
+            f.NewTypeReferenceNode(f.NewIdentifier("any[]"), nil),
             nil,
-            f.NewToken(shimast.KindEqualsGreaterThanToken),
-            props.Config.Decoder(UnionExplorer_ArrayLikeDecoderProps{
-              Input:      f.NewIdentifier("entire"),
-              Definition: meta,
-              Explore:    unionExplorer_with_tracable(props.Explore, true),
-            }),
+            props.Emit,
           ),
         }),
+        nativefactories.TypeFactory.Keyword("boolean", props.Emit),
+        nil,
+        f.NewToken(shimast.KindEqualsGreaterThanToken),
+        props.Config.Candidate(UnionExplorer_ArrayLikeCandidateProps{
+          Input:      f.NewIdentifier("entire"),
+          Definition: meta,
+          Explore:    unionExplorer_with_tracable(props.Explore, false),
+        }),
+      ))
+    }
+    return f.NewAsExpression(
+      f.NewArrayLiteralExpression(
+        f.NewNodeList(entries),
         true,
       ),
       f.NewTypeReferenceNode(f.NewIdentifier("const"), nil),
@@ -709,12 +739,17 @@ func unionExplorer_check_union_array_like(props unionExplorer_check_union_array_
         "pred",
         f.NewIdentifier("tuplePredicators"),
         f.NewIfStatement(
-          f.NewCallExpression(
-            f.NewIdentifier("pred[0]"),
-            nil,
-            nil,
-            f.NewNodeList([]*shimast.Node{array}),
-            shimast.NodeFlagsNone,
+          unionExplorer_array_candidate_condition(
+            f.NewCallExpression(
+              f.NewIdentifier("pred[0]"),
+              nil,
+              nil,
+              f.NewNodeList([]*shimast.Node{array}),
+              shimast.NodeFlagsNone,
+            ),
+            props.Config.Candidate != nil,
+            array,
+            props.Emit,
           ),
           f.NewReturnStatement(
             f.NewCallExpression(
@@ -741,12 +776,12 @@ func unionExplorer_check_union_array_like(props unionExplorer_check_union_array_
     for _, x := range arrayList {
       arrayPredicates = append(arrayPredicates, predicate(x))
     }
-    statements = append(statements,
-      nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-        Name:  "top",
-        Value: props.Accessor.Front(props.Input),
-      }, props.Emit),
-      f.NewIfStatement(
+    statements = append(statements, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+      Name:  "top",
+      Value: props.Accessor.Front(props.Input),
+    }, props.Emit))
+    if props.Config.Candidate == nil {
+      statements = append(statements, f.NewIfStatement(
         f.NewBinaryExpression(
           nil,
           nativefactories.ExpressionFactory.Number(0, props.Emit),
@@ -756,7 +791,9 @@ func unionExplorer_check_union_array_like(props unionExplorer_check_union_array_
         ),
         unionExplorer_return_or_statement(props.Config.Empty, props.Emit),
         nil,
-      ),
+      ))
+    }
+    statements = append(statements,
       nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
         Name: "arrayPredicators",
         Value: f.NewArrayLiteralExpression(
@@ -780,19 +817,37 @@ func unionExplorer_check_union_array_like(props unionExplorer_check_union_array_
               nil,
               nil,
               f.NewToken(shimast.KindEqualsGreaterThanToken),
-              f.NewCallExpression(
-                f.NewIdentifier("pred[0]"),
-                nil,
-                nil,
-                f.NewNodeList([]*shimast.Node{top}),
-                shimast.NodeFlagsNone,
-              ),
+              func() *shimast.Node {
+                element := f.NewCallExpression(
+                  f.NewIdentifier("pred[0]"),
+                  nil,
+                  nil,
+                  f.NewNodeList([]*shimast.Node{top}),
+                  shimast.NodeFlagsNone,
+                )
+                if props.Config.Candidate == nil {
+                  return element
+                }
+                return f.NewBinaryExpression(
+                  nil,
+                  f.NewBinaryExpression(
+                    nil,
+                    nativefactories.ExpressionFactory.Number(0, props.Emit),
+                    nil,
+                    f.NewToken(shimast.KindEqualsEqualsEqualsToken),
+                    props.Accessor.Size(props.Input),
+                  ),
+                  nil,
+                  f.NewToken(shimast.KindBarBarToken),
+                  element,
+                )
+              }(),
             ),
           }),
           shimast.NodeFlagsNone,
         ),
       }, props.Emit),
-      unionExplorer_array_if(iterate, array, top, props.Config.Success, props.Emit),
+      unionExplorer_array_if(iterate, array, top, props.Config.Success, props.Config.Candidate != nil, props.Emit),
     )
   }
   names := make([]string, 0, len(targets))
@@ -819,8 +874,75 @@ func unionExplorer_check_union_array_like(props unionExplorer_check_union_array_
   )
 }
 
-func unionExplorer_array_if(iterate func(init string, from *shimast.Expression, ifStatement *shimast.Node) *shimast.Node, array *shimast.Node, top *shimast.Node, success *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
+func unionExplorer_array_if(iterate func(init string, from *shimast.Expression, ifStatement *shimast.Node) *shimast.Node, array *shimast.Node, top *shimast.Node, success *shimast.Expression, candidate bool, emit ...*shimprinter.EmitContext) *shimast.Node {
   f := nativecontext.EmitFactoryOf(unionExplorer_factory, emit...)
+  if candidate {
+    elementCondition := f.NewCallExpression(
+      nativefactories.IdentifierFactory.Access(nil, array, "every"),
+      nil,
+      nil,
+      f.NewNodeList([]*shimast.Node{
+        f.NewArrowFunction(
+          nil,
+          nil,
+          f.NewNodeList([]*shimast.Node{
+            nativefactories.IdentifierFactory.Parameter("value", nativefactories.TypeFactory.Keyword("any", emit...), nil, emit...),
+          }),
+          nil,
+          nil,
+          f.NewToken(shimast.KindEqualsGreaterThanToken),
+          f.NewBinaryExpression(
+            nil,
+            success,
+            nil,
+            f.NewToken(shimast.KindEqualsEqualsEqualsToken),
+            f.NewCallExpression(
+              f.NewIdentifier("pred[0]"),
+              nil,
+              nil,
+              f.NewNodeList([]*shimast.Node{f.NewIdentifier("value")}),
+              shimast.NodeFlagsNone,
+            ),
+          ),
+        ),
+      }),
+      shimast.NodeFlagsNone,
+    )
+    return f.NewBlock(f.NewNodeList([]*shimast.Node{
+      iterate(
+        "pred",
+        f.NewIdentifier("passed"),
+        f.NewIfStatement(
+          unionExplorer_array_candidate_condition(elementCondition, true, array, emit...),
+          f.NewReturnStatement(f.NewCallExpression(
+            f.NewIdentifier("pred[1]"),
+            nil,
+            nil,
+            f.NewNodeList([]*shimast.Node{array}),
+            shimast.NodeFlagsNone,
+          )),
+          nil,
+        ),
+      ),
+      f.NewIfStatement(
+        f.NewBinaryExpression(
+          nil,
+          nativefactories.ExpressionFactory.Number(0, emit...),
+          nil,
+          f.NewToken(shimast.KindLessThanToken),
+          f.NewIdentifier("passed.length"),
+        ),
+        f.NewReturnStatement(f.NewCallExpression(
+          f.NewIdentifier("passed[0][1]"),
+          nil,
+          nil,
+          f.NewNodeList([]*shimast.Node{array}),
+          shimast.NodeFlagsNone,
+        )),
+        nil,
+      ),
+    }), true)
+  }
   return f.NewIfStatement(
     f.NewBinaryExpression(
       nil,
@@ -910,6 +1032,26 @@ func unionExplorer_array_if(iterate func(init string, from *shimast.Expression,
   )
 }
 
+func unionExplorer_array_candidate_condition(element *shimast.Node, candidate bool, array *shimast.Node, emit ...*shimprinter.EmitContext) *shimast.Node {
+  if candidate == false {
+    return element
+  }
+  f := nativecontext.EmitFactoryOf(unionExplorer_factory, emit...)
+  return f.NewBinaryExpression(
+    nil,
+    f.NewCallExpression(
+      f.NewIdentifier("pred[2]"),
+      nil,
+      nil,
+      f.NewNodeList([]*shimast.Node{array}),
+      shimast.NodeFlagsNone,
+    ),
+    nil,
+    f.NewToken(shimast.KindAmpersandAmpersandToken),
+    element,
+  )
+}
+
 func unionExplorer_return_or_statement(node *shimast.Node, emit ...*shimprinter.EmitContext) *shimast.Node {
   f := nativecontext.EmitFactoryOf(unionExplorer_factory, emit...)
   if node == nil || node.Kind == shimast.KindReturnStatement {

package/native/core/programmers/helpers/joiner_branch_coverage_test.go

@@ -52,9 +52,11 @@ func TestJoinerBranchCoverage(t *testing.T) {
 		t.Fatal("clone joiner returned nil")
 	}
 	if NotationJoiner.Object(NotationJoiner_ObjectProps{
-		Rename:  func(str string) string { return str },
-		Input:   input,
-		Entries: entries,
+		Rename:        func(str string) string { return str },
+		DynamicRename: func() *shimast.Node { return factory.NewIdentifier("rename") },
+		DynamicAssign: func() *shimast.Node { return factory.NewIdentifier("assign") },
+		Input:         input,
+		Entries:       entries,
 	}) == nil ||
 		NotationJoiner.Tuple(NotationJoiner_TupleProps{Elements: []*shimast.Expression{value}, Rest: input}) == nil ||
 		NotationJoiner.Array(NotationJoiner_ArrayProps{Input: input, Arrow: value}) == nil {

package/native/core/programmers/helpers/union_explorer_coverage_test.go

@@ -91,7 +91,7 @@ func TestUnionExplorerCoverage(t *testing.T) {
 	if unionExplorer_array_if(func(init string, from *shimast.Expression, ifStatement *shimast.Node) *shimast.Node {
 		iterated = init == "pred" && from != nil && ifStatement != nil
 		return ifStatement
-	}, input, input, factory.NewKeywordExpression(shimast.KindTrueKeyword)) == nil || !iterated {
+	}, input, input, factory.NewKeywordExpression(shimast.KindTrueKeyword), false) == nil || !iterated {
 		t.Fatal("array disambiguation helper did not invoke iterator")
 	}
 	if unionExplorer_return_or_statement(input) == nil ||

package/native/core/programmers/internal/CheckerProgrammer.go

@@ -826,21 +826,27 @@ func (checkerProgrammerNamespace) Decode(props CheckerProgrammer_DecodeProps) *s
         body = checkerProgrammer_explore_tuples(checkerProgrammer_exploreTuplesProps{Config: props.Config, Context: props.Context, Functor: props.Functor, Tuples: props.Metadata.Tuples, Input: props.Input, Explore: explore})
       }
     } else if checkerProgrammer_array_any(props.Metadata.Arrays) {
-      // Any-element arrays need no element exploration, but a sole array's
-      // validating wrapper tags (MinItems, custom predicates, ...) still
-      // constrain the container and survive on the entry conditions. Unions
-      // mixing a tag-constrained any-element array with other array-like
-      // variants keep the historical wholesale acceptance: the union
-      // explorer discriminates by element checks, which an any element
-      // satisfies trivially, so honoring those tags needs branch
-      // backtracking (tracked on #1933).
-      body = nil
+      // A sole any-element array only needs its wrapper predicates. In a
+      // union, however, those predicates participate in branch selection:
+      // a failed tagged-any candidate must backtrack to a concrete array or
+      // tuple candidate instead of accepting or rejecting the whole bucket.
       if len(props.Metadata.Arrays) == 1 && len(props.Metadata.Tuples) == 0 {
+        body = nil
         conditions = nativeiterate.Check_array_length(nativeiterate.Check_array_lengthProps{
           Context: props.Context,
           Array:   props.Metadata.Arrays[0],
           Input:   props.Input,
         }).Conditions
+      } else if checkerProgrammer_has_array_type_tags(props.Metadata.Arrays) {
+        explore := props.Explore
+        explore.From = "array"
+        if len(props.Metadata.Tuples) == 0 {
+          body = checkerProgrammer_explore_arrays(checkerProgrammer_exploreArraysProps{Config: props.Config, Context: props.Context, Functor: props.Functor, Arrays: props.Metadata.Arrays, Input: props.Input, Explore: explore})
+        } else {
+          body = checkerProgrammer_explore_arrays_and_tuples(checkerProgrammer_exploreArraysAndTuplesProps{Config: props.Config, Context: props.Context, Functor: props.Functor, Definitions: checkerProgrammer_array_tuple_definitions(props.Metadata.Arrays, props.Metadata.Tuples), Input: props.Input, Explore: explore})
+        }
+      } else {
+        body = nil
       }
     } else if len(props.Metadata.Tuples) == 0 {
       explore := props.Explore
@@ -1540,14 +1546,18 @@ func checkerProgrammer_explore_arrays(props checkerProgrammer_exploreArraysProps
       for _, value := range next.Definitions {
         arrays = append(arrays, value.(*nativemetadata.MetadataArray))
       }
+      config := checkerProgrammer_array_like_config(props.Context, props.Config, props.Functor,
+        func(v nativehelpers.UnionExplorer_ArrayLikeCheckerProps) *shimast.Node {
+          return CheckerProgrammer.Decode(CheckerProgrammer_DecodeProps{Context: props.Context, Config: props.Config, Functor: props.Functor, Metadata: v.Definition.(*nativemetadata.MetadataSchema), Input: v.Input, Explore: featureProgrammer_as_explore(v.Explore)})
+        },
+        func(v nativehelpers.UnionExplorer_ArrayLikeDecoderProps) *shimast.Node {
+          return checkerProgrammer_decode_array(checkerProgrammer_decodeArrayProps{Context: props.Context, Config: props.Config, Functor: props.Functor, Array: v.Definition.(*nativemetadata.MetadataArray), Input: v.Input, Explore: featureProgrammer_as_explore(v.Explore)})
+        })
+      if checkerProgrammer_has_array_type_tags(arrays) {
+        config.Candidate = checkerProgrammer_array_tag_candidate(props.Context)
+      }
       return nativehelpers.UnionExplorer.Array(nativehelpers.UnionExplorer_ArrayProps{
-        Config: checkerProgrammer_array_like_config(props.Context, props.Config, props.Functor,
-          func(v nativehelpers.UnionExplorer_ArrayLikeCheckerProps) *shimast.Node {
-            return CheckerProgrammer.Decode(CheckerProgrammer_DecodeProps{Context: props.Context, Config: props.Config, Functor: props.Functor, Metadata: v.Definition.(*nativemetadata.MetadataSchema), Input: v.Input, Explore: featureProgrammer_as_explore(v.Explore)})
-          },
-          func(v nativehelpers.UnionExplorer_ArrayLikeDecoderProps) *shimast.Node {
-            return checkerProgrammer_decode_array(checkerProgrammer_decodeArrayProps{Context: props.Context, Config: props.Config, Functor: props.Functor, Array: v.Definition.(*nativemetadata.MetadataArray), Input: v.Input, Explore: featureProgrammer_as_explore(v.Explore)})
-          }),
+        Config:     config,
         Parameters: next.Parameters,
         Arrays:     arrays,
         Input:      next.Input,
@@ -1562,37 +1572,41 @@ func checkerProgrammer_explore_arrays_and_tuples(props checkerProgrammer_explore
   return checkerProgrammer_explore_array_like_union_types(checkerProgrammer_exploreArrayLikeUnionTypesProps{
     Config: props.Config, Functor: props.Functor, Definitions: props.Definitions, Input: props.Input, Explore: props.Explore, Emit: props.Context.Emit,
     Factory: func(next checkerProgrammer_exploreArrayLikeUnionTypesFactoryProps) *shimast.Node {
-      return nativehelpers.UnionExplorer.Array_or_tuple(nativehelpers.UnionExplorer_ArrayOrTupleProps{
-        Config: checkerProgrammer_array_like_config(props.Context, props.Config, props.Functor,
-          func(v nativehelpers.UnionExplorer_ArrayLikeCheckerProps) *shimast.Node {
-            if tuple, ok := v.Definition.(*nativemetadata.MetadataTuple); ok {
-              return checkerProgrammer_decode_tuple(checkerProgrammer_decodeTupleProps{Config: props.Config, Context: props.Context, Functor: props.Functor, Input: v.Input, Tuple: tuple, Explore: featureProgrammer_as_explore(v.Explore)})
-            }
-            expected := []string{}
-            for _, elem := range props.Definitions {
-              switch x := elem.(type) {
-              case *nativemetadata.MetadataArray:
-                expected = append(expected, x.GetDisplayName())
-              case *nativemetadata.MetadataTuple:
-                expected = append(expected, x.Type.GetDisplayName())
-              }
-            }
-            return props.Config.Atomist(CheckerProgrammer_AtomistProps{
-              Explore: featureProgrammer_as_explore(v.Explore),
-              Entry: nativehelpers.ICheckEntry{
-                Expected:   strings.Join(expected, " | "),
-                Expression: CheckerProgrammer.Decode(CheckerProgrammer_DecodeProps{Functor: props.Functor, Context: props.Context, Config: props.Config, Metadata: v.Definition.(*nativemetadata.MetadataSchema), Input: v.Input, Explore: featureProgrammer_as_explore(v.Explore)}),
-                Conditions: [][]nativehelpers.ICheckEntry_ICondition{},
-              },
-              Input: v.Container,
-            })
-          },
-          func(v nativehelpers.UnionExplorer_ArrayLikeDecoderProps) *shimast.Node {
-            if tuple, ok := v.Definition.(*nativemetadata.MetadataTuple); ok {
-              return checkerProgrammer_decode_tuple(checkerProgrammer_decodeTupleProps{Context: props.Context, Config: props.Config, Functor: props.Functor, Input: v.Input, Tuple: tuple, Explore: featureProgrammer_as_explore(v.Explore)})
+      config := checkerProgrammer_array_like_config(props.Context, props.Config, props.Functor,
+        func(v nativehelpers.UnionExplorer_ArrayLikeCheckerProps) *shimast.Node {
+          if tuple, ok := v.Definition.(*nativemetadata.MetadataTuple); ok {
+            return checkerProgrammer_decode_tuple(checkerProgrammer_decodeTupleProps{Config: props.Config, Context: props.Context, Functor: props.Functor, Input: v.Input, Tuple: tuple, Explore: featureProgrammer_as_explore(v.Explore)})
+          }
+          expected := []string{}
+          for _, elem := range props.Definitions {
+            switch x := elem.(type) {
+            case *nativemetadata.MetadataArray:
+              expected = append(expected, x.GetDisplayName())
+            case *nativemetadata.MetadataTuple:
+              expected = append(expected, x.Type.GetDisplayName())
             }
-            return checkerProgrammer_decode_array(checkerProgrammer_decodeArrayProps{Context: props.Context, Config: props.Config, Functor: props.Functor, Input: v.Input, Array: v.Definition.(*nativemetadata.MetadataArray), Explore: featureProgrammer_as_explore(v.Explore)})
-          }),
+          }
+          return props.Config.Atomist(CheckerProgrammer_AtomistProps{
+            Explore: featureProgrammer_as_explore(v.Explore),
+            Entry: nativehelpers.ICheckEntry{
+              Expected:   strings.Join(expected, " | "),
+              Expression: CheckerProgrammer.Decode(CheckerProgrammer_DecodeProps{Functor: props.Functor, Context: props.Context, Config: props.Config, Metadata: v.Definition.(*nativemetadata.MetadataSchema), Input: v.Input, Explore: featureProgrammer_as_explore(v.Explore)}),
+              Conditions: [][]nativehelpers.ICheckEntry_ICondition{},
+            },
+            Input: v.Container,
+          })
+        },
+        func(v nativehelpers.UnionExplorer_ArrayLikeDecoderProps) *shimast.Node {
+          if tuple, ok := v.Definition.(*nativemetadata.MetadataTuple); ok {
+            return checkerProgrammer_decode_tuple(checkerProgrammer_decodeTupleProps{Context: props.Context, Config: props.Config, Functor: props.Functor, Input: v.Input, Tuple: tuple, Explore: featureProgrammer_as_explore(v.Explore)})
+          }
+          return checkerProgrammer_decode_array(checkerProgrammer_decodeArrayProps{Context: props.Context, Config: props.Config, Functor: props.Functor, Input: v.Input, Array: v.Definition.(*nativemetadata.MetadataArray), Explore: featureProgrammer_as_explore(v.Explore)})
+        })
+      if checkerProgrammer_definitions_have_array_type_tags(next.Definitions) {
+        config.Candidate = checkerProgrammer_array_tag_candidate(props.Context)
+      }
+      return nativehelpers.UnionExplorer.Array_or_tuple(nativehelpers.UnionExplorer_ArrayOrTupleProps{
+        Config:      config,
         Parameters:  next.Parameters,
         Definitions: next.Definitions,
         Input:       next.Input,
@@ -1785,7 +1799,7 @@ func checkerProgrammer_check_object_reference(props checkerProgrammer_decodeObje
   }
   return checkerProgrammer_and(
     decoded,
-    checkerProgrammer_object_type_tags_condition(tags, props.Context.Emit),
+    checkerProgrammer_entry_condition(tags, props.Context.Emit),
     props.Context.Emit,
   )
 }
@@ -1819,7 +1833,7 @@ func checkerProgrammer_decode_object_reference(props checkerProgrammer_decodeObj
   )
 }
 
-func checkerProgrammer_object_type_tags_condition(entry nativehelpers.ICheckEntry, emit *shimprinter.EmitContext) *shimast.Node {
+func checkerProgrammer_entry_condition(entry nativehelpers.ICheckEntry, emit *shimprinter.EmitContext) *shimast.Node {
   f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, emit)
   expressions := []*shimast.Node{}
   if entry.Expression != nil {
@@ -1852,6 +1866,44 @@ func checkerProgrammer_has_object_type_tags(objects []*nativemetadata.MetadataOb
   return false
 }
 
+func checkerProgrammer_has_array_type_tags(arrays []*nativemetadata.MetadataArray) bool {
+  for _, array := range arrays {
+    for _, row := range array.Tags {
+      for _, tag := range row {
+        if tag.Validate != "" {
+          return true
+        }
+      }
+    }
+  }
+  return false
+}
+
+func checkerProgrammer_definitions_have_array_type_tags(definitions []any) bool {
+  arrays := []*nativemetadata.MetadataArray{}
+  for _, definition := range definitions {
+    if array, ok := definition.(*nativemetadata.MetadataArray); ok {
+      arrays = append(arrays, array)
+    }
+  }
+  return checkerProgrammer_has_array_type_tags(arrays)
+}
+
+func checkerProgrammer_array_tag_candidate(context nativecontext.ITypiaContext) func(nativehelpers.UnionExplorer_ArrayLikeCandidateProps) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, context.Emit)
+  return func(props nativehelpers.UnionExplorer_ArrayLikeCandidateProps) *shimast.Node {
+    array, ok := props.Definition.(*nativemetadata.MetadataArray)
+    if ok == false {
+      return f.NewKeywordExpression(shimast.KindTrueKeyword)
+    }
+    return checkerProgrammer_entry_condition(nativeiterate.Check_array_length(nativeiterate.Check_array_lengthProps{
+      Context: context,
+      Array:   array,
+      Input:   props.Input,
+    }), context.Emit)
+  }
+}
+
 func checkerProgrammer_array_like_config(context nativecontext.ITypiaContext, config CheckerProgrammer_IConfig, functor *nativehelpers.FunctionProgrammer, checker func(v nativehelpers.UnionExplorer_ArrayLikeCheckerProps) *shimast.Node, decoder func(v nativehelpers.UnionExplorer_ArrayLikeDecoderProps) *shimast.Node) nativehelpers.UnionExplorer_ArrayLikeConfig {
   f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, context.Emit)
   return nativehelpers.UnionExplorer_ArrayLikeConfig{