On Friday, 1 May 2015 at 11:01:29 UTC, Chris wrote:
> This aside, how would I get something to load dynamically? It's either "mismatched function return type" or (with type check) "variable X cannot be read at compile time":
>
> void main(string[] args) {
>  auto type = args[1];
>  auto myType = factory!type();
> }
>
> So it's back to classes/interfaces again? Hmmmm.

Obviously, myType's static type and factory's return type can't depend on a dynamic value like args[1].

You could let factory return a std.variant.Variant, but at that point maybe just go with classes.

On Friday, 1 May 2015 at 11:11:28 UTC, biozic wrote:
> On Friday, 1 May 2015 at 11:01:29 UTC, Chris wrote:

>>
>> Thinking about it,
>>
>> T factory(T)() {
>>  return T();
>> }
>>
>> is better suited for a factory (with static type checks).
>
> But then I don't know what factory!X() provides that X() alone doesn't.

Just cleaner code with type checks

T factory(T)() {
  static if (is (T == A)
              || (is (T == B)))
    return T();
  else
    assert(0, "Type "~T.stringof~" is not supported");
}

and then you could have

auto getType(string type = "")() {
  static if (type == "A")
    return factory!A();
  else static if (type == "B")
    return factroy!B();
  else
    return factory!A();  // default
}

in order to separate the logic, i.e. the factory produces the type and performs all the type checks, whereas `getType` is the interface for the user.


>> This aside, how would I get something to load dynamically? It's either "mismatched function return type" or (with type check) "variable X cannot be read at compile time":
>>
>> void main(string[] args) {
>> auto type = args[1];
>> auto myType = factory!type();
>> }
>>
>> So it's back to classes/interfaces again? Hmmmm.
>
> Indeed. Runtime polymorphism is based on classes and interfaces. The struct and template solutions can only make "compile-time factories".

Yep. Only that "compile-time factories" kinda defeat the purpose.

On Friday, 1 May 2015 at 11:20:32 UTC, Chris wrote:
> On Friday, 1 May 2015 at 11:11:28 UTC, biozic wrote:
>> On Friday, 1 May 2015 at 11:01:29 UTC, Chris wrote:
>
>>>
>>> Thinking about it,
>>>
>>> T factory(T)() {
>>> return T();
>>> }
>>>
>>> is better suited for a factory (with static type checks).
>>
>> But then I don't know what factory!X() provides that X() alone doesn't.
>
> Just cleaner code with type checks
>
> T factory(T)() {
>   static if (is (T == A)
>               || (is (T == B)))
>     return T();
>   else
>     assert(0, "Type "~T.stringof~" is not supported");
> }
>
> and then you could have
>
> auto getType(string type = "")() {
>   static if (type == "A")
>     return factory!A();
>   else static if (type == "B")
>     return factroy!B();
>   else
>     return factory!A();  // default
> }
>
> in order to separate the logic, i.e. the factory produces the type and performs all the type checks, whereas `getType` is the interface for the user.

A "factory" that produces a *type* could be:
--
template checked(T) {
    static if (is (T == A) || (is (T == B)))
      alias checked = T;
    else
      static assert(0, "Type "~T.stringof~" is not supported");
}
--