22:03 <Perelandric> If I have an `var a: Array[Foo | Bar]` where `Foo` and `Bar` are primitives...

22:03 <Perelandric> should it be possible to assign an array literal?

22:04 <Perelandric> Like: `var a: Array[(Foo | Bar)] = [Foo, Foo]`

22:04 <Perelandric> Because it sees the Array literal as `Array[Foo]` when I try it.

22:05 <Perelandric> "Array[Foo val] ref has different type arguments than Array[(Foo val | Bar val)] ref"

22:12 <Praetonus> Perelandric: You can explicitly specify the element type of your array literal: `[as (Foo | Bar): Foo, Foo]`

22:20 <Perelandric> Thank you, Praetonus. That's what I was missing!

22:47 <Perelandric> Given: `type Foobar is ((Foo, USize) | (Bar, USize))` where `Foo` and `Bar` are still primitives.

22:47 <Perelandric> An assignment succeeds: `var test: Foobar = (Foo, USize(2))` ...

22:48 <Perelandric> But attempting to read from the tuple fails: `Debug(test._2.string())`

22:48 <Perelandric> "Error: can't lookup by name on a tuple" ... "Error: couldn't find _2 in (Foo val, USize val)"

22:49 <Perelandric> Seem like a bug? Or am I abusing the type system a little too much?

22:54 <Perelandric> https://gist.github.com/Perelandric/cb7b4774cbbe739b97b83907df97088e

22:57 <Praetonus> Perelandric: I think what you're trying to do is impossible, but the compiler is giving you a really unhelpful error message. The thing with union types is that you can't access a field directly even if it exists in every member of the union, because the field layout of the members may differ

22:58 <Praetonus> Could you open an issue for that?

22:59 <Perelandric> That makes sense. I would need to use a `match` in any other situation, so here too.

22:59 <Perelandric> Yes, I'll open an issue in a little bit. Thanks again!