Variant is just a class

[Josphe Brigmo]

On Friday, 7 September 2018 at 18:18:50 UTC, Neia Neutuladh wrote:
> On Friday, 7 September 2018 at 03:04:19 UTC, Josphe Brigmo 
> wrote:
>> We are talking about two different things that are related:
>>
>> A variant holds a set of objects. Using VariantClass limits 
>> the types to a subset and allows for inherited types to be 
>> added.
>
> Algebraic!SomeInterface should allow anything that inherits 
> from that interface (possibly with an explicit cast).

It doesn't.

import std.stdio, std.variant;

class A
{
}
class B : A { }

void main()
{
     B b;
     Algebraic!A a;
     a = b;

}

"Cannot store a B in a VariantN!(8LU, A). Valid types are (A)"


>> Why this is better is because it allows objects that may not 
>> have been inherited from some interface in the 
>> design(pre-existing).
>
> OOP is better when you don't trust people to implement types 
> correctly and you want them to get errors at the proper 
> location when they get it wrong.
>
> Structural typing is better when you don't trust people to 
> implement types correctly and you want to make things easier on 
> yourself when they don't.
>
> They're both useful. Most of the time, you're dealing with your 
> own types. Sometimes, you need a type you don't control to 
> implement an interface.
>
> the default way of making structural typing work in D is with 
> templates. You can also auto-generate a wrapper type.
>
>> Cool, I will check it out. It seems it would allow 
>> DuckingVariant to be created.
>
> It would allow you to make a wrapper type that works with a 
> wide range of types. It's probably worse on average than 
> writing a template to create a wrapper class that implements 
> the interface you need.
>
> I mean, the wrapper is pretty much (untested):
>
> class Wrapper(Interface, Wrapped): Interface
> {
>   Wrapped wrapped;
>   static foreach (member; __traits(allMembers, Interface))
>   {
>     static foreach (overload; __traits(getOverloads, Interface, 
> member))
>     {
>       mixin(`ReturnType!Overload ` ~ method ~ 
> `(Parameters!overload params)`
>       {
>         return wrapped.` ~ method ~ `(params);
>       }`);
>     }
>   }
> }
>
> And now you don't need a VariantClass!SomeInterface, just 
> SomeInterface.

One of the problems with the above is that it doesn't allow 
different 'Wrapped' to equate to the same type:

Wrapper!(I, A) != Wrapper!(I, B)

Although, by construction, they implement I

e.g., one couldn't make a variable

Wrapped!(I, A) a;

and put a Wrapped!(I,B) in it because D will think they are 
different types simply because the parameters are different.

I guess one needs to return a WrappedBase!I type that is common 
to all and does some magic to trick the compiler.




Although, maybe

Wrapped!(I, Object) a;

will allow this to work?