typia 3.8.0-dev.20230418 → 3.8.0-dev.20230420

package/src/transformers/features/miscellaneous/ApplicationTransformer.ts

@@ -12,87 +12,82 @@ import { ApplicationProgrammer } from "../../../programmers/ApplicationProgramme
 import { IProject } from "../../IProject";
 
 export namespace ApplicationTransformer {
-    export function transform(
-        { checker }: IProject,
-        _modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        if (!expression.typeArguments?.length)
-            throw new Error(NO_GENERIC_ARGUMENT);
+    export const transform =
+        ({ checker }: IProject) =>
+        (expression: ts.CallExpression): ts.Expression => {
+            if (!expression.typeArguments?.length)
+                throw new Error(NO_GENERIC_ARGUMENT);
 
-        //----
-        // GET ARGUMENTS
-        //----
-        // VALIDATE TUPLE ARGUMENTS
-        const top: ts.Node = expression.typeArguments[0]!;
-        if (!ts.isTupleTypeNode(top)) return expression;
-        else if (top.elements.some((child) => !ts.isTypeNode(child)))
-            return expression;
+            //----
+            // GET ARGUMENTS
+            //----
+            // VALIDATE TUPLE ARGUMENTS
+            const top: ts.Node = expression.typeArguments[0]!;
+            if (!ts.isTupleTypeNode(top)) return expression;
+            else if (top.elements.some((child) => !ts.isTypeNode(child)))
+                return expression;
 
-        // GET TYPES
-        const types: ts.Type[] = top.elements.map((child) =>
-            checker.getTypeFromTypeNode(child as ts.TypeNode),
-        );
-        if (types.some((t) => t.isTypeParameter()))
-            throw new Error(GENERIC_ARGUMENT);
+            // GET TYPES
+            const types: ts.Type[] = top.elements.map((child) =>
+                checker.getTypeFromTypeNode(child as ts.TypeNode),
+            );
+            if (types.some((t) => t.isTypeParameter()))
+                throw new Error(GENERIC_ARGUMENT);
 
-        // ADDITIONAL PARAMETERS
-        const purpose: "swagger" | "ajv" = get_parameter(
-            checker,
-            "Purpose",
-            expression.typeArguments[1],
-            (str) => str === "swagger" || str === "ajv",
-            () => "swagger",
-        );
-        const prefix: string = get_parameter(
-            checker,
-            "Prefix",
-            expression.typeArguments[2],
-            () => true,
-            () =>
-                purpose === "swagger"
-                    ? "#/components/schemas"
-                    : "components#/schemas",
-        );
+            // ADDITIONAL PARAMETERS
+            const purpose: "swagger" | "ajv" = get_parameter(
+                checker,
+                "Purpose",
+                expression.typeArguments[1],
+                (str) => str === "swagger" || str === "ajv",
+                () => "swagger",
+            );
+            const prefix: string = get_parameter(
+                checker,
+                "Prefix",
+                expression.typeArguments[2],
+                () => true,
+                () =>
+                    purpose === "swagger"
+                        ? "#/components/schemas"
+                        : "components#/schemas",
+            );
 
-        //----
-        // GENERATORS
-        //----
-        // METADATA
-        const collection: MetadataCollection = new MetadataCollection({
-            replace: MetadataCollection.replace,
-        });
-        const metadatas: Array<Metadata> = types.map((type) =>
-            MetadataFactory.generate(checker, collection, type, {
-                resolve: true,
-                constant: true,
-                validate: (meta) => {
-                    if (meta.atomics.find((str) => str === "bigint"))
-                        throw new Error(NO_BIGIT);
-                },
-            }),
-        );
+            //----
+            // GENERATORS
+            //----
+            // METADATA
+            const collection: MetadataCollection = new MetadataCollection({
+                replace: MetadataCollection.replace,
+            });
+            const metadatas: Array<Metadata> = types.map((type) =>
+                MetadataFactory.analyze(checker)({
+                    resolve: true,
+                    constant: true,
+                    validate: (meta) => {
+                        if (meta.atomics.find((str) => str === "bigint"))
+                            throw new Error(NO_BIGIT);
+                    },
+                })(collection)(type),
+            );
 
-        // APPLICATION
-        const app: IJsonApplication = ApplicationProgrammer.generate(
-            metadatas,
-            {
+            // APPLICATION
+            const app: IJsonApplication = ApplicationProgrammer.write({
                 purpose,
                 prefix,
-            },
-        );
+            })(metadatas);
 
-        // RETURNS WITH LITERAL EXPRESSION
-        return LiteralFactory.generate(app);
-    }
+            // RETURNS WITH LITERAL EXPRESSION
+            return LiteralFactory.generate(app);
+        };
 
-    function get_parameter<T extends string>(
+    const get_parameter = <T extends string>(
         checker: ts.TypeChecker,
         name: string,
         node: ts.TypeNode | undefined,
         predicator: (value: string) => boolean,
         defaulter: () => T,
-    ): T {
+    ): T => {
         if (!node) return defaulter();
 
         // CHECK LITERAL TYPE
@@ -109,7 +104,7 @@ export namespace ApplicationTransformer {
                 `Error on typia.application(): invalid value on generic argument "${name}".`,
             );
         return value as T;
-    }
+    };
 }
 
 const NO_GENERIC_ARGUMENT =

package/src/transformers/features/miscellaneous/AssertCloneTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace AssertCloneTransformer {
     export const transform = GenericTransformer.scalar("assertClone")(
-        (project, modulo) => AssertCloneProgrammer.generate(project, modulo),
+        (project) => (modulo) => AssertCloneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/miscellaneous/AssertPruneTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace AssertPruneTransformer {
     export const transform = GenericTransformer.scalar("assertPrune")(
-        (project, modulo) => AssertPruneProgrammer.generate(project, modulo),
+        (project) => (modulo) => AssertPruneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/miscellaneous/CloneTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CloneTransformer {
     export const transform = GenericTransformer.scalar("clone")(
-        (project, modulo) => CloneProgrammer.generate(project, modulo),
+        (project) => (modulo) => CloneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/miscellaneous/CreateAssertCloneTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateAssertCloneTransformer {
     export const transform = GenericTransformer.factory("createAssertClone")(
-        (project, modulo) => AssertCloneProgrammer.generate(project, modulo),
+        (project) => (modulo) => AssertCloneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/miscellaneous/CreateAssertPruneTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateAssertPruneTransformer {
     export const transform = GenericTransformer.factory("createAssertPrune")(
-        (project, modulo) => AssertPruneProgrammer.generate(project, modulo),
+        (project) => (modulo) => AssertPruneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/miscellaneous/CreateCloneTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateCloneTransformer {
     export const transform = GenericTransformer.factory("createClone")(
-        (project, modulo) => CloneProgrammer.generate(project, modulo),
+        (project) => (modulo) => CloneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/miscellaneous/CreateIsCloneTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateIsCloneTransformer {
     export const transform = GenericTransformer.factory("createIsClone")(
-        (project, modulo) => IsCloneProgrammer.generate(project, modulo),
+        (project) => (modulo) => IsCloneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/miscellaneous/CreateIsPruneTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateIsPruneTransformer {
     export const transform = GenericTransformer.factory("createIsPrune")(
-        (project, modulo) => IsPruneProgrammer.generate(project, modulo),
+        (project) => (modulo) => IsPruneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/miscellaneous/CreatePruneTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreatePruneTransformer {
     export const transform = GenericTransformer.factory("createPrune")(
-        (project, modulo) => PruneProgrammer.generate(project, modulo),
+        (project) => (modulo) => PruneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/miscellaneous/CreateRandomTransformer.ts

@@ -5,34 +5,32 @@ import { RandomProgrammer } from "../../../programmers/RandomProgrammer";
 import { IProject } from "../../IProject";
 
 export namespace CreateRandomTransformer {
-    export function transform(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments?.[0]) throw new Error(NOT_SPECIFIED);
+    export const transform =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (expression: ts.CallExpression): ts.Expression => {
+            // CHECK GENERIC ARGUMENT EXISTENCE
+            if (!expression.typeArguments?.[0]) throw new Error(NOT_SPECIFIED);
 
-        // GET TYPE INFO
-        const node: ts.TypeNode = expression.typeArguments[0];
-        const type: ts.Type = project.checker.getTypeFromTypeNode(node);
+            // GET TYPE INFO
+            const node: ts.TypeNode = expression.typeArguments[0];
+            const type: ts.Type = project.checker.getTypeFromTypeNode(node);
 
-        if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
+            if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
 
-        // DO TRANSFORM
-        return RandomProgrammer.generate(
-            {
+            // DO TRANSFORM
+            return RandomProgrammer.write({
                 ...project,
                 options: {
                     ...project.options,
                     functional: false,
                     numeric: false,
                 },
-            },
-            modulo,
-            expression.arguments?.[0],
-        )(type, node.getFullText().trim());
-    }
+            })(modulo)(expression.arguments?.[0])(
+                type,
+                node.getFullText().trim(),
+            );
+        };
 }
 
 const NOT_SPECIFIED =

package/src/transformers/features/miscellaneous/CreateValidateCloneTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateValidateCloneTransformer {
     export const transform = GenericTransformer.factory("createValidateClone")(
-        (project, modulo) => ValidateCloneProgrammer.generate(project, modulo),
+        (project) => (modulo) => ValidateCloneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/miscellaneous/CreateValidatePruneTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateValidatePruneTransformer {
     export const transform = GenericTransformer.factory("createValidatePrune")(
-        (project, modulo) => ValidatePruneProgrammer.generate(project, modulo),
+        (project) => (modulo) => ValidatePruneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/miscellaneous/IsCloneTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace IsCloneTransformer {
     export const transform = GenericTransformer.scalar("isClone")(
-        (project, modulo) => IsCloneProgrammer.generate(project, modulo),
+        (project) => (modulo) => IsCloneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/miscellaneous/IsPruneTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace IsPruneTransformer {
     export const transform = GenericTransformer.scalar("isPrune")(
-        (project, modulo) => IsPruneProgrammer.generate(project, modulo),
+        (project) => (modulo) => IsPruneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/miscellaneous/LiteralsTransformer.ts

@@ -5,23 +5,21 @@ import { LiteralsProgrammer } from "../../../programmers/LiteralsProgrammer";
 import { IProject } from "../../IProject";
 
 export namespace LiteralsTransformer {
-    export function transform(
-        project: IProject,
-        _modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments?.[0]) throw new Error(NOT_SPECIFIED);
+    export const transform =
+        (project: IProject) =>
+        (expression: ts.CallExpression): ts.Expression => {
+            // CHECK GENERIC ARGUMENT EXISTENCE
+            if (!expression.typeArguments?.[0]) throw new Error(NOT_SPECIFIED);
 
-        // GET TYPE INFO
-        const node: ts.TypeNode = expression.typeArguments[0];
-        const type: ts.Type = project.checker.getTypeFromTypeNode(node);
+            // GET TYPE INFO
+            const node: ts.TypeNode = expression.typeArguments[0];
+            const type: ts.Type = project.checker.getTypeFromTypeNode(node);
 
-        if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
+            if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
 
-        // DO TRANSFORM
-        return LiteralsProgrammer.generate(project)(type);
-    }
+            // DO TRANSFORM
+            return LiteralsProgrammer.write(project)(type);
+        };
 }
 
 const NOT_SPECIFIED =

package/src/transformers/features/miscellaneous/MetadataTransformer.ts

@@ -10,43 +10,41 @@ import { Metadata } from "../../../metadata/Metadata";
 import { IProject } from "../../IProject";
 
 export namespace MetadataTransformer {
-    export function transform(
-        { checker }: IProject,
-        _modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        if (!expression.typeArguments?.length)
-            throw new Error(NO_GENERIC_ARGUMENT);
-
-        // VALIDATE TUPLE ARGUMENTS
-        const top: ts.Node = expression.typeArguments[0]!;
-        if (!ts.isTupleTypeNode(top)) return expression;
-        else if (top.elements.some((child) => !ts.isTypeNode(child)))
-            return expression;
-
-        // GET TYPES
-        const types: ts.Type[] = top.elements.map((child) =>
-            checker.getTypeFromTypeNode(child as ts.TypeNode),
-        );
-        if (types.some((t) => t.isTypeParameter()))
-            throw new Error(GENERIC_ARGUMENT);
-
-        // METADATA
-        const collection: MetadataCollection = new MetadataCollection();
-        const metadatas: Array<Metadata> = types.map((type) =>
-            MetadataFactory.generate(checker, collection, type, {
-                resolve: false,
-                constant: true,
-            }),
-        );
-
-        // CONVERT TO PRIMITIVE TYPE
-        const app: IMetadataApplication = {
-            metadatas: metadatas.map((metadata) => metadata.toJSON()),
-            collection: collection.objects().map((obj) => obj.toJSON()),
+    export const transform =
+        ({ checker }: IProject) =>
+        (expression: ts.CallExpression): ts.Expression => {
+            if (!expression.typeArguments?.length)
+                throw new Error(NO_GENERIC_ARGUMENT);
+
+            // VALIDATE TUPLE ARGUMENTS
+            const top: ts.Node = expression.typeArguments[0]!;
+            if (!ts.isTupleTypeNode(top)) return expression;
+            else if (top.elements.some((child) => !ts.isTypeNode(child)))
+                return expression;
+
+            // GET TYPES
+            const types: ts.Type[] = top.elements.map((child) =>
+                checker.getTypeFromTypeNode(child as ts.TypeNode),
+            );
+            if (types.some((t) => t.isTypeParameter()))
+                throw new Error(GENERIC_ARGUMENT);
+
+            // METADATA
+            const collection: MetadataCollection = new MetadataCollection();
+            const metadatas: Array<Metadata> = types.map((type) =>
+                MetadataFactory.analyze(checker)({
+                    resolve: false,
+                    constant: true,
+                })(collection)(type),
+            );
+
+            // CONVERT TO PRIMITIVE TYPE
+            const app: IMetadataApplication = {
+                metadatas: metadatas.map((metadata) => metadata.toJSON()),
+                collection: collection.objects().map((obj) => obj.toJSON()),
+            };
+            return LiteralFactory.generate(app);
         };
-        return LiteralFactory.generate(app);
-    }
 }
 
 const NO_GENERIC_ARGUMENT = "Error on typia.metadata(): no generic argument.";

package/src/transformers/features/miscellaneous/PruneTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace PruneTransformer {
     export const transform = GenericTransformer.scalar("prune")(
-        (project, modulo) => PruneProgrammer.generate(project, modulo),
+        (project) => (modulo) => PruneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/miscellaneous/RandomTransformer.ts

@@ -5,39 +5,35 @@ import { RandomProgrammer } from "../../../programmers/RandomProgrammer";
 import { IProject } from "../../IProject";
 
 export namespace RandomTransformer {
-    export function transform(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments?.[0]) throw new Error(NOT_SPECIFIED);
+    export const transform =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (expression: ts.CallExpression): ts.Expression => {
+            // CHECK GENERIC ARGUMENT EXISTENCE
+            if (!expression.typeArguments?.[0]) throw new Error(NOT_SPECIFIED);
 
-        // GET TYPE INFO
-        const node: ts.TypeNode = expression.typeArguments[0];
-        const type: ts.Type = project.checker.getTypeFromTypeNode(node);
+            // GET TYPE INFO
+            const node: ts.TypeNode = expression.typeArguments[0];
+            const type: ts.Type = project.checker.getTypeFromTypeNode(node);
 
-        if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
+            if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
 
-        // DO TRANSFORM
-        return ts.factory.createCallExpression(
-            RandomProgrammer.generate(
-                {
+            // DO TRANSFORM
+            return ts.factory.createCallExpression(
+                RandomProgrammer.write({
                     ...project,
                     options: {
                         ...project.options,
                         functional: false,
                         numeric: false,
                     },
-                },
-                modulo,
-            )(type, node.getFullText().trim()),
-            undefined,
-            expression.arguments.length
-                ? [expression.arguments[0]!]
-                : undefined,
-        );
-    }
+                })(modulo)()(type, node.getFullText().trim()),
+                undefined,
+                expression.arguments.length
+                    ? [expression.arguments[0]!]
+                    : undefined,
+            );
+        };
 }
 
 const NOT_SPECIFIED =

package/src/transformers/features/miscellaneous/ValidateCloneTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace ValidateCloneTransformer {
     export const transform = GenericTransformer.scalar("validatClone")(
-        (project, modulo) => ValidateCloneProgrammer.generate(project, modulo),
+        (project) => (modulo) => ValidateCloneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/miscellaneous/ValidatePruneTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace ValidatePruneTransformer {
     export const transform = GenericTransformer.scalar("validatPrune")(
-        (project, modulo) => ValidatePruneProgrammer.generate(project, modulo),
+        (project) => (modulo) => ValidatePruneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/parsers/AssertParseTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace AssertParseTransformer {
     export const transform = GenericTransformer.scalar("assertParse")(
-        (project, modulo) => AssertParseProgrammer.generate(project, modulo),
+        (project) => (modulo) => AssertParseProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/parsers/CreateAssertParseTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateAssertParseTransformer {
     export const transform = GenericTransformer.factory("createAssertParse")(
-        (project, modulo) => AssertParseProgrammer.generate(project, modulo),
+        (project) => (modulo) => AssertParseProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/parsers/CreateIsParseTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateIsParseTransformer {
     export const transform = GenericTransformer.factory("createIsParse")(
-        (project, modulo) => IsParseProgrammer.generate(project, modulo),
+        (project) => (modulo) => IsParseProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/parsers/CreateValidateParseTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateValidateParseTransformer {
     export const transform = GenericTransformer.factory("createValidateParse")(
-        (project, modulo) => ValidateParseProgrammer.generate(project, modulo),
+        (project) => (modulo) => ValidateParseProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/parsers/IsParseTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace IsParseTransformer {
     export const transform = GenericTransformer.scalar("isParse")(
-        (project, modulo) => IsParseProgrammer.generate(project, modulo),
+        (project) => (modulo) => IsParseProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/parsers/ValidateParseTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace ValidateParseTransformer {
     export const transform = GenericTransformer.scalar("validatParse")(
-        (project, modulo) => ValidateParseProgrammer.generate(project, modulo),
+        (project) => (modulo) => ValidateParseProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/stringifiers/AssertStringifyTransformer.ts

@@ -4,7 +4,7 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace AssertStringifyTransformer {
     export const transform = GenericTransformer.scalar("assertStringify")(
-        (project, modulo) =>
-            AssertStringifyProgrammer.generate(project, modulo),
+        (project) => (modulo) =>
+            AssertStringifyProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/stringifiers/CreateAssertStringifyTransformer.ts

@@ -5,5 +5,8 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 export namespace CreateAssertStringifyTransformer {
     export const transform = GenericTransformer.factory(
         "createAssertStringify",
-    )((project, modulo) => AssertStringifyProgrammer.generate(project, modulo));
+    )(
+        (project) => (modulo) =>
+            AssertStringifyProgrammer.write(project)(modulo),
+    );
 }

package/src/transformers/features/stringifiers/CreateIsStringifyTransformer.ts

@@ -4,6 +4,6 @@ import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateIsStringifyTransformer {
     export const transform = GenericTransformer.factory("createIsStringify")(
-        (project, modulo) => IsStringifyProgrammer.generate(project, modulo),
+        (project) => (modulo) => IsStringifyProgrammer.write(project)(modulo),
     );
 }