--- a/parser_old.rhope	Tue Dec 22 01:22:09 2009 -0500
+++ b/parser_old.rhope	Tue Mar 02 00:18:49 2010 -0500
@@ -67,7 +67,7 @@
 	]Global Separator <<["::"]
 	]Hex Escape <<["x"]
 	]Uses <<["uses"]
-	]Escape Map <<[[[[New@Dictionary[]]Set["n","\n"]]Set["r","\r"]]Set["t","\t"]]
+	]Escape Map <<[[[[Dictionary[]]Set["n","\n"]]Set["r","\r"]]Set["t","\t"]]
 }
 
 Blueprint Output Reference
@@ -85,7 +85,7 @@
 {
 	reflist <- [refs]Index[name] {}
 	{
-		reflist <- New@List[]
+		reflist <- ()
 	}
 	out <- [refs]Set[name, [reflist]Append[reference]]
 }
@@ -111,9 +111,9 @@
 New@Parse Program[:out]
 {
 	out <- [[[Build["Parse Program"]
-	]Workers <<[New@Dictionary[]]
-	]Imports <<[New@Dictionary[]]
-	]Blueprints <<[New@Dictionary[]]
+	]Workers <<[Dictionary[]]
+	]Imports <<[[Dictionary[]]Set["kernel.rhope", Yes]]
+	]Blueprints <<[Dictionary[]]
 }
 
 Blueprint Blueprint Definition
@@ -141,7 +141,7 @@
 
 New@Parse Worker[name,inputs,outputs,intypes,outtypes,line:out]
 {
-	out <- [[[[[[[[Build["Parse Worker"]]Name <<[name]]Inputs <<[inputs]]Outputs <<[outputs]]Line Number <<[line]]Trees <<[New@List[]]]Uses Stores <<[New@List[]]]Input Types <<[intypes]]Output Types <<[outtypes]
+	out <- [[[[[[[[Build["Parse Worker"]]Name <<[name]]Inputs <<[inputs]]Outputs <<[outputs]]Line Number <<[line]]Trees <<[()]]Uses Stores <<[()]]Input Types <<[intypes]]Output Types <<[outtypes]
 }
 
 Blueprint Worker Node
@@ -155,7 +155,7 @@
 
 New@Worker Node[name,params:out]
 {
-	out <- [[[[Build["Worker Node"]]Name <<[name]]Params <<[params]]Assignments <<[New@List[]]]Blocks <<[New@List[]]
+	out <- [[[[Build["Worker Node"]]Name <<[name]]Params <<[params]]Assignments <<[()]]Blocks <<[()]
 }
 
 Add List Helper[inlist,worker,program,key,parse worker,refs:out list,out worker,out refs]
@@ -417,7 +417,7 @@
 
 New@Field Node[name,params,set:out]
 {
-	out <- [[[[[Build["Field Node"]]Name <<[name]]Assignments <<[New@List[]]]Blocks <<[New@List[]]]Set? <<[set]]Params <<[params]
+	out <- [[[[[Build["Field Node"]]Name <<[name]]Assignments <<[()]]Blocks <<[()]]Set? <<[set]]Params <<[params]
 }
 
 Add to Worker@Field Node[node,worker,program,parse worker,refs:out node,out worker,out refs]
@@ -474,7 +474,7 @@
 
 New@Named Pipe Node[name:out]
 {
-	out <- [[[Build["Named Pipe Node"]]Name <<[name]]Assignments <<[New@List[]]]Blocks <<[New@List[]]
+	out <- [[[Build["Named Pipe Node"]]Name <<[name]]Assignments <<[()]]Blocks <<[()]
 }
 
 Add to Worker@Named Pipe Node[node,worker,program,parse worker,refs:out node,out worker,out refs]
@@ -551,7 +551,7 @@
 
 New@Global Node[store,name:out]
 {
-	out <- [[[[Build["Global Node"]]Store <<[store]]Name <<[name]]Assignments <<[New@List[]]]Blocks <<[New@List[]]
+	out <- [[[[Build["Global Node"]]Store <<[store]]Name <<[name]]Assignments <<[()]]Blocks <<[()]
 }
 
 Add to Worker@Global Node[node,worker,unused,parse worker,refs:out node,out worker,refs]
@@ -589,7 +589,7 @@
 
 New@Literal Node[value:out]
 {
-	out <- [[[Build["Literal Node"]]Value <<[value]]Assignments <<[New@List[]]]Blocks <<[New@List[]]
+	out <- [[[Build["Literal Node"]]Value <<[value]]Assignments <<[()]]Blocks <<[()]
 }
 
 Add to Worker@Literal Node[node,worker,unused,parse worker,refs:out node,out worker,out refs]
@@ -706,7 +706,7 @@
 {
 	If[[block count] > [0]]
 	{
-		after, before <- [string]Get DString[[[New@List[]]Append[begin comment]]Append[end comment]] {} {}
+		after, before <- [string]Get DString[[[()]Append[begin comment]]Append[end comment]] {} {}
 		{
 			If[[~] = [begin comment]]
 			{
@@ -804,7 +804,7 @@
 		{
 			body lines <- [body]Split["\n"]
 			more lines <- [[[body lines]Length] - [1]] + [name lines]
-			fields <- Fold[["Process Blueprint Field"]Set Input[2, params], New@List[], Filter[Map[body lines, ["Trim"]Set Input[1,"\n\r\t "]], "Filter Empty"]]
+			fields <- Fold[["Process Blueprint Field"]Set Input[2, params], (), Filter[Map[body lines, ["Trim"]Set Input[1,"\n\r\t "]], "Filter Empty"]]
 			new tree <- [tree]Blueprints << [ [[tree]Blueprints >>]Set[name, New@Blueprint Definition[name, fields]] ]
 			out <- Null[~, params, new tree, [lines] + [more lines]]
 		} {} {
@@ -837,7 +837,7 @@
 	If[[check block]Starts With[[params]Block Begin >>]]
 	{
 		,begin block <- [check block]Slice[[[params]Block Begin >>]Length]
-		trees, after block <- Worker Body[begin block, params, New@List[]]
+		trees, after block <- Worker Body[begin block, params, ()]
 		blocks, after <- Get Expression Blocks[after block, params, [blocks]Append[trees]]
 	}{
 		If[[check block]Starts With[[params]Empty Block >>]]
@@ -869,7 +869,7 @@
 
 Parse String[string,params,current:value,after]
 {
-	delims <- [[New@List[]]Append[[params]String End >>]]Append[[params]String Escape >>]
+	delims <- [[()]Append[[params]String End >>]]Append[[params]String Escape >>]
 	afters, before, delim <- [string]Get Comment DString[delims, params]
 	{
 		If[[delim] = [[params]String End >>]]
@@ -952,7 +952,7 @@
 		If[[name]Starts With[[params]List Begin >>]]
 		{
 			,list start <- [name]Slice[[[params]List Begin >>]Length]
-			value,after <- Parse List[list start, params, New@List[]]
+			value,after <- Parse List[list start, params, ()]
 		}{
 			If[[[name]Slice[1]]In["-0123456789"]]
 			{
@@ -1055,7 +1055,7 @@
 
 Postfix or Infix[string,params:expression,after]
 {
-	args, after args <- Parse Arguments[string, params, New@List[]]
+	args, after args <- Parse Arguments[string, params, ()]
 	delims <- [[[[[("\n")]Append[[params]Arg Begin >>]]Append[[params]Empty Block >>]]Append[[params]Block Begin >>]]Append[[params]Arg End >>]]Append[[params]List Delim >>]
 	aftere,before,delim <- [after args]Get Comment DString[delims, params]
 	{
@@ -1093,7 +1093,7 @@
 					after expression <- [after literal]Append[[delim]Append[after]]
 					expression, after literal <- Named Pipe or Literal[Right Trim[before, "\r\n\t "], params]
 				}{
-					expression, after expression <- Prefix[after, params, maybe name, New@List[]]
+					expression, after expression <- Prefix[after, params, maybe name, ()]
 				}
 			}
 		}{
@@ -1125,7 +1125,7 @@
 		}
 		//Any expression can be followed by one or more blocks mapping the inputs of other expressions
 		//to the outputs of the current one
-		blocks,after blocks <- Get Expression Blocks[after expression, params, New@List[]]
+		blocks,after blocks <- Get Expression Blocks[after expression, params, ()]
 		final expression <- [expression]Blocks <<[blocks]
 	}
 }
@@ -1236,7 +1236,7 @@
 		Print[["Parsing worker: "]Append[worker name]]
 		in out <- [params]In Out Delim >>
 		arg end <- [params]Arg End >>
-		delims <- [[New@List[]]Append[in out]]Append[arg end]
+		delims <- [[()]Append[in out]]Append[arg end]
 		after <- [~]Get Comment DString[delims, params] {} 
 		{
 			arglist <- Trim[~,"\r\n\t "]
@@ -1268,7 +1268,7 @@
 				Print["Got parse worker"]
 				body text, modifiers <- [after arglist]Get Comment DString[[params]Block Begin >>, params]
 				modified <- Process Modifiers[~, params, modifiers]
-				expression trees, after body <- Worker Body[body text, params, New@List[]]
+				expression trees, after body <- Worker Body[body text, params, ()]
 				worker <- [modified]Trees <<[expression trees]
 				new worker dict <- [[tree]Workers >>]Set[worker name, worker]
 				out <- Null[after body, params, [tree]Workers <<[new worker dict], 0]
@@ -1318,7 +1318,7 @@
 {
 	Print[["Add Workers Compile: "]Append[name]]
 	{
-	trees, nworker, refs <- Add List to Worker[[worker]Trees >>, [NWorker["rhope"]]Uses[[worker]Uses Stores >>], prog, worker, New@Dictionary[]]
+	trees, nworker, refs <- Add List to Worker[[worker]Trees >>, [NWorker["rhope"]]Uses[[worker]Uses Stores >>], prog, worker, Dictionary[]]
 	final nworker <- Fold[[["Add Wires Helper"]Set Input[3, worker]]Set Input[4, refs], nworker, trees]
 	out <- [prog]Bind Worker[name, final nworker]
 	}
@@ -1328,7 +1328,7 @@
 {
 	Print["Add Wires Helper"]
 	{
-	out <- [node]Add Wires[worker, New@List[], parse worker, assignments]
+	out <- [node]Add Wires[worker, (), parse worker, assignments]
 	{ Print["Add Wires Helper Done"] }
 	}
 }
@@ -1337,7 +1337,7 @@
 {
 	Print[["Add Contents: "]Append[name]]
 	worker <- [[program]Find Worker[name]]Uses[[parse worker]Uses Stores >>]
-	trees, contents worker, refs <- Add List to Worker[[parse worker]Trees >>, worker, program, parse worker, New@Dictionary[]]
+	trees, contents worker, refs <- Add List to Worker[[parse worker]Trees >>, worker, program, parse worker, Dictionary[]]
 	Fold[[["Add Wires Helper"]Set Input[3, parse worker]]Set Input[4, refs], contents worker, trees]
 	out <- [parse worker]Trees <<[trees]
 	key <- name
@@ -1380,13 +1380,13 @@
 Tree to Program[parse tree:out]
 {
 	Print["Tree to Program"]
-	out <- _Tree to Program[parse tree, [New@Program[]]Add Builtins]
+	out <- _Tree to Program[parse tree, [Program[]]Add Builtins]
 	{ Print["done"] }
 }
 
 Tree to Program Native[parse tree:out]
 {
-	registered <- Fold["Register Workers Compile", Fold["Add Blueprint Compile", [NProgram[]]Register Builtins, [parse tree]Blueprints >>], [parse tree]Workers >>]
+	registered <- Fold["Register Workers Compile", [Fold["Add Blueprint Compile", NProgram[], [parse tree]Blueprints >>]]Register Builtins, [parse tree]Workers >>]
 	out <- Fold["Add Workers Compile", registered, [parse tree]Workers >>]
 	{ Print["Transformed AST to dataflow graph "] }
 }
@@ -1411,7 +1411,7 @@
 
 Process Imports[parse tree,params:out]
 {
-	needs import <- Fold["Needs Imports", New@List[], [parse tree]Imports >>]
+	needs import <- Fold["Needs Imports", (), [parse tree]Imports >>]
 	If[[[needs import]Length] > [0]]
 	{
 		import tree <- Fold[["Do Import"]Set Input[3, params], parse tree, needs import]
@@ -1476,16 +1476,16 @@
 			}
 		}{
 			Print["Expression"]
-			trees <- Worker Body[[line]Append["}"], params, New@List[]]
+			trees <- Worker Body[[line]Append["}"], params, ()]
 			{ Print["Parse done"] }
-			tree <- [New@Worker Node["Val", [New@List[]]Append[[trees]Index[0]]]]Assignments <<[("__out")]
+			tree <- [New@Worker Node["Val", [()]Append[[trees]Index[0]]]]Assignments <<[("__out")]
 			{ Print["Constructed new tree"] }
-			this stores <- [[tree]Gather Stores[params, New@Dictionary[]]]Keys
+			this stores <- [[tree]Gather Stores[params, Dictionary[]]]Keys
 			{ Print["Got stores"] }
 			next stores <- Fold["_Init Used Store", stores, this stores]
 			{
 				Print["Initialized stores"]
-				pworker <- [[New@Parse Worker["__Eval", New@List[], ("__out"), 0]]Trees <<[[New@List[]]Append[tree]]]Uses Stores <<[this stores]
+				pworker <- [[New@Parse Worker["__Eval", (), ("__out"), 0]]Trees <<[[()]Append[tree]]]Uses Stores <<[this stores]
 				{ Print["Constructed parse worker"] }
 			}
 			[[prog]Find Worker["__Eval"]]Clear
@@ -1494,7 +1494,7 @@
 				Add Contents[pworker, "__Eval", prog]
 				{ 
 					Print["Added Contents"]
-					Pretty Print[[[[prog]Find Worker["__Eval"]]Do[New@List[]]]Index[0], ""]
+					Pretty Print[[[[prog]Find Worker["__Eval"]]Do[()]]Index[0], ""]
 					{ 
 						Print["Finished executeion"]
 						_REPL[params, prog, next stores] } } }
@@ -1506,7 +1506,7 @@
 {
 	Print["Rhope Alpha 2\nCopyright 2008 by Michael Pavone\nEntering interactive mode\n"]
 	prog <- Tree to Program[Null["Val[in:out]\n{\n out <- in\n}\n__Eval[:__out]\n{\n}\n", params, New@Parse Program[], 0]]
-	_REPL[params, prog, New@Dictionary[]]
+	_REPL[params, prog, Dictionary[]]
 }
 
 Add If Store[stores,name,params:out]