typia 13.0.0-dev.20260427-2 → 13.0.0-dev.20260430

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

@@ -0,0 +1,168 @@
+package functional
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+	nativeprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers"
+)
+
+type functionalValidateFunctionProgrammerNamespace struct{}
+
+var FunctionalValidateFunctionProgrammer = functionalValidateFunctionProgrammerNamespace{}
+
+type FunctionalValidateFunctionProgrammer_IConfig struct {
+	Equals bool
+}
+
+type FunctionalValidateFunctionProgrammer_IProps struct {
+	Context     nativecontext.ITypiaContext
+	Modulo      *shimast.Node
+	Config      FunctionalValidateFunctionProgrammer_IConfig
+	Declaration *shimast.Node
+	Expression  *shimast.Node
+	Init        *shimast.Node
+}
+
+var functionalValidateProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+
+func (functionalValidateFunctionProgrammerNamespace) Write(props FunctionalValidateFunctionProgrammer_IProps) *shimast.Node {
+	p := FunctionalValidateParametersProgrammer.Decompose(FunctionalValidateParametersProgrammer_IDecomposeProps{
+		Context:     props.Context,
+		Modulo:      props.Modulo,
+		Config:      FunctionalValidateParametersProgrammer_IConfig{Equals: props.Config.Equals},
+		Declaration: props.Declaration,
+	})
+	r := FunctionalValidateReturnProgrammer.Decompose(FunctionalValidateReturnProgrammer_IDecomposeProps{
+		Context:     props.Context,
+		Modulo:      props.Modulo,
+		Config:      FunctionalValidateReturnProgrammer_IConfig{Equals: props.Config.Equals},
+		Expression:  props.Expression,
+		Declaration: props.Declaration,
+	})
+	statements := append([]*shimast.Node{}, p.Functions...)
+	statements = append(statements, r.Functions...)
+	body := append([]*shimast.Node{}, p.Statements...)
+	body = append(body, r.Statements...)
+	statements = append(statements, functionalValidateProgrammer_factory.NewReturnStatement(
+		functionalValidateProgrammer_factory.NewArrowFunction(
+			functionalIsProgrammer_asyncModifiers(r.Async),
+			nil,
+			functionalIsProgrammer_parameters(props.Declaration),
+			FunctionalValidateFunctionProgrammer.GetReturnTypeNode(struct {
+				Context     nativecontext.ITypiaContext
+				Declaration *shimast.Node
+				Async       bool
+			}{
+				Context:     props.Context,
+				Declaration: props.Declaration,
+				Async:       r.Async,
+			}),
+			nil,
+			functionalValidateProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+			functionalValidateProgrammer_factory.NewBlock(functionalValidateProgrammer_factory.NewNodeList(body), true),
+		),
+	))
+	return nativefactories.ExpressionFactory.SelfCall(
+		functionalValidateProgrammer_factory.NewBlock(functionalValidateProgrammer_factory.NewNodeList(statements), true),
+	)
+}
+
+func (functionalValidateFunctionProgrammerNamespace) HookErrors(props struct {
+	Expression *shimast.Node
+	Replacer   *shimast.Node
+}) *shimast.Node {
+	return functionalValidateProgrammer_factory.NewCallExpression(
+		nativefactories.IdentifierFactory.Access(props.Expression, "map"),
+		nil,
+		nil,
+		functionalValidateProgrammer_factory.NewNodeList([]*shimast.Node{
+			functionalValidateProgrammer_factory.NewArrowFunction(
+				nil,
+				nil,
+				functionalValidateProgrammer_factory.NewNodeList([]*shimast.Node{
+					nativefactories.IdentifierFactory.Parameter("error", nil, nil),
+				}),
+				nil,
+				nil,
+				functionalValidateProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+				functionalValidateProgrammer_factory.NewObjectLiteralExpression(functionalValidateProgrammer_factory.NewNodeList([]*shimast.Node{
+					functionalValidateProgrammer_factory.NewSpreadAssignment(functionalValidateProgrammer_factory.NewIdentifier("error")),
+					functionalValidateProgrammer_factory.NewPropertyAssignment(
+						nil,
+						nativefactories.IdentifierFactory.Identifier("path"),
+						nil,
+						nil,
+						functionalValidateProgrammer_factory.NewCallExpression(
+							nativefactories.IdentifierFactory.Access(
+								nativefactories.IdentifierFactory.Access(functionalValidateProgrammer_factory.NewIdentifier("error"), "path"),
+								"replace",
+							),
+							nil,
+							nil,
+							functionalValidateProgrammer_factory.NewNodeList([]*shimast.Node{
+								functionalValidateProgrammer_factory.NewStringLiteral("$input", shimast.TokenFlagsNone),
+								props.Replacer,
+							}),
+							shimast.NodeFlagsNone,
+						),
+					),
+				}), true),
+			),
+		}),
+		shimast.NodeFlagsNone,
+	)
+}
+
+func (functionalValidateFunctionProgrammerNamespace) GetReturnTypeNode(props struct {
+	Context     nativecontext.ITypiaContext
+	Declaration *shimast.Node
+	Async       bool
+}) *shimast.Node {
+	if props.Declaration == nil || props.Declaration.FunctionLikeData() == nil {
+		return nil
+	}
+	typ := props.Declaration.FunctionLikeData().Type
+	if typ == nil {
+		return nil
+	}
+	if props.Async {
+		var inner *shimast.Node
+		if typ.Kind == shimast.KindTypeReference {
+			ref := typ.AsTypeReferenceNode()
+			if ref.TypeArguments != nil && len(ref.TypeArguments.Nodes) != 0 {
+				inner = ref.TypeArguments.Nodes[0]
+			}
+		}
+		if inner == nil {
+			return nil
+		}
+		return functionalValidateProgrammer_factory.NewTypeReferenceNode(
+			functionalValidateProgrammer_factory.NewIdentifier("Promise"),
+			functionalValidateProgrammer_factory.NewNodeList([]*shimast.Node{
+				functionalValidateProgrammer_import_type(props.Context, nativeprogrammers.ImportProgrammer_TypeProps{
+					File:      "typia",
+					Name:      "IValidation",
+					Arguments: []*shimast.TypeNode{inner},
+				}),
+			}),
+		)
+	}
+	return functionalValidateProgrammer_import_type(props.Context, nativeprogrammers.ImportProgrammer_TypeProps{
+		File:      "typia",
+		Name:      "IValidation",
+		Arguments: []*shimast.TypeNode{typ},
+	})
+}
+
+func functionalValidateProgrammer_import_type(context nativecontext.ITypiaContext, props nativeprogrammers.ImportProgrammer_TypeProps) *shimast.Node {
+	if importer, ok := context.Importer.(interface {
+		Type(nativeprogrammers.ImportProgrammer_TypeProps) *shimast.Node
+	}); ok {
+		return importer.Type(props)
+	}
+	if str, ok := props.Name.(string); ok {
+		return functionalValidateProgrammer_factory.NewTypeReferenceNode(functionalValidateProgrammer_factory.NewIdentifier(str), functionalValidateProgrammer_factory.NewNodeList(props.Arguments))
+	}
+	return props.Name.(*shimast.Node)
+}

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

@@ -0,0 +1,248 @@
+package functional
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+	nativeprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers"
+	functionalinternal "github.com/samchon/typia/packages/typia/native/core/programmers/functional/internal"
+)
+
+type functionalValidateParametersProgrammerNamespace struct{}
+
+var FunctionalValidateParametersProgrammer = functionalValidateParametersProgrammerNamespace{}
+
+type FunctionalValidateParametersProgrammer_IConfig struct {
+	Equals bool
+}
+
+type FunctionalValidateParametersProgrammer_IProps struct {
+	Context     nativecontext.ITypiaContext
+	Modulo      *shimast.Node
+	Config      FunctionalValidateParametersProgrammer_IConfig
+	Declaration *shimast.Node
+	Expression  *shimast.Node
+	Init        *shimast.Node
+}
+
+type FunctionalValidateParametersProgrammer_IDecomposeProps struct {
+	Context     nativecontext.ITypiaContext
+	Modulo      *shimast.Node
+	Config      FunctionalValidateParametersProgrammer_IConfig
+	Declaration *shimast.Node
+}
+
+type FunctionalValidateParametersProgrammer_IDecomposeOutput struct {
+	Functions  []*shimast.Node
+	Statements []*shimast.Node
+}
+
+func (functionalValidateParametersProgrammerNamespace) Write(props FunctionalValidateParametersProgrammer_IProps) *shimast.Node {
+	output := functionalinternal.FunctionalGeneralProgrammer.GetReturnType(functionalinternal.FunctionalGeneralProgrammer_IProps{
+		Checker:     props.Context.Checker,
+		Declaration: props.Declaration,
+	})
+	result := FunctionalValidateParametersProgrammer.Decompose(FunctionalValidateParametersProgrammer_IDecomposeProps{
+		Context:     props.Context,
+		Modulo:      props.Modulo,
+		Config:      props.Config,
+		Declaration: props.Declaration,
+	})
+	caller := functionalValidateProgrammer_factory.NewCallExpression(
+		props.Expression,
+		nil,
+		nil,
+		functionalValidateProgrammer_factory.NewNodeList(functionalIsProgrammer_parameterIdentifiers(props.Declaration)),
+		shimast.NodeFlagsNone,
+	)
+	data := caller
+	if output.Async {
+		data = functionalValidateProgrammer_factory.NewAwaitExpression(caller)
+	}
+	statements := append([]*shimast.Node{}, result.Functions...)
+	body := append([]*shimast.Node{}, result.Statements...)
+	body = append(body, functionalValidateProgrammer_factory.NewReturnStatement(functionalValidateProgrammer_factory.NewObjectLiteralExpression(functionalValidateProgrammer_factory.NewNodeList([]*shimast.Node{
+		functionalValidateProgrammer_factory.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("success"), nil, nil, functionalValidateProgrammer_factory.NewKeywordExpression(shimast.KindTrueKeyword)),
+		functionalValidateProgrammer_factory.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("data"), nil, nil, data),
+		functionalValidateProgrammer_factory.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("errors"), nil, nil, functionalValidateProgrammer_factory.NewArrayLiteralExpression(functionalValidateProgrammer_factory.NewNodeList(nil), false)),
+	}), true)))
+	statements = append(statements, functionalValidateProgrammer_factory.NewReturnStatement(
+		functionalValidateProgrammer_factory.NewArrowFunction(
+			functionalIsProgrammer_asyncModifiers(output.Async),
+			nil,
+			functionalIsProgrammer_parameters(props.Declaration),
+			FunctionalValidateFunctionProgrammer.GetReturnTypeNode(struct {
+				Context     nativecontext.ITypiaContext
+				Declaration *shimast.Node
+				Async       bool
+			}{
+				Context:     props.Context,
+				Declaration: props.Declaration,
+				Async:       output.Async,
+			}),
+			nil,
+			functionalValidateProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+			functionalValidateProgrammer_factory.NewBlock(functionalValidateProgrammer_factory.NewNodeList(body), true),
+		),
+	))
+	return nativefactories.ExpressionFactory.SelfCall(
+		functionalValidateProgrammer_factory.NewBlock(functionalValidateProgrammer_factory.NewNodeList(statements), true),
+	)
+}
+
+func (functionalValidateParametersProgrammerNamespace) Decompose(props FunctionalValidateParametersProgrammer_IDecomposeProps) FunctionalValidateParametersProgrammer_IDecomposeOutput {
+	parameters := functionalIsProgrammer_parameterNodes(props.Declaration)
+	resultName := functionalIsProgrammer_escapeDuplicate(functionalIsProgrammer_parameterNames(props.Declaration), "paramErrorResults")
+	functions := make([]*shimast.Node, 0, len(parameters))
+	results := make([]*shimast.Node, 0, len(parameters))
+	for i, p := range parameters {
+		functions = append(functions, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+			Name: "__validate_param_" + functionalIsProgrammer_itoa(i),
+			Value: nativeprogrammers.ValidateProgrammer.Write(nativeprogrammers.ValidateProgrammer_IProps{
+				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")),
+				),
+			}),
+		}))
+		results = append(results, functionalValidateProgrammer_factory.NewAsExpression(
+			functionalValidateProgrammer_factory.NewCallExpression(
+				functionalValidateProgrammer_factory.NewIdentifier("__validate_param_"+functionalIsProgrammer_itoa(i)),
+				nil,
+				nil,
+				functionalValidateProgrammer_factory.NewNodeList([]*shimast.Node{
+					functionalValidateProgrammer_factory.NewIdentifier(functionalIsProgrammer_parameterName(p)),
+				}),
+				shimast.NodeFlagsNone,
+			),
+			functionalValidateProgrammer_import_type(props.Context, nativeprogrammers.ImportProgrammer_TypeProps{
+				File: "typia",
+				Name: "IValidation.IFailure",
+			}),
+		))
+	}
+	validationResultArray := functionalValidateProgrammer_factory.NewArrayLiteralExpression(functionalValidateProgrammer_factory.NewNodeList(results), true)
+	errorMatrix := functionalValidateProgrammer_factory.NewCallExpression(
+		nativefactories.IdentifierFactory.Access(validationResultArray, "map"),
+		nil,
+		nil,
+		functionalValidateProgrammer_factory.NewNodeList([]*shimast.Node{
+			functionalValidateProgrammer_factory.NewArrowFunction(
+				nil,
+				nil,
+				functionalValidateProgrammer_factory.NewNodeList([]*shimast.Node{
+					nativefactories.IdentifierFactory.Parameter("r", nil, nil),
+					nativefactories.IdentifierFactory.Parameter("i", nil, nil),
+				}),
+				nil,
+				nil,
+				functionalValidateProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+				functionalValidateProgrammer_factory.NewConditionalExpression(
+					functionalValidateProgrammer_factory.NewBinaryExpression(
+						nil,
+						functionalValidateProgrammer_factory.NewKeywordExpression(shimast.KindTrueKeyword),
+						nil,
+						functionalValidateProgrammer_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
+						nativefactories.IdentifierFactory.Access(functionalValidateProgrammer_factory.NewIdentifier("r"), "success"),
+					),
+					nil,
+					functionalValidateProgrammer_factory.NewIdentifier("r"),
+					nil,
+					functionalValidateProgrammer_factory.NewObjectLiteralExpression(functionalValidateProgrammer_factory.NewNodeList([]*shimast.Node{
+						functionalValidateProgrammer_factory.NewSpreadAssignment(functionalValidateProgrammer_factory.NewIdentifier("r")),
+						functionalValidateProgrammer_factory.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("errors"), nil, nil, FunctionalValidateFunctionProgrammer.HookErrors(struct {
+							Expression *shimast.Node
+							Replacer   *shimast.Node
+						}{
+							Expression: nativefactories.IdentifierFactory.Access(functionalValidateProgrammer_factory.NewIdentifier("r"), "errors"),
+							Replacer: functionalValidateProgrammer_factory.NewTemplateExpression(
+								functionalValidateProgrammer_factory.NewTemplateHead("$input.parameters[", "$input.parameters[", shimast.TokenFlagsNone),
+								functionalValidateProgrammer_factory.NewNodeList([]*shimast.Node{
+									functionalValidateProgrammer_factory.NewTemplateSpan(
+										functionalValidateProgrammer_factory.NewIdentifier("i"),
+										functionalValidateProgrammer_factory.NewTemplateTail("]", "]", shimast.TokenFlagsNone),
+									),
+								}),
+							),
+						})),
+					}), true),
+				),
+			),
+		}),
+		shimast.NodeFlagsNone,
+	)
+	failures := functionalValidateProgrammer_factory.NewCallExpression(
+		nativefactories.IdentifierFactory.Access(errorMatrix, "filter"),
+		nil,
+		nil,
+		functionalValidateProgrammer_factory.NewNodeList([]*shimast.Node{
+			functionalValidateProgrammer_factory.NewArrowFunction(
+				nil,
+				nil,
+				functionalValidateProgrammer_factory.NewNodeList([]*shimast.Node{
+					nativefactories.IdentifierFactory.Parameter("r", nil, nil),
+				}),
+				nil,
+				nil,
+				functionalValidateProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+				functionalValidateProgrammer_factory.NewBinaryExpression(
+					nil,
+					functionalValidateProgrammer_factory.NewKeywordExpression(shimast.KindFalseKeyword),
+					nil,
+					functionalValidateProgrammer_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
+					nativefactories.IdentifierFactory.Access(functionalValidateProgrammer_factory.NewIdentifier("r"), "success"),
+				),
+			),
+		}),
+		shimast.NodeFlagsNone,
+	)
+	return FunctionalValidateParametersProgrammer_IDecomposeOutput{
+		Functions: functions,
+		Statements: []*shimast.Node{
+			nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+				Name:  resultName,
+				Value: failures,
+			}),
+			functionalValidateProgrammer_factory.NewIfStatement(
+				functionalValidateProgrammer_factory.NewBinaryExpression(
+					nil,
+					nativefactories.ExpressionFactory.Number(0),
+					nil,
+					functionalValidateProgrammer_factory.NewToken(shimast.KindExclamationEqualsEqualsToken),
+					nativefactories.IdentifierFactory.Access(functionalValidateProgrammer_factory.NewIdentifier(resultName), "length"),
+				),
+				functionalValidateProgrammer_factory.NewReturnStatement(functionalValidateProgrammer_factory.NewObjectLiteralExpression(functionalValidateProgrammer_factory.NewNodeList([]*shimast.Node{
+					functionalValidateProgrammer_factory.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("success"), nil, nil, functionalValidateProgrammer_factory.NewKeywordExpression(shimast.KindFalseKeyword)),
+					functionalValidateProgrammer_factory.NewPropertyAssignment(nil, nativefactories.IdentifierFactory.Identifier("errors"), nil, nil, functionalValidateProgrammer_factory.NewCallExpression(
+						nativefactories.IdentifierFactory.Access(functionalValidateProgrammer_factory.NewCallExpression(
+							nativefactories.IdentifierFactory.Access(functionalValidateProgrammer_factory.NewIdentifier(resultName), "map"),
+							nil,
+							nil,
+							functionalValidateProgrammer_factory.NewNodeList([]*shimast.Node{
+								functionalValidateProgrammer_factory.NewArrowFunction(
+									nil,
+									nil,
+									functionalValidateProgrammer_factory.NewNodeList([]*shimast.Node{
+										nativefactories.IdentifierFactory.Parameter("r", nativefactories.TypeFactory.Keyword("any"), nil),
+									}),
+									nil,
+									nil,
+									functionalValidateProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+									nativefactories.IdentifierFactory.Access(functionalValidateProgrammer_factory.NewIdentifier("r"), "errors"),
+								),
+							}),
+							shimast.NodeFlagsNone,
+						), "flat"),
+						nil,
+						nil,
+						nil,
+						shimast.NodeFlagsNone,
+					)),
+				}), true)),
+				nil,
+			),
+		},
+	}
+}

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

@@ -0,0 +1,142 @@
+package functional
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
+	nativeprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers"
+	functionalinternal "github.com/samchon/typia/packages/typia/native/core/programmers/functional/internal"
+)
+
+type functionalValidateReturnProgrammerNamespace struct{}
+
+var FunctionalValidateReturnProgrammer = functionalValidateReturnProgrammerNamespace{}
+
+type FunctionalValidateReturnProgrammer_IConfig struct {
+	Equals bool
+}
+
+type FunctionalValidateReturnProgrammer_IProps struct {
+	Context     nativecontext.ITypiaContext
+	Modulo      *shimast.Node
+	Config      FunctionalValidateReturnProgrammer_IConfig
+	Declaration *shimast.Node
+	Expression  *shimast.Node
+	Init        *shimast.Node
+}
+
+type FunctionalValidateReturnProgrammer_IDecomposeProps struct {
+	Context     nativecontext.ITypiaContext
+	Modulo      *shimast.Node
+	Config      FunctionalValidateReturnProgrammer_IConfig
+	Expression  *shimast.Node
+	Declaration *shimast.Node
+}
+
+type FunctionalValidateReturnProgrammer_IDecomposeOutput struct {
+	Async      bool
+	Functions  []*shimast.Node
+	Statements []*shimast.Node
+}
+
+func (functionalValidateReturnProgrammerNamespace) Write(props FunctionalValidateReturnProgrammer_IProps) *shimast.Node {
+	result := FunctionalValidateReturnProgrammer.Decompose(FunctionalValidateReturnProgrammer_IDecomposeProps{
+		Context:     props.Context,
+		Modulo:      props.Modulo,
+		Config:      props.Config,
+		Expression:  props.Expression,
+		Declaration: props.Declaration,
+	})
+	statements := append([]*shimast.Node{}, result.Functions...)
+	statements = append(statements, functionalValidateProgrammer_factory.NewReturnStatement(
+		functionalValidateProgrammer_factory.NewArrowFunction(
+			functionalIsProgrammer_asyncModifiers(result.Async),
+			nil,
+			functionalIsProgrammer_parameters(props.Declaration),
+			FunctionalValidateFunctionProgrammer.GetReturnTypeNode(struct {
+				Context     nativecontext.ITypiaContext
+				Declaration *shimast.Node
+				Async       bool
+			}{
+				Context:     props.Context,
+				Declaration: props.Declaration,
+				Async:       result.Async,
+			}),
+			nil,
+			functionalValidateProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+			functionalValidateProgrammer_factory.NewBlock(functionalValidateProgrammer_factory.NewNodeList(result.Statements), true),
+		),
+	))
+	return nativefactories.ExpressionFactory.SelfCall(
+		functionalValidateProgrammer_factory.NewBlock(functionalValidateProgrammer_factory.NewNodeList(statements), true),
+	)
+}
+
+func (functionalValidateReturnProgrammerNamespace) Decompose(props FunctionalValidateReturnProgrammer_IDecomposeProps) FunctionalValidateReturnProgrammer_IDecomposeOutput {
+	output := functionalinternal.FunctionalGeneralProgrammer.GetReturnType(functionalinternal.FunctionalGeneralProgrammer_IProps{
+		Checker:     props.Context.Checker,
+		Declaration: props.Declaration,
+	})
+	caller := functionalValidateProgrammer_factory.NewCallExpression(
+		props.Expression,
+		nil,
+		nil,
+		functionalValidateProgrammer_factory.NewNodeList(functionalIsProgrammer_parameterIdentifiers(props.Declaration)),
+		shimast.NodeFlagsNone,
+	)
+	value := caller
+	if output.Async {
+		value = functionalValidateProgrammer_factory.NewAwaitExpression(caller)
+	}
+	name := functionalIsProgrammer_escapeDuplicate(functionalIsProgrammer_parameterNames(props.Declaration), "result")
+	return FunctionalValidateReturnProgrammer_IDecomposeOutput{
+		Async: output.Async,
+		Functions: []*shimast.Node{
+			nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+				Name: "__validate_return",
+				Value: nativeprogrammers.ValidateProgrammer.Write(nativeprogrammers.ValidateProgrammer_IProps{
+					Context: props.Context,
+					Modulo:  props.Modulo,
+					Config:  nativeprogrammers.ValidateProgrammer_IConfig{Equals: props.Config.Equals},
+					Type:    output.Type,
+				}),
+			}),
+		},
+		Statements: []*shimast.Node{
+			nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+				Name: name,
+				Value: functionalValidateProgrammer_factory.NewCallExpression(
+					functionalValidateProgrammer_factory.NewIdentifier("__validate_return"),
+					nil,
+					nil,
+					functionalValidateProgrammer_factory.NewNodeList([]*shimast.Node{value}),
+					shimast.NodeFlagsNone,
+				),
+			}),
+			functionalValidateProgrammer_factory.NewIfStatement(
+				functionalValidateProgrammer_factory.NewBinaryExpression(
+					nil,
+					functionalValidateProgrammer_factory.NewKeywordExpression(shimast.KindFalseKeyword),
+					nil,
+					functionalValidateProgrammer_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
+					nativefactories.IdentifierFactory.Access(functionalValidateProgrammer_factory.NewIdentifier(name), "success"),
+				),
+				functionalValidateProgrammer_factory.NewExpressionStatement(functionalValidateProgrammer_factory.NewBinaryExpression(
+					nil,
+					nativefactories.IdentifierFactory.Access(functionalValidateProgrammer_factory.NewIdentifier(name), "errors"),
+					nil,
+					functionalValidateProgrammer_factory.NewToken(shimast.KindEqualsToken),
+					FunctionalValidateFunctionProgrammer.HookErrors(struct {
+						Expression *shimast.Node
+						Replacer   *shimast.Node
+					}{
+						Expression: nativefactories.IdentifierFactory.Access(functionalValidateProgrammer_factory.NewIdentifier(name), "errors"),
+						Replacer:   functionalValidateProgrammer_factory.NewStringLiteral("$input.return", shimast.TokenFlagsNone),
+					}),
+				)),
+				nil,
+			),
+			functionalValidateProgrammer_factory.NewReturnStatement(functionalValidateProgrammer_factory.NewIdentifier(name)),
+		},
+	}
+}

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

@@ -0,0 +1 @@
+package functional

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

@@ -0,0 +1,53 @@
+package internal
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+type functionalGeneralProgrammerNamespace struct{}
+
+var FunctionalGeneralProgrammer = functionalGeneralProgrammerNamespace{}
+
+type FunctionalGeneralProgrammer_IProps struct {
+	Checker     *shimchecker.Checker
+	Declaration *shimast.Node
+}
+
+type FunctionalGeneralProgrammer_IOutput struct {
+	Type  *shimchecker.Type
+	Async bool
+}
+
+func (functionalGeneralProgrammerNamespace) GetReturnType(props FunctionalGeneralProgrammer_IProps) FunctionalGeneralProgrammer_IOutput {
+	var signature *shimchecker.Signature
+	if props.Checker != nil && props.Declaration != nil {
+		signature = props.Checker.GetSignatureFromDeclaration(props.Declaration)
+	}
+	var t *shimchecker.Type
+	if signature != nil {
+		t = props.Checker.GetReturnTypeOfSignature(signature)
+	}
+	if t == nil && props.Checker != nil {
+		t = props.Checker.GetAnyType()
+	}
+	if t != nil {
+		if symbol := t.Symbol(); symbol != nil && symbol.Name == "Promise" {
+			generic := props.Checker.GetTypeArguments(t)
+			if len(generic) == 1 {
+				return FunctionalGeneralProgrammer_IOutput{
+					Type:  generic[0],
+					Async: true,
+				}
+			}
+			return FunctionalGeneralProgrammer_IOutput{
+				Type:  props.Checker.GetAnyType(),
+				Async: false,
+			}
+		}
+	}
+	return FunctionalGeneralProgrammer_IOutput{
+		Type:  t,
+		Async: false,
+	}
+}

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

@@ -0,0 +1,62 @@
+package helpers
+
+import nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+
+type atomicPredicatorNamespace struct{}
+
+var AtomicPredicator = atomicPredicatorNamespace{}
+
+func (atomicPredicatorNamespace) Constant(props struct {
+	Metadata *nativemetadata.MetadataSchema
+	Name     string
+}) bool {
+	for _, native := range props.Metadata.Natives {
+		if lower(native.Name) == props.Name {
+			return false
+		}
+	}
+	return true
+}
+
+func (atomicPredicatorNamespace) Atomic(props struct {
+	Metadata *nativemetadata.MetadataSchema
+	Name     string
+}) bool {
+	for _, native := range props.Metadata.Natives {
+		if lower(native.Name) == props.Name {
+			return false
+		}
+	}
+	return true
+}
+
+func (atomicPredicatorNamespace) Native(name string) bool {
+	_, ok := atomicPredicator_like[lower(name)]
+	return ok
+}
+
+func (atomicPredicatorNamespace) Template(metadata *nativemetadata.MetadataSchema) bool {
+	for _, native := range metadata.Natives {
+		if lower(native.Name) == "string" {
+			return false
+		}
+	}
+	return true
+}
+
+var atomicPredicator_like = map[string]struct{}{
+	"boolean": {},
+	"bigint":  {},
+	"number":  {},
+	"string":  {},
+}
+
+func lower(str string) string {
+	output := []byte(str)
+	for i, ch := range output {
+		if 'A' <= ch && ch <= 'Z' {
+			output[i] = ch + ('a' - 'A')
+		}
+	}
+	return string(output)
+}