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

package/src/programmers/PruneProgrammer.ts

@@ -18,43 +18,48 @@ import { UnionExplorer } from "./helpers/UnionExplorer";
 import { decode_union_object } from "./internal/decode_union_object";
 
 export namespace PruneProgrammer {
-    export function generate(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-    ) {
-        const importer: FunctionImporter = new FunctionImporter();
-        return FeatureProgrammer.generate(
-            project,
-            CONFIG(project, importer),
-            importer,
-            (collection) => {
-                const isFunctors = IsProgrammer.generate_functors(
-                    project,
-                    importer,
-                )(collection);
-                const isUnioners = IsProgrammer.generate_unioners(
-                    project,
-                    importer,
-                )(collection);
+    /**
+     * @deprecated Use `write()` function instead
+     */
+    export const generate =
+        (project: IProject, modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string) =>
+            write(project)(modulo)(type, name);
 
-                return [
-                    ...importer.declare(modulo),
-                    ...isFunctors.filter((_, i) =>
-                        importer.hasLocal(`$io${i}`),
-                    ),
-                    ...isUnioners.filter((_, i) =>
-                        importer.hasLocal(`$iu${i}`),
-                    ),
-                ];
-            },
-        );
-    }
+    export const write =
+        (project: IProject) => (modulo: ts.LeftHandSideExpression) => {
+            const importer: FunctionImporter = new FunctionImporter();
+            return FeatureProgrammer.analyze(project)({
+                ...configure(project)(importer),
+                addition: (collection) => {
+                    const isFunctors =
+                        IsProgrammer.write_functors(project)(importer)(
+                            collection,
+                        );
+                    const isUnioners =
+                        IsProgrammer.write_unioners(project)(importer)(
+                            collection,
+                        );
+
+                    return [
+                        ...importer.declare(modulo),
+                        ...isFunctors.filter((_, i) =>
+                            importer.hasLocal(`$io${i}`),
+                        ),
+                        ...isUnioners.filter((_, i) =>
+                            importer.hasLocal(`$iu${i}`),
+                        ),
+                    ];
+                },
+            })(importer);
+        };
 
     /* -----------------------------------------------------------
         DECODERS
     ----------------------------------------------------------- */
     const decode =
-        (project: IProject, importer: FunctionImporter) =>
+        (project: IProject) =>
+        (importer: FunctionImporter) =>
         (
             input: ts.Expression,
             meta: Metadata,
@@ -91,7 +96,7 @@ export namespace PruneProgrammer {
                             [],
                         ),
                     value: () =>
-                        decode_tuple(project, importer)(input, tuple, explore),
+                        decode_tuple(project)(importer)(input, tuple, explore),
                 });
 
             // ARRAYS
@@ -100,7 +105,7 @@ export namespace PruneProgrammer {
                     type: "array",
                     is: () => ExpressionFactory.isArray(input),
                     value: () =>
-                        explore_arrays(project, importer)(
+                        explore_arrays(project)(importer)(
                             input,
                             meta.arrays,
                             {
@@ -117,19 +122,19 @@ export namespace PruneProgrammer {
                 for (const native of meta.natives)
                     unions.push({
                         type: "native",
-                        is: () => ExpressionFactory.isInstanceOf(input, native),
+                        is: () => ExpressionFactory.isInstanceOf(native)(input),
                         value: () => ts.factory.createReturnStatement(),
                     });
             if (meta.sets.length)
                 unions.push({
                     type: "set",
-                    is: () => ExpressionFactory.isInstanceOf(input, "Set"),
+                    is: () => ExpressionFactory.isInstanceOf("Set")(input),
                     value: () => ts.factory.createReturnStatement(),
                 });
             if (meta.maps.length)
                 unions.push({
                     type: "map",
-                    is: () => ExpressionFactory.isInstanceOf(input, "Map"),
+                    is: () => ExpressionFactory.isInstanceOf("Map")(input),
                     value: () => ts.factory.createReturnStatement(),
                 });
 
@@ -138,10 +143,10 @@ export namespace PruneProgrammer {
                 unions.push({
                     type: "object",
                     is: () =>
-                        ExpressionFactory.isObject(input, {
+                        ExpressionFactory.isObject({
                             checkNull: true,
                             checkArray: false,
-                        }),
+                        })(input),
                     value: () =>
                         explore_objects(importer)(input, meta, {
                             ...explore,
@@ -166,7 +171,8 @@ export namespace PruneProgrammer {
         };
 
     const decode_tuple =
-        (project: IProject, importer: FunctionImporter) =>
+        (project: IProject) =>
+        (importer: FunctionImporter) =>
         (
             input: ts.Expression,
             tuple: Metadata[],
@@ -176,7 +182,7 @@ export namespace PruneProgrammer {
                 .map((elem, index) => [elem, index] as const)
                 .filter(([elem]) => filter(elem) && elem.rest === null)
                 .map(([elem, index]) =>
-                    decode(project, importer)(
+                    decode(project)(importer)(
                         ts.factory.createElementAccessExpression(input, index),
                         elem,
                         {
@@ -192,9 +198,9 @@ export namespace PruneProgrammer {
                 const rest: Metadata | null = last.rest;
                 if (rest === null || filter(rest) === false) return null;
 
-                return decode(project, importer)(
+                return decode(project)(importer)(
                     ts.factory.createCallExpression(
-                        IdentifierFactory.join(input, "slice"),
+                        IdentifierFactory.join(input)("slice"),
                         undefined,
                         [ts.factory.createNumericLiteral(tuple.length - 1)],
                     ),
@@ -212,10 +218,8 @@ export namespace PruneProgrammer {
             return PruneJoiner.tuple(children, rest);
         };
 
-    const decode_array = (project: IProject, importer: FunctionImporter) =>
-        FeatureProgrammer.decode_array(
-            CONFIG(project, importer),
-            importer,
+    const decode_array = (project: IProject) => (importer: FunctionImporter) =>
+        FeatureProgrammer.decode_array(configure(project)(importer))(importer)(
             PruneJoiner.array,
         );
 
@@ -226,15 +230,16 @@ export namespace PruneProgrammer {
             functors: FUNCTORS,
         })(importer);
 
-    const explore_arrays = (project: IProject, importer: FunctionImporter) =>
-        UnionExplorer.array({
-            checker: IsProgrammer.decode(project, importer),
-            decoder: decode_array(project, importer),
-            empty: ts.factory.createReturnStatement(),
-            success: ts.factory.createTrue(),
-            failure: (input, expected) =>
-                create_throw_error(importer, input, expected),
-        });
+    const explore_arrays =
+        (project: IProject) => (importer: FunctionImporter) =>
+            UnionExplorer.array({
+                checker: IsProgrammer.decode(project, importer),
+                decoder: decode_array(project)(importer),
+                empty: ts.factory.createReturnStatement(),
+                success: ts.factory.createTrue(),
+                failure: (input, expected) =>
+                    create_throw_error(importer)(expected)(input),
+            });
 
     const explore_objects =
         (importer: FunctionImporter) =>
@@ -269,75 +274,74 @@ export namespace PruneProgrammer {
     const FUNCTORS = "$po";
     const UNIONERS = "$pu";
 
-    const CONFIG = (
-        project: IProject,
-        importer: FunctionImporter,
-    ): FeatureProgrammer.IConfig => ({
-        types: {
-            input: (type, name) =>
-                ts.factory.createTypeReferenceNode(
-                    name ?? TypeFactory.getFullName(project.checker, type),
-                ),
-            output: () => TypeFactory.keyword("void"),
-        },
-        functors: FUNCTORS,
-        unioners: UNIONERS,
-        trace: false,
-        path: false,
-        initializer,
-        decoder: decode(project, importer),
-        objector: OBJECTOR(project, importer),
-    });
-
-    const OBJECTOR = (
-        project: IProject,
-        importer: FunctionImporter,
-    ): FeatureProgrammer.IConfig.IObjector => ({
-        checker: IsProgrammer.decode(project, importer),
-        decoder: decode_object(importer),
-        joiner: PruneJoiner.object,
-        unionizer: decode_union_object(IsProgrammer.decode_object(importer))(
-            decode_object(importer),
-        )((exp) => exp)((value, expected) =>
-            create_throw_error(importer, value, expected),
-        ),
-        failure: (input, expected) =>
-            create_throw_error(importer, input, expected),
-    });
-
-    const initializer: FeatureProgrammer.IConfig["initializer"] = (
-        { checker },
-        type,
-    ) => {
-        const collection = new MetadataCollection();
-        const meta = MetadataFactory.generate(checker, collection, type, {
-            resolve: false,
-            constant: true,
+    const configure =
+        (project: IProject) =>
+        (importer: FunctionImporter): FeatureProgrammer.IConfig => ({
+            types: {
+                input: (type, name) =>
+                    ts.factory.createTypeReferenceNode(
+                        name ?? TypeFactory.getFullName(project.checker)(type),
+                    ),
+                output: () => TypeFactory.keyword("void"),
+            },
+            functors: FUNCTORS,
+            unioners: UNIONERS,
+            trace: false,
+            path: false,
+            initializer,
+            decoder: decode(project)(importer),
+            objector: objector(project)(importer),
         });
-        return [collection, meta];
-    };
 
-    const create_throw_error = (
-        importer: FunctionImporter,
-        value: ts.Expression,
-        expected: string,
-    ) =>
-        ts.factory.createExpressionStatement(
-            ts.factory.createCallExpression(
-                importer.use("throws"),
-                [],
-                [
-                    ts.factory.createObjectLiteralExpression(
-                        [
-                            ts.factory.createPropertyAssignment(
-                                "expected",
-                                ts.factory.createStringLiteral(expected),
-                            ),
-                            ts.factory.createPropertyAssignment("value", value),
-                        ],
-                        true,
-                    ),
-                ],
+    const objector =
+        (project: IProject) =>
+        (importer: FunctionImporter): FeatureProgrammer.IConfig.IObjector => ({
+            checker: IsProgrammer.decode(project, importer),
+            decoder: decode_object(importer),
+            joiner: PruneJoiner.object,
+            unionizer: decode_union_object(
+                IsProgrammer.decode_object(importer),
+            )(decode_object(importer))((exp) => exp)((value, expected) =>
+                create_throw_error(importer)(expected)(value),
             ),
-        );
+            failure: (input, expected) =>
+                create_throw_error(importer)(expected)(input),
+        });
+
+    const initializer: FeatureProgrammer.IConfig["initializer"] =
+        ({ checker }) =>
+        (type) => {
+            const collection = new MetadataCollection();
+            const meta = MetadataFactory.analyze(checker)({
+                resolve: false,
+                constant: true,
+            })(collection)(type);
+            return [collection, meta];
+        };
+
+    const create_throw_error =
+        (importer: FunctionImporter) =>
+        (expected: string) =>
+        (value: ts.Expression) =>
+            ts.factory.createExpressionStatement(
+                ts.factory.createCallExpression(
+                    importer.use("throws"),
+                    [],
+                    [
+                        ts.factory.createObjectLiteralExpression(
+                            [
+                                ts.factory.createPropertyAssignment(
+                                    "expected",
+                                    ts.factory.createStringLiteral(expected),
+                                ),
+                                ts.factory.createPropertyAssignment(
+                                    "value",
+                                    value,
+                                ),
+                            ],
+                            true,
+                        ),
+                    ],
+                ),
+            );
 }

package/src/programmers/RandomProgrammer.ts

@@ -20,63 +20,74 @@ import { RandomRanger } from "./helpers/RandomRanger";
 import { random_custom } from "./internal/random_custom";
 
 export namespace RandomProgrammer {
-    export function generate(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        init?: ts.Expression,
-    ) {
-        const importer: FunctionImporter = new FunctionImporter();
-        return (type: ts.Type, name?: string) => {
-            // INITIALIZE METADATA
-            const collection: MetadataCollection = new MetadataCollection();
-            const meta: Metadata = MetadataFactory.generate(
-                project.checker,
-                collection,
-                type,
-                {
-                    resolve: true,
-                    constant: true,
-                },
-            );
+    /**
+     * @deprecated Use `write()` function instead
+     */
+    export const generate =
+        (
+            project: IProject,
+            modulo: ts.LeftHandSideExpression,
+            init?: ts.Expression,
+        ) =>
+        (type: ts.Type, name?: string) =>
+            write(project)(modulo)(init)(type, name);
 
-            // GENERATE FUNCTION
-            const functors: ts.VariableStatement[] =
-                generate_functors(importer)(collection);
-            const output: ts.Expression = decode(importer)({
-                object: false,
-                recursive: false,
-            })(meta, [], []);
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (init?: ts.Expression) => {
+            const importer: FunctionImporter = new FunctionImporter();
+            return (type: ts.Type, name?: string) => {
+                // INITIALIZE METADATA
+                const collection: MetadataCollection = new MetadataCollection();
+                const meta: Metadata = MetadataFactory.analyze(project.checker)(
+                    {
+                        resolve: true,
+                        constant: true,
+                    },
+                )(collection)(type);
 
-            return ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [
-                    IdentifierFactory.parameter(
-                        "generator",
-                        ts.factory.createTypeReferenceNode(
-                            "Partial<typia.IRandomGenerator>",
-                        ),
-                        init ??
-                            ts.factory.createToken(ts.SyntaxKind.QuestionToken),
-                    ),
-                ],
-                ts.factory.createTypeReferenceNode(
-                    `typia.Primitive<${
-                        name ?? TypeFactory.getFullName(project.checker, type)
-                    }>`,
-                ),
-                undefined,
-                ts.factory.createBlock(
+                // GENERATE FUNCTION
+                const functors: ts.VariableStatement[] =
+                    generate_functors(importer)(collection);
+                const output: ts.Expression = decode(importer)({
+                    object: false,
+                    recursive: false,
+                })(meta, [], []);
+
+                return ts.factory.createArrowFunction(
+                    undefined,
+                    undefined,
                     [
-                        ...importer.declare(modulo),
-                        ...functors,
-                        ts.factory.createReturnStatement(output),
+                        IdentifierFactory.parameter(
+                            "generator",
+                            ts.factory.createTypeReferenceNode(
+                                "Partial<typia.IRandomGenerator>",
+                            ),
+                            init ??
+                                ts.factory.createToken(
+                                    ts.SyntaxKind.QuestionToken,
+                                ),
+                        ),
                     ],
-                    true,
-                ),
-            );
+                    ts.factory.createTypeReferenceNode(
+                        `typia.Primitive<${
+                            name ??
+                            TypeFactory.getFullName(project.checker)(type)
+                        }>`,
+                    ),
+                    undefined,
+                    ts.factory.createBlock(
+                        [
+                            ...importer.declare(modulo),
+                            ...functors,
+                            ts.factory.createReturnStatement(output),
+                        ],
+                        true,
+                    ),
+                );
+            };
         };
-    }
 
     const generate_functors =
         (importer: FunctionImporter) => (collection: MetadataCollection) =>
@@ -409,5 +420,4 @@ const COALESCE = (importer: FunctionImporter) => (name: string) =>
             ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
             ts.factory.createIdentifier(name),
         ),
-        IdentifierFactory.join(importer.use("generator"), name),
-    );
+    )(IdentifierFactory.join(importer.use("generator"))(name));