Discussion: Module Reflection - import.reflect

[Randy Buchholz]

Maybe my example was misleading by using an `import`. What I'm talking about is inspecting the module from within itself. Similar to `this` or `self`,  AFAIK, I can't get a reference to the module from within the module - e.g., `module`. Say, I'm in a module that has a default export of class "Foo". In a function *in* that module (or class), I want to create an instance of that default export. I can do it by name `new Foo()`. But, in more generic code, I need to do it by "role" - `default`. So my generic version wants something that represents `new module.default()`. This is because I may not have access to the name - say the function is in a base class. Take for example a "type" module, that is a wrapper for a single class, and the filename = class name. One way I can implement `instanceof` is a string approach:

```
    // Foo.mjs
    export default class Foo {
        static type = import.meta.url;

        meta = { type: import.meta.url };

        // instanceof
        static [Symbol.hasInstance](instance) {
            return instance.meta.type === Foo.type;
        }
    }
```
Some weaknesses are it's strings, and I need to know the name of the class (for `Foo.type`). So I can't move this to a base class.

With module reflection, I could do this with objects:
```
    // Foo.mjs
    export default class Foo {
        meta = { type: import.reflect.default };

        // instanceof
        static [Symbol.hasInstance](instance) {
            return instance.meta.type === import.reflect.default;
        }
    }
```

A similar idea would be to define a Module Scope - `module`. Within a module, using `module` would be like a "static self" - it works on the structure (e.g., definition) of the module.
Then `import.reflect.default`  could be `module.default`.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20190424/2369e3bc/attachment.html>