reification

Let's say I have a specialized class and an associated companion object: trait Slice[@specialized +T] { ... override def equals(that :Any) = that match { case s :Slice[_] => ??? case _ => false } } object Slice { def newInstance[@specialized T] = ??? } Is there any way to check Inside a method of Slice if this instance is a specialized subclass, Inside a method of Slice if another instance is a specialized subclass for the same primitive, Inside a specialized method on a companion object if I'm running an erased or specialized variant without resorting to ClassTags or passing Class[_] manually

I've been hearing a lot about different JVM languages, still in vaporware mode, that propose to implement reification somehow. I have this nagging half-remembered (or wholly imagined, don't know which) thought that somewhere I read that Scala somehow took advantage of the JVM's type erasure to do things that it wouldn't be able to do with reification. Which doesn't really make sense to me since Scala is implemented on the CLR as well as on the JVM, so if reification caused some kind of limitation it would show up in the CLR implementation (unless Scala on the CLR is just ignoring reification).

I have an interface that contains an array (or list) of T and some metadata. interface DataWithMetadata<T> { val someMetadata: Int fun getData(): Array<T> } If I write the simplest implementation of the interface, I get a compile error on the emptyArray() : "Cannot use T as a reified type parameter. Use a class instead." class ArrayWithMetadata<T>(override val someMetadata: Int): DataWithMetadata<T> { private var myData: Array<T> = emptyArray() override fun getData(): Array<T> { return myData } fun addData(moreData: Array<T>) { this.myData += moreData } } However, if I change both the

I know this question will probably provoke more discussion than concrete answers (which I know isn't preferable). But with the recent acquisition by Oracle, I was wondering if there's been any word that Java might (someday) get reified generics? I've heard that Oracle wants to give Java a bit of a boost, and I can think of no better way. There's a good article on the discussion of reified generics, here , that you should read in regards to Java. Basically it outlines some of the pitfalls that might happen with the introduction of such a change. It's fairly brutal for backwards compatibility

I read this term a lot in blogs about haskell and functional programming (specially in sigfpe's blog ) but I don't have a clue about what it means. I get away with not knowing it most of the times, but I probably would have understood the texts a lot better if I knew. Google didn't help me. I get lost in the technical stuff. Also the non-technical meaning of the world ("turning the abstract concrete") doesn't help me understand what it practically means to reify something in code. I'm kinda slow with computer science concepts, so practical examples with code would be nice. :P Vivin Paliath So

If I define the following generic event handler trait Handles[E <: Event] { def handle(event: E) } with event type's like this trait Event { } class InventoryItemDeactivated(val id: UUID) extends Event; class InventoryItemCreated(val id: UUID, val name: String) extends Event; how do I then make a single class that implements event handlers for each of these events ?. I tried: class InventoryListView extends Handles[InventoryItemCreated] with Handles[InventoryItemDeactivated] { def handle(event: InventoryItemCreated) = { } def handle(event: InventoryItemDeactivated) = { } } but Scala complains