On Tuesday, 20 October 2015 at 15:22:41 UTC, Vladimir Panteleev wrote:
> "This video is not available from your location".
> I haven't been able to find a mirror that's watchable from here either.
Same here, though I finally googled out it's key phrase: "It's a floor wax and a dessert topping!"
Pretty much explains Walter's suggestion :D

On 10/18/2015 09:00 PM, rcorre wrote:
> SuperStruct is a struct that acts like a class:
>
> ---
> struct Square {
>    float size;
>    float area() { return size * size; }
> }
>
> struct Circle {
>    float r;
>    float area() { return r * r * PI; }
> }
>
> alias Shape = SuperStruct!(Square, Circle);
>
> // look! polymorphism!
> Shape sqr = Square(2);
> Shape cir = Circle(4);
> Shape[] shapes = [ sqr, cir ];
>
> // call functions that are shared between the source types!
> assert(shapes.map!(x => x.area).sum.approxEqual(2 * 2 + 4 * 4 * PI));
> ---
>
> SuperStruct is basically a Variant that exposes the common members of
> its source
> types. You can check it out here:
>
> https://github.com/rcorre/superstruct
>
> I'm not quite sure if this is a good idea (or if it already exists in some
> form that I haven't seen), but it was fun to work on. There's a lot more
> info on
> the README if you're curious. Let me know what you think!

"A call signature for a given member is 'compatible'
 * if, for an instance of any one of `SubTypes`, that member can be called with
 * the provided set of arguments _and_ all such calls have a common return type."


Probably you could/should return your SuperStruct instead of the/when there is no common return type.

On Wednesday, 21 October 2015 at 23:09:52 UTC, Timon Gehr wrote:
> "A call signature for a given member is 'compatible'
>  * if, for an instance of any one of `SubTypes`, that member can be called with
>  * the provided set of arguments _and_ all such calls have a common return type."
>
>
> Probably you could/should return your SuperStruct instead of the/when there is no common return type.

Interesting idea! At first I thought you meant returning the original SuperStruct, but then I realized it could be a SuperStruct of the return types.

That could be really nice for functions that return different types of ranges, as your return type would just be 'something' that has 'front, top, empty, ect.'.

Come to think of it, SuperStruct actually sounds pretty similar to std.range.chooseAmong (which I just realized exists).

On 10/21/2015 3:28 PM, burjui wrote:
> On Tuesday, 20 October 2015 at 15:22:41 UTC, Vladimir Panteleev wrote:
>> "This video is not available from your location".
>> I haven't been able to find a mirror that's watchable from here either.
> Same here, though I finally googled out it's key phrase: "It's a floor wax and a
> dessert topping!"
> Pretty much explains Walter's suggestion :D

Dang, it was also yanked from youtube. What a shame. It's one of the all-time great SNL skits. Still makes me laugh after 40 years :-)

And it is a perfect metaphor for "is it a value, or is it a reference?"

On Thursday, 22 October 2015 at 02:35:34 UTC, rcorre wrote:
>
> Come to think of it, SuperStruct actually sounds pretty similar to std.range.chooseAmong (which I just realized exists).

It seems to work quite nicely as an alternative to choose that works with any types as opposed to just ranges:

auto pick(T...)(size_t index, T values) {
  foreach(idx, val ; values)
    if (idx == index)
      return SuperStruct!T(val);

  assert(0, "index not in range of provided values");
}

/// `pick` is useful for something that is a floor wax _and_ a dessert topping:
unittest {
  struct FloorWax       { string itIs() { return "a floor wax!";       } }
  struct DessertTopping { string itIs() { return "a dessert topping!"; } }

  auto shimmer(bool hungry) {
    return pick(hungry, FloorWax(), DessertTopping());
  }

  assert(shimmer(false).itIs == "a floor wax!");
  assert(shimmer(true ).itIs == "a dessert topping!");
}

I can't think of a time I've wanted to do this with something _other_ than a range, but hey, its there.