package
{

public class Singleton
{

private static var instance:Singleton;
private static var isLock:Boolean = true;

public function Singleton ()
{
if (isLock) throw new Error(‘ooops’) else isLock = true;
}

public static function getInstance ():Singleton
{
return instance ||= (isLock = false, new Singleton());
}

}

}

private static var __called : Boolean;
private static var __instance : Class;

public static function get instance() : Class {
Class.__called = true;
if(Class.__instance == null) Class.__instance = new Class();

return Class.__instance;
}

public function Class() {
if(__instance) throw Error(‘This class uses Singelton pattern.’);
else if(!__called) throw Error(‘You must access to class by Class.instance’);
}

var s : Singleton = new Singleton(null);

You have to explicitly check the nullity and type of the parameter:

public function Singleton(enforcer:*=null){
if(enforcer==null || !(enforcer is SingletonEnforcer))
throw new Error(“FAIL!”);
}

public static var get instance():Singleton { return getInstance(); }

and change all the instance to _instance (to avoid the conflict)?

The private static instance variable is instantiated on declaration. Simple and clean:

package
{
public class Singleton
{

private static var instance:Singleton = new Singleton();

public function Singleton()
{

if( instance ) throw new Error( “Singleton and can only be accessed through Singleton.getInstance()” );
}

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