Anyone have any thoughts on this? What I'm trying to figure out is a way to
dispatch on different elements all in the same collection, without
declaring the collection to be of abstract type. Meaning `func(a::Foo)` and
`func(a::Bar)` should be different, even though `Bar` and `Foo` have the
same internal representation (should be no underlying difference in memory).
This boils down to wondering if having a collection of an unparametrized
parametric type is better/different than just an abstract type. Reiterating
my example from above:
Option 1:
abstract Root
type Foo <: Root
...
end
type Bar <: Root
...
end
(the ... are the same for both Foo and Bar)
Option 2:
type Root
...
end
typealias Foo Root{:Foo}
typealias Bar Root{:Bar}
Would either option generate better code when iterating over a collection
of `Root`? Or is `Root` in option 2 still treated the same as an abstract
parameter (even though the internal structure is invariant among all
parametrizations)?
