typia 3.8.0-dev.20230417 → 3.8.0-dev.20230420

package/src/programmers/ApplicationProgrammer.ts

@@ -18,7 +18,7 @@ export namespace ApplicationProgrammer {
      * @internal
      */
     export namespace IOptions {
-        export function complement(options?: Partial<IOptions>): IOptions {
+        export const complement = (options?: Partial<IOptions>): IOptions => {
             const purpose: "swagger" | "ajv" = options?.purpose ?? "swagger";
             return {
                 purpose,
@@ -26,30 +26,37 @@ export namespace ApplicationProgrammer {
                     options?.prefix ||
                     (purpose === "swagger" ? SWAGGER_PREFIX : AJV_PREFIX),
             };
-        }
+        };
     }
 
-    export function generate(
+    /**
+     * @deprecated Use `write()` function instead
+     */
+    export const generate = (
         metadatas: Array<Metadata>,
         options?: Partial<IOptions>,
-    ): IJsonApplication {
-        const fullOptions: IOptions = IOptions.complement(options);
-        const components: IJsonComponents = {
-            schemas: {},
-        };
-        const generator = application_schema(fullOptions)(components)(true);
+    ): IJsonApplication => generate(metadatas, options);
 
-        return {
-            schemas: metadatas.map((meta, i) => {
-                const schema: IJsonSchema | null = generator(meta, {});
-                if (schema === null)
-                    throw new Error(
-                        `Error on typia.application(): invalid type on argument - (${meta.getName()}, ${i})`,
-                    );
-                return schema;
-            }),
-            components,
-            ...fullOptions,
+    export const write =
+        (options?: Partial<IOptions>) =>
+        (metadatas: Array<Metadata>): IJsonApplication => {
+            const fullOptions: IOptions = IOptions.complement(options);
+            const components: IJsonComponents = {
+                schemas: {},
+            };
+            const generator = application_schema(fullOptions)(true)(components);
+
+            return {
+                schemas: metadatas.map((meta, i) => {
+                    const schema: IJsonSchema | null = generator(meta)({});
+                    if (schema === null)
+                        throw new Error(
+                            `Error on typia.application(): invalid type on argument - (${meta.getName()}, ${i})`,
+                        );
+                    return schema;
+                }),
+                components,
+                ...fullOptions,
+            };
         };
-    }
 }

package/src/programmers/AssertCloneProgrammer.ts

@@ -10,8 +10,17 @@ import { AssertProgrammer } from "./AssertProgrammer";
 import { CloneProgrammer } from "./CloneProgrammer";
 
 export namespace AssertCloneProgrammer {
+    /**
+     * @deprecated Use `write()` function instead
+     */
     export const generate =
         (project: IProject, modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string) =>
+            write(project)(modulo)(type, name);
+
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
         (type: ts.Type, name?: string) =>
             ts.factory.createArrowFunction(
                 undefined,
@@ -24,28 +33,28 @@ export namespace AssertCloneProgrammer {
                 ],
                 ts.factory.createTypeReferenceNode(
                     `typia.Primitive<${
-                        name ?? TypeFactory.getFullName(project.checker, type)
+                        name ?? TypeFactory.getFullName(project.checker)(type)
                     }>`,
                 ),
                 undefined,
                 ts.factory.createBlock([
                     StatementFactory.constant(
                         "assert",
-                        AssertProgrammer.generate(project, modulo)(type, name),
+                        AssertProgrammer.write(project)(modulo)(false)(
+                            type,
+                            name,
+                        ),
                     ),
                     StatementFactory.constant(
                         "clone",
-                        CloneProgrammer.generate(
-                            {
-                                ...project,
-                                options: {
-                                    ...project.options,
-                                    functional: false,
-                                    numeric: false,
-                                },
+                        CloneProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
                             },
-                            modulo,
-                        )(type, name),
+                        })(modulo)(type, name),
                     ),
                     ts.factory.createExpressionStatement(
                         ts.factory.createCallExpression(

package/src/programmers/AssertParseProgrammer.ts

@@ -9,8 +9,17 @@ import { IProject } from "../transformers/IProject";
 import { AssertProgrammer } from "./AssertProgrammer";
 
 export namespace AssertParseProgrammer {
+    /**
+     * @deprecated Use `write()` function instead
+     */
     export const generate =
         (project: IProject, modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string) =>
+            write(project)(modulo)(type, name);
+
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
         (type: ts.Type, name?: string) =>
             ts.factory.createArrowFunction(
                 undefined,
@@ -23,24 +32,21 @@ export namespace AssertParseProgrammer {
                 ],
                 ts.factory.createTypeReferenceNode(
                     `typia.Primitive<${
-                        name ?? TypeFactory.getFullName(project.checker, type)
+                        name ?? TypeFactory.getFullName(project.checker)(type)
                     }>`,
                 ),
                 undefined,
                 ts.factory.createBlock([
                     StatementFactory.constant(
                         "assert",
-                        AssertProgrammer.generate(
-                            {
-                                ...project,
-                                options: {
-                                    ...project.options,
-                                    functional: false,
-                                    numeric: false,
-                                },
+                        AssertProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
                             },
-                            modulo,
-                        )(type, name),
+                        })(modulo)(false)(type, name),
                     ),
                     ts.factory.createExpressionStatement(
                         ts.factory.createBinaryExpression(

package/src/programmers/AssertProgrammer.ts

@@ -13,53 +13,59 @@ import { OptionPredicator } from "./helpers/OptionPredicator";
 import { check_object } from "./internal/check_object";
 
 export namespace AssertProgrammer {
+    /**
+     * @deprecated Use `write()` function instead
+     */
     export const generate =
         (
             project: IProject,
             modulo: ts.LeftHandSideExpression,
             equals: boolean = false,
         ) =>
+        (type: ts.Type, name?: string) =>
+            write(project)(modulo)(equals)(type, name);
+
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (equals: boolean) =>
         (type: ts.Type, name?: string) => {
             const importer: FunctionImporter = new FunctionImporter();
-            const program: ts.ArrowFunction = CheckerProgrammer.generate(
-                project,
-                {
-                    functors: "$ao",
-                    unioners: "$au",
-                    path: true,
-                    trace: true,
-                    numeric: OptionPredicator.numeric(project.options),
-                    equals,
-                    atomist: (explore) => (tuple) => (input) =>
-                        [
-                            tuple.expression,
-                            ...tuple.tags.map((tag) =>
-                                ts.factory.createLogicalOr(
-                                    tag.expression,
-                                    create_guard_call(importer)(
-                                        explore.from === "top"
-                                            ? ts.factory.createTrue()
-                                            : ts.factory.createIdentifier(
-                                                  "_exceptionable",
-                                              ),
-                                    )(
-                                        ts.factory.createIdentifier(
-                                            explore.postfix
-                                                ? `_path + ${explore.postfix}`
-                                                : "_path",
-                                        ),
-                                        tag.expected,
-                                        input,
+            const program: ts.ArrowFunction = CheckerProgrammer.write(project)({
+                functors: "$ao",
+                unioners: "$au",
+                path: true,
+                trace: true,
+                numeric: OptionPredicator.numeric(project.options),
+                equals,
+                atomist: (explore) => (tuple) => (input) =>
+                    [
+                        tuple.expression,
+                        ...tuple.tags.map((tag) =>
+                            ts.factory.createLogicalOr(
+                                tag.expression,
+                                create_guard_call(importer)(
+                                    explore.from === "top"
+                                        ? ts.factory.createTrue()
+                                        : ts.factory.createIdentifier(
+                                              "_exceptionable",
+                                          ),
+                                )(
+                                    ts.factory.createIdentifier(
+                                        explore.postfix
+                                            ? `_path + ${explore.postfix}`
+                                            : "_path",
                                     ),
+                                    tag.expected,
+                                    input,
                                 ),
                             ),
-                        ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
-                    combiner: combiner(equals)(importer),
-                    joiner: joiner(equals)(importer),
-                    success: ts.factory.createTrue(),
-                },
-                importer,
-            )(type, name);
+                        ),
+                    ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
+                combiner: combiner(equals)(importer),
+                joiner: joiner(equals)(importer),
+                success: ts.factory.createTrue(),
+            })(importer)(type, name);
 
             return ts.factory.createArrowFunction(
                 undefined,
@@ -71,7 +77,7 @@ export namespace AssertProgrammer {
                     ),
                 ],
                 ts.factory.createTypeReferenceNode(
-                    name ?? TypeFactory.getFullName(project.checker, type),
+                    name ?? TypeFactory.getFullName(project.checker)(type),
                 ),
                 undefined,
                 ts.factory.createBlock(
@@ -79,15 +85,10 @@ export namespace AssertProgrammer {
                         ...importer.declare(modulo),
                         StatementFactory.constant(
                             "__is",
-                            IsProgrammer.generate(
-                                project,
-                                modulo,
-                                equals,
-                            )(
+                            IsProgrammer.write(project)(modulo)(equals)(
                                 type,
                                 name ??
-                                    TypeFactory.getFullName(
-                                        project.checker,
+                                    TypeFactory.getFullName(project.checker)(
                                         type,
                                     ),
                             ),
@@ -130,7 +131,7 @@ export namespace AssertProgrammer {
         (importer: FunctionImporter): CheckerProgrammer.IConfig.Combiner =>
         (explore: CheckerProgrammer.IExplore) => {
             if (explore.tracable === false)
-                return IsProgrammer.CONFIG({
+                return IsProgrammer.configure({
                     object: assert_object(equals)(importer),
                     numeric: true,
                 })(importer).combiner(explore);
@@ -222,7 +223,7 @@ export namespace AssertProgrammer {
             object: assert_object(equals)(importer),
             array: (input, arrow) =>
                 ts.factory.createCallExpression(
-                    IdentifierFactory.join(input, "every"),
+                    IdentifierFactory.join(input)("every"),
                     undefined,
                     [arrow],
                 ),

package/src/programmers/AssertPruneProgrammer.ts

@@ -10,8 +10,17 @@ import { AssertProgrammer } from "./AssertProgrammer";
 import { PruneProgrammer } from "./PruneProgrammer";
 
 export namespace AssertPruneProgrammer {
+    /**
+     * @deprecated Use `write()` function instead
+     */
     export const generate =
         (project: IProject, modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string) =>
+            write(project)(modulo)(type, name);
+
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
         (type: ts.Type, name?: string) =>
             ts.factory.createArrowFunction(
                 undefined,
@@ -23,27 +32,27 @@ export namespace AssertPruneProgrammer {
                     ),
                 ],
                 ts.factory.createTypeReferenceNode(
-                    name ?? TypeFactory.getFullName(project.checker, type),
+                    name ?? TypeFactory.getFullName(project.checker)(type),
                 ),
                 undefined,
                 ts.factory.createBlock([
                     StatementFactory.constant(
                         "assert",
-                        AssertProgrammer.generate(project, modulo)(type, name),
+                        AssertProgrammer.write(project)(modulo)(false)(
+                            type,
+                            name,
+                        ),
                     ),
                     StatementFactory.constant(
                         "prune",
-                        PruneProgrammer.generate(
-                            {
-                                ...project,
-                                options: {
-                                    ...project.options,
-                                    functional: false,
-                                    numeric: false,
-                                },
+                        PruneProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
                             },
-                            modulo,
-                        )(type, name),
+                        })(modulo)(type, name),
                     ),
                     ts.factory.createExpressionStatement(
                         ts.factory.createCallExpression(

package/src/programmers/AssertStringifyProgrammer.ts

@@ -10,8 +10,17 @@ import { AssertProgrammer } from "./AssertProgrammer";
 import { StringifyProgrammer } from "./StringifyProgrammer";
 
 export namespace AssertStringifyProgrammer {
+    /**
+     * @deprecated Use `write()` function instead
+     */
     export const generate =
         (project: IProject, modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string) =>
+            write(project)(modulo)(type, name);
+
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
         (type: ts.Type, name?: string) =>
             ts.factory.createArrowFunction(
                 undefined,
@@ -27,31 +36,25 @@ export namespace AssertStringifyProgrammer {
                 ts.factory.createBlock([
                     StatementFactory.constant(
                         "assert",
-                        AssertProgrammer.generate(
-                            {
-                                ...project,
-                                options: {
-                                    ...project.options,
-                                    functional: false,
-                                    numeric: true,
-                                },
+                        AssertProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: true,
                             },
-                            modulo,
-                        )(type, name),
+                        })(modulo)(false)(type, name),
                     ),
                     StatementFactory.constant(
                         "stringify",
-                        StringifyProgrammer.generate(
-                            {
-                                ...project,
-                                options: {
-                                    ...project.options,
-                                    functional: false,
-                                    numeric: false,
-                                },
+                        StringifyProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
                             },
-                            modulo,
-                        )(type, name),
+                        })(modulo)(type, name),
                     ),
                     ts.factory.createReturnStatement(
                         ts.factory.createCallExpression(