typia 15.0.0 → 15.1.0

package/native/core/programmers/functional/FunctionalIsParametersProgrammer.go

@@ -2,6 +2,7 @@ package functional
 
 import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "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"
@@ -13,28 +14,81 @@ type functionalIsParametersProgrammerNamespace struct{}
 
 var FunctionalIsParametersProgrammer = functionalIsParametersProgrammerNamespace{}
 
+// FunctionalIsParametersProgrammer_IConfig selects the generator's variants:
+// Equals is the strict form that also rejects properties the type does not
+// declare.
+//
+// @evidence contracts/common.md#principled-implementation Each variant of the generator is one boolean or option on a record, so the transformers pick a form by naming the field and no second code path is copied.
+// @evidence contracts/common.md#clear-and-simple-design A record of 1 field.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc states what each field selects.
 type FunctionalIsParametersProgrammer_IConfig struct {
+  // Equals rejects surplus properties in addition to checking declared values.
   Equals bool
 }
 
+// FunctionalIsParametersProgrammer_IProps is the input of Write for the is
+// parameters generator: Context (the transform context), Modulo (the call's
+// callee expression), Config (the configuration), Declaration (the function
+// declaration) and Expression (the function expression).
+//
+// @evidence contracts/common.md#principled-implementation Write needs the transform context, the call's callee expression, the configuration, the function declaration and the function expression, and the record carries them in one argument.
+// @evidence contracts/common.md#clear-and-simple-design A flat argument record of 5 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc names each field.
 type FunctionalIsParametersProgrammer_IProps struct {
-  Context     nativecontext.ITypiaContext
-  Modulo      *shimast.Node
-  Config      FunctionalIsParametersProgrammer_IConfig
+  // Context borrows the checker, emitter and importer for this transform.
+  Context nativecontext.ITypiaContext
+
+  // Modulo identifies the typia call for helper naming and diagnostics.
+  Modulo *shimast.Node
+
+  // Config selects ordinary validation or rejection of surplus properties.
+  Config FunctionalIsParametersProgrammer_IConfig
+
+  // Declaration supplies parameter bindings and the checker return signature.
   Declaration *shimast.Node
-  Expression  *shimast.Node
-  Init        *shimast.Node
+
+  // Expression is the original callable, invoked with the wrapper receiver.
+  Expression *shimast.Node
 }
 
+// FunctionalIsParametersProgrammer_IDecomposeProps is the input of Decompose for
+// the is parameters generator: Context (the transform context), Config (the
+// configuration), Modulo (the call's callee expression) and Declaration (the
+// function declaration).
+//
+// @evidence contracts/common.md#principled-implementation Decompose needs the transform context, the configuration, the call's callee expression and the function declaration, and the record carries them in one argument.
+// @evidence contracts/common.md#clear-and-simple-design A flat argument record of 4 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc names each field.
 type FunctionalIsParametersProgrammer_IDecomposeProps struct {
-  Context     nativecontext.ITypiaContext
-  Config      FunctionalIsParametersProgrammer_IConfig
-  Modulo      *shimast.Node
+  // Context borrows the checker, emitter and importer for this transform.
+  Context nativecontext.ITypiaContext
+
+  // Config selects ordinary validation or rejection of surplus properties.
+  Config FunctionalIsParametersProgrammer_IConfig
+
+  // Modulo identifies the typia call for helper naming and diagnostics.
+  Modulo *shimast.Node
+
+  // Declaration supplies parameter bindings and the checker return signature.
   Declaration *shimast.Node
 }
 
+// FunctionalIsParametersProgrammer_IDecomposeOutput is what the generator
+// returns: Functions is the helper function statements and Statements is the
+// body statements.
+//
+// @evidence contracts/common.md#principled-implementation The generator returns its pieces separately so the caller can place helper functions, statements and values where its own wrapper needs them.
+// @evidence contracts/common.md#clear-and-simple-design A record of 2 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc states each returned part.
 type FunctionalIsParametersProgrammer_IDecomposeOutput struct {
-  Functions  []*shimast.Node
+  // Functions contains helper declarations placed outside the returned wrapper.
+  Functions []*shimast.Node
+
+  // Statements contains ordered checks and returns inside the wrapper body.
   Statements []*shimast.Node
 }
 
@@ -91,9 +145,7 @@ func (functionalIsParametersProgrammerNamespace) Decompose(props FunctionalIsPar
         Context: props.Context,
         Modulo:  props.Modulo,
         Config:  nativeprogrammers.IsProgrammer_IConfig{Equals: props.Config.Equals},
-        Type: props.Context.Checker.GetTypeFromTypeNode(
-          functionalIsProgrammer_parameterType(p, nativefactories.TypeFactory.Keyword("any", props.Context.Emit)),
-        ),
+        Type:    functionalIsProgrammer_parameterCheckerType(props.Context, p),
       }),
     }, props.Context.Emit))
     statements = append(statements, f.NewIfStatement(
@@ -157,7 +209,7 @@ func functionalIsProgrammer_function(
     nil,
     nil,
     nil,
-    functionalIsProgrammer_parameters(declaration, context.Emit),
+    functionalIsProgrammer_wrapperParameters(declaration, context.Emit),
     returnType,
     nil,
     body,
@@ -184,13 +236,84 @@ func functionalIsProgrammer_parameterIdentifiers(declaration *shimast.Node, emit
   parameters := functionalIsProgrammer_parameterNodes(declaration)
   output := make([]*shimast.Node, 0, len(parameters))
   for _, p := range parameters {
-    output = append(output, f.NewIdentifier(functionalIsProgrammer_parameterName(p)))
+    identifier := f.NewIdentifier(functionalIsProgrammer_parameterName(p))
+    // a rest parameter received its arguments as an array; spread them back
+    if p.Kind == shimast.KindParameter && p.AsParameterDeclaration().DotDotDotToken != nil {
+      identifier = f.NewSpreadElement(identifier)
+    }
+    output = append(output, identifier)
   }
   return output
 }
 
+// functionalIsProgrammer_wrapperParameters is the declaration's parameter list
+// for the wrapper, a destructuring pattern renamed to the identifier
+// functionalIsProgrammer_parameterName gives it: the wrapper validates and
+// forwards the whole argument, and a pattern names no single value.
+func functionalIsProgrammer_wrapperParameters(declaration *shimast.Node, emit ...*shimprinter.EmitContext) *shimast.ParameterList {
+  f := nativecontext.EmitFactoryOf(functionalIsProgrammer_factory, emit...)
+  list := functionalIsProgrammer_parameters(declaration, emit...)
+  if list == nil {
+    return list
+  }
+  if functionalIsProgrammer_hasBindingPattern(declaration) == false {
+    return list
+  }
+  // A default may read a name an earlier pattern binds (`({ a }, b = a)`),
+  // which the renamed wrapper no longer binds. So no default is copied: the
+  // wrapper forwards what it received, the function applies its own
+  // defaults, and a defaulted argument may be `undefined`; see
+  // functionalIsProgrammer_parameterCheckerType.
+  output := make([]*shimast.Node, 0, len(list.Nodes))
+  for _, param := range list.Nodes {
+    if param.Kind == shimast.KindParameter && param.Name() != nil && functionalIsProgrammer_parameterName(param) != "this" {
+      data := param.AsParameterDeclaration()
+      param = f.NewParameterDeclaration(
+        nil,
+        data.DotDotDotToken,
+        f.NewIdentifier(functionalIsProgrammer_parameterName(param)),
+        data.QuestionToken,
+        data.Type,
+        nil,
+      )
+    }
+    output = append(output, param)
+  }
+  return f.NewNodeList(output)
+}
+
+// functionalIsProgrammer_hasBindingPattern reports whether any parameter of
+// declaration destructures its argument.
+func functionalIsProgrammer_hasBindingPattern(declaration *shimast.Node) bool {
+  if list := functionalIsProgrammer_parameters(declaration); list != nil {
+    for _, param := range list.Nodes {
+      if param.Name() != nil && functionalIsProgrammer_isBindingPattern(param.Name()) {
+        return true
+      }
+    }
+  }
+  return false
+}
+
 func functionalIsProgrammer_parameterName(param *shimast.Node) string {
   if param != nil && param.Name() != nil {
+    // A destructuring pattern has no name; the wrapper gives it one by its
+    // position (samchon/typia#2461), apart from every other parameter's name,
+    // or the wrapper would declare it twice.
+    if functionalIsProgrammer_isBindingPattern(param.Name()) {
+      index := 0
+      names := []string{}
+      if parent := param.Parent; parent != nil && parent.FunctionLikeData() != nil && parent.FunctionLikeData().Parameters != nil {
+        for i, sibling := range parent.FunctionLikeData().Parameters.Nodes {
+          if sibling == param {
+            index = i
+          } else if sibling.Name() != nil && functionalIsProgrammer_isBindingPattern(sibling.Name()) == false {
+            names = append(names, sibling.Name().Text())
+          }
+        }
+      }
+      return functionalIsProgrammer_escapeDuplicate(names, "__param"+functionalIsProgrammer_itoa(index))
+    }
     text := param.Name().Text()
     if text != "" {
       return text
@@ -200,13 +323,34 @@ func functionalIsProgrammer_parameterName(param *shimast.Node) string {
   return "input"
 }
 
-func functionalIsProgrammer_parameterType(param *shimast.Node, fallback *shimast.Node) *shimast.Node {
-  if param != nil && param.Kind == shimast.KindParameter {
-    if typ := param.AsParameterDeclaration().Type; typ != nil {
+// functionalIsProgrammer_parameterCheckerType is the type an argument must
+// satisfy: the parameter symbol's type, which adds `undefined` to an optional
+// parameter and reads a type inferred from a default. The written annotation
+// alone made `y?: string` require a `string` (samchon/typia#2461).
+func functionalIsProgrammer_parameterCheckerType(context nativecontext.ITypiaContext, param *shimast.Node) *shimchecker.Type {
+  typ := functionalIsProgrammer_declaredType(context, param)
+  // A wrapper beside a destructured parameter copies no default, so a
+  // defaulted argument arrives as sent, `undefined` included.
+  if param.Kind == shimast.KindParameter &&
+    param.AsParameterDeclaration().Initializer != nil &&
+    functionalIsProgrammer_hasBindingPattern(param.Parent) {
+    return context.Checker.GetUnionType([]*shimchecker.Type{typ, context.Checker.GetUndefinedType()})
+  }
+  return typ
+}
+
+func functionalIsProgrammer_declaredType(context nativecontext.ITypiaContext, param *shimast.Node) *shimchecker.Type {
+  if symbol := param.Symbol(); symbol != nil {
+    if typ := context.Checker.GetTypeOfSymbol(symbol); typ != nil {
       return typ
     }
   }
-  return fallback
+  if param.Kind == shimast.KindParameter {
+    if typ := param.AsParameterDeclaration().Type; typ != nil {
+      return context.Checker.GetTypeFromTypeNode(typ)
+    }
+  }
+  return context.Checker.GetAnyType()
 }
 
 func functionalIsProgrammer_asyncModifiers(async bool, emit ...*shimprinter.EmitContext) *shimast.ModifierList {
@@ -255,3 +399,10 @@ func functionalIsProgrammer_itoa(value int) string {
   }
   return string(digits)
 }
+
+// functionalIsProgrammer_isBindingPattern reports whether name destructures
+// an object or an array. It compares the kind itself because the shim of the
+// oldest supported ttsc exports no IsBindingPattern.
+func functionalIsProgrammer_isBindingPattern(name *shimast.Node) bool {
+  return name.Kind == shimast.KindObjectBindingPattern || name.Kind == shimast.KindArrayBindingPattern
+}

package/native/core/programmers/functional/FunctionalIsReturnProgrammer.go

@@ -12,30 +12,86 @@ type functionalIsReturnProgrammerNamespace struct{}
 
 var FunctionalIsReturnProgrammer = functionalIsReturnProgrammerNamespace{}
 
+// FunctionalIsReturnProgrammer_IConfig selects the generator's variants: Equals
+// is the strict form that also rejects properties the type does not declare.
+//
+// @evidence contracts/common.md#principled-implementation Each variant of the generator is one boolean or option on a record, so the transformers pick a form by naming the field and no second code path is copied.
+// @evidence contracts/common.md#clear-and-simple-design A record of 1 field.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc states what each field selects.
 type FunctionalIsReturnProgrammer_IConfig struct {
+  // Equals rejects surplus properties in addition to checking declared values.
   Equals bool
 }
 
+// FunctionalIsReturnProgrammer_IProps is the input of Write for the is return
+// generator: Context (the transform context), Modulo (the call's callee
+// expression), Config (the configuration), Declaration (the function
+// declaration) and Expression (the function expression).
+//
+// @evidence contracts/common.md#principled-implementation Write needs the transform context, the call's callee expression, the configuration, the function declaration and the function expression, and the record carries them in one argument.
+// @evidence contracts/common.md#clear-and-simple-design A flat argument record of 5 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc names each field.
 type FunctionalIsReturnProgrammer_IProps struct {
-  Context     nativecontext.ITypiaContext
-  Modulo      *shimast.Node
-  Config      FunctionalIsReturnProgrammer_IConfig
+  // Context borrows the checker, emitter and importer for this transform.
+  Context nativecontext.ITypiaContext
+
+  // Modulo identifies the typia call for helper naming and diagnostics.
+  Modulo *shimast.Node
+
+  // Config selects ordinary validation or rejection of surplus properties.
+  Config FunctionalIsReturnProgrammer_IConfig
+
+  // Declaration supplies parameter bindings and the checker return signature.
   Declaration *shimast.Node
-  Expression  *shimast.Node
-  Init        *shimast.Node
+
+  // Expression is the original callable, invoked with the wrapper receiver.
+  Expression *shimast.Node
 }
 
+// FunctionalIsReturnProgrammer_IDecomposeProps is the input of Decompose for the
+// is return generator: Context (the transform context), Modulo (the call's
+// callee expression), Config (the configuration), Expression (the function
+// expression) and Declaration (the function declaration).
+//
+// @evidence contracts/common.md#principled-implementation Decompose needs the transform context, the call's callee expression, the configuration, the function expression and the function declaration, and the record carries them in one argument.
+// @evidence contracts/common.md#clear-and-simple-design A flat argument record of 5 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc names each field.
 type FunctionalIsReturnProgrammer_IDecomposeProps struct {
-  Context     nativecontext.ITypiaContext
-  Modulo      *shimast.Node
-  Config      FunctionalIsReturnProgrammer_IConfig
-  Expression  *shimast.Node
+  // Context borrows the checker, emitter and importer for this transform.
+  Context nativecontext.ITypiaContext
+
+  // Modulo identifies the typia call for helper naming and diagnostics.
+  Modulo *shimast.Node
+
+  // Config selects ordinary validation or rejection of surplus properties.
+  Config FunctionalIsReturnProgrammer_IConfig
+
+  // Expression is the original callable, invoked with the wrapper receiver.
+  Expression *shimast.Node
+
+  // Declaration supplies parameter bindings and the checker return signature.
   Declaration *shimast.Node
 }
 
+// FunctionalIsReturnProgrammer_IDecomposeOutput is what the generator returns:
+// Async is whether the wrapped function is asynchronous, Functions is the helper
+// function statements and Statements is the body statements.
+//
+// @evidence contracts/common.md#principled-implementation The generator returns its pieces separately so the caller can place helper functions, statements and values where its own wrapper needs them.
+// @evidence contracts/common.md#clear-and-simple-design A record of 3 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc states each returned part.
 type FunctionalIsReturnProgrammer_IDecomposeOutput struct {
-  Async      bool
-  Functions  []*shimast.Node
+  // Async requests an async wrapper and awaiting of the original return value.
+  Async bool
+
+  // Functions contains helper declarations placed outside the returned wrapper.
+  Functions []*shimast.Node
+
+  // Statements contains ordered checks and returns inside the wrapper body.
   Statements []*shimast.Node
 }
 

package/native/core/programmers/functional/FunctionalValidateFunctionProgrammer.go

@@ -10,17 +10,43 @@ type functionalValidateFunctionProgrammerNamespace struct{}
 
 var FunctionalValidateFunctionProgrammer = functionalValidateFunctionProgrammerNamespace{}
 
+// FunctionalValidateFunctionProgrammer_IConfig selects the generator's variants:
+// Equals is the strict form that also rejects properties the type does not
+// declare.
+//
+// @evidence contracts/common.md#principled-implementation Each variant of the generator is one boolean or option on a record, so the transformers pick a form by naming the field and no second code path is copied.
+// @evidence contracts/common.md#clear-and-simple-design A record of 1 field.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc states what each field selects.
 type FunctionalValidateFunctionProgrammer_IConfig struct {
+  // Equals rejects surplus properties in addition to checking declared values.
   Equals bool
 }
 
+// FunctionalValidateFunctionProgrammer_IProps is the input of Write for the
+// validate function generator: Context (the transform context), Modulo (the
+// call's callee expression), Config (the configuration), Declaration (the
+// function declaration) and Expression (the function expression).
+//
+// @evidence contracts/common.md#principled-implementation Write needs the transform context, the call's callee expression, the configuration, the function declaration and the function expression, and the record carries them in one argument.
+// @evidence contracts/common.md#clear-and-simple-design A flat argument record of 5 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc names each field.
 type FunctionalValidateFunctionProgrammer_IProps struct {
-  Context     nativecontext.ITypiaContext
-  Modulo      *shimast.Node
-  Config      FunctionalValidateFunctionProgrammer_IConfig
+  // Context borrows the checker, emitter and importer for this transform.
+  Context nativecontext.ITypiaContext
+
+  // Modulo identifies the typia call for helper naming and diagnostics.
+  Modulo *shimast.Node
+
+  // Config selects ordinary validation or rejection of surplus properties.
+  Config FunctionalValidateFunctionProgrammer_IConfig
+
+  // Declaration supplies parameter bindings and the checker return signature.
   Declaration *shimast.Node
-  Expression  *shimast.Node
-  Init        *shimast.Node
+
+  // Expression is the original callable, invoked with the wrapper receiver.
+  Expression *shimast.Node
 }
 
 var functionalValidateProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})

package/native/core/programmers/functional/FunctionalValidateParametersProgrammer.go

@@ -12,28 +12,81 @@ type functionalValidateParametersProgrammerNamespace struct{}
 
 var FunctionalValidateParametersProgrammer = functionalValidateParametersProgrammerNamespace{}
 
+// FunctionalValidateParametersProgrammer_IConfig selects the generator's
+// variants: Equals is the strict form that also rejects properties the type does
+// not declare.
+//
+// @evidence contracts/common.md#principled-implementation Each variant of the generator is one boolean or option on a record, so the transformers pick a form by naming the field and no second code path is copied.
+// @evidence contracts/common.md#clear-and-simple-design A record of 1 field.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc states what each field selects.
 type FunctionalValidateParametersProgrammer_IConfig struct {
+  // Equals rejects surplus properties in addition to checking declared values.
   Equals bool
 }
 
+// FunctionalValidateParametersProgrammer_IProps is the input of Write for the
+// validate parameters generator: Context (the transform context), Modulo (the
+// call's callee expression), Config (the configuration), Declaration (the
+// function declaration) and Expression (the function expression).
+//
+// @evidence contracts/common.md#principled-implementation Write needs the transform context, the call's callee expression, the configuration, the function declaration and the function expression, and the record carries them in one argument.
+// @evidence contracts/common.md#clear-and-simple-design A flat argument record of 5 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc names each field.
 type FunctionalValidateParametersProgrammer_IProps struct {
-  Context     nativecontext.ITypiaContext
-  Modulo      *shimast.Node
-  Config      FunctionalValidateParametersProgrammer_IConfig
+  // Context borrows the checker, emitter and importer for this transform.
+  Context nativecontext.ITypiaContext
+
+  // Modulo identifies the typia call for helper naming and diagnostics.
+  Modulo *shimast.Node
+
+  // Config selects ordinary validation or rejection of surplus properties.
+  Config FunctionalValidateParametersProgrammer_IConfig
+
+  // Declaration supplies parameter bindings and the checker return signature.
   Declaration *shimast.Node
-  Expression  *shimast.Node
-  Init        *shimast.Node
+
+  // Expression is the original callable, invoked with the wrapper receiver.
+  Expression *shimast.Node
 }
 
+// FunctionalValidateParametersProgrammer_IDecomposeProps is the input of
+// Decompose for the validate parameters generator: Context (the transform
+// context), Modulo (the call's callee expression), Config (the configuration)
+// and Declaration (the function declaration).
+//
+// @evidence contracts/common.md#principled-implementation Decompose needs the transform context, the call's callee expression, the configuration and the function declaration, and the record carries them in one argument.
+// @evidence contracts/common.md#clear-and-simple-design A flat argument record of 4 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc names each field.
 type FunctionalValidateParametersProgrammer_IDecomposeProps struct {
-  Context     nativecontext.ITypiaContext
-  Modulo      *shimast.Node
-  Config      FunctionalValidateParametersProgrammer_IConfig
+  // Context borrows the checker, emitter and importer for this transform.
+  Context nativecontext.ITypiaContext
+
+  // Modulo identifies the typia call for helper naming and diagnostics.
+  Modulo *shimast.Node
+
+  // Config selects ordinary validation or rejection of surplus properties.
+  Config FunctionalValidateParametersProgrammer_IConfig
+
+  // Declaration supplies parameter bindings and the checker return signature.
   Declaration *shimast.Node
 }
 
+// FunctionalValidateParametersProgrammer_IDecomposeOutput is what the generator
+// returns: Functions is the helper function statements and Statements is the
+// body statements.
+//
+// @evidence contracts/common.md#principled-implementation The generator returns its pieces separately so the caller can place helper functions, statements and values where its own wrapper needs them.
+// @evidence contracts/common.md#clear-and-simple-design A record of 2 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc states each returned part.
 type FunctionalValidateParametersProgrammer_IDecomposeOutput struct {
-  Functions  []*shimast.Node
+  // Functions contains helper declarations placed outside the returned wrapper.
+  Functions []*shimast.Node
+
+  // Statements contains ordered checks and returns inside the wrapper body.
   Statements []*shimast.Node
 }
 
@@ -97,9 +150,7 @@ func (functionalValidateParametersProgrammerNamespace) Decompose(props Functiona
         Context: props.Context,
         Modulo:  props.Modulo,
         Config:  nativeprogrammers.ValidateProgrammer_IConfig{Equals: props.Config.Equals},
-        Type: props.Context.Checker.GetTypeFromTypeNode(
-          functionalIsProgrammer_parameterType(p, nativefactories.TypeFactory.Keyword("any", props.Context.Emit)),
-        ),
+        Type:    functionalIsProgrammer_parameterCheckerType(props.Context, p),
       }),
     }, props.Context.Emit))
     results = append(results, f.NewAsExpression(

package/native/core/programmers/functional/FunctionalValidateReturnProgrammer.go

@@ -12,30 +12,87 @@ type functionalValidateReturnProgrammerNamespace struct{}
 
 var FunctionalValidateReturnProgrammer = functionalValidateReturnProgrammerNamespace{}
 
+// FunctionalValidateReturnProgrammer_IConfig selects the generator's variants:
+// Equals is the strict form that also rejects properties the type does not
+// declare.
+//
+// @evidence contracts/common.md#principled-implementation Each variant of the generator is one boolean or option on a record, so the transformers pick a form by naming the field and no second code path is copied.
+// @evidence contracts/common.md#clear-and-simple-design A record of 1 field.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc states what each field selects.
 type FunctionalValidateReturnProgrammer_IConfig struct {
+  // Equals rejects surplus properties in addition to checking declared values.
   Equals bool
 }
 
+// FunctionalValidateReturnProgrammer_IProps is the input of Write for the
+// validate return generator: Context (the transform context), Modulo (the
+// call's callee expression), Config (the configuration), Declaration (the
+// function declaration) and Expression (the function expression).
+//
+// @evidence contracts/common.md#principled-implementation Write needs the transform context, the call's callee expression, the configuration, the function declaration and the function expression, and the record carries them in one argument.
+// @evidence contracts/common.md#clear-and-simple-design A flat argument record of 5 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc names each field.
 type FunctionalValidateReturnProgrammer_IProps struct {
-  Context     nativecontext.ITypiaContext
-  Modulo      *shimast.Node
-  Config      FunctionalValidateReturnProgrammer_IConfig
+  // Context borrows the checker, emitter and importer for this transform.
+  Context nativecontext.ITypiaContext
+
+  // Modulo identifies the typia call for helper naming and diagnostics.
+  Modulo *shimast.Node
+
+  // Config selects ordinary validation or rejection of surplus properties.
+  Config FunctionalValidateReturnProgrammer_IConfig
+
+  // Declaration supplies parameter bindings and the checker return signature.
   Declaration *shimast.Node
-  Expression  *shimast.Node
-  Init        *shimast.Node
+
+  // Expression is the original callable, invoked with the wrapper receiver.
+  Expression *shimast.Node
 }
 
+// FunctionalValidateReturnProgrammer_IDecomposeProps is the input of Decompose
+// for the validate return generator: Context (the transform context), Modulo
+// (the call's callee expression), Config (the configuration), Expression (the
+// function expression) and Declaration (the function declaration).
+//
+// @evidence contracts/common.md#principled-implementation Decompose needs the transform context, the call's callee expression, the configuration, the function expression and the function declaration, and the record carries them in one argument.
+// @evidence contracts/common.md#clear-and-simple-design A flat argument record of 5 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc names each field.
 type FunctionalValidateReturnProgrammer_IDecomposeProps struct {
-  Context     nativecontext.ITypiaContext
-  Modulo      *shimast.Node
-  Config      FunctionalValidateReturnProgrammer_IConfig
-  Expression  *shimast.Node
+  // Context borrows the checker, emitter and importer for this transform.
+  Context nativecontext.ITypiaContext
+
+  // Modulo identifies the typia call for helper naming and diagnostics.
+  Modulo *shimast.Node
+
+  // Config selects ordinary validation or rejection of surplus properties.
+  Config FunctionalValidateReturnProgrammer_IConfig
+
+  // Expression is the original callable, invoked with the wrapper receiver.
+  Expression *shimast.Node
+
+  // Declaration supplies parameter bindings and the checker return signature.
   Declaration *shimast.Node
 }
 
+// FunctionalValidateReturnProgrammer_IDecomposeOutput is what the generator
+// returns: Async is whether the wrapped function is asynchronous, Functions is
+// the helper function statements and Statements is the body statements.
+//
+// @evidence contracts/common.md#principled-implementation The generator returns its pieces separately so the caller can place helper functions, statements and values where its own wrapper needs them.
+// @evidence contracts/common.md#clear-and-simple-design A record of 3 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc states each returned part.
 type FunctionalValidateReturnProgrammer_IDecomposeOutput struct {
-  Async      bool
-  Functions  []*shimast.Node
+  // Async requests an async wrapper and awaiting of the original return value.
+  Async bool
+
+  // Functions contains helper declarations placed outside the returned wrapper.
+  Functions []*shimast.Node
+
+  // Statements contains ordered checks and returns inside the wrapper body.
   Statements []*shimast.Node
 }
 

package/native/core/programmers/functional/internal/FunctionalGeneralProgrammer.go

@@ -10,13 +10,33 @@ type functionalGeneralProgrammerNamespace struct{}
 
 var FunctionalGeneralProgrammer = functionalGeneralProgrammerNamespace{}
 
+// FunctionalGeneralProgrammer_IProps is the checker and the function declaration
+// whose return type is wanted.
+//
+// @evidence contracts/common.md#principled-implementation The return type is read from the declaration's signature, so only those two inputs are needed.
+// @evidence contracts/common.md#clear-and-simple-design A two-field record.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc names both fields.
 type FunctionalGeneralProgrammer_IProps struct {
-  Checker     *shimchecker.Checker
+  // Checker resolves the declaration signature within the current program.
+  Checker *shimchecker.Checker
+
+  // Declaration supplies parameter bindings and the checker return signature.
   Declaration *shimast.Node
 }
 
+// FunctionalGeneralProgrammer_IOutput is the return type with a Promise
+// unwrapped and whether it was unwrapped.
+//
+// @evidence contracts/common.md#principled-implementation PromiseTypeFactory resolves the return type against the global Promise contract. The payload and resolution flag let wrappers await that value; syntax alone does not set Async.
+// @evidence contracts/common.md#clear-and-simple-design A two-field record.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc names both fields.
 type FunctionalGeneralProgrammer_IOutput struct {
-  Type  *shimchecker.Type
+  // Type is the checker return type after supported Promise resolution.
+  Type *shimchecker.Type
+
+  // Async means PromiseTypeFactory resolved the global Promise contract.
   Async bool
 }