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

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

@@ -0,0 +1,130 @@
+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 functionalAssertParametersProgrammerNamespace struct{}
+
+var FunctionalAssertParametersProgrammer = functionalAssertParametersProgrammerNamespace{}
+
+type FunctionalAssertParametersProgrammer_IConfig struct {
+	Equals bool
+}
+
+type FunctionalAssertParametersProgrammer_IProps struct {
+	Context     nativecontext.ITypiaContext
+	Modulo      *shimast.Node
+	Config      FunctionalAssertParametersProgrammer_IConfig
+	Declaration *shimast.Node
+	Expression  *shimast.Node
+	Init        *shimast.Node
+}
+
+type FunctionalAssertParametersProgrammer_IDecomposeProps struct {
+	Context    nativecontext.ITypiaContext
+	Config     FunctionalAssertParametersProgrammer_IConfig
+	Modulo     *shimast.Node
+	Parameters []*shimast.Node
+	Wrapper    string
+}
+
+type FunctionalAssertParametersProgrammer_IDecomposeOutput struct {
+	Functions   []*shimast.Node
+	Expressions []*shimast.Node
+}
+
+func (functionalAssertParametersProgrammerNamespace) Write(props FunctionalAssertParametersProgrammer_IProps) *shimast.Node {
+	wrapper := FunctionalAssertFunctionProgrammer.ErrorFactoryWrapper(struct {
+		Context    nativecontext.ITypiaContext
+		Parameters []*shimast.Node
+		Init       *shimast.Node
+	}{
+		Context:    props.Context,
+		Parameters: functionalIsProgrammer_parameterNodes(props.Declaration),
+		Init:       props.Init,
+	})
+	output := functionalinternal.FunctionalGeneralProgrammer.GetReturnType(functionalinternal.FunctionalGeneralProgrammer_IProps{
+		Checker:     props.Context.Checker,
+		Declaration: props.Declaration,
+	})
+	result := FunctionalAssertParametersProgrammer.Decompose(FunctionalAssertParametersProgrammer_IDecomposeProps{
+		Context:    props.Context,
+		Modulo:     props.Modulo,
+		Config:     props.Config,
+		Parameters: functionalIsProgrammer_parameterNodes(props.Declaration),
+		Wrapper:    wrapper.Name,
+	})
+	statements := []*shimast.Node{wrapper.Variable}
+	statements = append(statements, result.Functions...)
+	body := []*shimast.Node{}
+	for _, exp := range result.Expressions {
+		body = append(body, functionalAssertProgrammer_factory.NewExpressionStatement(exp))
+	}
+	body = append(body, functionalAssertProgrammer_factory.NewReturnStatement(functionalAssertProgrammer_factory.NewCallExpression(
+		props.Expression,
+		nil,
+		nil,
+		functionalAssertProgrammer_factory.NewNodeList(functionalIsProgrammer_parameterIdentifiers(props.Declaration)),
+		shimast.NodeFlagsNone,
+	)))
+	statements = append(statements, functionalAssertProgrammer_factory.NewReturnStatement(
+		functionalAssertProgrammer_factory.NewArrowFunction(
+			functionalIsProgrammer_asyncModifiers(output.Async),
+			nil,
+			functionalIsProgrammer_parameters(props.Declaration),
+			functionalAssertProgrammer_returnType(props.Declaration),
+			nil,
+			functionalAssertProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+			functionalAssertProgrammer_factory.NewBlock(functionalAssertProgrammer_factory.NewNodeList(body), true),
+		),
+	))
+	return nativefactories.ExpressionFactory.SelfCall(
+		functionalAssertProgrammer_factory.NewBlock(functionalAssertProgrammer_factory.NewNodeList(statements), true),
+	)
+}
+
+func (functionalAssertParametersProgrammerNamespace) Decompose(props FunctionalAssertParametersProgrammer_IDecomposeProps) FunctionalAssertParametersProgrammer_IDecomposeOutput {
+	functions := make([]*shimast.Node, 0, len(props.Parameters))
+	expressions := make([]*shimast.Node, 0, len(props.Parameters))
+	for i, p := range props.Parameters {
+		functions = append(functions, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+			Name: "__assert_param_" + functionalIsProgrammer_itoa(i),
+			Value: nativeprogrammers.AssertProgrammer.Write(nativeprogrammers.AssertProgrammer_IProps{
+				Context: props.Context,
+				Modulo:  props.Modulo,
+				Config: nativeprogrammers.AssertProgrammer_IConfig{
+					Equals: props.Config.Equals,
+					Guard:  false,
+				},
+				Type: props.Context.Checker.GetTypeFromTypeNode(
+					functionalIsProgrammer_parameterType(p, nativefactories.TypeFactory.Keyword("any")),
+				),
+				Init: FunctionalAssertFunctionProgrammer.HookPath(struct {
+					Wrapper  string
+					Replacer string
+				}{
+					Wrapper:  props.Wrapper,
+					Replacer: "$input.parameters[" + functionalIsProgrammer_itoa(i) + "]",
+				}),
+			}),
+		}))
+		expressions = append(expressions, functionalAssertProgrammer_factory.NewCallExpression(
+			functionalAssertProgrammer_factory.NewIdentifier("__assert_param_"+functionalIsProgrammer_itoa(i)),
+			nil,
+			nil,
+			functionalAssertProgrammer_factory.NewNodeList([]*shimast.Node{
+				functionalAssertProgrammer_factory.NewIdentifier(functionalIsProgrammer_parameterName(p)),
+			}),
+			shimast.NodeFlagsNone,
+		))
+	}
+	return FunctionalAssertParametersProgrammer_IDecomposeOutput{
+		Functions:   functions,
+		Expressions: expressions,
+	}
+}

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

@@ -0,0 +1,126 @@
+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 functionAssertReturnProgrammerNamespace struct{}
+
+var FunctionAssertReturnProgrammer = functionAssertReturnProgrammerNamespace{}
+
+type FunctionAssertReturnProgrammer_IConfig struct {
+	Equals bool
+}
+
+type FunctionAssertReturnProgrammer_IProps struct {
+	Context     nativecontext.ITypiaContext
+	Modulo      *shimast.Node
+	Config      FunctionAssertReturnProgrammer_IConfig
+	Expression  *shimast.Node
+	Declaration *shimast.Node
+	Init        *shimast.Node
+}
+
+type FunctionAssertReturnProgrammer_IDecomposeProps struct {
+	Context     nativecontext.ITypiaContext
+	Modulo      *shimast.Node
+	Config      FunctionAssertReturnProgrammer_IConfig
+	Expression  *shimast.Node
+	Declaration *shimast.Node
+	Wrapper     string
+}
+
+type FunctionAssertReturnProgrammer_IDecomposeOutput struct {
+	Async     bool
+	Functions []*shimast.Node
+	Value     *shimast.Node
+}
+
+func (functionAssertReturnProgrammerNamespace) Write(props FunctionAssertReturnProgrammer_IProps) *shimast.Node {
+	wrapper := FunctionalAssertFunctionProgrammer.ErrorFactoryWrapper(struct {
+		Context    nativecontext.ITypiaContext
+		Parameters []*shimast.Node
+		Init       *shimast.Node
+	}{
+		Context:    props.Context,
+		Parameters: functionalIsProgrammer_parameterNodes(props.Declaration),
+		Init:       props.Init,
+	})
+	result := FunctionAssertReturnProgrammer.Decompose(FunctionAssertReturnProgrammer_IDecomposeProps{
+		Context:     props.Context,
+		Modulo:      props.Modulo,
+		Config:      props.Config,
+		Expression:  props.Expression,
+		Declaration: props.Declaration,
+		Wrapper:     wrapper.Name,
+	})
+	statements := []*shimast.Node{wrapper.Variable}
+	statements = append(statements, result.Functions...)
+	statements = append(statements, functionalAssertProgrammer_factory.NewReturnStatement(
+		functionalAssertProgrammer_factory.NewArrowFunction(
+			functionalIsProgrammer_asyncModifiers(result.Async),
+			nil,
+			functionalIsProgrammer_parameters(props.Declaration),
+			functionalAssertProgrammer_returnType(props.Declaration),
+			nil,
+			functionalAssertProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+			result.Value,
+		),
+	))
+	return nativefactories.ExpressionFactory.SelfCall(
+		functionalAssertProgrammer_factory.NewBlock(functionalAssertProgrammer_factory.NewNodeList(statements), true),
+	)
+}
+
+func (functionAssertReturnProgrammerNamespace) Decompose(props FunctionAssertReturnProgrammer_IDecomposeProps) FunctionAssertReturnProgrammer_IDecomposeOutput {
+	output := functionalinternal.FunctionalGeneralProgrammer.GetReturnType(functionalinternal.FunctionalGeneralProgrammer_IProps{
+		Checker:     props.Context.Checker,
+		Declaration: props.Declaration,
+	})
+	caller := functionalAssertProgrammer_factory.NewCallExpression(
+		props.Expression,
+		nil,
+		nil,
+		functionalAssertProgrammer_factory.NewNodeList(functionalIsProgrammer_parameterIdentifiers(props.Declaration)),
+		shimast.NodeFlagsNone,
+	)
+	value := caller
+	if output.Async {
+		value = functionalAssertProgrammer_factory.NewAwaitExpression(caller)
+	}
+	return FunctionAssertReturnProgrammer_IDecomposeOutput{
+		Async: output.Async,
+		Functions: []*shimast.Node{
+			nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+				Name: "__assert_return",
+				Value: nativeprogrammers.AssertProgrammer.Write(nativeprogrammers.AssertProgrammer_IProps{
+					Context: props.Context,
+					Modulo:  props.Modulo,
+					Config: nativeprogrammers.AssertProgrammer_IConfig{
+						Equals: props.Config.Equals,
+						Guard:  false,
+					},
+					Type: output.Type,
+					Init: FunctionalAssertFunctionProgrammer.HookPath(struct {
+						Wrapper  string
+						Replacer string
+					}{
+						Wrapper:  props.Wrapper,
+						Replacer: "$input.return",
+					}),
+				}),
+			}),
+		},
+		Value: functionalAssertProgrammer_factory.NewCallExpression(
+			functionalAssertProgrammer_factory.NewIdentifier("__assert_return"),
+			nil,
+			nil,
+			functionalAssertProgrammer_factory.NewNodeList([]*shimast.Node{value}),
+			shimast.NodeFlagsNone,
+		),
+	}
+}

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

@@ -0,0 +1,100 @@
+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"
+)
+
+type functionalIsFunctionProgrammerNamespace struct{}
+
+var FunctionalIsFunctionProgrammer = functionalIsFunctionProgrammerNamespace{}
+
+type FunctionalIsFunctionProgrammer_IConfig struct {
+	Equals bool
+}
+
+type FunctionalIsFunctionProgrammer_IProps struct {
+	Context     nativecontext.ITypiaContext
+	Modulo      *shimast.Node
+	Config      FunctionalIsFunctionProgrammer_IConfig
+	Declaration *shimast.Node
+	Expression  *shimast.Node
+	Init        *shimast.Node
+}
+
+func (functionalIsFunctionProgrammerNamespace) Write(props FunctionalIsFunctionProgrammer_IProps) *shimast.Node {
+	p := FunctionalIsParametersProgrammer.Decompose(FunctionalIsParametersProgrammer_IDecomposeProps{
+		Context:     props.Context,
+		Config:      FunctionalIsParametersProgrammer_IConfig{Equals: props.Config.Equals},
+		Modulo:      props.Modulo,
+		Declaration: props.Declaration,
+	})
+	r := FunctionalIsReturnProgrammer.Decompose(FunctionalIsReturnProgrammer_IDecomposeProps{
+		Context:     props.Context,
+		Modulo:      props.Modulo,
+		Config:      FunctionalIsReturnProgrammer_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, functionalIsProgrammer_factory.NewReturnStatement(
+		functionalIsProgrammer_factory.NewArrowFunction(
+			functionalIsProgrammer_asyncModifiers(r.Async),
+			nil,
+			functionalIsProgrammer_parameters(props.Declaration),
+			FunctionalIsFunctionProgrammer.GetReturnTypeNode(struct {
+				Declaration *shimast.Node
+				Async       bool
+			}{
+				Declaration: props.Declaration,
+				Async:       r.Async,
+			}),
+			nil,
+			functionalIsProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+			functionalIsProgrammer_factory.NewBlock(functionalIsProgrammer_factory.NewNodeList(body), true),
+		),
+	))
+	return nativefactories.ExpressionFactory.SelfCall(
+		functionalIsProgrammer_factory.NewBlock(functionalIsProgrammer_factory.NewNodeList(statements), true),
+	)
+}
+
+func (functionalIsFunctionProgrammerNamespace) GetReturnTypeNode(props struct {
+	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
+	}
+	nullType := functionalIsProgrammer_factory.NewTypeReferenceNode(functionalIsProgrammer_factory.NewIdentifier("null"), 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 functionalIsProgrammer_factory.NewTypeReferenceNode(
+			functionalIsProgrammer_factory.NewIdentifier("Promise"),
+			functionalIsProgrammer_factory.NewNodeList([]*shimast.Node{
+				functionalIsProgrammer_factory.NewUnionTypeNode(functionalIsProgrammer_factory.NewNodeList([]*shimast.Node{inner, nullType})),
+			}),
+		)
+	}
+	return functionalIsProgrammer_factory.NewUnionTypeNode(functionalIsProgrammer_factory.NewNodeList([]*shimast.Node{
+		typ,
+		nullType,
+	}))
+}

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

@@ -0,0 +1,214 @@
+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 functionalIsParametersProgrammerNamespace struct{}
+
+var FunctionalIsParametersProgrammer = functionalIsParametersProgrammerNamespace{}
+
+type FunctionalIsParametersProgrammer_IConfig struct {
+	Equals bool
+}
+
+type FunctionalIsParametersProgrammer_IProps struct {
+	Context     nativecontext.ITypiaContext
+	Modulo      *shimast.Node
+	Config      FunctionalIsParametersProgrammer_IConfig
+	Declaration *shimast.Node
+	Expression  *shimast.Node
+	Init        *shimast.Node
+}
+
+type FunctionalIsParametersProgrammer_IDecomposeProps struct {
+	Context     nativecontext.ITypiaContext
+	Config      FunctionalIsParametersProgrammer_IConfig
+	Modulo      *shimast.Node
+	Declaration *shimast.Node
+}
+
+type FunctionalIsParametersProgrammer_IDecomposeOutput struct {
+	Functions  []*shimast.Node
+	Statements []*shimast.Node
+}
+
+var functionalIsProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+
+func (functionalIsParametersProgrammerNamespace) Write(props FunctionalIsParametersProgrammer_IProps) *shimast.Node {
+	output := functionalinternal.FunctionalGeneralProgrammer.GetReturnType(functionalinternal.FunctionalGeneralProgrammer_IProps{
+		Checker:     props.Context.Checker,
+		Declaration: props.Declaration,
+	})
+	result := FunctionalIsParametersProgrammer.Decompose(FunctionalIsParametersProgrammer_IDecomposeProps{
+		Context:     props.Context,
+		Config:      props.Config,
+		Modulo:      props.Modulo,
+		Declaration: props.Declaration,
+	})
+	statements := append([]*shimast.Node{}, result.Functions...)
+	statements = append(statements, functionalIsProgrammer_factory.NewReturnStatement(
+		functionalIsProgrammer_factory.NewArrowFunction(
+			functionalIsProgrammer_asyncModifiers(output.Async),
+			nil,
+			functionalIsProgrammer_parameters(props.Declaration),
+			FunctionalIsFunctionProgrammer.GetReturnTypeNode(struct {
+				Declaration *shimast.Node
+				Async       bool
+			}{
+				Declaration: props.Declaration,
+				Async:       output.Async,
+			}),
+			nil,
+			functionalIsProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+			functionalIsProgrammer_factory.NewBlock(functionalIsProgrammer_factory.NewNodeList(append(
+				append([]*shimast.Node{}, result.Statements...),
+				functionalIsProgrammer_factory.NewReturnStatement(functionalIsProgrammer_factory.NewCallExpression(
+					props.Expression,
+					nil,
+					nil,
+					functionalIsProgrammer_factory.NewNodeList(functionalIsProgrammer_parameterIdentifiers(props.Declaration)),
+					shimast.NodeFlagsNone,
+				)),
+			)), true),
+		),
+	))
+	return nativefactories.ExpressionFactory.SelfCall(
+		functionalIsProgrammer_factory.NewBlock(functionalIsProgrammer_factory.NewNodeList(statements), true),
+	)
+}
+
+func (functionalIsParametersProgrammerNamespace) Decompose(props FunctionalIsParametersProgrammer_IDecomposeProps) FunctionalIsParametersProgrammer_IDecomposeOutput {
+	parameters := functionalIsProgrammer_parameterNodes(props.Declaration)
+	functions := make([]*shimast.Node, 0, len(parameters))
+	statements := []*shimast.Node{}
+	for i, p := range parameters {
+		functions = append(functions, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+			Name: "__is_param_" + functionalIsProgrammer_itoa(i),
+			Value: nativeprogrammers.IsProgrammer.Write(nativeprogrammers.IsProgrammer_IProps{
+				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")),
+				),
+			}),
+		}))
+		statements = append(statements, functionalIsProgrammer_factory.NewIfStatement(
+			functionalIsProgrammer_factory.NewBinaryExpression(
+				nil,
+				functionalIsProgrammer_factory.NewKeywordExpression(shimast.KindFalseKeyword),
+				nil,
+				functionalIsProgrammer_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
+				functionalIsProgrammer_factory.NewCallExpression(
+					functionalIsProgrammer_factory.NewIdentifier("__is_param_"+functionalIsProgrammer_itoa(i)),
+					nil,
+					nil,
+					functionalIsProgrammer_factory.NewNodeList([]*shimast.Node{
+						functionalIsProgrammer_factory.NewIdentifier(functionalIsProgrammer_parameterName(p)),
+					}),
+					shimast.NodeFlagsNone,
+				),
+			),
+			functionalIsProgrammer_factory.NewReturnStatement(functionalIsProgrammer_factory.NewKeywordExpression(shimast.KindNullKeyword)),
+			nil,
+		))
+	}
+	return FunctionalIsParametersProgrammer_IDecomposeOutput{
+		Functions:  functions,
+		Statements: statements,
+	}
+}
+
+func functionalIsProgrammer_parameters(declaration *shimast.Node) *shimast.ParameterList {
+	if declaration == nil || declaration.FunctionLikeData() == nil || declaration.FunctionLikeData().Parameters == nil {
+		return functionalIsProgrammer_factory.NewNodeList(nil)
+	}
+	return declaration.FunctionLikeData().Parameters
+}
+
+func functionalIsProgrammer_parameterNodes(declaration *shimast.Node) []*shimast.Node {
+	if params := functionalIsProgrammer_parameters(declaration); params != nil {
+		return params.Nodes
+	}
+	return nil
+}
+
+func functionalIsProgrammer_parameterIdentifiers(declaration *shimast.Node) []*shimast.Node {
+	parameters := functionalIsProgrammer_parameterNodes(declaration)
+	output := make([]*shimast.Node, 0, len(parameters))
+	for _, p := range parameters {
+		output = append(output, functionalIsProgrammer_factory.NewIdentifier(functionalIsProgrammer_parameterName(p)))
+	}
+	return output
+}
+
+func functionalIsProgrammer_parameterName(param *shimast.Node) string {
+	if param != nil && param.Name() != nil {
+		text := param.Name().Text()
+		if text != "" {
+			return text
+		}
+		return nativefactories.IdentifierFactory.GetName(param.Name())
+	}
+	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 {
+			return typ
+		}
+	}
+	return fallback
+}
+
+func functionalIsProgrammer_asyncModifiers(async bool) *shimast.ModifierList {
+	if async == false {
+		return nil
+	}
+	return functionalIsProgrammer_factory.NewModifierList([]*shimast.Node{
+		functionalIsProgrammer_factory.NewModifier(shimast.KindAsyncKeyword),
+	})
+}
+
+func functionalIsProgrammer_escapeDuplicate(keep []string, input string) string {
+	used := map[string]bool{}
+	for _, name := range keep {
+		used[name] = true
+	}
+	if used[input] == false {
+		return input
+	}
+	for i := 0; ; i++ {
+		next := input + functionalIsProgrammer_itoa(i)
+		if used[next] == false {
+			return next
+		}
+	}
+}
+
+func functionalIsProgrammer_parameterNames(declaration *shimast.Node) []string {
+	parameters := functionalIsProgrammer_parameterNodes(declaration)
+	output := make([]string, 0, len(parameters))
+	for _, p := range parameters {
+		output = append(output, functionalIsProgrammer_parameterName(p))
+	}
+	return output
+}
+
+func functionalIsProgrammer_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/native/core/programmers/functional/FunctionalIsReturnProgrammer.go

@@ -0,0 +1,125 @@
+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 functionalIsReturnProgrammerNamespace struct{}
+
+var FunctionalIsReturnProgrammer = functionalIsReturnProgrammerNamespace{}
+
+type FunctionalIsReturnProgrammer_IConfig struct {
+	Equals bool
+}
+
+type FunctionalIsReturnProgrammer_IProps struct {
+	Context     nativecontext.ITypiaContext
+	Modulo      *shimast.Node
+	Config      FunctionalIsReturnProgrammer_IConfig
+	Declaration *shimast.Node
+	Expression  *shimast.Node
+	Init        *shimast.Node
+}
+
+type FunctionalIsReturnProgrammer_IDecomposeProps struct {
+	Context     nativecontext.ITypiaContext
+	Modulo      *shimast.Node
+	Config      FunctionalIsReturnProgrammer_IConfig
+	Expression  *shimast.Node
+	Declaration *shimast.Node
+}
+
+type FunctionalIsReturnProgrammer_IDecomposeOutput struct {
+	Async      bool
+	Functions  []*shimast.Node
+	Statements []*shimast.Node
+}
+
+func (functionalIsReturnProgrammerNamespace) Write(props FunctionalIsReturnProgrammer_IProps) *shimast.Node {
+	result := FunctionalIsReturnProgrammer.Decompose(FunctionalIsReturnProgrammer_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, functionalIsProgrammer_factory.NewReturnStatement(
+		functionalIsProgrammer_factory.NewArrowFunction(
+			functionalIsProgrammer_asyncModifiers(result.Async),
+			nil,
+			functionalIsProgrammer_parameters(props.Declaration),
+			FunctionalIsFunctionProgrammer.GetReturnTypeNode(struct {
+				Declaration *shimast.Node
+				Async       bool
+			}{
+				Declaration: props.Declaration,
+				Async:       result.Async,
+			}),
+			nil,
+			functionalIsProgrammer_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+			functionalIsProgrammer_factory.NewBlock(functionalIsProgrammer_factory.NewNodeList(result.Statements), true),
+		),
+	))
+	return nativefactories.ExpressionFactory.SelfCall(
+		functionalIsProgrammer_factory.NewBlock(functionalIsProgrammer_factory.NewNodeList(statements), true),
+	)
+}
+
+func (functionalIsReturnProgrammerNamespace) Decompose(props FunctionalIsReturnProgrammer_IDecomposeProps) FunctionalIsReturnProgrammer_IDecomposeOutput {
+	output := functionalinternal.FunctionalGeneralProgrammer.GetReturnType(functionalinternal.FunctionalGeneralProgrammer_IProps{
+		Checker:     props.Context.Checker,
+		Declaration: props.Declaration,
+	})
+	caller := functionalIsProgrammer_factory.NewCallExpression(
+		props.Expression,
+		nil,
+		nil,
+		functionalIsProgrammer_factory.NewNodeList(functionalIsProgrammer_parameterIdentifiers(props.Declaration)),
+		shimast.NodeFlagsNone,
+	)
+	name := functionalIsProgrammer_escapeDuplicate(functionalIsProgrammer_parameterNames(props.Declaration), "result")
+	value := caller
+	if output.Async {
+		value = functionalIsProgrammer_factory.NewAwaitExpression(caller)
+	}
+	return FunctionalIsReturnProgrammer_IDecomposeOutput{
+		Async: output.Async,
+		Functions: []*shimast.Node{
+			nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+				Name: "__is_return",
+				Value: nativeprogrammers.IsProgrammer.Write(nativeprogrammers.IsProgrammer_IProps{
+					Context: props.Context,
+					Modulo:  props.Modulo,
+					Config:  nativeprogrammers.IsProgrammer_IConfig{Equals: props.Config.Equals},
+					Type:    output.Type,
+				}),
+			}),
+		},
+		Statements: []*shimast.Node{
+			nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
+				Name:  name,
+				Value: value,
+			}),
+			functionalIsProgrammer_factory.NewReturnStatement(functionalIsProgrammer_factory.NewConditionalExpression(
+				functionalIsProgrammer_factory.NewCallExpression(
+					functionalIsProgrammer_factory.NewIdentifier("__is_return"),
+					nil,
+					nil,
+					functionalIsProgrammer_factory.NewNodeList([]*shimast.Node{
+						functionalIsProgrammer_factory.NewIdentifier(name),
+					}),
+					shimast.NodeFlagsNone,
+				),
+				nil,
+				functionalIsProgrammer_factory.NewIdentifier(name),
+				nil,
+				functionalIsProgrammer_factory.NewKeywordExpression(shimast.KindNullKeyword),
+			)),
+		},
+	}
+}