There is no way to dynamically (enum type selected at run-time) instantiate an enum
without using a type-unsafe (Dynamic arguments) and switch.  This is boilerplate
coding which the compiler should be able to do and make it type-safe.  I have shown
how it should work (see single line "var morphed"):

http://copute.com/dev/docs/Copute/ref/class.html#Enumerated_Inheritance

The only way that single line can currently be done in HaXe is:

var morphed = clone<int>( c, [0xFF, Rgb<int>( 0, 0, 0 )] )

function clone( c : Color<T>, args : Array<Dynamic> ) : Color<T>
{
  switch( c )
  {
  case Rgb<T>( r, g, b ):
     return Alpha<T>( args[0], args[1], args[2] )
  case Alpha<T>( a, c ):
     return Alpha<T>( args[0], args[1] )
  default:
  }
}

I came across this issue when designing a compiler (for Copute) where I want each
terminal token to be an enum, and I have hard-coded the map of token regular
expressions (e.g. [0-9] for Terminal.Int) to these enums from the grammar, but the
enum is created at run-time by the lexer to fill it with the value from the regular
expression.

So I instead of forcing me to make an unnecessary giant switch (which has to be
maintained every time I add a new constructor to the enum Color<T>), which is not
type-safe, I prefer to suggest the optimization at the link above.  Any way, I am
just sharing, if you do not like this, then do not implement it.

I see Nicolas CannASSe marked this "Won't Fix" for HaXe (he continues to fight all my
contribution to HaXe):

https://code.google.com/p/haxe/issues/detail?id=91#c1

No worries, I will implement it in Copute.  I was only sharing and trying to help.