typia 3.8.8 → 3.9.0-dev.20230603

package/src/metadata/Metadata.ts

@@ -1,49 +1,44 @@
 import { Atomic } from "../typings/Atomic";
 import { ClassProperties } from "../typings/ClassProperties";
+import { Writable } from "../typings/Writable";
 
 import { ArrayUtil } from "../utils/ArrayUtil";
 
 import { IMetadata } from "./IMetadata";
-import { IMetadataObject } from "./IMetadataObject";
+import { IMetadataCollection } from "./IMetadataCollection";
+import { IMetadataDictionary } from "./IMetadataDictionary";
+import { MetadataArray } from "./MetadataArray";
 import { MetadataConstant } from "./MetadataConstant";
+import { MetadataDefinition } from "./MetadataDefinition";
 import { MetadataObject } from "./MetadataObject";
 import { MetadataProperty } from "./MetadataProperty";
+import { MetadataTuple } from "./MetadataTuple";
 
 export class Metadata {
-    public readonly any: boolean;
-    public readonly required: boolean;
-    public readonly optional: boolean;
-    public readonly nullable: boolean;
-    public readonly functional: boolean;
-
-    public readonly resolved: Metadata | null;
-    public readonly atomics: Atomic.Literal[];
-    public readonly constants: MetadataConstant[];
-    public readonly templates: Metadata[][];
-
-    public readonly rest: Metadata | null;
-    public readonly arrays: Metadata[];
-    public readonly tuples: Metadata[][];
-    public readonly objects: MetadataObject[];
-
-    public readonly natives: string[];
-    public readonly sets: Metadata[];
-    public readonly maps: Metadata.Entry[];
-
-    /**
-     * @internal
-     */
-    private name_: string | undefined = undefined;
-
-    /**
-     * @internal
-     */
-    private parent_resolved_: boolean = false;
-
-    /**
-     * @internal
-     */
-    public union_index?: number;
+    public any: boolean;
+    public required: boolean;
+    public optional: boolean;
+    public nullable: boolean;
+    public functional: boolean;
+
+    public resolved: Metadata | null;
+    public atomics: Atomic.Literal[];
+    public constants: MetadataConstant[];
+    public templates: Metadata[][];
+
+    public rest: Metadata | null;
+    public arrays: MetadataArray[];
+    public tuples: MetadataTuple[];
+    public objects: MetadataObject[];
+    public definitions: MetadataDefinition[];
+
+    public natives: string[];
+    public sets: Metadata[];
+    public maps: Metadata.Entry[];
+
+    /** @internal */ private name_?: string;
+    /** @internal */ private parent_resolved_: boolean = false;
+    /** @internal */ public union_index?: number;
 
     /* -----------------------------------------------------------
         CONSTRUCTORS
@@ -67,6 +62,7 @@ export class Metadata {
         this.arrays = props.arrays;
         this.tuples = props.tuples;
         this.objects = props.objects;
+        this.definitions = props.definitions;
 
         this.natives = props.natives;
         this.sets = props.sets;
@@ -98,6 +94,7 @@ export class Metadata {
             arrays: [],
             tuples: [],
             objects: [],
+            definitions: [],
 
             rest: null,
             natives: [],
@@ -124,11 +121,10 @@ export class Metadata {
             resolved: this.resolved ? this.resolved.toJSON() : null,
 
             rest: this.rest ? this.rest.toJSON() : null,
-            arrays: this.arrays.map((meta) => meta.toJSON()),
-            tuples: this.tuples.map((meta) =>
-                meta.map((meta) => meta.toJSON()),
-            ),
+            arrays: this.arrays.map((array) => array.name),
+            tuples: this.tuples.map((tuple) => tuple.name),
             objects: this.objects.map((obj) => obj.name),
+            definitions: this.definitions.map((def) => def.name),
 
             natives: this.natives.slice(),
             sets: this.sets.map((meta) => meta.toJSON()),
@@ -139,29 +135,66 @@ export class Metadata {
         };
     }
 
-    public static from(meta: IMetadata, objects: IMetadataObject[]): Metadata {
-        const dict: Map<string, MetadataObject> = new Map();
-        for (const obj of objects)
-            dict.set(obj.name, MetadataObject._From_without_properties(obj));
+    public static from(
+        meta: IMetadata,
+        collection: IMetadataCollection,
+    ): Metadata {
+        const dict: IMetadataDictionary = {
+            objects: new Map(
+                collection.objects.map((obj) => [
+                    obj.name,
+                    MetadataObject._From_without_properties(obj),
+                ]),
+            ),
+            definitions: new Map(
+                collection.definitions.map((def) => [
+                    def.name,
+                    MetadataDefinition._From_without_value(def),
+                ]),
+            ),
+            arrays: new Map(
+                collection.arrays.map((arr) => [
+                    arr.name,
+                    MetadataArray._From_without_value(arr),
+                ]),
+            ),
+            tuples: new Map(
+                collection.tuples.map((tpl) => [
+                    tpl.name,
+                    MetadataTuple._From_without_elements(tpl),
+                ]),
+            ),
+        };
 
-        for (const obj of objects) {
-            const initialized = dict.get(obj.name)!;
+        for (const obj of collection.objects) {
+            const initialized = dict.objects.get(obj.name)!;
             initialized.properties.push(
                 ...obj.properties.map((prop) =>
                     MetadataProperty._From(prop, dict),
                 ),
             );
         }
+        for (const def of collection.definitions)
+            Writable(dict.definitions.get(def.name)!).value = this._From(
+                def.value,
+                dict,
+            );
+        for (const array of collection.arrays)
+            Writable(dict.arrays.get(array.name)!).value = this._From(
+                array.value,
+                dict,
+            );
+        for (const tuple of collection.tuples)
+            Writable(dict.tuples.get(tuple.name)!).elements =
+                tuple.elements.map((elem) => this._From(elem, dict));
+
         return this._From(meta, dict);
     }
 
     /**
      * @internal
      */
-    public static _From(
-        meta: IMetadata,
-        objects: Map<string, MetadataObject>,
-    ): Metadata {
+    public static _From(meta: IMetadata, dict: IMetadataDictionary): Metadata {
         return this.create({
             any: meta.any,
             required: meta.required,
@@ -172,29 +205,49 @@ export class Metadata {
             constants: JSON.parse(JSON.stringify(meta.constants)),
             atomics: meta.atomics.slice(),
             templates: meta.templates.map((tpl) =>
-                tpl.map((meta) => this._From(meta, objects)),
+                tpl.map((meta) => this._From(meta, dict)),
             ),
-            resolved: meta.resolved ? this._From(meta.resolved, objects) : null,
+            resolved: meta.resolved ? this._From(meta.resolved, dict) : null,
 
-            rest: meta.rest ? this._From(meta.rest, objects) : null,
-            arrays: meta.arrays.map((meta) => this._From(meta, objects)),
-            tuples: meta.tuples.map((tuple) =>
-                tuple.map((meta) => this._From(meta, objects)),
-            ),
+            rest: meta.rest ? this._From(meta.rest, dict) : null,
+            arrays: meta.arrays.map((id) => {
+                const array = dict.arrays.get(id);
+                if (array === undefined)
+                    throw new Error(
+                        `Error on Metadata.from(): failed to find array "${id}".`,
+                    );
+                return array;
+            }),
+            tuples: meta.tuples.map((id) => {
+                const tuple = dict.tuples.get(id);
+                if (tuple === undefined)
+                    throw new Error(
+                        `Error on Metadata.from(): failed to find tuple "${id}".`,
+                    );
+                return tuple;
+            }),
             objects: meta.objects.map((name) => {
-                const found = objects.get(name);
+                const found = dict.objects.get(name);
                 if (found === undefined)
                     throw new Error(
                         `Error on Metadata.from(): failed to find object "${name}".`,
                     );
                 return found;
             }),
+            definitions: meta.definitions.map((def) => {
+                const found = dict.definitions.get(def);
+                if (found === undefined)
+                    throw new Error(
+                        `Error on Metadata.from(): failed to find definition "${def}".`,
+                    );
+                return found;
+            }),
 
             natives: meta.natives.slice(),
-            sets: meta.sets.map((meta) => this._From(meta, objects)),
+            sets: meta.sets.map((meta) => this._From(meta, dict)),
             maps: meta.maps.map((entry) => ({
-                key: this._From(entry.key, objects),
-                value: this._From(entry.value, objects),
+                key: this._From(entry.key, dict),
+                value: this._From(entry.value, dict),
             })),
         });
     }
@@ -203,7 +256,7 @@ export class Metadata {
         ACCESSORS
     ----------------------------------------------------------- */
     public getName(): string {
-        this.name_ ||= getName(this);
+        this.name_ ??= getName(this);
         return this.name_;
     }
 
@@ -214,18 +267,19 @@ export class Metadata {
         return (
             (this.resolved ? 1 : 0) +
             (this.functional ? 1 : 0) +
+            (this.rest ? this.rest.size() : 0) +
             this.templates.length +
             this.atomics.length +
             this.constants
                 .map((c) => c.values.length)
                 .reduce((x, y) => x + y, 0) +
-            (this.rest ? this.rest.size() : 0) +
             this.arrays.length +
             this.tuples.length +
-            this.objects.length +
             this.natives.length +
+            this.maps.length +
             this.sets.length +
-            this.maps.length
+            this.objects.length +
+            this.definitions.length
         );
     }
     public bucket(): number {
@@ -238,10 +292,11 @@ export class Metadata {
             (this.rest ? this.rest.size() : 0) +
             (this.arrays.length ? 1 : 0) +
             (this.tuples.length ? 1 : 0) +
-            (this.objects.length ? 1 : 0) +
             (this.natives.length ? 1 : 0) +
             (this.sets.length ? 1 : 0) +
-            (this.maps.length ? 1 : 0)
+            (this.maps.length ? 1 : 0) +
+            (this.objects.length ? 1 : 0) +
+            (this.definitions.length ? 1 : 0)
         );
     }
     public isConstant(): boolean {
@@ -284,49 +339,316 @@ export class Metadata {
     public isParentResolved(): boolean {
         return this.parent_resolved_;
     }
+
+    // /* -----------------------------------------------------------
+    //     COMBINERS
+    // ----------------------------------------------------------- */
+    // public computeEmpty(): boolean {
+    //     return this.computeSize() === 0;
+    // }
+
+    // public computeSize(): number {
+    //     return (this.computed_size_ ??=
+    //         (this.computeResolved() ? 1 : 0) +
+    //         (this.computeFunctional() ? 1 : 0) +
+    //         (this.computeRest() ? 1 : 0) +
+    //         this.computeTemplates().length +
+    //         this.computeAtomics().size +
+    //         [...this.computeConstants().values()]
+    //             .map((v) => v.size)
+    //             .reduce((a, b) => a + b, 0) +
+    //         this.computeArrays().length +
+    //         this.computeTuples().length +
+    //         this.computeObjects().length +
+    //         this.computeDefinitions().length +
+    //         this.computeNatives().size +
+    //         this.computeSets().length +
+    //         this.computeMaps().length);
+    // }
+
+    // public computeBucket(): number {
+    //     return (this.computed_bucket_ ??=
+    //         (this.computeResolved() ? 1 : 0) +
+    //         (this.computeFunctional() ? 1 : 0) +
+    //         (this.computeTemplates().length ? 1 : 0) +
+    //         (this.computeAtomics().size ? 1 : 0) +
+    //         (this.computeConstants().size ? 1 : 0) +
+    //         (this.computeRest() ? 1 : 0) +
+    //         (this.computeArrays().length ? 1 : 0) +
+    //         (this.computeTuples().length ? 1 : 0) +
+    //         (this.computeObjects().length ? 1 : 0) +
+    //         (this.computeNatives().size ? 1 : 0) +
+    //         (this.computeSets().length ? 1 : 0) +
+    //         (this.computeMaps().length ? 1 : 0));
+    // }
+
+    // public computeAny(): boolean {
+    //     return (this.computed_any_ ??= Metadata._Iterate([] as boolean[])(
+    //         (flags) => (meta) => flags.push(meta.any),
+    //     )(this).reduce((x, y) => x || y));
+    // }
+
+    // public computeRequired(): boolean {
+    //     return (this.computed_required_ ??= Metadata._Iterate([] as boolean[])(
+    //         (flags) => (meta) => flags.push(meta.required),
+    //     )(this).reduce((x, y) => x && y));
+    // }
+
+    // public computeOptional(): boolean {
+    //     return (this.computed_optional_ ??= Metadata._Iterate([] as boolean[])(
+    //         (flags) => (meta) => flags.push(meta.optional),
+    //     )(this).reduce((x, y) => x || y));
+    // }
+
+    // public computeNullable(): boolean {
+    //     return (this.computed_nullable_ ??= Metadata._Iterate([] as boolean[])(
+    //         (flags) => (meta) => flags.push(meta.nullable),
+    //     )(this).reduce((x, y) => x || y));
+    // }
+
+    // public computeFunctional(): boolean {
+    //     return (this.computed_functional_ ??= Metadata._Iterate(
+    //         [] as boolean[],
+    //     )((flags) => (meta) => flags.push(meta.any))(this).reduce(
+    //         (x, y) => x || y,
+    //     ));
+    // }
+
+    // public computeAtomics(): Set<Atomic.Literal> {
+    //     return (this.computed_atomics_ ??= Metadata._Iterate(
+    //         new Set<Atomic.Literal>(),
+    //     )((values) => (meta) => {
+    //         for (const atomic of meta.atomics) values.add(atomic);
+    //     })(this));
+    // }
+
+    // public computeConstants(): Map<Atomic.Literal, Set<Atomic.Type>> {
+    //     return (this.computed_constants_ ??= Metadata._Iterate(
+    //         new Map<Atomic.Literal, Set<Atomic.Type>>(),
+    //     )((container) => (meta) => {
+    //         for (const constant of meta.constants) {
+    //             const line = MapUtil.take(container)(
+    //                 constant.type,
+    //                 () => new Set(),
+    //             );
+    //             for (const v of constant.values) line.add(v);
+    //         }
+    //     })(this));
+    // }
+
+    // public computeTemplates(): Metadata[][] {
+    //     return (this.computed_templates_ ??= (() => {
+    //         const dict = Metadata._Iterate(new Map<string, Metadata[]>())(
+    //             (dict) => (meta) =>
+    //                 meta.templates.forEach((tpl) =>
+    //                     dict.set(tpl.map((t) => t.getName).join(","), tpl),
+    //                 ),
+    //         )(this);
+    //         return [...dict.values()];
+    //     })());
+    // }
+
+    // public computeResolved(): Metadata | null {
+    //     return (this.computed_resolved_ ??= this.resolved);
+    // }
+
+    // public computeRest(): Metadata | null {
+    //     return (this.computed_rest_ ??= this.rest);
+    // }
+
+    // public computeArrays(): Metadata[] {
+    //     return (this.computed_arrays_ ??= (() => {
+    //         const dict = Metadata._Iterate(new Map<string, Metadata>())(
+    //             (dict) => (meta) =>
+    //                 meta.arrays.forEach((array) =>
+    //                     dict.set(array.getName(), array),
+    //                 ),
+    //         )(this);
+    //         return [...dict.values()];
+    //     })());
+    // }
+
+    // public computeTuples(): Metadata[][] {
+    //     return (this.computed_tuples_ ??= (() => {
+    //         const dict = Metadata._Iterate(new Map<string, Metadata[]>())(
+    //             (dict) => (meta) =>
+    //                 meta.tuples.forEach((tpl) =>
+    //                     dict.set(tpl.map((t) => t.getName).join(","), tpl),
+    //                 ),
+    //         )(this);
+    //         return [...dict.values()];
+    //     })());
+    // }
+
+    // public computeNatives(): Set<string> {
+    //     return (this.computed_natives_ ??= Metadata._Iterate(new Set<string>())(
+    //         (values) => (meta) => {
+    //             for (const native of meta.natives) values.add(native);
+    //         },
+    //     )(this));
+    // }
+
+    // public computeSets(): Metadata[] {
+    //     return (this.computed_sets_ ??= (() => {
+    //         const dict = Metadata._Iterate(new Map<string, Metadata>())(
+    //             (dict) => (meta) =>
+    //                 meta.sets.forEach((set) => dict.set(set.getName(), set)),
+    //         )(this);
+    //         return [...dict.values()];
+    //     })());
+    // }
+
+    // public computeMaps(): Metadata.Entry[] {
+    //     return (this.computed_maps_ ??= (() => {
+    //         const dict = Metadata._Iterate(new Map<string, Metadata.Entry>())(
+    //             (dict) => (meta) =>
+    //                 meta.maps.forEach((m) =>
+    //                     dict.set(
+    //                         [m.key.getName(), m.value.getName()].join(","),
+    //                         m,
+    //                     ),
+    //                 ),
+    //         )(this);
+    //         return [...dict.values()];
+    //     })());
+    // }
+
+    // public computeObjects(): MetadataObject[] {
+    //     return (this.computed_objects_ ??= (() => {
+    //         const dict = Metadata._Iterate(new Map<string, MetadataObject>())(
+    //             (dict) => (meta) =>
+    //                 meta.objects.forEach((obj) => dict.set(obj.name, obj)),
+    //         )(this);
+    //         return [...dict.values()];
+    //     })());
+    // }
+
+    // public computeDefinitions(): MetadataDefinition[] {
+    //     return (this.computed_definitions_ ??= (() => {
+    //         const dict = Metadata._Iterate(
+    //             new Map<string, MetadataDefinition>(),
+    //         )(
+    //             (dict) => (meta) =>
+    //                 meta.definitions.forEach((def) => dict.set(def.name, def)),
+    //         )(this);
+    //         return [...dict.values()];
+    //     })());
+    // }
+
+    // public absorb(): void {
+    //     this._Absorb(new Set());
+    // }
+
+    // private _Absorb(visited: Set<Metadata>): void {
+    //     if (visited.has(this)) return;
+    //     visited.add(this);
+
+    //     if (this.size() === 1 && this.definitions.length === 1) return;
+
+    //     //----
+    //     // ITERATIONS
+    //     //----
+    //     if (this.resolved) this.resolved._Absorb(visited);
+    //     if (this.rest) this.rest._Absorb(visited);
+
+    //     for (const array of this.arrays) array._Absorb(visited);
+    //     for (const tuple of this.tuples)
+    //         for (const elem of tuple) elem._Absorb(visited);
+
+    //     for (const set of this.sets) set._Absorb(visited);
+    //     for (const map of this.maps) map.value._Absorb(visited);
+    //     for (const object of this.objects)
+    //         for (const property of object.properties)
+    //             property.value._Absorb(visited);
+    //     for (const definition of this.definitions)
+    //         definition.value._Absorb(visited);
+
+    //     //----
+    //     // MEMBERS
+    //     //----
+    //     // FLAGS
+    //     this.any = this.computeAny();
+    //     this.required = this.computeRequired();
+    //     this.optional = this.computeOptional();
+    //     this.nullable = this.computeNullable();
+    //     this.functional = this.computeFunctional();
+
+    //     // ATOMICS
+    //     this.atomics = [...this.computeAtomics()];
+    //     this.constants = [...this.computeConstants()].map(([type, values]) => ({
+    //         type,
+    //         values: [...values],
+    //     })) as MetadataConstant[];
+    //     this.templates = this.computeTemplates();
+
+    //     // INSTANCES
+    //     this.resolved = this.computeResolved();
+    //     this.rest = this.computeRest();
+    //     this.arrays = this.computeArrays();
+    //     this.tuples = this.computeTuples();
+    //     this.natives = [...this.computeNatives()];
+    //     this.maps = this.computeMaps();
+    //     this.sets = this.computeSets();
+    //     this.objects = this.computeObjects();
+    //     this.definitions = this.computeDefinitions();
+    // }
+
+    // private static _Iterate =
+    //     <T>(container: T) =>
+    //     (closure: (container: T) => (meta: Metadata) => any) => {
+    //         const visited: Set<string> = new Set();
+    //         const iterate = (meta: Metadata): T => {
+    //             closure(container)(meta);
+    //             for (const def of meta.definitions) {
+    //                 const name: string = def.value.getName();
+    //                 if (visited.has(name)) continue;
+    //                 visited.add(name);
+    //                 iterate(def.value);
+    //             }
+    //             return container;
+    //         };
+    //         return iterate;
+    //     };
+
+    // /** @internal */ private computed_size_?: number;
+    // /** @internal */ private computed_bucket_?: number;
+    // /** @internal */ private computed_any_?: boolean;
+    // /** @internal */ private computed_required_?: boolean;
+    // /** @internal */ private computed_optional_?: boolean;
+    // /** @internal */ private computed_nullable_?: boolean;
+    // /** @internal */ private computed_functional_?: boolean;
+    // /** @internal */ private computed_atomics_?: Set<Atomic.Literal>;
+    // /** @internal */ private computed_constants_?: Map<
+    //     Atomic.Literal,
+    //     Set<Atomic.Type>
+    // >;
+    // /** @internal */ private computed_templates_?: Metadata[][];
+    // /** @internal */ private computed_rest_?: Metadata | null;
+    // /** @internal */ private computed_resolved_?: Metadata | null;
+    // /** @internal */ private computed_arrays_?: Metadata[];
+    // /** @internal */ private computed_tuples_?: Metadata[][];
+    // /** @internal */ private computed_natives_?: Set<string>;
+    // /** @internal */ private computed_sets_?: Metadata[];
+    // /** @internal */ private computed_maps_?: Metadata.Entry[];
+    // /** @internal */ private computed_objects_?: MetadataObject[];
+    // /** @internal */ private computed_definitions_?: MetadataDefinition[];
 }
 export namespace Metadata {
-    export const intersects = (
-        x: Metadata,
-        y: Metadata,
-        deep: boolean,
-    ): boolean => {
+    export const intersects = (x: Metadata, y: Metadata): boolean => {
         // CHECK ANY & OPTIONAL
         if (x.any || y.any) return true;
         if (x.required === false && false === y.required) return true;
         if (x.nullable === true && true === y.nullable) return true;
+        if (x.functional === true && y.functional === true) return true;
 
         //----
         // INSTANCES
         //----
-        // ARRAYS AND OBJECTS
-        if (deep === true) {
-            for (const xa of x.arrays)
-                for (const ya of y.arrays)
-                    if (intersects(xa, ya, deep)) {
-                        return true;
-                    }
-            for (const xo of x.objects)
-                for (const yo of y.objects)
-                    if (MetadataObject.intersects(xo, yo)) {
-                        return true;
-                    }
-        } else {
-            if (x.arrays.length && y.arrays.length) return true;
-            if (x.objects.length && y.objects.length) return true;
-        }
-
-        // TUPLES
-        for (const xt of x.tuples)
-            for (const yt of y.tuples)
-                if (xt.length === 0 || yt.length === 0)
-                    return xt.length === 0 && yt.length === 0;
-                else if (
-                    xt
-                        .slice(0, Math.min(xt.length, yt.length))
-                        .some((xv, i) => intersects(xv, yt[i]!, deep))
-                )
-                    return true;
+        // ARRAYS
+        if (x.arrays.length && y.arrays.length) return true;
+        if (x.tuples.length && y.tuples.length) return true;
+        if (x.objects.length && y.objects.length) return true;
+        if (x.definitions.length && y.definitions.length) return true;
 
         //----
         // VALUES
@@ -349,46 +671,63 @@ export namespace Metadata {
             if (values.size !== constant.values.length + opposite.values.length)
                 return true;
         }
-
-        // FUNCTIONAL
-        if (x.functional === true && y.functional === true) return true;
-
         return false;
     };
 
-    export const covers = (x: Metadata, y: Metadata): boolean => {
+    export const covers = (
+        x: Metadata,
+        y: Metadata,
+        level: number = 0,
+    ): boolean => {
         // CHECK ANY
-        if (x.any) return true;
+        if (x === y) return false;
+        else if (x.any) return true;
         else if (y.any) return false;
 
         //----
         // INSTANCES
         //----
-        // ARRAYS
-        for (const ya of y.arrays)
-            if (x.arrays.some((xa) => covers(xa, ya) === true) === false)
-                return false;
+        if (level === 0) {
+            // ARRAYS
+            for (const ya of y.arrays)
+                if (
+                    !x.arrays.some((xa) =>
+                        covers(xa.value, ya.value, level + 1),
+                    )
+                ) {
+                    return false;
+                }
+
+            // TUPLES
+            for (const yt of y.tuples)
+                if (
+                    yt.elements.length !== 0 &&
+                    x.tuples.some(
+                        (xt) =>
+                            xt.elements.length >= yt.elements.length &&
+                            xt.elements
+                                .slice(yt.elements.length)
+                                .every((xv, i) =>
+                                    covers(xv, yt.elements[i]!, level + 1),
+                                ),
+                    ) === false
+                )
+                    return false;
+        }
 
         // OBJECTS
         for (const yo of y.objects)
             if (x.objects.some((xo) => MetadataObject.covers(xo, yo)) === false)
                 return false;
 
-        // TUPLES
-        for (const yt of y.tuples)
-            if (
-                yt.length !== 0 &&
-                x.tuples.some(
-                    (xt) =>
-                        xt.length >= yt.length &&
-                        xt
-                            .slice(yt.length)
-                            .every((xv, i) => covers(xv, yt[i]!)),
-                ) === false
-            )
+        // DEFINITIONS
+        for (const yd of y.definitions)
+            if (x.definitions.some((xd) => xd.name === yd.name) === false)
                 return false;
 
         // NATIVES
+        for (const yn of y.natives)
+            if (x.natives.some((xn) => xn === yn) === false) return false;
 
         // SETS
         for (const ys of y.sets)
@@ -422,6 +761,9 @@ export namespace Metadata {
         return true;
     };
 
+    /**
+     * @internal
+     */
     export const merge = (x: Metadata, y: Metadata): Metadata => {
         const output: Metadata = Metadata.create({
             any: x.any || y.any,
@@ -445,6 +787,7 @@ export namespace Metadata {
             arrays: x.arrays.slice(),
             tuples: x.tuples.slice(),
             objects: x.objects.slice(),
+            definitions: x.definitions.slice(),
 
             natives: [...new Set([...x.natives, ...y.natives])],
             sets: x.sets.slice(),
@@ -463,14 +806,13 @@ export namespace Metadata {
                 ArrayUtil.add(target.values, value);
         }
         for (const array of y.arrays)
-            ArrayUtil.set(output.arrays, array, (elem) => elem.getName());
+            ArrayUtil.set(output.arrays, array, (elem) => elem.name);
+        for (const tuple of y.tuples)
+            ArrayUtil.set(output.tuples, tuple, (elem) => elem.name);
         for (const obj of y.objects)
             ArrayUtil.set(output.objects, obj, (elem) => elem.name);
-
-        if (x.rest !== null)
-            ArrayUtil.set(output.arrays, x.rest, (elem) => elem.getName());
-        if (y.rest !== null)
-            ArrayUtil.set(output.arrays, y.rest, (elem) => elem.getName());
+        for (const def of y.definitions)
+            ArrayUtil.set(output.definitions, def, (elem) => elem.name);
 
         return output;
     };
@@ -513,15 +855,12 @@ const getName = (metadata: Metadata): string => {
     for (const map of metadata.maps)
         elements.push(`Map<${map.key.getName()}, ${map.value.getName()}>`);
 
-    // ARRAY
+    // INSTANCES
     if (metadata.rest !== null) elements.push(`...${metadata.rest.getName()}`);
-    for (const tuple of metadata.tuples)
-        elements.push(`[${tuple.map((elem) => elem.getName()).join(", ")}]`);
-    for (const array of metadata.arrays)
-        elements.push(`Array<${array.getName()}>`);
-
-    // OBJECT
+    for (const tuple of metadata.tuples) elements.push(tuple.name);
+    for (const array of metadata.arrays) elements.push(array.name);
     for (const object of metadata.objects) elements.push(object.name);
+    for (const def of metadata.definitions) elements.push(def.name);
     if (metadata.resolved !== null) elements.push(metadata.resolved.getName());
 
     // RETURNS