closure based prototypes using ephemeron tables

Bradley Meck · Bradley Meck · commit e01a3543fb94 · 2010-07-28T16:08:18.000-05:00
diff --git a/example/multiple_inheritence.js b/example/multiple_inheritence.js
@@ -37,7 +37,7 @@ var PrototypeChain = function(prototypes) {
   	}
   	, "delete": function(ArgInfo) {
   	}
-  } )
+  }, prototypes[prototypes.length-1] )
 }
 function mySuper() {}
 mySuper.prototype.fly = function() {
@@ -61,9 +61,15 @@ function myself(){}
 myself.prototype = proto
 
 var me = new myself
-me.fly()
-me.run()
-me.id()
+me.fly()//from superduper
+me.run()//from super
+me.id()//from identity
+
+console.log("Am I an Identity? "+(me instanceof myIdentity))
+//only one chain can be used for instanceof T_T
+console.log("Am I an Super? "+(me instanceof mySuperduper))
+
+//prototype chain changes are preserved!
 mySuper.prototype.run = function() {
 	console.log("Acting mild mannered I walk")
 }
diff --git a/example/sharing_closures.js b/example/sharing_closures.js
@@ -0,0 +1,57 @@
+//sharing closures can allow prototypal construction speed times while gaining access to a closure
+//and not just any closure, all closures to objects of a given type!
+var EphemeronTable = require("../lib/overload").EphemeronTable
+
+var MyType
+;(function(){
+	var closures = new EphemeronTable;
+	MyType = function() {
+		var myClosures = {views:0}
+		closures.set(this,myClosures)
+	}
+	var communicate = MyType.prototype.communicate = function(object) {
+		return closures.get(object)
+	}
+	MyType.prototype.view = function() {
+		return communicate(this).views++
+	}
+	MyType.prototype.views = function() {
+			return communicate(this).views
+	}
+	MyType.prototype.syncViewsWith = function(obj) {
+		communicate(this).views = communicate(obj).views
+	}
+})()
+var instance_a = new MyType
+  , instance_b = new MyType
+
+instance_a.view()
+instance_b.syncViewsWith(instance_a)
+console.log(instance_b.views())//1
+
+//making new prototypes is still possible!
+MyType.prototype.doubleView = (function(){
+	var communicate = MyType.prototype.communicate
+	return function() {
+		communicate(this).views += 2
+	}
+})()
+instance_a.doubleView()
+
+//since communicate is available you can still access closures until it isnt
+console.log(MyType.prototype.communicate(instance_a).views)//3
+delete MyType.prototype.communicate
+
+//Communicate is no longer available (kinda like sealing)
+try{
+	console.log(MyType.prototype.communicate(instance_a))//fails
+}
+catch(e) {
+	console.log(e.stack)//error!
+}
+
+//Compiled functions keep the key!
+var instance_c = new MyType
+instance_c.syncViewsWith(instance_a)
+instance_c.doubleView()
+console.log(instance_c.views())//5
