public class Foo {
private static const MAGIC_NUM:Number = Math.random();
private static const INSTANCE:Foo = new Foo(MAGIC_NUM);

public function Foo(_magicNum) {
if (_magicNum != MAGIC_NUM)
throw new Error("Singleton, dummy!");
}

public function getInstance():Foo
{
return INSTANCE;
}
}

package {
	final public class ColorEnum  {
		//STATIC
		public static const BLACK:ColorEnum = new ColorEnum(0x000000,null);
		public static const WHITE:ColorEnum = new ColorEnum(0xFFFFFF,null);

		//INSTANCE
		private var _color:uint

		public function get color():uint  {
			return _color
		}

		function ColorEnum(color:uint,block_:block_constructor)  {
			if (ColorEnum) throw new Error("You can't instantiate ColorEnum");
			_color = color;
		}
	}
}

class block_constructor {}

The static initializer has a subtle benefit: no race condition. It's theoretically possible with the constructor-conditional method that two threads could instantiate objects at the same time and you end up with to singletons. Currently, the Adobe Flash player is single threaded so it's not actually possible, but that's an implementation detail.

Because the static initializer happens at class load time, and you'll never see the same class loaded more than once, you're safe. A subtle point, and with the current implementation an irrelevant one, but still worth mentioning, I think.

package foo
{
class Singleton
{
private static const m_instance:Singleton = new Singleton();

public function Singleton()
{
if (m_instance != null) throw new Error("Noooooooo!!!!");
// one time init code here
}

public static function getInstance():Singleton
{
return m_instance;
}
}
}

Static initializers are cool though. Thanks for the post!