Hello all. In my application I came across a desire to store an
ordered array of handles that could point to one of several
different objects, and it seems like the tool I want for that is
SumType.
I started with something like (simplified of course):
```d
class Foo {}
class Bar {}
alias Item = SumType!(Foo, Bar);
```
And then I could do:
```d
Item[] items;
items ~= Item(new Foo());
```
But, I found I wanted while iterating through my items to
sometimes only operate on those of a certain type. Rather than
having to call SumType.match! and specify patterns to test if
they had the type I wanted, I wanted a more concise syntax, and
also the ability to just directly extract the handle, or null if
the item kind wasn't what I was asking for.
So I came up with:
```d
struct Item
{
SumType!(Foo, Bar) item;
alias item this;
this(T)(T v)
{
item = v;
}
bool is_a(T)()
{
return item.match!(
(T v) => true,
_ => false);
}
T get(T)()
{
return item.match!(
(T v) => v,
_ => null);
}
}
```
This seems to give me the syntax that I want, so I can do things
like:
```d
foreach (item; items)
{
if (Foo foo = item.get!Foo)
{
/* do something with foo */
}
}
```
I realized that I could stick with defining `Item` as an `alias`
and use UFCS to define global `is_a` or `get`, but I prefer
having `is_a` and `get` scoped to the `Item` struct instead of
globally defined.
Questions:
1. Would there be something more appropriate than SumType for
what I'm trying to do?
2. Am I missing anything with a short syntax like my is_a() or
get() that already exists in SumType so I wouldn't need to define
my own struct to wrap it?
3. If not, could something like these two be added to SumType for
more direct access?
4. Any other general improvements to my solution?
