typia 13.0.1-dev.20260703.1 → 13.0.2

package/native/core/programmers/IsProgrammer.go

@@ -1,419 +1,418 @@
-package programmers
-
-import (
-  shimast "github.com/microsoft/typescript-go/shim/ast"
-  nativechecker "github.com/microsoft/typescript-go/shim/checker"
-  shimprinter "github.com/microsoft/typescript-go/shim/printer"
-  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
-  nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
-  nativeinternal "github.com/samchon/typia/packages/typia/native/core/programmers/internal"
-  nativeiterate "github.com/samchon/typia/packages/typia/native/core/programmers/iterate"
-  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
-)
-
-type isProgrammerNamespace struct{}
-
-var IsProgrammer = isProgrammerNamespace{}
-
-type IsProgrammer_CONFIG_IOptions struct {
-  Numeric   *bool
-  Undefined *bool
-  Object    func(props IsProgrammer_CONFIG_IOptions_ObjectProps) *shimast.Node
-}
-
-type IsProgrammer_CONFIG_IOptions_ObjectProps struct {
-  Input   *shimast.Expression
-  Entries []nativehelpers.IExpressionEntry
-  Object  *nativemetadata.MetadataObjectType
-}
-
-type IsProgrammer_IConfig struct {
-  Equals bool
-  Depth  *int
-}
-
-type IsProgrammer_IProps struct {
-  Context nativecontext.ITypiaContext
-  Modulo  *shimast.Node
-  Type    *nativechecker.Type
-  Name    *string
-  Init    *shimast.Node
-  Config  IsProgrammer_IConfig
-}
-
-type IsProgrammer_DecomposeProps struct {
-  Context nativecontext.ITypiaContext
-  Functor *nativehelpers.FunctionProgrammer
-  Config  IsProgrammer_IConfig
-  Type    *nativechecker.Type
-  Name    *string
-}
-
-type IsProgrammer_WriteFunctionStatementsProps struct {
-  Context    nativecontext.ITypiaContext
-  Functor    *nativehelpers.FunctionProgrammer
-  Collection *nativemetadata.MetadataCollection
-  // Prefix overrides the is-helper namespace ("" => the default "_i"). Used by
-  // plain.classify's VALIDATED union construction, which emits its OWN is-check
-  // helpers under "_yi" so the construction ladder references them by the
-  // classify collection's index — disjoint from the assert/validate side's "_i"
-  // (whose helpers come from a SEPARATE collection that may reorder/dedup).
-  Prefix string
-}
-
-type IsProgrammer_DecodeProps struct {
-  Context  nativecontext.ITypiaContext
-  Functor  *nativehelpers.FunctionProgrammer
-  Metadata *nativemetadata.MetadataSchema
-  Input    *shimast.Expression
-  Explore  nativeinternal.CheckerProgrammer_IExplore
-  // Prefix overrides the is-helper namespace ("" => the default "_i"). See
-  // IsProgrammer_WriteFunctionStatementsProps.Prefix — the classify validated
-  // union ladder passes "_yi" so its _yio<i>/_yiu<i> references line up with the
-  // helpers its own Addition emits, not the assert side's _io<i>.
-  Prefix string
-}
-
-type IsProgrammer_DecodeObjectProps struct {
-  Context nativecontext.ITypiaContext
-  Functor *nativehelpers.FunctionProgrammer
-  Object  *nativemetadata.MetadataObjectType
-  Input   *shimast.Expression
-  Explore nativeinternal.FeatureProgrammer_IExplore
-  // Prefix overrides the is-helper namespace ("" => the default "_i"). See
-  // IsProgrammer_DecodeProps.Prefix — plain.classify's VALIDATED path passes
-  // "_yi" so a NESTED object discrimination references _yio<i> emitted by its own
-  // classify collection, not the assert side's reordered/deduped _io<i>.
-  Prefix string
-}
-
-var isProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
-func (isProgrammerNamespace) Configure(props struct {
-  Options *IsProgrammer_CONFIG_IOptions
-  Context nativecontext.ITypiaContext
-  Functor *nativehelpers.FunctionProgrammer
-}) nativeinternal.CheckerProgrammer_IConfig {
-  f := nativecontext.EmitFactoryOf(isProgrammer_factory, props.Context.Emit)
-  options := props.Options
-  return nativeinternal.CheckerProgrammer_IConfig{
-    Prefix:        "_i",
-    Equals:        options != nil && options.Object != nil,
-    Trace:         false,
-    Path:          false,
-    Numeric:       isProgrammer_option_numeric(options),
-    ObjectParents: options == nil || options.Object == nil,
-    Atomist: func(next nativeinternal.CheckerProgrammer_AtomistProps) *shimast.Node {
-      expressions := []*shimast.Node{}
-      if next.Entry.Expression != nil {
-        expressions = append(expressions, next.Entry.Expression)
-      }
-      if len(next.Entry.Conditions) != 0 {
-        rows := []*shimast.Node{}
-        for _, set := range next.Entry.Conditions {
-          cols := make([]*shimast.Node, 0, len(set))
-          for _, cond := range set {
-            cols = append(cols, cond.Expression)
-          }
-          rows = append(rows, isProgrammer_reduce(cols, shimast.KindAmpersandAmpersandToken, f.NewKeywordExpression(shimast.KindTrueKeyword), props.Context.Emit))
-        }
-        expressions = append(expressions, isProgrammer_reduce(rows, shimast.KindBarBarToken, f.NewKeywordExpression(shimast.KindFalseKeyword), props.Context.Emit))
-      }
-      return isProgrammer_reduce(expressions, shimast.KindAmpersandAmpersandToken, f.NewKeywordExpression(shimast.KindTrueKeyword), props.Context.Emit)
-    },
-    Combiner: func(next nativeinternal.CheckerProgrammer_CombinerProps) *shimast.Node {
-      initial := f.NewKeywordExpression(shimast.KindFalseKeyword)
-      operator := shimast.KindBarBarToken
-      if next.Logic == "and" {
-        initial = f.NewKeywordExpression(shimast.KindTrueKeyword)
-        operator = shimast.KindAmpersandAmpersandToken
-      }
-      expressions := make([]*shimast.Node, 0, len(next.Binaries))
-      for _, binary := range next.Binaries {
-        expressions = append(expressions, binary.Expression)
-      }
-      return isProgrammer_reduce(expressions, operator, initial, props.Context.Emit)
-    },
-    Joiner: nativeinternal.CheckerProgrammer_IConfig_IJoiner{
-      Object: func(v nativeinternal.CheckerProgrammer_JoinerObjectProps) *shimast.Node {
-        if options != nil && options.Object != nil {
-          return options.Object(IsProgrammer_CONFIG_IOptions_ObjectProps{
-            Input:   v.Input,
-            Entries: v.Entries,
-            Object:  v.Object,
-          })
-        }
-        return nativeiterate.Check_object(nativeiterate.Check_objectProps{
-          Config: nativeiterate.Check_object_IConfig{
-            Equals:    options != nil && options.Object != nil,
-            Undefined: isProgrammer_option_undefined(options),
-            Assert:    true,
-            Reduce: func(a *shimast.Expression, b *shimast.Expression) *shimast.Node {
-              return isProgrammer_binary(a, shimast.KindAmpersandAmpersandToken, b, props.Context.Emit)
-            },
-            Positive: f.NewKeywordExpression(shimast.KindTrueKeyword),
-            Superfluous: func(value *shimast.Expression, description *shimast.Expression) *shimast.Node {
-              return f.NewKeywordExpression(shimast.KindFalseKeyword)
-            },
-          },
-          Context: props.Context,
-          Entries: v.Entries,
-          Input:   v.Input,
-        })
-      },
-      Array: func(v nativeinternal.CheckerProgrammer_JoinerArrayProps) *shimast.Node {
-        return f.NewCallExpression(
-          nativefactories.IdentifierFactory.Access(props.Context.Emit, v.Input, "every"),
-          nil,
-          nil,
-          f.NewNodeList([]*shimast.Node{v.Arrow}),
-          shimast.NodeFlagsNone,
-        )
-      },
-      Failure: func(nativeinternal.CheckerProgrammer_JoinerFailureProps) *shimast.Node {
-        return f.NewKeywordExpression(shimast.KindFalseKeyword)
-      },
-    },
-    Success: f.NewKeywordExpression(shimast.KindTrueKeyword),
-  }
-}
-
-func (isProgrammerNamespace) Decompose(props IsProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
-  f := nativecontext.EmitFactoryOf(isProgrammer_factory, props.Context.Emit)
-  options := &IsProgrammer_CONFIG_IOptions{
-    Numeric: props.Context.Options.Numeric,
-    Object: func(v IsProgrammer_CONFIG_IOptions_ObjectProps) *shimast.Node {
-      return nativeiterate.Check_object(nativeiterate.Check_objectProps{
-        Config: nativeiterate.Check_object_IConfig{
-          Equals:    props.Config.Equals,
-          Undefined: nativehelpers.OptionPredicator.Undefined(props.Context.Options),
-          Assert:    true,
-          Reduce: func(a *shimast.Expression, b *shimast.Expression) *shimast.Node {
-            return isProgrammer_binary(a, shimast.KindAmpersandAmpersandToken, b, props.Context.Emit)
-          },
-          Positive: f.NewKeywordExpression(shimast.KindTrueKeyword),
-          Superfluous: func(value *shimast.Expression, description *shimast.Expression) *shimast.Node {
-            return f.NewKeywordExpression(shimast.KindFalseKeyword)
-          },
-        },
-        Context: props.Context,
-        Entries: v.Entries,
-        Input:   v.Input,
-      })
-    },
-  }
-  config := IsProgrammer.Configure(struct {
-    Options *IsProgrammer_CONFIG_IOptions
-    Context nativecontext.ITypiaContext
-    Functor *nativehelpers.FunctionProgrammer
-  }{Options: options, Context: props.Context, Functor: props.Functor})
-  config.Trace = props.Config.Equals
-  config.ObjectParents = props.Config.Equals == false
-  config.Depth = props.Config.Depth
-  if config.Depth != nil {
-    config.ObjectParents = false
-  }
-
-  composed := nativeinternal.CheckerProgrammer.Compose(nativeinternal.CheckerProgrammer_ComposeProps{
-    Context: props.Context,
-    Config:  config,
-    Functor: props.Functor,
-    Type:    props.Type,
-    Name:    props.Name,
-  })
-  return nativeinternal.FeatureProgrammer_IDecomposed{
-    Functions:  composed.Functions,
-    Statements: composed.Statements,
-    Arrow: f.NewArrowFunction(
-      nil,
-      nil,
-      f.NewNodeList(composed.Parameters),
-      composed.Response,
-      nil,
-      f.NewToken(shimast.KindEqualsGreaterThanToken),
-      composed.Body,
-    ),
-  }
-}
-
-func (isProgrammerNamespace) Write(props IsProgrammer_IProps) *shimast.Node {
-  method := nativehelpers.ModuloMethodText(props.Modulo)
-  functor := nativehelpers.NewFunctionProgrammer(method, props.Context.Emit)
-  result := IsProgrammer.Decompose(IsProgrammer_DecomposeProps{
-    Config:  props.Config,
-    Context: props.Context,
-    Functor: functor,
-    Type:    props.Type,
-    Name:    props.Name,
-  })
-  return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{
-    Modulo:  props.Modulo,
-    Functor: functor,
-    Result:  result,
-  })
-}
-
-func (isProgrammerNamespace) Write_function_statements(props IsProgrammer_WriteFunctionStatementsProps) []*shimast.Node {
-  config := IsProgrammer.Configure(struct {
-    Options *IsProgrammer_CONFIG_IOptions
-    Context nativecontext.ITypiaContext
-    Functor *nativehelpers.FunctionProgrammer
-  }{Options: nil, Context: props.Context, Functor: props.Functor})
-  if props.Prefix != "" {
-    config.Prefix = props.Prefix
-  }
-  next := nativeinternal.CheckerProgrammer_WriteObjectFunctionsProps{
-    Context:    props.Context,
-    Config:     config,
-    Functor:    props.Functor,
-    Collection: props.Collection,
-  }
-  objects := nativeinternal.CheckerProgrammer.Write_object_functions(next)
-  unions := nativeinternal.CheckerProgrammer.Write_union_functions(next)
-  arrays := nativeinternal.CheckerProgrammer.Write_array_functions(next)
-  tuples := nativeinternal.CheckerProgrammer.Write_tuple_functions(next)
-
-  output := []*shimast.Node{}
-  for i, stmt := range objects {
-    if props.Functor.HasLocal(config.Prefix + "o" + isProgrammer_itoa(i)) {
-      output = append(output, stmt)
-    }
-  }
-  for i, stmt := range unions {
-    if props.Functor.HasLocal(config.Prefix + "u" + isProgrammer_itoa(i)) {
-      output = append(output, stmt)
-    }
-  }
-  for i, stmt := range arrays {
-    if props.Functor.HasLocal(config.Prefix + "a" + isProgrammer_itoa(i)) {
-      output = append(output, stmt)
-    }
-  }
-  for i, stmt := range tuples {
-    if props.Functor.HasLocal(config.Prefix + "t" + isProgrammer_itoa(i)) {
-      output = append(output, stmt)
-    }
-  }
-  return output
-}
-
-func (isProgrammerNamespace) Decode(props IsProgrammer_DecodeProps) *shimast.Node {
-  config := IsProgrammer.Configure(struct {
-    Options *IsProgrammer_CONFIG_IOptions
-    Context nativecontext.ITypiaContext
-    Functor *nativehelpers.FunctionProgrammer
-  }{Options: nil, Context: props.Context, Functor: props.Functor})
-  if props.Prefix != "" {
-    config.Prefix = props.Prefix
-  }
-  return nativeinternal.CheckerProgrammer.Decode(nativeinternal.CheckerProgrammer_DecodeProps{
-    Context:  props.Context,
-    Config:   config,
-    Functor:  props.Functor,
-    Metadata: props.Metadata,
-    Input:    props.Input,
-    Explore:  props.Explore,
-  })
-}
-
-func (isProgrammerNamespace) Decode_object(props IsProgrammer_DecodeObjectProps) *shimast.Node {
-  config := IsProgrammer.Configure(struct {
-    Options *IsProgrammer_CONFIG_IOptions
-    Context nativecontext.ITypiaContext
-    Functor *nativehelpers.FunctionProgrammer
-  }{Options: nil, Context: props.Context, Functor: props.Functor})
-  if props.Prefix != "" {
-    config.Prefix = props.Prefix
-  }
-  return nativeinternal.CheckerProgrammer.Decode_object(nativeinternal.CheckerProgrammer_DecodeObjectProps{
-    Config:  config,
-    Context: props.Context,
-    Functor: props.Functor,
-    Object:  props.Object,
-    Input:   props.Input,
-    Explore: props.Explore,
-  })
-}
-
-func (isProgrammerNamespace) Decode_to_json(props struct {
-  Input     *shimast.Expression
-  CheckNull bool
-}, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(isProgrammer_factory, emit...)
-  var ec *shimprinter.EmitContext
-  if len(emit) != 0 {
-    ec = emit[0]
-  }
-  return isProgrammer_binary(
-    nativefactories.ExpressionFactory.IsObject(nativefactories.ExpressionFactory_IsObjectProps{
-      CheckArray: false,
-      CheckNull:  props.CheckNull,
-      Input:      props.Input,
-    }),
-    shimast.KindAmpersandAmpersandToken,
-    isProgrammer_binary(
-      f.NewStringLiteral("function", shimast.TokenFlagsNone),
-      shimast.KindEqualsEqualsEqualsToken,
-      nativefactories.ValueFactory.TYPEOF(nativefactories.IdentifierFactory.Access(ec, props.Input, "toJSON")),
-      ec,
-    ),
-    ec,
-  )
-}
-
-func (isProgrammerNamespace) Decode_functional(input *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(isProgrammer_factory, emit...)
-  var ec *shimprinter.EmitContext
-  if len(emit) != 0 {
-    ec = emit[0]
-  }
-  return isProgrammer_binary(
-    f.NewStringLiteral("function", shimast.TokenFlagsNone),
-    shimast.KindEqualsEqualsEqualsToken,
-    nativefactories.ValueFactory.TYPEOF(input),
-    ec,
-  )
-}
-
-func isProgrammer_reduce(expressions []*shimast.Node, operator shimast.Kind, initial *shimast.Expression, emit *shimprinter.EmitContext) *shimast.Node {
-  if len(expressions) == 0 {
-    return initial
-  }
-  output := expressions[0]
-  for _, expr := range expressions[1:] {
-    output = isProgrammer_binary(output, operator, expr, emit)
-  }
-  return output
-}
-
-func isProgrammer_binary(left *shimast.Expression, operator shimast.Kind, right *shimast.Expression, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(isProgrammer_factory, emit)
-  return f.NewBinaryExpression(
-    nil,
-    left,
-    nil,
-    f.NewToken(operator),
-    right,
-  )
-}
-
-func isProgrammer_option_numeric(options *IsProgrammer_CONFIG_IOptions) bool {
-  return options != nil && options.Numeric != nil && *options.Numeric
-}
-
-func isProgrammer_option_undefined(options *IsProgrammer_CONFIG_IOptions) bool {
-  return options == nil || options.Undefined == nil || *options.Undefined
-}
-
-func isProgrammer_itoa(value int) string {
-  if value == 0 {
-    return "0"
-  }
-  digits := []byte{}
-  for value > 0 {
-    digits = append([]byte{byte('0' + value%10)}, digits...)
-    value /= 10
-  }
-  return string(digits)
-}
+package programmers
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativechecker "github.com/microsoft/typescript-go/shim/checker"
+  shimprinter "github.com/microsoft/typescript-go/shim/printer"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+  nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
+  nativeinternal "github.com/samchon/typia/packages/typia/native/core/programmers/internal"
+  nativeiterate "github.com/samchon/typia/packages/typia/native/core/programmers/iterate"
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+type isProgrammerNamespace struct{}
+
+var IsProgrammer = isProgrammerNamespace{}
+
+type IsProgrammer_CONFIG_IOptions struct {
+  Numeric   *bool
+  Undefined *bool
+  Object    func(props IsProgrammer_CONFIG_IOptions_ObjectProps) *shimast.Node
+}
+
+type IsProgrammer_CONFIG_IOptions_ObjectProps struct {
+  Input   *shimast.Expression
+  Entries []nativehelpers.IExpressionEntry
+  Object  *nativemetadata.MetadataObjectType
+}
+
+type IsProgrammer_IConfig struct {
+  Equals bool
+  Depth  *int
+}
+
+type IsProgrammer_IProps struct {
+  Context nativecontext.ITypiaContext
+  Modulo  *shimast.Node
+  Type    *nativechecker.Type
+  Name    *string
+  Init    *shimast.Node
+  Config  IsProgrammer_IConfig
+}
+
+type IsProgrammer_DecomposeProps struct {
+  Context nativecontext.ITypiaContext
+  Functor *nativehelpers.FunctionProgrammer
+  Config  IsProgrammer_IConfig
+  Type    *nativechecker.Type
+  Name    *string
+}
+
+type IsProgrammer_WriteFunctionStatementsProps struct {
+  Context    nativecontext.ITypiaContext
+  Functor    *nativehelpers.FunctionProgrammer
+  Collection *nativemetadata.MetadataCollection
+  // Prefix overrides the is-helper namespace ("" => the default "_i"). Use it
+  // when a caller emits branch-selection helpers from its own metadata
+  // collection, disjoint from an outer assert/validate/is collection that may
+  // reorder or deduplicate helper indexes. For example, plain.classify uses
+  // "_yi" and validated json.stringify uses "_si".
+  Prefix string
+}
+
+type IsProgrammer_DecodeProps struct {
+  Context  nativecontext.ITypiaContext
+  Functor  *nativehelpers.FunctionProgrammer
+  Metadata *nativemetadata.MetadataSchema
+  Input    *shimast.Expression
+  Explore  nativeinternal.CheckerProgrammer_IExplore
+  // Prefix overrides the is-helper namespace ("" => the default "_i"). See
+  // IsProgrammer_WriteFunctionStatementsProps.Prefix; callers must pass the
+  // same prefix to Decode and Write_function_statements so helper references
+  // line up with the helpers emitted from the caller's own collection.
+  Prefix string
+}
+
+type IsProgrammer_DecodeObjectProps struct {
+  Context nativecontext.ITypiaContext
+  Functor *nativehelpers.FunctionProgrammer
+  Object  *nativemetadata.MetadataObjectType
+  Input   *shimast.Expression
+  Explore nativeinternal.FeatureProgrammer_IExplore
+  // Prefix overrides the is-helper namespace ("" => the default "_i"). See
+  // IsProgrammer_DecodeProps.Prefix; nested object discriminations must use the
+  // same caller-owned helper namespace as the surrounding union ladder.
+  Prefix string
+}
+
+var isProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+
+func (isProgrammerNamespace) Configure(props struct {
+  Options *IsProgrammer_CONFIG_IOptions
+  Context nativecontext.ITypiaContext
+  Functor *nativehelpers.FunctionProgrammer
+}) nativeinternal.CheckerProgrammer_IConfig {
+  f := nativecontext.EmitFactoryOf(isProgrammer_factory, props.Context.Emit)
+  options := props.Options
+  return nativeinternal.CheckerProgrammer_IConfig{
+    Prefix:        "_i",
+    Equals:        options != nil && options.Object != nil,
+    Trace:         false,
+    Path:          false,
+    Numeric:       isProgrammer_option_numeric(options),
+    ObjectParents: options == nil || options.Object == nil,
+    Atomist: func(next nativeinternal.CheckerProgrammer_AtomistProps) *shimast.Node {
+      expressions := []*shimast.Node{}
+      if next.Entry.Expression != nil {
+        expressions = append(expressions, next.Entry.Expression)
+      }
+      if len(next.Entry.Conditions) != 0 {
+        rows := []*shimast.Node{}
+        for _, set := range next.Entry.Conditions {
+          cols := make([]*shimast.Node, 0, len(set))
+          for _, cond := range set {
+            cols = append(cols, cond.Expression)
+          }
+          rows = append(rows, isProgrammer_reduce(cols, shimast.KindAmpersandAmpersandToken, f.NewKeywordExpression(shimast.KindTrueKeyword), props.Context.Emit))
+        }
+        expressions = append(expressions, isProgrammer_reduce(rows, shimast.KindBarBarToken, f.NewKeywordExpression(shimast.KindFalseKeyword), props.Context.Emit))
+      }
+      return isProgrammer_reduce(expressions, shimast.KindAmpersandAmpersandToken, f.NewKeywordExpression(shimast.KindTrueKeyword), props.Context.Emit)
+    },
+    Combiner: func(next nativeinternal.CheckerProgrammer_CombinerProps) *shimast.Node {
+      initial := f.NewKeywordExpression(shimast.KindFalseKeyword)
+      operator := shimast.KindBarBarToken
+      if next.Logic == "and" {
+        initial = f.NewKeywordExpression(shimast.KindTrueKeyword)
+        operator = shimast.KindAmpersandAmpersandToken
+      }
+      expressions := make([]*shimast.Node, 0, len(next.Binaries))
+      for _, binary := range next.Binaries {
+        expressions = append(expressions, binary.Expression)
+      }
+      return isProgrammer_reduce(expressions, operator, initial, props.Context.Emit)
+    },
+    Joiner: nativeinternal.CheckerProgrammer_IConfig_IJoiner{
+      Object: func(v nativeinternal.CheckerProgrammer_JoinerObjectProps) *shimast.Node {
+        if options != nil && options.Object != nil {
+          return options.Object(IsProgrammer_CONFIG_IOptions_ObjectProps{
+            Input:   v.Input,
+            Entries: v.Entries,
+            Object:  v.Object,
+          })
+        }
+        return nativeiterate.Check_object(nativeiterate.Check_objectProps{
+          Config: nativeiterate.Check_object_IConfig{
+            Equals:    options != nil && options.Object != nil,
+            Undefined: isProgrammer_option_undefined(options),
+            Assert:    true,
+            Reduce: func(a *shimast.Expression, b *shimast.Expression) *shimast.Node {
+              return isProgrammer_binary(a, shimast.KindAmpersandAmpersandToken, b, props.Context.Emit)
+            },
+            Positive: f.NewKeywordExpression(shimast.KindTrueKeyword),
+            Superfluous: func(value *shimast.Expression, description *shimast.Expression) *shimast.Node {
+              return f.NewKeywordExpression(shimast.KindFalseKeyword)
+            },
+          },
+          Context: props.Context,
+          Entries: v.Entries,
+          Input:   v.Input,
+        })
+      },
+      Array: func(v nativeinternal.CheckerProgrammer_JoinerArrayProps) *shimast.Node {
+        return f.NewCallExpression(
+          nativefactories.IdentifierFactory.Access(props.Context.Emit, v.Input, "every"),
+          nil,
+          nil,
+          f.NewNodeList([]*shimast.Node{v.Arrow}),
+          shimast.NodeFlagsNone,
+        )
+      },
+      Failure: func(nativeinternal.CheckerProgrammer_JoinerFailureProps) *shimast.Node {
+        return f.NewKeywordExpression(shimast.KindFalseKeyword)
+      },
+    },
+    Success: f.NewKeywordExpression(shimast.KindTrueKeyword),
+  }
+}
+
+func (isProgrammerNamespace) Decompose(props IsProgrammer_DecomposeProps) nativeinternal.FeatureProgrammer_IDecomposed {
+  f := nativecontext.EmitFactoryOf(isProgrammer_factory, props.Context.Emit)
+  options := &IsProgrammer_CONFIG_IOptions{
+    Numeric: props.Context.Options.Numeric,
+    Object: func(v IsProgrammer_CONFIG_IOptions_ObjectProps) *shimast.Node {
+      return nativeiterate.Check_object(nativeiterate.Check_objectProps{
+        Config: nativeiterate.Check_object_IConfig{
+          Equals:    props.Config.Equals,
+          Undefined: nativehelpers.OptionPredicator.Undefined(props.Context.Options),
+          Assert:    true,
+          Reduce: func(a *shimast.Expression, b *shimast.Expression) *shimast.Node {
+            return isProgrammer_binary(a, shimast.KindAmpersandAmpersandToken, b, props.Context.Emit)
+          },
+          Positive: f.NewKeywordExpression(shimast.KindTrueKeyword),
+          Superfluous: func(value *shimast.Expression, description *shimast.Expression) *shimast.Node {
+            return f.NewKeywordExpression(shimast.KindFalseKeyword)
+          },
+        },
+        Context: props.Context,
+        Entries: v.Entries,
+        Input:   v.Input,
+      })
+    },
+  }
+  config := IsProgrammer.Configure(struct {
+    Options *IsProgrammer_CONFIG_IOptions
+    Context nativecontext.ITypiaContext
+    Functor *nativehelpers.FunctionProgrammer
+  }{Options: options, Context: props.Context, Functor: props.Functor})
+  config.Trace = props.Config.Equals
+  config.ObjectParents = props.Config.Equals == false
+  config.Depth = props.Config.Depth
+  if config.Depth != nil {
+    config.ObjectParents = false
+  }
+
+  composed := nativeinternal.CheckerProgrammer.Compose(nativeinternal.CheckerProgrammer_ComposeProps{
+    Context: props.Context,
+    Config:  config,
+    Functor: props.Functor,
+    Type:    props.Type,
+    Name:    props.Name,
+  })
+  return nativeinternal.FeatureProgrammer_IDecomposed{
+    Functions:  composed.Functions,
+    Statements: composed.Statements,
+    Arrow: f.NewArrowFunction(
+      nil,
+      nil,
+      f.NewNodeList(composed.Parameters),
+      composed.Response,
+      nil,
+      f.NewToken(shimast.KindEqualsGreaterThanToken),
+      composed.Body,
+    ),
+  }
+}
+
+func (isProgrammerNamespace) Write(props IsProgrammer_IProps) *shimast.Node {
+  method := nativehelpers.ModuloMethodText(props.Modulo)
+  functor := nativehelpers.NewFunctionProgrammer(method, props.Context.Emit)
+  result := IsProgrammer.Decompose(IsProgrammer_DecomposeProps{
+    Config:  props.Config,
+    Context: props.Context,
+    Functor: functor,
+    Type:    props.Type,
+    Name:    props.Name,
+  })
+  return nativeinternal.FeatureProgrammer.WriteDecomposed(nativeinternal.FeatureProgrammer_WriteDecomposedProps{
+    Modulo:  props.Modulo,
+    Functor: functor,
+    Result:  result,
+  })
+}
+
+func (isProgrammerNamespace) Write_function_statements(props IsProgrammer_WriteFunctionStatementsProps) []*shimast.Node {
+  config := IsProgrammer.Configure(struct {
+    Options *IsProgrammer_CONFIG_IOptions
+    Context nativecontext.ITypiaContext
+    Functor *nativehelpers.FunctionProgrammer
+  }{Options: nil, Context: props.Context, Functor: props.Functor})
+  if props.Prefix != "" {
+    config.Prefix = props.Prefix
+  }
+  next := nativeinternal.CheckerProgrammer_WriteObjectFunctionsProps{
+    Context:    props.Context,
+    Config:     config,
+    Functor:    props.Functor,
+    Collection: props.Collection,
+  }
+  objects := nativeinternal.CheckerProgrammer.Write_object_functions(next)
+  unions := nativeinternal.CheckerProgrammer.Write_union_functions(next)
+  arrays := nativeinternal.CheckerProgrammer.Write_array_functions(next)
+  tuples := nativeinternal.CheckerProgrammer.Write_tuple_functions(next)
+
+  output := []*shimast.Node{}
+  for i, stmt := range objects {
+    if props.Functor.HasLocal(config.Prefix + "o" + isProgrammer_itoa(i)) {
+      output = append(output, stmt)
+    }
+  }
+  for i, stmt := range unions {
+    if props.Functor.HasLocal(config.Prefix + "u" + isProgrammer_itoa(i)) {
+      output = append(output, stmt)
+    }
+  }
+  for i, stmt := range arrays {
+    if props.Functor.HasLocal(config.Prefix + "a" + isProgrammer_itoa(i)) {
+      output = append(output, stmt)
+    }
+  }
+  for i, stmt := range tuples {
+    if props.Functor.HasLocal(config.Prefix + "t" + isProgrammer_itoa(i)) {
+      output = append(output, stmt)
+    }
+  }
+  return output
+}
+
+func (isProgrammerNamespace) Decode(props IsProgrammer_DecodeProps) *shimast.Node {
+  config := IsProgrammer.Configure(struct {
+    Options *IsProgrammer_CONFIG_IOptions
+    Context nativecontext.ITypiaContext
+    Functor *nativehelpers.FunctionProgrammer
+  }{Options: nil, Context: props.Context, Functor: props.Functor})
+  if props.Prefix != "" {
+    config.Prefix = props.Prefix
+  }
+  return nativeinternal.CheckerProgrammer.Decode(nativeinternal.CheckerProgrammer_DecodeProps{
+    Context:  props.Context,
+    Config:   config,
+    Functor:  props.Functor,
+    Metadata: props.Metadata,
+    Input:    props.Input,
+    Explore:  props.Explore,
+  })
+}
+
+func (isProgrammerNamespace) Decode_object(props IsProgrammer_DecodeObjectProps) *shimast.Node {
+  config := IsProgrammer.Configure(struct {
+    Options *IsProgrammer_CONFIG_IOptions
+    Context nativecontext.ITypiaContext
+    Functor *nativehelpers.FunctionProgrammer
+  }{Options: nil, Context: props.Context, Functor: props.Functor})
+  if props.Prefix != "" {
+    config.Prefix = props.Prefix
+  }
+  return nativeinternal.CheckerProgrammer.Decode_object(nativeinternal.CheckerProgrammer_DecodeObjectProps{
+    Config:  config,
+    Context: props.Context,
+    Functor: props.Functor,
+    Object:  props.Object,
+    Input:   props.Input,
+    Explore: props.Explore,
+  })
+}
+
+func (isProgrammerNamespace) Decode_to_json(props struct {
+  Input     *shimast.Expression
+  CheckNull bool
+}, emit ...*shimprinter.EmitContext) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(isProgrammer_factory, emit...)
+  var ec *shimprinter.EmitContext
+  if len(emit) != 0 {
+    ec = emit[0]
+  }
+  return isProgrammer_binary(
+    nativefactories.ExpressionFactory.IsObject(nativefactories.ExpressionFactory_IsObjectProps{
+      CheckArray: false,
+      CheckNull:  props.CheckNull,
+      Input:      props.Input,
+    }),
+    shimast.KindAmpersandAmpersandToken,
+    isProgrammer_binary(
+      f.NewStringLiteral("function", shimast.TokenFlagsNone),
+      shimast.KindEqualsEqualsEqualsToken,
+      nativefactories.ValueFactory.TYPEOF(nativefactories.IdentifierFactory.Access(ec, props.Input, "toJSON")),
+      ec,
+    ),
+    ec,
+  )
+}
+
+func (isProgrammerNamespace) Decode_functional(input *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(isProgrammer_factory, emit...)
+  var ec *shimprinter.EmitContext
+  if len(emit) != 0 {
+    ec = emit[0]
+  }
+  return isProgrammer_binary(
+    f.NewStringLiteral("function", shimast.TokenFlagsNone),
+    shimast.KindEqualsEqualsEqualsToken,
+    nativefactories.ValueFactory.TYPEOF(input),
+    ec,
+  )
+}
+
+func isProgrammer_reduce(expressions []*shimast.Node, operator shimast.Kind, initial *shimast.Expression, emit *shimprinter.EmitContext) *shimast.Node {
+  if len(expressions) == 0 {
+    return initial
+  }
+  output := expressions[0]
+  for _, expr := range expressions[1:] {
+    output = isProgrammer_binary(output, operator, expr, emit)
+  }
+  return output
+}
+
+func isProgrammer_binary(left *shimast.Expression, operator shimast.Kind, right *shimast.Expression, emit *shimprinter.EmitContext) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(isProgrammer_factory, emit)
+  return f.NewBinaryExpression(
+    nil,
+    left,
+    nil,
+    f.NewToken(operator),
+    right,
+  )
+}
+
+func isProgrammer_option_numeric(options *IsProgrammer_CONFIG_IOptions) bool {
+  return options != nil && options.Numeric != nil && *options.Numeric
+}
+
+func isProgrammer_option_undefined(options *IsProgrammer_CONFIG_IOptions) bool {
+  return options == nil || options.Undefined == nil || *options.Undefined
+}
+
+func isProgrammer_itoa(value int) string {
+  if value == 0 {
+    return "0"
+  }
+  digits := []byte{}
+  for value > 0 {
+    digits = append([]byte{byte('0' + value%10)}, digits...)
+    value /= 10
+  }
+  return string(digits)
+}