repos/tabletprog: types.js comparison

comparison types.js @ 100:9db0e3533b23

Some work on parameterized types

author	Mike Pavone <pavone@retrodev.com>
date	Wed, 08 Aug 2012 09:19:14 -0700
parents	b58b19c455ec
children	5d15b91e738a

comparison

equal deleted inserted replaced

-:b58b19c455ec
+:9db0e3533b23
 	}
 	//temporarily set cache entry to true to prevent infinite recursion
 	this.satisfies_cache[type.id] = true;
 	var ret = true;
 	if (type.messages === undefined) {
+		print('type has no messages');
 		ret = false;
 	}
 	if (ret) {
 		for (var msgname in this.messages) {
 			if (!(msgname in type.messages) || !this.messages[msgname].satisfiedBy(type.messages[msgname])) {
+				print(msgname, 'missing in type');
 				ret = false;
 				break;
 			}
 		}
 	}
 	}
 	return ret + indent + '}\n';
 };
 objecttype.prototype.replaceParams = function(paramtypes, visited) {
-	if (visisted === undefined) {
+	if (visited === undefined) {
 		visited = {};
 	}
 	if (this.id in visited) {
 		return visited[this.id];
 	}
 	}
 	//temporarily set cache entry to true to prevent infinite recursion
 	this.satisfies_cache[type.id] = true;
 	var ret = true;
 	if (!(type.callable) || this.params.length != type.params.length) {
+		print('type is not callable or param length mismatch');
 		ret = false;
 	}
 	if (ret) {
 		for (var i in this.params) {
 			if (i >= type.params.length || !this.params[i].satisfiedBy(type.params[i])) {
+				print('param ', i, ' is not satisfied');
 				ret = false;
 				break;
 			}
 		}
 	}
 	if (ret) {
 		for (var msgname in this.messages) {
 			if (!(msgname in type.messages) || !this.messages[msgname].satisfiedBy(type.messages[msgname])) {
+				print('message', msgname, 'is not satisfied');
 				ret = false;
 				break;
 			}
 		}
 	}
 	}
 	return ret + indent + '}\n';
 };
 lambdatype.prototype.replaceParams = function(paramtypes, visited) {
-	if (visisted === undefined) {
+	if (visited === undefined) {
 		visited = {};
 	}
 	if (this.id in visited) {
 		return visited[this.id];
 	}
 	this.id = nexttypeid++;
 	this.satisfies_cache = null;
 }
 uniontype.prototype.lazyinit = function() {
-	if (this.satisfies_cache = null) {
+	if (this.satisfies_cache == null) {
 		this.satisfies_cache = {};
 		this.satisfies_cache[this.id] = true;
 		this.messages = {};
-		if (a.messages !== undefined && b.messages !== undefined) {
+		if (this.a.messages !== undefined && this.b.messages !== undefined) {
-			for (var msgname in a.messages) {
+			for (var msgname in this.a.messages) {
-				if (msgname in b.messages) {
+				if (msgname in this.b.messages) {
-					this.messages[msgname] = mkunion(a.messages[msgname], b.messages[msgname]);
+					this.messages[msgname] = mkunion(this.a.messages[msgname], this.b.messages[msgname]);
 				}
 			}
 		}
 		this.callable = false;
-		if (a.callable && b.callable && a.params.length == b.params.length) {
+		if (this.a.callable && this.b.callable && this.a.params.length == this.b.params.length) {
 			this.callable = true;
 			this.params = [];
-			for (var i = 0; i < a.params.length; i++) {
+			for (var i = 0; i < this.a.params.length; i++) {
-				this.params.push(mkunion(a.params[i], b.params[i]));
+				this.params.push(mkunion(this.a.params[i], this.b.params[i]));
 			}
-			this.returntype = mkunion(a.returntype, b.returntype);
+			this.returntype = mkunion(this.a.returntype, this.b.returntype);
 		}
 	}
 };
 uniontype.prototype.satisfiedBy = function(type)
 		indent = '';
 	}
 	if (indent.length > 6) {
 		return 'max depth reached\n';
 	}
-	return indent + 'Union {\n\t' + indent + this.a.str() + '\t' + indent + this.b.str() + indent + '}\n';
+	return indent + 'Union {\n\t' + indent + this.a.str(indent+'\t') + '\t' + indent + this.b.str(indent+'\t') + indent + '}\n';
 };
 uniontype.prototype.replaceParams = function(paramtypes, visited) {
-	if (visisted === undefined) {
+	if (visited === undefined) {
 		visited = {};
 	}
 	if (this.id in visited) {
 		return visited[this.id];
 	}
 function withtparams(type, params)
 {
 	this.type = type;
 	this.params = params;
-}
+	this.replaced = false;
+}
-withtparams.prototype.satisfiedBy = function(type) {
-	return this.type.satisfiedBy(type);
+withtparams.prototype = {
-};
+	satisfiedBy: function(type) {
+		this.lazyinit();
-withtparams.prototype.str = function(indent) {
+		return this.type.satisfiedBy(type);
-	return this.type.str(indent) + indent + '<' + this.params.map(function(p) { return p.str(indent); }).join(', ') + '>';
+	},
-};
+	str: function(indent) {
+		if (indent === undefined) {
-withtparams.prototype.replaceParams = function(paramtypes) {
+			indent = '';
-	var replaced = false;
+		}
-	for (var i in this.params) {
+		if (indent.length > 6) {
-		var newp = this.params[i].replaceParams(paramtypes);
+			return 'max depth reached\n';
-		if (newp != this.params[i]) {
+		}
-			replaced = true;
+		return this.type.str(indent) + indent + '<' + this.params.map(function(p) { return p.str(indent); }).join(', ') + '>';
-			this.params[i] = newp;
+	},
-		}
+	replaceParams: function(paramtypes) {
-	}
+		var replaced = false;
-	if (replaced) {
+		for (var i in this.params) {
-		var childptypes = {};
+			var newp = this.params[i].replaceParams(paramtypes);
-		for (var i in this.type.typeparams) {
+			if (newp != this.params[i]) {
-			childptypes[this.type.typeparams[i]] = this.params[i]
+				replaced = true;
-		}
+				this.params[i] = newp;
-		this.type = this.type.replaceParams(childptypes, {});
+			}
-	}
+		}
-	return this;
+		return this;
+	},
+	lazyinit: function() {
+		if (!this.replaced) {
+			var childptypes = {};
+			for (var i in this.type.typeparams) {
+				print(this.type.typeparams[i], 'is', this.params[i].str());
+				childptypes[this.type.typeparams[i]] = this.params[i]
+			}
+			this.type = this.type.replaceParams(childptypes, {});
+			this.replaced = true;
+		}
+	},
+	get messages() {
+		this.lazyinit();
+		return this.type.messages;
+	}
 };
 function typetest()
 {
 	var foo = new objecttype();
 	var tlnode = new objecttype();
 	tlnode.typeparams = ['T'];
 	var t = new typeparam('T', any);
 	var q = new typeparam('Q', any);
 	var head = new lambdatype();
-	head.returnType = t;
+	head.returntype = t;
 	tlnode.addMessage('head', head);
 	var tail = new lambdatype();
 	var econs = new lambdatype();
 	econs.addParam('val');
 	econs.typeparams = ['Q'];