On 3/5/22 12:48, bauss wrote:
> This is where compile-time has its limits compared to runtime type creation, because templates only live during compile-time then it isn't really that easy to do something like this, where it would be trivial in other languages like C#.

That's something I don't really get. I totally understand that you can't instantiate the template during runtime, but why can't already instantiated classes be registered just like non-templated ones?

I tried the following snippet, and couldn't find C!int.C anywhere, although it **must** be there: I can get the `TypeInfo_Class` object, so I can clearly create new instances at runtime:

```d
import std.stdio : writeln;

class C(T) {}
class D {}

void main() {
    auto c = new C!int();
    auto c2 = typeid(c).create();
    auto d = new D();
    writeln(typeid(c).name);
    writeln(typeid(c2).name);
    writeln(typeid(d).name);
    writeln("----");
    writeln;
    writeln;
    foreach (m; ModuleInfo) {
        if (m) {
            writeln(m.name);
            writeln("--------------------");
            foreach (c; m.localClasses) {
                if (c) {
            		writeln(c.name);
                }
            }
            writeln;
        }
    }
}
```

On Tuesday, 3 May 2022 at 09:42:45 UTC, cc wrote:
> something I can pass to `Object.factory`.

Object.factory is useless and will hopefully be removed someday.

Instead, make your own factory registration function.

Put a static constructor in the class which appends a factory delegate to an array or something you can use later. Then you can use your own thing to construct registered objects.

On 3/5/22 14:46, Adam D Ruppe wrote:
> Put a static constructor in the class which appends a factory delegate to an array or something you can use later. Then you can use your own thing to construct registered objects.

I'd like to do a runtime registration system myself, using a "template this" static constructor. A simple version supporting only default constructors would be:

```d
module test;

import std.stdio : writeln;

class MyObject {
	
    /* static */ this(this T)() {
        string type = typeid(T).name;
        if (type !in generators) {
            generators[type] = () => new T();
        }
    }

    static MyObject factory(string type) {
        if(type in generators) {
            return generators[type]();
        } else {
            return null;
        }
    }

    private:
    static MyObject function()[string] generators;
}

class MyClass : MyObject {
    this() {
        writeln("Creating MyClass");
    }
}

void main() {
    auto _ = new MyClass(); // Shouldn't be needed
    auto myClass = MyObject.factory("test.MyClass");
}
```

Unfortunately, this isn't currently possible:

https://issues.dlang.org/show_bug.cgi?id=10488
https://issues.dlang.org/show_bug.cgi?id=20277

(notice the big number of duplicates).

The closest feasible option is to put it in a non-static constructor, and that's suboptimal: it forces an instantiation of the class, and it will be run at every instantiation.

Alternatively, instruct the users to create a static constructor for each of the classes they'd like registered (perhaps through a mixin), but that's also quite cumbersome.

On Tuesday, 3 May 2022 at 13:25:14 UTC, Arafel wrote:
> I'd like to do a runtime registration system myself, using a "template this" static constructor. A simple version supporting only default constructors would be:

Yeah, you can't template this a static constructor, but you can just use a static constructor. It will have to be mixed into each child class though, and the compiler won't help to remind you.

But do something along the lines of:


```d
module factory.register;

private Object function()[string] factories;

Object construct(string name) {
        if(auto f = name in factories)
                return (*f)();
        return null;
}

mixin template Register() {
        static this() {
                import factory.register;

                alias This = typeof(this);

                // bypassing private
                __traits(getMember, factory.register, "factories")
                [This.mangleof] = function Object() {
                        // you could even delegate to a static
                        // function if one is present, or pass arguments
                        // etc. this impossible with Object.factory
                        return new This();
                };
        }
}
```

That code is your library. Then, to use it:


```d
import factory.register;

class MyThing {
        // you have to remember to do this in each child
        mixin Register;
}

void main() {
        auto t = new MyThing();

        // I used the mangle instead of the FQN since it
        // is easier.
        Object o = construct(typeof(t).mangleof);
        MyThing t2 = cast(MyThing) o;
        assert(t2 !is null); // assert it actually worked
}
```




Now, you can extend this a little if you're willing to add an interface too. And if you forget to register the base class, the interface method being not implemented will remind user they did something wrong, and you can runtime assert to check child classes.

Check this out:


```d
module factory.register;

private Object function()[string] factories;

Object construct(string name) {
        if(auto f = name in factories)
                return (*f)();
        return null;
}

// adding this for the assert
bool typeIsRegistered(string name) {
        return (name in factories) !is null;
}

// this interface gives runtime access to the info we need
interface Serializable {
        string typeCode() const;
}

mixin template Register() {
        // interface implementation
        override string typeCode() const {
                // casting away const for more consistent names
                alias no_const = typeof(cast() this);

                auto name = no_const.mangleof;

                // a runtime check to help remind you if something not registered
                import factory.register;
                assert(typeIsRegistered(name), "Type "~typeof(this).stringof~" not registered!");

                // also making sure the child class was registered
                // by ensuring the runtime type is the same as the static type
                assert(typeid(this) == typeid(no_const), "Child class "~typeid(this).toString()~" was not registered!");

                return name;
        }

        static this() {
                import factory.register;

                alias This = typeof(this);

                // bypassing private
                __traits(getMember, factory.register, "factories")
                [This.mangleof] = function Object() {
                        // you could even delegate to a static
                        // function if one is present, or pass arguments
                        // etc. this impossible with Object.factory
                        return new This();
                };
        }
}


```


And the usage:


```d

import factory.register;

class MyThing : Serializable {
        mixin Register;
}

class Child : MyThing {
        // forgot to register uh oh
        // mixin Register;
}

void main() {
        auto t = new MyThing();

        Object o = construct(typeof(t).mangleof);
        MyThing t2 = cast(MyThing) o;
        assert(t2 !is null);

        auto child = new Child();
        // if we called this in the serialize function or even one of those constructors' contracts
        // it can verify things work by triggering the asserts back in the library implementation
        child.typeCode();
}
```



So doing things yourself gives you some control.

On 3/5/22 15:57, Adam D Ruppe wrote:
> So doing things yourself gives you some control.

Yes, it is indeed possible (I acknowledged it), but I think it's much more cumbersome than it should, and puts the load on the user.

If templated this worked in static context (ideally everywhere else too), then we'd be able to implement RTTI in a 100% "pay as you go" way: just inherit from SerializableObject, or perhaps add a mixin to your own root class, and that'd be it.

Actually, it would be cool to do it through an interface, although I don't think an interface's static constructors are invoked by the implementing classes... it would be cool, though.

And, in one of the bugs, you argue yourself that according to the spec, it *should* work. So please let me just whine... I mean, raise awareness ;-), in case somebody thinks it's interesting and feels brave enough to have a go at it.

I'd try it myself, but I wouldn't know where to start. Compiler internals are way beyond my comfort zone...

On Tuesday, 3 May 2022 at 14:38:53 UTC, Arafel wrote:
> Actually, it would be cool to do it through an interface, although I don't think an interface's static constructors are invoked by the implementing classes... it would be cool, though.

yeah interfaces can't have constructors.

> I'd try it myself, but I wouldn't know where to start. Compiler internals are way beyond my comfort zone...

Believe it or not, you don't need to touch the compiler. Open your druntime's object.d and search for `RTInfo`

http://druntime.dpldocs.info/object.RTInfo.html

That is instantiated for every user defined type in the program and you have the compile time info..... all druntime uses it for is a tiny bit of GC info and even then only sometimes.

But it could do so so so much more. Including doing custom factories and runtime reflection buildups!