- Changed the way types in the currently compiling module are resolved

- Updating Shared with a new compiled version
- Fixed some java source generation bugs

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/CompilingPackage.java

 import java.util.List;
 import java.util.Map;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
  * @author Hoofdgebruiker
  */
 public class CompilingPackage {
+	private final ZSPackage pkg;
 	private final Map<String, CompilingPackage> packages = new HashMap<>();
 	private final Map<String, CompilingType> types = new HashMap<>();
 	
+	public CompilingPackage(ZSPackage pkg) {
+		this.pkg = pkg;
+	}
+	
+	public ZSPackage getPackage() {
+		return pkg;
+	}
+	
+	public CompilingPackage getOrCreatePackage(String name) {
+		if (packages.containsKey(name))
+			return packages.get(name);
+		
+		CompilingPackage newPackage = new CompilingPackage(pkg.getOrCreatePackage(name));
+		packages.put(name, newPackage);
+		return newPackage;
+	}
+	
 	public void addPackage(String name, CompilingPackage package_) {
 		packages.put(name, package_);
 	}
 	
 	private HighLevelDefinition getImportType(TypeResolutionContext context, CompilingType type, List<String> name, int index) {
 		if (index == name.size())
-			return type.load(context);
+			return type.load();
 		
 		return getImportType(context, type.getInner(name.get(index)), name, index + 1);
 	}
 		
 		if (types.containsKey(name.get(index).name)) {
 			CompilingType type = types.get(name.get(index).name);
-			DefinitionTypeID result = context.getTypeRegistry().getForDefinition(type.load(context), name.get(index).arguments);
+			DefinitionTypeID result = context.getTypeRegistry().getForDefinition(type.load(), name.get(index).arguments);
 			return getInner(context, name, index + 1, type, result);
 		}
 		
 		if (innerType == null)
 			return null;
 		
-		DefinitionTypeID innerResult = context.getTypeRegistry().getForDefinition(innerType.load(context), name.get(index).arguments, result);
+		DefinitionTypeID innerResult = context.getTypeRegistry().getForDefinition(innerType.load(), name.get(index).arguments, result);
 		return getInner(context, name, index + 1, innerType, innerResult);
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/CompilingType.java

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 
 /**
  *
 public interface CompilingType {
 	CompilingType getInner(String name);
 	
-	HighLevelDefinition load(TypeResolutionContext context);
+	HighLevelDefinition load();
 	
-	default DefinitionTypeID getInnerType(TypeResolutionContext context, List<GenericName> name, int index, DefinitionTypeID outer) {
-		DefinitionTypeID type = context.getTypeRegistry().getForDefinition(load(context), name.get(index).arguments, outer);
+	default DefinitionTypeID getInnerType(GlobalTypeRegistry registry, List<GenericName> name, int index, DefinitionTypeID outer) {
+		DefinitionTypeID type = registry.getForDefinition(load(), name.get(index).arguments, outer);
 		index++;
 		if (index == name.size())
 			return type;
 		if (innerType == null)
 			return null;
 		
-		return innerType.getInnerType(context, name, index, type);
+		return innerType.getInnerType(registry, name, index, type);
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/FileResolutionContext.java

  */
 public class FileResolutionContext implements TypeResolutionContext {
 	private final ModuleTypeResolutionContext module;
+	private final CompilingPackage modulePackage;
 	private final Map<String, HighLevelDefinition> imports = new HashMap<>();
 	
-	public FileResolutionContext(ModuleTypeResolutionContext module) {
+	public FileResolutionContext(ModuleTypeResolutionContext module, CompilingPackage modulePackage) {
 		this.module = module;
+		this.modulePackage = modulePackage;
 	}
 	
 	public void addImport(String name, HighLevelDefinition definition) {
 					1);
 		}
 		
+		ITypeID moduleType = modulePackage.getType(this, name);
+		if (moduleType != null)
+			return moduleType;
+		
 		return module.getType(position, name);
 	}
 

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/LocalTypeResolutionContext.java

 		if (type != null) {
 			CompilingType compiling = type.getInner(name.get(0).name);
 			if (compiling != null) {
-				DefinitionTypeID outer = getTypeRegistry().getForMyDefinition(type.load(this));
-				return compiling.getInnerType(this, name, 0, outer);
+				DefinitionTypeID outer = getTypeRegistry().getForMyDefinition(type.load());
+				return compiling.getInnerType(getTypeRegistry(), name, 0, outer);
 			}
 		}
 		
 	
 	@Override
 	public ITypeID getThisType() {
-		return type == null ? null : getTypeRegistry().getForMyDefinition(type.load(this));
+		return type == null ? null : getTypeRegistry().getForMyDefinition(type.load());
 	}
 }

Constructor/src/main/java/org/openzen/zenscript/constructor/Module.java

 		}
 	}
 	
-	public ParsedFile[] parse(ZSPackage pkg, CompilingPackage compilingPackage) throws IOException {
+	public ParsedFile[] parse(CompilingPackage compilingPackage) throws IOException {
 		// TODO: load bracket parsers from host plugins
 		List<ParsedFile> files = new ArrayList<>();
-		parse(files, pkg, compilingPackage, null, sourceDirectory);
+		parse(files, compilingPackage, null, sourceDirectory);
 		return files.toArray(new ParsedFile[files.size()]);
 	}
 	
-	private void parse(List<ParsedFile> files, ZSPackage pkg, CompilingPackage compilingPackage, BracketExpressionParser bracketParser, File directory) throws IOException {
+	private void parse(List<ParsedFile> files, CompilingPackage pkg, BracketExpressionParser bracketParser, File directory) throws IOException {
 		for (File file : directory.listFiles()) {
 			if (file.getName().endsWith(".zs")) {
 				try {
-					files.add(ParsedFile.parse(pkg, compilingPackage, bracketParser, file));
+					files.add(ParsedFile.parse(pkg, bracketParser, file));
 				} catch (CompileException ex) {
 					exceptionLogger.accept(ex);
 				}
 			} else if (file.isDirectory()) {
-				CompilingPackage innerPackage = new CompilingPackage();
-				compilingPackage.addPackage(file.getName(), innerPackage);
-				parse(files, pkg.getOrCreatePackage(file.getName()), innerPackage, bracketParser, file);
+				CompilingPackage innerPackage = pkg.getOrCreatePackage(file.getName());
+				pkg.addPackage(file.getName(), innerPackage);
+				parse(files, innerPackage, bracketParser, file);
 			}
 		}
 	}
 	public static SemanticModule compileSyntaxToSemantic(
 			String name,
 			String[] dependencies,
-			ZSPackage pkg,
-			CompilingPackage compilingPkg,
+			CompilingPackage pkg,
 			ParsedFile[] files,
 			ModuleSpace registry,
 			Consumer<CompileException> exceptionLogger) {
 				registry.compilationUnit.globalTypeRegistry,
 				registry.getAnnotations(),
 				rootPackage,
-				compilingPkg,
+				pkg,
 				globals);
 		
+		for (ParsedFile file : files) {
+			file.registerTypes(moduleContext, rootPackage, pkg);
+		}
+		
 		for (ParsedFile file : files) {
 			// compileMembers will register all definition members to their
 			// respective definitions, such as fields, constructors, methods...
 			// It doesn't yet compile the method contents.
 			try {
-				file.compileTypes(moduleContext, rootPackage, compilingPkg);
+				file.compileTypes(moduleContext, rootPackage, pkg);
 			} catch (CompileException ex) {
 				exceptionLogger.accept(ex);
 				failed = true;
 		}
 		
 		if (failed)
-			return new SemanticModule(name, dependencies, SemanticModule.State.INVALID, rootPackage, pkg, definitions, Collections.emptyList(), registry.compilationUnit, expansions, registry.getAnnotations());
+			return new SemanticModule(name, dependencies, SemanticModule.State.INVALID, rootPackage, pkg.getPackage(), definitions, Collections.emptyList(), registry.compilationUnit, expansions, registry.getAnnotations());
 		
 		// scripts will store all the script blocks encountered in the files
 		PrecompilationState precompiler = new PrecompilationState();
 		for (ParsedFile file : files) {
-			file.registerMembers(moduleContext, precompiler, rootPackage, compilingPkg, expansions, globals);
+			file.registerMembers(moduleContext, precompiler, rootPackage, pkg, expansions, globals);
 		}
 		
 		List<ScriptBlock> scripts = new ArrayList<>();
 			// into semantic code. This semantic code can then be compiled
 			// to various targets.
 			try {
-				file.compileCode(moduleContext, precompiler, rootPackage, compilingPkg, expansions, scripts, globals);
+				file.compileCode(moduleContext, precompiler, rootPackage, pkg, expansions, scripts, globals);
 			} catch (CompileException ex) {
 				exceptionLogger.accept(ex);
 				failed = true;
 			}
 		}
 		
-		return new SemanticModule(name, dependencies, SemanticModule.State.ASSEMBLED, rootPackage, pkg, definitions, scripts, registry.compilationUnit, expansions, registry.getAnnotations());
+		return new SemanticModule(name, dependencies, SemanticModule.State.ASSEMBLED, rootPackage, pkg.getPackage(), definitions, scripts, registry.compilationUnit, expansions, registry.getAnnotations());
 	}
 }

Constructor/src/main/java/org/openzen/zenscript/constructor/module/DirectoryModuleReference.java

 
 			Module module = new Module(moduleName, directory, jsonFile, exceptionLogger);
 			ZSPackage pkg = isStdlib ? unit.globalTypeRegistry.stdlib : new ZSPackage(null, module.packageName);
-			CompilingPackage compilingPackage = new CompilingPackage();
+			CompilingPackage compilingPackage = new CompilingPackage(pkg);
 			
-			ParsedFile[] parsedFiles = module.parse(pkg, compilingPackage);
-			SemanticModule result = Module.compileSyntaxToSemantic(module.name, module.dependencies, pkg, compilingPackage, parsedFiles, space, exceptionLogger);
+			ParsedFile[] parsedFiles = module.parse(compilingPackage);
+			SemanticModule result = Module.compileSyntaxToSemantic(module.name, module.dependencies, compilingPackage, parsedFiles, space, exceptionLogger);
 			
 			JSONObject globals = json.optJSONObject("globals");
 			if (globals != null) {

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaDefinitionVisitor.java

 				String name = option.types.length == 1 ? "value" : "value" + (i + 1);
 				output.append(scope.type(option.types[i])).append(' ').append(name);
 			}
-			output.append("){\n");
+			output.append(") {\n");
 			for (int i = 0; i < option.types.length; i++) {
 				if (i > 0)
 					output.append(indent).append(settings.indent).append(settings.indent).append(settings.indent).append(";\n");

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/prepare/JavaSourcePrepareDefinitionVisitor.java

 		
 		{
 			JavaNativeClass cls = new JavaNativeClass(new JavaSourceClass("java.io", "StringReader"), true);
-			cls.addInstanceMethod("constructor", "");
+			cls.addConstructor("constructor", "");
 			cls.addInstanceMethod("destructor", "close");
 			cls.addInstanceMethod("readCharacter", "read");
 			cls.addInstanceMethod("readSlice", "read");

Parser/src/main/java/org/openzen/zenscript/lexer/ZSTokenType.java

 	T_WHITESPACE_TAB(true, "\t", "\t"),
 	T_WHITESPACE_NEWLINE(true, "\n", "\n", true),
 	T_WHITESPACE_CARRIAGE_RETURN(true, "\r", "\r"),
-	T_IDENTIFIER("[a-zA-Z_][a-zA-Z_0-9]*"),
+	T_IDENTIFIER("@?[a-zA-Z_][a-zA-Z_0-9]*"),
+	T_LOCAL_IDENTIFIER("$[a-zA-Z_][a-zA-Z_0-9]*"),
 	T_FLOAT("\\-?(0|[1-9][0-9]*)\\.[0-9]+([eE][\\+\\-]?[0-9]+)?"),
 	T_INT("\\-?(0|[1-9][0-9]*)"),
 	T_STRING_SQ("\"([^\"\\\\\\n]|\\\\([\'\"\\\\/bfnrt&]|u[0-9a-fA-F]{4}))*\""),
 	K_PRIVATE(true, "private"),
 	K_PUBLIC(true, "public"),
 	K_EXPORT(true, "export"),
+	K_INTERNAL(true, "internal"),
 	K_STATIC(true, "static"),
 	K_PROTECTED(true, "protected"),
 	K_IMPLICIT(true, "implicit"),

Parser/src/main/java/org/openzen/zenscript/parser/ParsedDefinition.java

  */
 package org.openzen.zenscript.parser;
 
-import java.util.Map;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.context.CompilingType;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import static org.openzen.zenscript.lexer.ZSTokenType.*;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
  *
  * @author Hoofdgebruiker
  */
-public abstract class ParsedDefinition implements CompilingType {
-	public static ParsedDefinition parse(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
+public abstract class ParsedDefinition {
+	public static ParsedDefinition parse(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
 		if (tokens.optional(K_CLASS) != null) {
 			return ParsedClass.parseClass(pkg, position, modifiers, annotations, tokens, outerDefinition);
 		} else if (tokens.optional(K_INTERFACE) != null) {
 	public final CodePosition position;
 	public final int modifiers;
 	public final ParsedAnnotation[] annotations;
+	public final CompilingPackage pkg;
 	
-	public ParsedDefinition(CodePosition position, int modifiers, ParsedAnnotation[] annotations) {
+	public ParsedDefinition(CodePosition position, int modifiers, CompilingPackage pkg, ParsedAnnotation[] annotations) {
 		this.position = position;
+		this.pkg = pkg;
 		this.modifiers = modifiers;
 		this.annotations = annotations;
 	}
 		return modifiers;
 	}
 	
+	public abstract CompilingType getCompiling(TypeResolutionContext context);
+	
 	public abstract HighLevelDefinition getCompiled();
 	
 	public abstract void linkTypes(TypeResolutionContext context);

Parser/src/main/java/org/openzen/zenscript/parser/ParsedFile.java

 import org.openzen.zencode.shared.FileSourceFile;
 import org.openzen.zencode.shared.LiteralSourceFile;
 import org.openzen.zencode.shared.SourceFile;
-import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.PackageDefinitions;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.statement.Statement;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import static org.openzen.zenscript.lexer.ZSTokenType.*;
 import org.openzen.zenscript.codemodel.scope.FileScope;
  * @author Hoofdgebruiker
  */
 public class ParsedFile {
-	public static ParsedFile parse(ZSPackage pkg, CompilingPackage compilingPackage, BracketExpressionParser bracketParser, File file) throws IOException {
-		return parse(pkg, compilingPackage, bracketParser, new FileSourceFile(file.getName(), file));
+	public static ParsedFile parse(CompilingPackage compilingPackage, BracketExpressionParser bracketParser, File file) throws IOException {
+		return parse(compilingPackage, bracketParser, new FileSourceFile(file.getName(), file));
 	}
 	
-	public static ParsedFile parse(ZSPackage pkg, CompilingPackage compilingPackage, BracketExpressionParser bracketParser, String filename, String content) {
+	public static ParsedFile parse(CompilingPackage compilingPackage, BracketExpressionParser bracketParser, String filename, String content) {
 		try {
-			return parse(pkg, compilingPackage, bracketParser, new LiteralSourceFile(filename, content));
+			return parse(compilingPackage, bracketParser, new LiteralSourceFile(filename, content));
 		} catch (IOException ex) {
 			throw new AssertionError(); // shouldn't happen
 		}
 	}
 	
-	public static ParsedFile parse(ZSPackage pkg, CompilingPackage compilingPackage, BracketExpressionParser bracketParser, SourceFile file) throws IOException {
+	public static ParsedFile parse(CompilingPackage compilingPackage, BracketExpressionParser bracketParser, SourceFile file) throws IOException {
 		ZSTokenParser tokens = ZSTokenParser.create(file, bracketParser, 4);
-		return parse(pkg, compilingPackage, tokens);
+		return parse(compilingPackage, tokens);
 	}
 	
-	public static ParsedFile parse(ZSPackage pkg, CompilingPackage compilingPackage, ZSTokenParser tokens) {
+	public static ParsedFile parse(CompilingPackage compilingPackage, ZSTokenParser tokens) {
 		ParsedFile result = new ParsedFile(tokens.getFile());
 
 		while (true) {
 			} else if ((tokens.optional(EOF)) != null) {
 				break;
 			} else {
-				ParsedDefinition definition = ParsedDefinition.parse(pkg, position, modifiers, annotations, tokens, null);
+				ParsedDefinition definition = ParsedDefinition.parse(compilingPackage, position, modifiers, annotations, tokens, null);
 				if (definition == null) {
 					result.statements.add(ParsedStatement.parse(tokens, annotations));
 				} else {
 					result.definitions.add(definition);
 					definition.getCompiled().setTag(SourceFile.class, tokens.getFile());
-					
-					if (definition.getName() != null)
-						compilingPackage.addType(definition.getName(), definition);
 				}
 			}
 		}
 		}
 	}
 	
+	public void registerTypes(
+			ModuleTypeResolutionContext moduleContext,
+			ZSPackage rootPackage,
+			CompilingPackage modulePackage) {
+		FileResolutionContext context = new FileResolutionContext(moduleContext, modulePackage);
+		loadImports(context, rootPackage, modulePackage);
+		
+		for (ParsedDefinition definition : this.definitions) {
+			if (definition.getName() != null)
+				definition.pkg.addType(definition.getName(), definition.getCompiling(context));
+		}
+	}
+	
 	public void compileTypes(
 			ModuleTypeResolutionContext moduleContext,
 			ZSPackage rootPackage,
 			CompilingPackage modulePackage) {
-		FileResolutionContext context = new FileResolutionContext(moduleContext);
+		FileResolutionContext context = new FileResolutionContext(moduleContext, modulePackage);
 		loadImports(context, rootPackage, modulePackage);
+		
+		for (ParsedDefinition definition : this.definitions) {
+			if (definition.getName() != null)
+				modulePackage.addType(definition.getName(), definition.getCompiling(context));
+		}
+		
 		for (ParsedDefinition definition : this.definitions) {
-			definition.linkTypes(context);
+			definition.getCompiling(context).load();
 		}
 	}
 	
 			CompilingPackage modulePackage,
 			List<ExpansionDefinition> expansions,
 			Map<String, ISymbol> globals) {
-		FileResolutionContext context = new FileResolutionContext(moduleContext);
+		FileResolutionContext context = new FileResolutionContext(moduleContext, modulePackage);
 		loadImports(context, rootPackage, modulePackage);
 		
 		FileScope scope = new FileScope(context, expansions, globals, precompiler);
 			List<ExpansionDefinition> expansions,
 			List<ScriptBlock> scripts,
 			Map<String, ISymbol> globals) {
-		FileResolutionContext context = new FileResolutionContext(moduleContext);
+		FileResolutionContext context = new FileResolutionContext(moduleContext, modulePackage);
 		loadImports(context, rootPackage, modulePackage);
 		
 		FileScope scope = new FileScope(context, expansions, globals, precompiler);

Parser/src/main/java/org/openzen/zenscript/parser/definitions/BaseParsedDefinition.java

 import java.util.Map;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.context.CompilingType;
 import org.openzen.zenscript.codemodel.context.LocalTypeResolutionContext;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 public abstract class BaseParsedDefinition extends ParsedDefinition {
 	protected final List<ParsedDefinitionMember> members = new ArrayList<>();
 	private boolean typesCompiled = false;
-	private final Map<String, CompilingType> innerTypes = new HashMap<>();
+	private final Map<String, ParsedDefinition> innerTypes = new HashMap<>();
 	private boolean isCompiled = false;
 	
-	public BaseParsedDefinition(CodePosition position, int modifiers, ParsedAnnotation[] annotations) {
-		super(position, modifiers, annotations);
+	public BaseParsedDefinition(CodePosition position, int modifiers, CompilingPackage pkg, ParsedAnnotation[] annotations) {
+		super(position, modifiers, pkg, annotations);
 	}
 	
 	public void addMember(ParsedDefinitionMember member) {
 		typesCompiled = true;
 		
 		System.out.println("compileTypes " + getCompiled().name);
-		LocalTypeResolutionContext localContext = new LocalTypeResolutionContext(context, this, getCompiled().genericParameters);
-		linkTypesLocal(localContext);
+		linkTypesLocal(context);
 	}
 	
 	protected void linkTypesLocal(TypeResolutionContext localContext) {
 		for (ParsedDefinitionMember member : members)
 			member.compile(innerScope);
 	}
-	
+
 	@Override
-	public HighLevelDefinition load(TypeResolutionContext context) {
-		linkTypes(context);
-		return getCompiled();
+	public CompilingType getCompiling(TypeResolutionContext context) {
+		return new Compiling(context);
 	}
 	
-	@Override
-	public CompilingType getInner(String name) {
-		return innerTypes.get(name);
+	private class Compiling implements CompilingType {
+		private final TypeResolutionContext context;
+		
+		public Compiling(TypeResolutionContext context) {
+			this.context = new LocalTypeResolutionContext(context, this, getCompiled().genericParameters);
+		}
+		
+		@Override
+		public HighLevelDefinition load() {
+			linkTypes(context);
+			return getCompiled();
+		}
+
+		@Override
+		public CompilingType getInner(String name) {
+			if (!innerTypes.containsKey(name))
+				return null;
+			
+			return innerTypes.get(name).getCompiling(context);
+		}
 	}
 }

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedAlias.java

 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.context.CompilingType;
 import org.openzen.zenscript.codemodel.context.LocalTypeResolutionContext;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.AliasDefinition;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.lexer.ZSTokenType;
  * @author Hoofdgebruiker
  */
 public class ParsedAlias extends ParsedDefinition {
-	public static ParsedAlias parseAlias(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
+	public static ParsedAlias parseAlias(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
 		String name = tokens.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
 		List<ParsedTypeParameter> parameters = ParsedTypeParameter.parseAll(tokens);
 		tokens.required(ZSTokenType.K_AS, "as expected");
 	private final AliasDefinition compiled;
 	private boolean typesLinked = false;
 	
-	public ParsedAlias(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, List<ParsedTypeParameter> parameters, IParsedType type, HighLevelDefinition outerDefinition) {
-		super(position, modifiers, annotations);
+	public ParsedAlias(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, List<ParsedTypeParameter> parameters, IParsedType type, HighLevelDefinition outerDefinition) {
+		super(position, modifiers, pkg, annotations);
 		
 		this.name = name;
 		this.parameters = parameters;
 		this.type = type;
 		
-		compiled = new AliasDefinition(position, pkg, name, modifiers, outerDefinition);
+		compiled = new AliasDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
 		
 		if (parameters != null && parameters.size() > 0) {
 			TypeParameter[] typeParameters = new TypeParameter[parameters.size()];
 			return;
 		typesLinked = true;
 		
-		LocalTypeResolutionContext localContext = new LocalTypeResolutionContext(context, this, compiled.genericParameters);
-		compiled.setType(type.compile(localContext));
+		compiled.setType(type.compile(context));
 		
 		for (int i = 0; i < compiled.genericParameters.length; i++) {
 			TypeParameter output = compiled.genericParameters[i];
 			ParsedTypeParameter input = this.parameters.get(i);
 			for (ParsedGenericBound bound : input.bounds) {
-				output.addBound(bound.compile(localContext));
+				output.addBound(bound.compile(context));
 			}
 		}
 	}
 	}
 
 	@Override
-	public CompilingType getInner(String name) {
-		// TODO: this should be possible too
-		return null;
+	public CompilingType getCompiling(TypeResolutionContext context) {
+		return new Compiling(context);
 	}
+	
+	private class Compiling implements CompilingType {
+		private final TypeResolutionContext context;
+		
+		public Compiling(TypeResolutionContext context) {
+			this.context = new LocalTypeResolutionContext(context, this, compiled.genericParameters);
+		}
+		
+		@Override
+		public CompilingType getInner(String name) {
+			// TODO: this should be possible too
+			return null;
+		}
 
-	@Override
-	public HighLevelDefinition load(TypeResolutionContext context) {
-		linkTypes(context);
-		return compiled;
+		@Override
+		public HighLevelDefinition load() {
+			linkTypes(context);
+			return compiled;
+		}
 	}
 }

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedClass.java

 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.ClassDefinition;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.lexer.ZSTokenType;
 import org.openzen.zenscript.parser.ParsedAnnotation;
  * @author Stan Hebben
  */
 public class ParsedClass extends BaseParsedDefinition {
-	public static ParsedClass parseClass(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
+	public static ParsedClass parseClass(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
 		String name = tokens.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
 		List<ParsedTypeParameter> genericParameters = ParsedTypeParameter.parseAll(tokens);
 		
 		
 		ParsedClass result = new ParsedClass(pkg, position, modifiers, annotations, name, genericParameters, superclass, outerDefinition);
 		while (tokens.optional(ZSTokenType.T_ACLOSE) == null) {
-			result.addMember(ParsedDefinitionMember.parse(tokens, result.compiled, null));
+			result.addMember(ParsedDefinitionMember.parse(tokens, result, null));
 		}
 		return result;
 	}
 	
 	private final ClassDefinition compiled;
 	
-	public ParsedClass(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, List<ParsedTypeParameter> parameters, IParsedType superclass, HighLevelDefinition outerDefinition) {
-		super(position, modifiers, annotations);
+	public ParsedClass(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, List<ParsedTypeParameter> parameters, IParsedType superclass, HighLevelDefinition outerDefinition) {
+		super(position, modifiers, pkg, annotations);
 		
 		this.parameters = parameters;
 		this.superclass = superclass;
 		
-		compiled = new ClassDefinition(position, pkg, name, modifiers, outerDefinition);
+		compiled = new ClassDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
 		compiled.setTypeParameters(ParsedTypeParameter.getCompiled(parameters));
 	}
 

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedEnum.java

 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.EnumDefinition;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.parser.ParsedAnnotation;
-import org.openzen.zenscript.parser.PrecompilationState;
 import org.openzen.zenscript.parser.member.ParsedDefinitionMember;
 
 /**
  * @author Hoofdgebruiker
  */
 public class ParsedEnum extends BaseParsedDefinition {
-	public static ParsedEnum parseEnum(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
+	public static ParsedEnum parseEnum(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
 		String name = tokens.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
 		tokens.required(ZSTokenType.T_AOPEN, "{ expected");
 		
 		
 		if (tokens.optional(ZSTokenType.T_SEMICOLON) != null) {
 			while (tokens.optional(ZSTokenType.T_ACLOSE) == null) {
-				result.addMember(ParsedDefinitionMember.parse(tokens, result.compiled, null));
+				result.addMember(ParsedDefinitionMember.parse(tokens, result, null));
 			}
 		} else {
 			tokens.required(ZSTokenType.T_ACLOSE, "} expected");
 	
 	private final EnumDefinition compiled;
 	
-	public ParsedEnum(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, HighLevelDefinition outerDefinition) {
-		super(position, modifiers, annotations);
+	public ParsedEnum(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, HighLevelDefinition outerDefinition) {
+		super(position, modifiers, pkg, annotations);
 		
-		compiled = new EnumDefinition(position, pkg, name, modifiers, outerDefinition);
+		compiled = new EnumDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
 	}
 	
 	public void addEnumValue(ParsedEnumConstant value) {

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedExpansion.java

 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.context.LocalTypeResolutionContext;
+import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.lexer.ZSTokenType;
-import org.openzen.zenscript.codemodel.scope.BaseScope;
-import org.openzen.zenscript.codemodel.scope.GenericFunctionScope;
 import org.openzen.zenscript.parser.ParsedAnnotation;
 import org.openzen.zenscript.parser.member.ParsedDefinitionMember;
 import org.openzen.zenscript.parser.type.IParsedType;
  * @author Hoofdgebruiker
  */
 public class ParsedExpansion extends BaseParsedDefinition {
-	public static ParsedExpansion parseExpansion(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
+	public static ParsedExpansion parseExpansion(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
 		List<ParsedTypeParameter> parameters = ParsedTypeParameter.parseAll(tokens);
 		IParsedType target = IParsedType.parse(tokens);
 		tokens.required(ZSTokenType.T_AOPEN, "{ expected");
 		
 		ParsedExpansion result = new ParsedExpansion(pkg, position, modifiers, annotations, parameters, target, outerDefinition);
 		while (tokens.optional(ZSTokenType.T_ACLOSE) == null) {
-			result.addMember(ParsedDefinitionMember.parse(tokens, result.compiled, null));
+			result.addMember(ParsedDefinitionMember.parse(tokens, result, null));
 		}
 		return result;
 	}
 	private final IParsedType target;
 	private final ExpansionDefinition compiled;
 	
-	public ParsedExpansion(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, List<ParsedTypeParameter> genericParameters, IParsedType target, HighLevelDefinition outerDefinition) {
-		super(position, modifiers, annotations);
+	public ParsedExpansion(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, List<ParsedTypeParameter> genericParameters, IParsedType target, HighLevelDefinition outerDefinition) {
+		super(position, modifiers, pkg, annotations);
 		
 		this.parameters = genericParameters;
 		this.target = target;
 		
-		compiled = new ExpansionDefinition(position, pkg, modifiers, outerDefinition);
+		compiled = new ExpansionDefinition(position, pkg.getPackage(), modifiers, outerDefinition);
 		compiled.setTypeParameters(ParsedTypeParameter.getCompiled(genericParameters));
 	}
 	

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedFunction.java

 import org.openzen.zencode.shared.CodePosition;
 import static org.openzen.zenscript.lexer.ZSTokenType.*;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.context.CompilingType;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.FunctionDefinition;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
 import org.openzen.zenscript.codemodel.scope.FunctionScope;
  * @author Stanneke
  */
 public class ParsedFunction extends ParsedDefinition {
-	public static ParsedFunction parseFunction(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser parser, HighLevelDefinition outerDefinition) {
+	public static ParsedFunction parseFunction(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser parser, HighLevelDefinition outerDefinition) {
 		String name = parser.required(T_IDENTIFIER, "identifier expected").content;
 		ParsedFunctionHeader header = ParsedFunctionHeader.parse(parser);
 		ParsedFunctionBody body = ParsedStatement.parseFunctionBody(parser);
 
 	private final FunctionDefinition compiled;
 	
-	private ParsedFunction(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, ParsedFunctionHeader header, ParsedFunctionBody body, HighLevelDefinition outerDefinition) {
-		super(position, modifiers, annotations);
+	private ParsedFunction(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, ParsedFunctionHeader header, ParsedFunctionBody body, HighLevelDefinition outerDefinition) {
+		super(position, modifiers, pkg, annotations);
 		
 		this.header = header;
 		this.body = body;
 		
-		compiled = new FunctionDefinition(position, pkg, name, modifiers, outerDefinition);
+		compiled = new FunctionDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
 	}
 
 	@Override
 	}
 
 	@Override
-	public CompilingType getInner(String name) {
-		return null;
+	public CompilingType getCompiling(TypeResolutionContext context) {
+		return new Compiling(context);
 	}
 
-	@Override
-	public HighLevelDefinition load(TypeResolutionContext context) {
-		return compiled;
+	private class Compiling implements CompilingType {
+		private final TypeResolutionContext context;
+		
+		public Compiling(TypeResolutionContext context) {
+			this.context = context;
+		}
+		
+		@Override
+		public CompilingType getInner(String name) {
+			return null;
+		}
+
+		@Override
+		public HighLevelDefinition load() {
+			return compiled;
+		}
 	}
 }

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedInterface.java

 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.lexer.ZSTokenType;
 import org.openzen.zenscript.parser.ParsedAnnotation;
  * @author Hoofdgebruiker
  */
 public class ParsedInterface extends BaseParsedDefinition {
-	public static ParsedInterface parseInterface(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
+	public static ParsedInterface parseInterface(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
 		String name = tokens.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
 		List<ParsedTypeParameter> genericParameters = ParsedTypeParameter.parseAll(tokens);
 		List<IParsedType> superInterfaces = Collections.emptyList();
 		
 		ParsedInterface result = new ParsedInterface(pkg, position, modifiers, annotations, name, genericParameters, superInterfaces, outerDefinition);
 		while (tokens.optional(ZSTokenType.T_ACLOSE) == null) {
-			result.addMember(ParsedDefinitionMember.parse(tokens, result.compiled, null));
+			result.addMember(ParsedDefinitionMember.parse(tokens, result, null));
 		}
 		return result;
 	}
 	
 	private final InterfaceDefinition compiled;
 	
-	public ParsedInterface(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, List<ParsedTypeParameter> typeParameters, List<IParsedType> superInterfaces, HighLevelDefinition outerDefinition) {
-		super(position, modifiers, annotations);
+	public ParsedInterface(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, List<ParsedTypeParameter> typeParameters, List<IParsedType> superInterfaces, HighLevelDefinition outerDefinition) {
+		super(position, modifiers, pkg, annotations);
 		
 		this.typeParameters = typeParameters;
 		this.superInterfaces = superInterfaces;
 		
-		compiled = new InterfaceDefinition(position, pkg, name, modifiers, outerDefinition);
+		compiled = new InterfaceDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
 		compiled.setTypeParameters(ParsedTypeParameter.getCompiled(typeParameters));
 	}
 

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedStruct.java

 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.StructDefinition;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.lexer.ZSTokenType;
-import org.openzen.zenscript.codemodel.scope.BaseScope;
 import org.openzen.zenscript.parser.ParsedAnnotation;
 import org.openzen.zenscript.parser.member.ParsedDefinitionMember;
 
  * @author Hoofdgebruiker
  */
 public class ParsedStruct extends BaseParsedDefinition {
-	public static ParsedStruct parseStruct(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
+	public static ParsedStruct parseStruct(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
 		String name = tokens.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
 		List<ParsedTypeParameter> parameters = ParsedTypeParameter.parseAll(tokens);
 		
 		
 		ParsedStruct result = new ParsedStruct(pkg, position, modifiers, annotations, name, parameters, outerDefinition);
 		while (tokens.optional(ZSTokenType.T_ACLOSE) == null) {
-			result.addMember(ParsedDefinitionMember.parse(tokens, result.compiled, null));
+			result.addMember(ParsedDefinitionMember.parse(tokens, result, null));
 		}
 		return result;
 	}
 	
 	private final StructDefinition compiled;
 	
-	public ParsedStruct(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, List<ParsedTypeParameter> genericParameters, HighLevelDefinition outerDefinition) {
-		super(position, modifiers, annotations);
+	public ParsedStruct(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, List<ParsedTypeParameter> genericParameters, HighLevelDefinition outerDefinition) {
+		super(position, modifiers, pkg, annotations);
 		
 		this.parameters = genericParameters;
 		
-		compiled = new StructDefinition(position, pkg, name, modifiers, outerDefinition);
+		compiled = new StructDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
 		compiled.setTypeParameters(ParsedTypeParameter.getCompiled(genericParameters));
 	}
 

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedVariant.java

 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.VariantDefinition;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.lexer.ZSTokenType;
 import org.openzen.zenscript.parser.ParsedAnnotation;
  * @author Hoofdgebruiker
  */
 public class ParsedVariant extends BaseParsedDefinition {
-	public static ParsedVariant parseVariant(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
+	public static ParsedVariant parseVariant(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, ZSTokenParser tokens, HighLevelDefinition outerDefinition) {
 		String name = tokens.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
 		List<ParsedTypeParameter> typeParameters = ParsedTypeParameter.parseAll(tokens);
 		tokens.required(ZSTokenType.T_AOPEN, "{ expected");
 		
 		if (tokens.optional(ZSTokenType.T_SEMICOLON) != null) {
 			while (tokens.optional(ZSTokenType.T_ACLOSE) == null) {
-				result.addMember(ParsedDefinitionMember.parse(tokens, result.compiled, null));
+				result.addMember(ParsedDefinitionMember.parse(tokens, result, null));
 			}
 		} else {
 			tokens.required(ZSTokenType.T_ACLOSE, "} expected");
 	
 	private final VariantDefinition compiled;
 	
-	public ParsedVariant(ZSPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, List<ParsedTypeParameter> typeParameters, HighLevelDefinition outerDefinition) {
-		super(position, modifiers, annotations);
+	public ParsedVariant(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, List<ParsedTypeParameter> typeParameters, HighLevelDefinition outerDefinition) {
+		super(position, modifiers, pkg, annotations);
 		
 		this.typeParameters = typeParameters;
-		compiled = new VariantDefinition(position, pkg, name, modifiers, outerDefinition);
+		compiled = new VariantDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
 		compiled.setTypeParameters(ParsedTypeParameter.getCompiled(typeParameters));
 	}
 	

Parser/src/main/java/org/openzen/zenscript/parser/member/ParsedDefinitionMember.java

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.OperatorType;
-import org.openzen.zenscript.codemodel.context.CompilingType;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.lexer.ZSToken;
  * @author Hoofdgebruiker
  */
 public abstract class ParsedDefinitionMember {
-	public static ParsedDefinitionMember parse(ZSTokenParser tokens, HighLevelDefinition forDefinition, ParsedImplementation forImplementation) {
+	public static ParsedDefinitionMember parse(ZSTokenParser tokens, ParsedDefinition forDefinition, ParsedImplementation forImplementation) {
 		CodePosition start = tokens.getPosition();
 		ParsedAnnotation[] annotations = ParsedAnnotation.parseAnnotations(tokens);
 		int modifiers = 0;
 					initializer = ParsedExpression.parse(tokens);
 				}
 				tokens.required(ZSTokenType.T_SEMICOLON, "; expected");
-				return new ParsedField(start, forDefinition, modifiers, annotations, name, type, initializer, t.type == ZSTokenType.K_VAL, autoGetter, autoSetter);
+				return new ParsedField(start, forDefinition.getCompiled(), modifiers, annotations, name, type, initializer, t.type == ZSTokenType.K_VAL, autoGetter, autoSetter);
 			}
 			case K_THIS: {
 				tokens.next();
 				if (body == null)
 					throw new CompileException(start, CompileExceptionCode.METHOD_BODY_REQUIRED, "Function body is required for constructors");
 				
-				return new ParsedConstructor(start, forDefinition, forImplementation, modifiers, annotations, header, body);
+				return new ParsedConstructor(start, forDefinition.getCompiled(), forImplementation, modifiers, annotations, header, body);
 			}
 			case T_IDENTIFIER: {
 				String name = tokens.next().content;
 					tokens.required(ZSTokenType.T_ASSIGN, "= expected");
 					ParsedExpression value = ParsedExpression.parse(tokens);
 					tokens.required(ZSTokenType.T_SEMICOLON, "; expected");
-					return new ParsedConst(start, forDefinition, modifiers & ~Modifiers.CONST, annotations, name, type, value);
+					return new ParsedConst(start, forDefinition.getCompiled(), modifiers & ~Modifiers.CONST, annotations, name, type, value);
 				}
 				
 				ParsedFunctionHeader header = ParsedFunctionHeader.parse(tokens);
 				ParsedFunctionBody body = ParsedStatement.parseFunctionBody(tokens);
-				return new ParsedMethod(start, forDefinition, forImplementation, modifiers, annotations, name, header, body);
+				return new ParsedMethod(start, forDefinition.getCompiled(), forImplementation, modifiers, annotations, name, header, body);
 			}
 			case K_SET: {
 				tokens.next();
 					type = IParsedType.parse(tokens);
 				}
 				ParsedFunctionBody body = ParsedStatement.parseFunctionBody(tokens);
-				return new ParsedSetter(start, forDefinition, forImplementation, modifiers, annotations, name, type, body);
+				return new ParsedSetter(start, forDefinition.getCompiled(), forImplementation, modifiers, annotations, name, type, body);
 			}
 			case K_GET: {
 				tokens.next();
 					type = IParsedType.parse(tokens);
 				}
 				ParsedFunctionBody statements = ParsedStatement.parseFunctionBody(tokens);
-				return new ParsedGetter(start, forDefinition, forImplementation, modifiers, annotations, name, type, statements);
+				return new ParsedGetter(start, forDefinition.getCompiled(), forImplementation, modifiers, annotations, name, type, statements);
 			}
 			case K_IMPLEMENTS: {
 				tokens.next();
 				IParsedType type = IParsedType.parse(tokens);
-				ParsedImplementation implementation = new ParsedImplementation(start, forDefinition, modifiers, annotations, type);
+				ParsedImplementation implementation = new ParsedImplementation(start, forDefinition.getCompiled(), modifiers, annotations, type);
 				if (tokens.optional(ZSTokenType.T_SEMICOLON) == null) {
 					tokens.required(ZSTokenType.T_AOPEN, "{ expected");
 					while (tokens.optional(ZSTokenType.T_ACLOSE) == null) {
 			case T_BROPEN: {
 				ParsedFunctionHeader header = ParsedFunctionHeader.parse(tokens);
 				ParsedFunctionBody body = ParsedStatement.parseFunctionBody(tokens);
-				return new ParsedCaller(start, forDefinition, forImplementation, modifiers, annotations, header, body);
+				return new ParsedCaller(start, forDefinition.getCompiled(), forImplementation, modifiers, annotations, header, body);
 			}
 			case T_SQOPEN: {
 				tokens.next();
 				}
 				ParsedFunctionHeader header = ParsedFunctionHeader.parse(tokens);
 				ParsedFunctionBody body = ParsedStatement.parseFunctionBody(tokens);
-				return new ParsedOperator(start, forDefinition, forImplementation, modifiers, annotations, operator, header, body);
+				return new ParsedOperator(start, forDefinition.getCompiled(), forImplementation, modifiers, annotations, operator, header, body);
 			}
 			case T_CAT:
 				tokens.pushMark();
 					
 					// destructor
 					ParsedFunctionBody body = ParsedStatement.parseFunctionBody(tokens);
-					return new ParsedDestructor(start, forDefinition, forImplementation, modifiers, annotations, body);
+					return new ParsedDestructor(start, forDefinition.getCompiled(), forImplementation, modifiers, annotations, body);
 				}
 				tokens.reset();
 				// else it is a ~ operator, continue...
 				ZSToken token = tokens.next();
 				ParsedFunctionHeader header = ParsedFunctionHeader.parse(tokens);
 				ParsedFunctionBody body = ParsedStatement.parseFunctionBody(tokens);
-				return new ParsedOperator(start, forDefinition, forImplementation, modifiers, annotations, getOperator(token.type), header, body);
+				return new ParsedOperator(start, forDefinition.getCompiled(), forImplementation, modifiers, annotations, getOperator(token.type), header, body);
 			}
 			case T_EQUAL2: {
 				tokens.next();
 				ParsedFunctionHeader header = ParsedFunctionHeader.parse(tokens);
 				ParsedFunctionBody body = ParsedStatement.parseFunctionBody(tokens);
-				return new ParsedOperator(start, forDefinition, forImplementation, modifiers, annotations, OperatorType.EQUALS, header, body);
+				return new ParsedOperator(start, forDefinition.getCompiled(), forImplementation, modifiers, annotations, OperatorType.EQUALS, header, body);
 			}
 			case K_AS: {
 				tokens.next();
 				IParsedType type = IParsedType.parse(tokens);
 				ParsedFunctionBody body = ParsedStatement.parseFunctionBody(tokens);
-				return new ParsedCaster(start, forDefinition, forImplementation, modifiers, annotations, type, body);
+				return new ParsedCaster(start, forDefinition.getCompiled(), forImplementation, modifiers, annotations, type, body);
 			}
 			case K_IN: {
 				tokens.next();
 				ParsedFunctionHeader header = ParsedFunctionHeader.parse(tokens);
 				ParsedFunctionBody body = ParsedStatement.parseFunctionBody(tokens);
-				return new ParsedOperator(start, forDefinition, forImplementation, modifiers, annotations, OperatorType.CONTAINS, header, body);
+				return new ParsedOperator(start, forDefinition.getCompiled(), forImplementation, modifiers, annotations, OperatorType.CONTAINS, header, body);
 			}
 			case K_CLASS:
 			case K_INTERFACE:
 			case K_ALIAS:
 			case K_STRUCT:
 			case K_ENUM:
-				return new ParsedInnerDefinition(forDefinition, ParsedDefinition.parse(forDefinition.pkg, start, modifiers, annotations, tokens, forDefinition));
+				return new ParsedInnerDefinition(forDefinition.getCompiled(), ParsedDefinition.parse(forDefinition.pkg, start, modifiers, annotations, tokens, forDefinition.getCompiled()));
 			case K_FOR: {
 				tokens.next();
 				ParsedFunctionHeader header = ParsedFunctionHeader.parse(tokens);
 				ParsedFunctionBody body = ParsedStatement.parseFunctionBody(tokens);
-				return new ParsedIterator(start, forDefinition, modifiers, annotations, header, body);
+				return new ParsedIterator(start, forDefinition.getCompiled(), modifiers, annotations, header, body);
 			}
 			default:
 				if (modifiers == Modifiers.STATIC && tokens.peek().type == ZSTokenType.T_AOPEN) {
 					ParsedStatementBlock body = ParsedStatementBlock.parseBlock(tokens, annotations, true);
-					return new ParsedStaticInitializer(forDefinition, tokens.getPosition(), annotations, body);
+					return new ParsedStaticInitializer(forDefinition.getCompiled(), tokens.getPosition(), annotations, body);
 				}
 				throw new CompileException(tokens.getPosition(), CompileExceptionCode.UNEXPECTED_TOKEN, "Unexpected token: " + tokens.peek().content);
 		}
 	
 	public abstract void linkTypes(TypeResolutionContext context);
 	
-	public void registerInnerTypes(Map<String, CompilingType> innerTypes) {}
+	public void registerInnerTypes(Map<String, ParsedDefinition> innerTypes) {}
 	
 	public abstract IDefinitionMember getCompiled();
 	

Parser/src/main/java/org/openzen/zenscript/parser/member/ParsedInnerDefinition.java

 
 import java.util.Map;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.context.CompilingType;
+import org.openzen.zenscript.codemodel.context.LocalTypeResolutionContext;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.member.InnerDefinitionMember;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
 	}
 	
 	@Override
-	public void registerInnerTypes(Map<String, CompilingType> inner) {
+	public void registerInnerTypes(Map<String, ParsedDefinition> inner) {
 		inner.put(innerDefinition.getCompiled().name, innerDefinition);
 	}
 	

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/Main.java

 		File[] inputFiles = Optional.ofNullable(inputDirectory.listFiles((dir, name) -> name.endsWith(".zs"))).orElseGet(() -> new File[0]);
 		
 		ZSPackage pkg = new ZSPackage(null, "");
-		CompilingPackage compilingPkg = new CompilingPackage();
+		CompilingPackage compilingPkg = new CompilingPackage(pkg);
 		ParsedFile[] parsedFiles = parse(pkg, compilingPkg, inputFiles);
 		
 		ZSPackage global = new ZSPackage(null, "");
 	private static ParsedFile[] parse(ZSPackage pkg, CompilingPackage compilingPkg, File[] files) throws IOException {
 		ParsedFile[] parsedFiles = new ParsedFile[files.length];
 		for (int i = 0; i < files.length; i++) {
-			parsedFiles[i] = ParsedFile.parse(pkg, compilingPkg, new TestBracketParser(), files[i]);
+			parsedFiles[i] = ParsedFile.parse(compilingPkg, new TestBracketParser(), files[i]);
 		}
 		return parsedFiles;
 	}
 		SemanticModule result = Module.compileSyntaxToSemantic(
 				"scripts",
 				new String[0],
-				pkg,
 				compiling,
 				files,
 				space,

Shared/src/main/java/listeners/DummyListenerHandle.java

+package listeners;
+
+
+public final class DummyListenerHandle<T> implements ListenerHandle<T>, AutoCloseable {
+    public final T listener;
+    
+    public DummyListenerHandle(T listener) {
+        this.listener = listener;
+    }
+    
+    @Override
+    public void close() {
+    }
+    
+    public T getListener() {
+        return listener;
+    }
+}

Shared/src/main/java/listeners/ListenerHandle.java

+package listeners;
+
+
+public interface ListenerHandle<T> extends AutoCloseable {
+    @Override
+    public void close();
+    
+    T getListener();
+}

Shared/src/main/java/listeners/ListenerList.java

+package listeners;
+
+import listeners.ListenerList;
+import zsynthetic.FunctionTToVoid;
+
+public final class ListenerList<T> {
+    public static final int PRIORITY_HIGH = 100;
+    public static final int PRIORITY_DEFAULT = 0;
+    public static final int PRIORITY_LOW = -100;
+    private ListenerList<T>.EventListenerNode first = null;
+    private ListenerList<T>.EventListenerNode last = null;
+    
+    public ListenerHandle<T> add(T listener) {
+        return this.add(listener, ListenerList.PRIORITY_DEFAULT);
+    }
+    
+    public ListenerHandle<T> add(T listener, int priority) {
+        ListenerList<T>.EventListenerNode node = new ListenerList<T>.EventListenerNode(listener, priority);
+        if (first == null) {
+            this.first = this.last = node;
+        }
+        else {
+            ListenerList<T>.EventListenerNode previousNode = last;
+            while (previousNode != null && priority > previousNode.priority)
+                previousNode = previousNode.prev;
+            if (previousNode == null) {
+                node.next = first;
+                first.prev = previousNode;
+                this.first = node;
+            }
+            else {
+                if (previousNode.next == null)
+                    this.last = node;
+                else
+                    previousNode.next.prev = node;
+                previousNode.next = node;
+                node.prev = previousNode;
+            }
+        }
+        return node;
+    }
+    
+    public void clear() {
+        this.first = this.last = null;
+    }
+    
+    public void accept(FunctionTToVoid<T> consumer) {
+        ListenerList<T>.EventListenerNode current = first;
+        while (current != null) {
+            consumer.invoke(current.getListener());
+            current = current.next;
+        }
+    }
+    
+    public boolean getIsEmpty() {
+        return first == null;
+    }
+    private final class EventListenerNode implements ListenerHandle<T>, AutoCloseable {
+        public final T listener;
+        private final int priority;
+        private ListenerList<T>.EventListenerNode next = null;
+        private ListenerList<T>.EventListenerNode prev = null;
+        
+        public EventListenerNode(T listener, int priority) {
+            this.listener = listener;
+            this.priority = priority;
+        }
+        
+        @Override
+        public void close() {
+            if (prev == null)
+                ListenerList.this.first = next;
+            else
+                prev.next = next;
+            if (next == null)
+                ListenerList.this.last = prev;
+            else
+                next.prev = prev;
+        }
+        
+        public T getListener() {
+            return listener;
+        }
+    }
+}

Shared/src/main/java/live/ImmutableLiveBool.java

+package live;
+
+import listeners.DummyListenerHandle;
+import listeners.ListenerHandle;
+import live.ImmutableLiveBool;
+import zsynthetic.FunctionBoolBoolToVoid;
+
+public final class ImmutableLiveBool implements LiveBool {
+    public static final ImmutableLiveBool TRUE = new ImmutableLiveBool(true);
+    public static final ImmutableLiveBool FALSE = new ImmutableLiveBool(false);
+    public final boolean value;
+    
+    private ImmutableLiveBool(boolean value) {
+        this.value = value;
+    }
+    
+    @Override
+    public ListenerHandle<FunctionBoolBoolToVoid> addListener(FunctionBoolBoolToVoid listener) {
+        return new DummyListenerHandle<FunctionBoolBoolToVoid>(listener);
+    }
+    
+    public boolean getValue() {
+        return value;
+    }
+}

Shared/src/main/java/live/ImmutableLiveObject.java

+package live;
+
+import listeners.DummyListenerHandle;
+import listeners.ListenerHandle;
+import zsynthetic.FunctionTTToVoid;
+
+public final class ImmutableLiveObject<T> implements LiveObject<T> {
+    public final T value;
+    
+    public ImmutableLiveObject(T value) {
+        this.value = value;
+    }
+    
+    @Override
+    public ListenerHandle<FunctionTTToVoid<T>> addListener(FunctionTTToVoid<T> listener) {
+        return new DummyListenerHandle<FunctionTTToVoid<T>>(listener);
+    }
+    
+    public T getValue() {
+        return value;
+    }
+}

Shared/src/main/java/live/ImmutableLiveString.java

+package live;
+
+import listeners.DummyListenerHandle;
+import listeners.ListenerHandle;
+import zsynthetic.FunctionStringStringToVoid;
+
+public final class ImmutableLiveString implements LiveString {
+    public final String value;
+    
+    public ImmutableLiveString(String value) {
+        this.value = value;
+    }
+    
+    @Override
+    public ListenerHandle<FunctionStringStringToVoid> addListener(FunctionStringStringToVoid listener) {
+        return new DummyListenerHandle<FunctionStringStringToVoid>(listener);
+    }
+    
+    public String getValue() {
+        return value;
+    }
+}

Shared/src/main/java/live/InverseLiveBool.java

+package live;
+
+import listeners.ListenerHandle;
+import zsynthetic.FunctionBoolBoolToVoid;
+
+public final class InverseLiveBool implements LiveBool {
+    private final LiveBool source;
+    
+    public InverseLiveBool(LiveBool source) {
+        this.source = source;
+    }
+    
+    @Override
+    public boolean getValue() {
+        return !source.getValue();
+    }
+    
+    @Override
+    public ListenerHandle<FunctionBoolBoolToVoid> addListener(FunctionBoolBoolToVoid listener) {
+        return source.addListener((oldVal, newVal) -> 
+        listener.invoke(!oldVal, !newVal));
+    }
+}

Shared/src/main/java/live/LiveArrayList.java

+package live;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import listeners.ListenerHandle;
+import listeners.ListenerList;
+
+final class LiveArrayList<T> implements MutableLiveList<T>, AutoCloseable {
+    private final List<T> values = new ArrayList<T>();
+    private final ListenerList<LiveList.Listener<T>> listeners = new ListenerList<LiveList.Listener<T>>();
+    
+    @Override
+    public void add(T value) {
+        int index = values.size();
+        values.add(value);
+        listeners.accept(listener -> 
+        listener.onInserted(index, value));
+    }
+    
+    @Override
+    public void insert(int index, T value) {
+        values.add(index, value);
+        listeners.accept(listener -> 
+        listener.onInserted(index, value));
+    }
+    
+    @Override
+    public void setAt(int index, T value) {
+        T oldValue = values.get(index);
+        values.set(index, value);
+        listeners.accept(listener -> 
+        listener.onChanged(index, oldValue, value));
+    }
+    
+    @Override
+    public void remove(int index) {
+        T oldValue = values.remove(index);
+        listeners.accept(listener -> 
+        listener.onRemoved(index, oldValue));
+    }
+    
+    @Override
+    public void remove(T value) {
+        int index = this.indexOf(value);
+        if (index < 0)
+            return;
+        this.remove(index);
+    }
+    
+    @Override
+    public void clear() {
+        int i = this.getLength();
+        while (i > 0) {
+            i--;
+            this.remove(i);
+        }
+    }
+    
+    @Override
+    public Iterator<T> iterator() {
+        return values.iterator();
+    }
+    
+    @Override
+    public int indexOf(T value) {
+        return values.indexOf(value);
+    }
+    
+    @Override
+    public int getLength() {
+        return values.size();
+    }
+    
+    @Override
+    public T getAt(int index) {
+        return values.get(index);
+    }
+    
+    @Override
+    public ListenerHandle<LiveList.Listener<T>> addListener(LiveList.Listener<T> listener) {
+        return listeners.add(listener);
+    }
+    
+    @Override
+    public void close() {
+    }
+}

Shared/src/main/java/live/LiveBool.java

+package live;
+
+import listeners.ListenerHandle;
+import zsynthetic.FunctionBoolBoolToVoid;
+
+public interface LiveBool {
+    boolean getValue();
+    
+    ListenerHandle<FunctionBoolBoolToVoid> addListener(FunctionBoolBoolToVoid listener);
+}

Shared/src/main/java/live/LiveInt.java

+package live;
+
+import listeners.ListenerHandle;
+import zsynthetic.FunctionIntIntToVoid;
+
+public interface LiveInt {
+    int getValue();
+    
+    void setValue(int value);
+    
+    ListenerHandle<FunctionIntIntToVoid> addListener(FunctionIntIntToVoid listener);
+}

Shared/src/main/java/live/LiveList.java

+package live;
+
+import listeners.ListenerHandle;
+
+public interface LiveList<T> extends AutoCloseable, Iterable<T> {
+    @Override
+    public void close();
+    
+    int getLength();
+    
+    int indexOf(T value);
+    
+    T getAt(int index);
+    
+    ListenerHandle<LiveList.Listener<T>> addListener(LiveList.Listener<T> listener);
+    public interface Listener<T> {
+        void onInserted(int index, T value);
+        
+        void onChanged(int index, T oldValue, T newValue);
+        
+        void onRemoved(int index, T oldValue);
+    }
+}

Shared/src/main/java/live/LiveObject.java

+package live;
+
+import listeners.ListenerHandle;
+import zsynthetic.FunctionTTToVoid;
+
+public interface LiveObject<T> {
+    T getValue();
+    
+    ListenerHandle<FunctionTTToVoid<T>> addListener(FunctionTTToVoid<T> listener);
+}

Shared/src/main/java/live/LiveString.java

+package live;
+
+import listeners.ListenerHandle;
+import zsynthetic.FunctionStringStringToVoid;
+
+public interface LiveString {
+    String getValue();
+    
+    ListenerHandle<FunctionStringStringToVoid> addListener(FunctionStringStringToVoid listener);
+}

Shared/src/main/java/live/MutableLiveList.java

+package live;
+
+
+public interface MutableLiveList<T> extends AutoCloseable, LiveList<T> {
+    void add(T value);
+    
+    void insert(int index, T value);
+    
+    void setAt(int index, T value);
+    
+    void remove(int index);
+    
+    void remove(T value);
+    
+    void clear();
+    
+    @Override
+    public void close();
+}

Shared/src/main/java/org/openzen/zencode/shared/CharacterEntity.java

 package org.openzen.zencode.shared;
 
 public final class CharacterEntity {
-	public final char charValue;
-	public final String stringValue;
-	
-	public CharacterEntity(String stringValue, char charValue) {
-	    this.charValue = charValue;
-	    this.stringValue = stringValue;
-	}
-	
-	public char getCharValue() {
-	    return charValue;
-	}
-	
-	public String getStringValue() {
-	    return stringValue;
-	}
+    public final char charValue;
+    public final String stringValue;
+    
+    public CharacterEntity(String stringValue, char charValue) {
+        this.charValue = charValue;
+        this.stringValue = stringValue;
+    }
+    
+    public char getCharValue() {
+        return charValue;
+    }
+    
+    public String getStringValue() {
+        return stringValue;
+    }
 }

Shared/src/main/java/org/openzen/zencode/shared/CompileException.java

 package org.openzen.zencode.shared;
 
+import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileException;
 
 public final class CompileException extends RuntimeException {
-	public static CompileException internalError(String message) {
-	    return new CompileException(CodePosition.BUILTIN, CompileExceptionCode.INTERNAL_ERROR, message);
-	}
-	
-	public final CodePosition position;
-	public final CompileExceptionCode code;
-	
-	public CompileException(CodePosition position, CompileExceptionCode code, String message) {
-	    super(position.toString() + ": [" + code.toString() + "] " + message);
-	    
-	    this.position = position;
-	    this.code = code;
-	}
-	
-	public CodePosition getPosition() {
-	    return position;
-	}
-	
-	public CompileExceptionCode getCode() {
-	    return code;
-	}
+    public static CompileException internalError(String message) {
+        return new CompileException(CodePosition.BUILTIN, CompileExceptionCode.INTERNAL_ERROR, message);
+    }
+    
+    public final CodePosition position;
+    public final CompileExceptionCode code;
+    
+    public CompileException(CodePosition position, CompileExceptionCode code, String message) {
+        super(position.toString() + ": [" + code.toString() + "] " + message);
+        this.position = position;
+        this.code = code;
+    }
+    
+    public CodePosition getPosition() {
+        return position;
+    }
+    
+    public CompileExceptionCode getCode() {
+        return code;
+    }
 }

Shared/src/main/java/org/openzen/zencode/shared/ConcatMap.java

 package org.openzen.zencode.shared;
 
+import org.openzen.zencode.shared.ConcatMap;
 import stdlib.EqualsComparable;
 
-public final class ConcatMap<K extends EqualsComparable<K>, V>  {
-	public static final <K extends EqualsComparable<K>, V> ConcatMap<K, V> empty(Class<K> typeOfK, Class<V> typeOfV) {
-	    return new ConcatMap<K, V>(null, null, null);
-	}
-	
-	private final K key;
-	private final V value;
-	private final ConcatMap<K, V> remaining;
-	
-	private ConcatMap(K key, V value, ConcatMap<K, V> remaining) {
-	    this.key = key;
-	    this.value = value;
-	    this.remaining = remaining;
-	}
-	
-	public boolean getIsEmpty() {
-	    return key == null;
-	}
-	
-	public ConcatMap<K, V> concat(K key, V value) {
-	    return new ConcatMap<K, V>(key, value, this);
-	}
-	
-	public boolean contains(K key) {
-	    if (this.key == null)
-	        return false;
-	    if (key.equals_(this.key))
-	        return true;
-	    if (remaining == null)
-	        return false;
-	    return remaining.contains(key);
-	}
-	
-	public V getAt(K key) {
-	    if (this.key == null)
-	        return null;
-	    if (key.equals_(this.key))
-	        return value;
-	    return remaining.getAt(key);
-	}
-	
-	public V getOrDefault(K key, V defaultValue) {
-	    if (this.key == null)
-	        return defaultValue;
-	    if (key.equals_(this.key))
-	        return value;
-	    return remaining.getOrDefault(key, defaultValue);
-	}
+public final class ConcatMap<K extends EqualsComparable<K>, V> {
+    public static final <K extends EqualsComparable<K>, V> ConcatMap<K, V> empty(Class<K> typeOfK, Class<V> typeOfV) {
+        return new ConcatMap<K, V>(null, null, null);
+    }
+    
+    private final K key;
+    private final V value;
+    private final ConcatMap<K, V> remaining;
+    
+    private ConcatMap(K key, V value, ConcatMap<K, V> remaining) {
+        this.key = key;
+        this.value = value;
+        this.remaining = remaining;
+    }
+    
+    public boolean getIsEmpty() {
+        return key == null;
+    }
+    
+    public ConcatMap<K, V> concat(K key, V value) {
+        return new ConcatMap<K, V>(key, value, this);
+    }
+    
+    public boolean contains(K key) {
+        if (this.key == null)
+            return false;
+        if (key.equals_(this.key))
+            return true;
+        if (remaining == null)
+            return false;
+        return remaining.contains(key);
+    }
+    
+    public V getAt(K key) {
+        if (this.key == null)
+            return null;
+        if (key.equals_(this.key))
+            return value;
+        return remaining.getAt(key);
+    }
+    
+    public V getOrDefault(K key, V defaultValue) {
+        if (this.key == null)
+            return defaultValue;
+        if (key.equals_(this.key))
+            return value;
+        return remaining.getOrDefault(key, defaultValue);
+    }
 }

Shared/src/main/java/org/openzen/zencode/shared/StringExpansion.java

 	
 	static  {
 	    CharacterEntity[] entities = StringExpansion.getCharacterEntities();
-	    // TODO: getCharacterEntities().index(e => e.stringValue);
-	    
 	    NAMED_CHARACTER_ENTITIES = new HashMap<>();
 	    for (CharacterEntity entity : entities)
-	        
 	        StringExpansion.NAMED_CHARACTER_ENTITIES.put(entity.stringValue, entity);
 	}
 	
 	                return new Error("Unfinished escape sequence");
 	            switch (quoted.charAt(i + 1)) {
 	                case '\\':
-	                    
 	                    i++;
 	                    result.append('\\');
 	                    break;
 	                case '&':
-	                    
 	                    Result<CharacterEntity, String> temp1 = StringExpansion.readCharacterEntity(quoted, i + 1);
 	                    if (temp1 instanceof Result.Error)
 	                        return new Result.Error<>(((Result.Error<CharacterEntity, String>)temp1).value);
 	                    result.append('\'');
 	                    break;
 	                case 'u':
-	                    
 	                    if (i >= quoted.length() - 5)
 	                        return new Error("Unfinished escape sequence");
 	                    Result<Integer, String> temp2 = StringExpansion.readHexCharacter(quoted.charAt(i + 2));
 	                    result.append((char)hex0 << 12 | hex1 << 8 | hex2 << 4 | hex3);
 	                    break;
 	                default:
-	                    
 	                    return new Error("Illegal escape sequence");
 	            }
 	        }
 	    for (char c : self.toCharArray()) {
 	        switch (c) {
 	            case '\\':
-	                
 	                output.append("\\\\");
 	                break;
 	            case '"':
-	                
 	                if (quote == '"')
 	                    output.append("\\\"");
 	                else
 	                    output.append('"');
 	                break;
 	            case '\'':
-	                
 	                if (quote == '\'')
 	                    output.append("\\'");
 	                else
 	                output.append("\\t");
 	                break;
 	            default:
-	                
 	                if (escapeUnicode && c > '') {
 	                    output.append("\\u").append(Strings.lpad(Integer.toHexString((int)c), 4, '0'));
 	                }
 	    if (entity.charAt(0) == '#') {
 	        if (entity.length() < 2)
 	            return new Error("Character entity number too short");
-	        if (str.charAt(1) == 'x') {// hex character entity
-	            
+	        if (str.charAt(1) == 'x') {
 	            if (entity.length() != 7)
 	                return new Error("Hexadecimal character entity must have 4 hex digits");
 	            int ivalue = Integer.parseInt(entity.substring(2, entity.length()), 16);
 	            return new Ok(new CharacterEntity(entity, (char)ivalue));
 	        }
-	        else {// decimal character entity
-	            
+	        else {
 	            int ivalue = Integer.parseInt(entity.substring(1, entity.length()));
 	            return new Ok(new CharacterEntity(entity, (char)ivalue));
 	        }

Shared/src/main/java/org/openzen/zencode/shared/Taggable.java

 import java.util.Map;
 
 public class Taggable {
-	private final Map<Class<?>, Object> tags = new HashMap<Class<?>, Object>();
-	
-	public <T> void setTag(Class<T> typeOfT, T tag) {
-	    tags.put(typeOfT, tag);
-	}
-	
-	public <T> T getTag(Class<T> typeOfT) {
-	    return (T)(tags.get(typeOfT));
-	}
-	
-	public <T> boolean hasTag(Class<T> typeOfT) {
-	    return tags.containsKey(typeOfT);
-	}
-	
-	public void addAllTagsFrom(Taggable other) {
-	    tags.putAll(other.tags);
-	}
+    private final Map<Class<?>, Object> tags = new HashMap<Class<?>, Object>();
+    
+    public <T> void setTag(Class<T> typeOfT, T tag) {
+        tags.put(typeOfT, tag);
+    }
+    
+    public <T> T getTag(Class<T> typeOfT) {
+        return (T)(tags.get(typeOfT));
+    }
+    
+    public <T> boolean hasTag(Class<T> typeOfT) {
+        return tags.containsKey(typeOfT);
+    }
+    
+    public void addAllTagsFrom(Taggable other) {
+        tags.putAll(other.tags);
+    }
 }

Shared/src/main/java/org/openzen/zencode/shared/VirtualSourceFile.java

-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
 package org.openzen.zencode.shared;
 
 import java.io.IOException;
 import java.io.Reader;
 
-/**
- *
- * @author Hoofdgebruiker
- */
-public class VirtualSourceFile implements SourceFile {
-	private final String filename;
-	
-	public VirtualSourceFile(String filename) {
-		this.filename = filename;
-	}
-
-	@Override
-	public String getFilename() {
-		return filename;
-	}
-
-	@Override
-	public Reader open() throws IOException {
-		throw new UnsupportedOperationException("Cannot open virtual source files");
-	}
+public final class VirtualSourceFile implements SourceFile {
+    public final String filename;
+    
+    public VirtualSourceFile(String filename) {
+        this.filename = filename;
+    }
+    
+    @Override
+    public Reader open() throws IOException {
+        throw new AssertionError("Cannot open virtual source files");
+    }
+    
+    public String getFilename() {
+        return filename;
+    }
 
 	@Override
 	public void update(String content) throws IOException {
-		throw new UnsupportedOperationException("Cannot write to virtual source files");
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
 	}
 }

Shared/src/main/java/stdlib/Arrays.java

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import zsynthetic.Function1;
-import zsynthetic.Function2;
-import zsynthetic.Function3;
-import zsynthetic.Function4;
-import zsynthetic.Function5;
-import zsynthetic.Function6;
-import zsynthetic.Function7;
+import zsynthetic.FunctionIntTToBool;
+import zsynthetic.FunctionIntTToU;
+import zsynthetic.FunctionIntTToVoid;
+import zsynthetic.FunctionTToBool;
+import zsynthetic.FunctionTToU;
+import zsynthetic.FunctionTToVoid;
 
 public final class Arrays {
     private Arrays() {}
-	public static <T> T getFirst(Class<T> typeOfT, T[] self) {
-	    return self.length == 0 ? null : self[0];
-	}
-	
-	public static <T> T getLast(Class<T> typeOfT, T[] self) {
-	    return self.length == 0 ? null : self[self.length - 1];
-	}
-	
-	public static <T> void reverse(Class<T> typeOfT, T[] self) {
-	    int limitForI = self.length / 2;
-	    for (int i = 0; i < limitForI; i++) {
-	        T temp = self[i];
-	        self[i] = self[self.length - i - 1];
-	        self[self.length - i - 1] = temp;
-	    }
-	}
-	
-	public static <U, T> U[] map(Class<T> typeOfT, T[] self, Class<U> typeOfU, Function1<U, T> projection) {
-	    U[] temp1 = (U[])(Array.newInstance(typeOfU, self.length));
-	    for (int temp2 = 0; temp2 < temp1.length; temp2++)
-	        temp1[temp2] = projection.invoke(self[temp2]);
-	    return temp1;
-	}
-	
-	public static <U, T> U[] map(Class<T> typeOfT, T[] self, Class<U> typeOfU, Function2<U, T> projection) {
-	    U[] temp1 = (U[])(Array.newInstance(typeOfU, self.length));
-	    for (int temp2 = 0; temp2 < temp1.length; temp2++)
-	        temp1[temp2] = projection.invoke(temp2, self[temp2]);
-	    return temp1;
-	}
-	
-	public static <T> T[] filter(Class<T> typeOfT, T[] self, Function3<T> predicate) {
-	    List<T> values = new ArrayList<T>();
-	    for (T value : self)
-	        
-	        if (predicate.invoke(value))
-	            values.add(value);
-	    return values.toArray((T[])(Array.newInstance(typeOfT, values.size())));
-	}
-	
-	public static <T> T[] filter(Class<T> typeOfT, T[] self, Function4<T> predicate) {
-	    List<T> values = new ArrayList<T>();
-	    for (int i = 0; i < self.length; i++) {
-	        T value = self[i];
-	        
-	        if (predicate.invoke(i, value))
-	            values.add(value);
-	    }
-	    return values.toArray((T[])(Array.newInstance(typeOfT, values.size())));
-	}
-	
-	public static <T> void each(Class<T> typeOfT, T[] self, Function5<T> consumer) {
-	    for (T value : self)
-	        
-	        consumer.invoke(value);
-	}
-	
-	public static <T> void each(Class<T> typeOfT, T[] self, Function6<T> consumer) {
-	    for (int i = 0; i < self.length; i++) {
-	        T value = self[i];
-	        
-	        consumer.invoke(i, value);
-	    }
-	}
-	
-	public static <T> boolean contains(Class<T> typeOfT, T[] self, Function3<T> predicate) {
-	    for (T value : self)
-	        
-	        if (predicate.invoke(value))
-	            return true;
-	    return false;
-	}
-	
-	public static <T> boolean contains(Class<T> typeOfT, T[] self, Function4<T> predicate) {
-	    for (int i = 0; i < self.length; i++) {
-	        T value = self[i];
-	        
-	        if (predicate.invoke(i, value))
-	            return true;
-	    }
-	    return false;
-	}
-	
-	public static <T> boolean all(Class<T> typeOfT, T[] self, Function3<T> predicate) {
-	    for (T value : self)
-	        
-	        if (!predicate.invoke(value))
-	            return false;
-	    return true;
-	}
-	
-	public static <T> boolean all(Class<T> typeOfT, T[] self, Function4<T> predicate) {
-	    for (int i = 0; i < self.length; i++) {
-	        T value = self[i];
-	        
-	        if (!predicate.invoke(i, value))
-	            return false;
-	    }
-	    return true;
-	}
-	
-	public static <T> T first(Class<T> typeOfT, T[] self, Function3<T> predicate) {
-	    for (T value : self)
-	        
-	        if (predicate.invoke(value))
-	            return value;
-	    return null;
-	}
-	
-	public static <T> T first(Class<T> typeOfT, T[] self, Function4<T> predicate) {
-	    for (int i = 0; i < self.length; i++) {
-	        T value = self[i];
-	        
-	        if (predicate.invoke(i, value))
-	            return value;
-	    }
-	    return null;
-	}
-	
-	public static <T> T last(Class<T> typeOfT, T[] self, Function3<T> predicate) {
-	    int i = self.length;
-	    while (i > 0) {
-	        i--;
-	        if (predicate.invoke(self[i]))
-	            return self[i];
-	    }
-	    return null;
-	}
-	
-	public static <T> T last(Class<T> typeOfT, T[] self, Function4<T> predicate) {
-	    int i = self.length;
-	    while (i > 0) {
-	        i--;
-	        if (predicate.invoke(i, self[i]))
-	            return self[i];
-	    }
-	    return null;
-	}
-	
-	public static <T> int count(Class<T> typeOfT, T[] self, Function3<T> predicate) {
-	    int result = 0;
-	    for (T value : self)
-	        
-	        if (predicate.invoke(value))
-	            result++;
-	    return result;
-	}
-	
-	public static <T> int count(Class<T> typeOfT, T[] self, Function4<T> predicate) {
-	    int result = 0;
-	    for (int i = 0; i < self.length; i++) {
-	        T value = self[i];
-	        
-	        if (predicate.invoke(i, value))
-	            result++;
-	    }
-	    return result;
-	}
-	
-	public static <K, T> Map<K, T> index(Class<T> typeOfT, T[] self, Class<K> typeOfK, Function7<K, T> key) {
-	    Map<K, T> result = new HashMap<>();
-	    for (T value : self)
-	        
-	        result.put(key.invoke(value), value);
-	    return result;
-	}
+    public static <T> T getFirst(Class<T> typeOfT, T[] self) {
+        return self.length == 0 ? null : self[0];
+    }
+    
+    public static <T> T getLast(Class<T> typeOfT, T[] self) {
+        return self.length == 0 ? null : self[self.length - 1];
+    }
+    
+    public static <T> void reverse(Class<T> typeOfT, T[] self) {
+        int limitForI = self.length / 2;
+        for (int i = 0; i < limitForI; i++) {
+            T temp = self[i];
+            self[i] = self[self.length - i - 1];
+            self[self.length - i - 1] = temp;
+        }
+    }
+    
+    public static <U, T> U[] map(Class<T> typeOfT, T[] self, Class<U> typeOfU, FunctionTToU<U, T> projection) {
+        U[] temp1 = (U[])(Array.newInstance(typeOfU, self.length));
+        for (int temp2 = 0; temp2 < temp1.length; temp2++)
+            temp1[temp2] = projection.invoke(self[temp2]);
+        return temp1;
+    }
+    
+    public static <U, T> U[] map(Class<T> typeOfT, T[] self, Class<U> typeOfU, FunctionIntTToU<U, T> projection) {
+        U[] temp1 = (U[])(Array.newInstance(typeOfU, self.length));
+        for (int temp2 = 0; temp2 < temp1.length; temp2++)
+            temp1[temp2] = projection.invoke(temp2, self[temp2]);
+        return temp1;
+    }
+    
+    public static <T> T[] filter(Class<T> typeOfT, T[] self, FunctionTToBool<T> predicate) {
+        List<T> values = new ArrayList<T>();
+        for (T value : self)
+            if (predicate.invoke(value))
+                values.add(value);
+        return values.toArray((T[])(Array.newInstance(typeOfT, values.size())));
+    }
+    
+    public static <T> T[] filter(Class<T> typeOfT, T[] self, FunctionIntTToBool<T> predicate) {
+        List<T> values = new ArrayList<T>();
+        for (int i = 0; i < self.length; i++) {
+            T value = self[i];
+            if (predicate.invoke(i, value))
+                values.add(value);
+        }
+        return values.toArray((T[])(Array.newInstance(typeOfT, values.size())));
+    }
+    
+    public static <T> void each(Class<T> typeOfT, T[] self, FunctionTToVoid<T> consumer) {
+        for (T value : self)
+            consumer.invoke(value);
+    }
+    
+    public static <T> void each(Class<T> typeOfT, T[] self, FunctionIntTToVoid<T> consumer) {
+        for (int i = 0; i < self.length; i++) {
+            T value = self[i];
+            consumer.invoke(i, value);
+        }
+    }
+    
+    public static <T> boolean contains(Class<T> typeOfT, T[] self, FunctionTToBool<T> predicate) {
+        for (T value : self)
+            if (predicate.invoke(value))
+                return true;
+        return false;
+    }
+    
+    public static <T> boolean contains(Class<T> typeOfT, T[] self, FunctionIntTToBool<T> predicate) {
+        for (int i = 0; i < self.length; i++) {
+            T value = self[i];
+            if (predicate.invoke(i, value))
+                return true;
+        }
+        return false;
+    }
+    
+    public static <T> boolean all(Class<T> typeOfT, T[] self, FunctionTToBool<T> predicate) {
+        for (T value : self)
+            if (!predicate.invoke(value))
+                return false;
+        return true;
+    }
+    
+    public static <T> boolean all(Class<T> typeOfT, T[] self, FunctionIntTToBool<T> predicate) {
+        for (int i = 0; i < self.length; i++) {
+            T value = self[i];
+            if (!predicate.invoke(i, value))
+                return false;
+        }
+        return true;
+    }
+    
+    public static <T> T first(Class<T> typeOfT, T[] self, FunctionTToBool<T> predicate) {
+        for (T value : self)
+            if (predicate.invoke(value))
+                return value;
+        return null;
+    }
+    
+    public static <T> T first(Class<T> typeOfT, T[] self, FunctionIntTToBool<T> predicate) {
+        for (int i = 0; i < self.length; i++) {
+            T value = self[i];
+            if (predicate.invoke(i, value))
+                return value;
+        }
+        return null;
+    }
+    
+    public static <T> T last(Class<T> typeOfT, T[] self, FunctionTToBool<T> predicate) {
+        int i = self.length;
+        while (i > 0) {
+            i--;
+            if (predicate.invoke(self[i]))
+                return self[i];
+        }
+        return null;
+    }
+    
+    public static <T> T last(Class<T> typeOfT, T[] self, FunctionIntTToBool<T> predicate) {
+        int i = self.length;
+        while (i > 0) {
+            i--;
+            if (predicate.invoke(i, self[i]))
+                return self[i];
+        }
+        return null;
+    }
+    
+    public static <T> int count(Class<T> typeOfT, T[] self, FunctionTToBool<T> predicate) {
+        int result = 0;
+        for (T value : self)
+            if (predicate.invoke(value))
+                result++;
+        return result;
+    }
+    
+    public static <T> int count(Class<T> typeOfT, T[] self, FunctionIntTToBool<T> predicate) {
+        int result = 0;
+        for (int i = 0; i < self.length; i++) {
+            T value = self[i];
+            if (predicate.invoke(i, value))
+                result++;
+        }
+        return result;
+    }
+    
+    public static <K, T> Map<K, T> index(Class<T> typeOfT, T[] self, Class<K> typeOfK, FunctionTToU<K, T> key) {
+        Map<K, T> result = new HashMap<>();
+        for (T value : self)
+            result.put(key.invoke(value), value);
+        return result;
+    }
 }

Shared/src/main/java/stdlib/Assoc.java

 
 import java.util.HashMap;
 import java.util.Map;
-import zsynthetic.Function8;
+import zsynthetic.FunctionTToU;
 
 public final class Assoc {
     private Assoc() {}
-	static <W, K, V> Map<K, W> mapValues(Class<K> typeOfK, Class<V> typeOfV, Map<K, V> self, Class<W> typeOfW, Function8<W, V> projection) {
+	static <W, K, V> Map<K, W> mapValues(Class<K> typeOfK, Class<V> typeOfV, Map<K, V> self, Class<W> typeOfW, FunctionTToU<W, V> projection) {
 	    Map<K, W> result = new HashMap<>();
 	    for (Map.Entry<K, V> temp1 : self.entrySet()) {
 	        K k = temp1.getKey();
 	        V v = temp1.getValue();
-	        
 	        result.put(k, projection.invoke(v));
 	    }
 	    return result;

Shared/src/main/java/stdlib/EnforcementLevel.java

 package stdlib;
 
 public enum EnforcementLevel {
-	INFO,
-	ENFORCE,
-	PROVE
+	INFO(),
+	ENFORCE(),
+	PROVE()
 }

Shared/src/main/java/stdlib/EqualsComparable.java

 package stdlib;
 
-public interface EqualsComparable<T>  {
-	boolean equals_(T other);
+public interface EqualsComparable<T> {
+    boolean equals_(T other);
 }

Shared/src/main/java/stdlib/Hashable.java

 package stdlib;
 
-public interface Hashable<T>  {
-	int hashCode();
-	
-	boolean equals_(T other);
+public interface Hashable<T> {
+    int hashCode();
+    
+    boolean equals_(T other);
 }

Shared/src/main/java/stdlib/Result.java

 import stdlib.Result;
 import stdlib.Result.Error;
 import stdlib.Result.Ok;
-import zsynthetic.Function10;
-import zsynthetic.Function11;
-import zsynthetic.Function9;
+import zsynthetic.FunctionTToResultWithUV;
+import zsynthetic.FunctionTToU;
 
 public abstract class Result<T, E> {
-	public <R> Result<R, E> then(Class<R> typeOfR, Function9<R, E, T> fn) {
-	    Result<R, E> temp1;
-	    switch (this.getDiscriminant()) {
-	        case Ok:
-	            T result = ((Result.Ok<T, E>)this).value;
-	            temp1 = fn.invoke(result);
-	            break;
-	        case Error:
-	            E error = ((Result.Error<T, E>)this).value;
-	            temp1 = new Error(error);
-	            break;
-	        default:
-	            throw new AssertionError("Missing case");
-	    }
-	    return temp1;
-	}
-	
-	public <X> Result<T, X> handle(Class<X> typeOfX, Function10<T, X, E> handler) {
-	    Result<T, X> temp1;
-	    switch (this.getDiscriminant()) {
-	        case Ok:
-	            T result = ((Result.Ok<T, E>)this).value;
-	            temp1 = new Ok(result);
-	            break;
-	        case Error:
-	            E error = ((Result.Error<T, E>)this).value;
-	            temp1 = handler.invoke(error);
-	            break;
-	        default:
-	            throw new AssertionError("Missing case");
-	    }
-	    return temp1;
-	}
-	
-	public T expect() {
-	    T temp1;
-	    switch (this.getDiscriminant()) {
-	        case Ok:
-	            T result = ((Result.Ok<T, E>)this).value;
-	            temp1 = result;
-	            break;
-	        case Error:
-	            E error = ((Result.Error<T, E>)this).value;
-	            throw new AssertionError("expect() called on an error value");
-	        default:
-	            throw new AssertionError("Missing case");
-	    }
-	    return temp1;
-	}
-	
-	public T orElse(T other) {
-	    T temp1;
-	    switch (this.getDiscriminant()) {
-	        case Ok:
-	            T result = ((Result.Ok<T, E>)this).value;
-	            temp1 = result;
-	            break;
-	        case Error:
-	            E error = ((Result.Error<T, E>)this).value;
-	            temp1 = other;
-	            break;
-	        default:
-	            throw new AssertionError("Missing case");
-	    }
-	    return temp1;
-	}
-	
-	public T orElse(Function11<T, E> other) {
-	    T temp1;
-	    switch (this.getDiscriminant()) {
-	        case Ok:
-	            T result = ((Result.Ok<T, E>)this).value;
-	            temp1 = result;
-	            break;
-	        case Error:
-	            E error = ((Result.Error<T, E>)this).value;
-	            temp1 = other.invoke(error);
-	            break;
-	        default:
-	            throw new AssertionError("Missing case");
-	    }
-	    return temp1;
-	}
+    public <R> Result<R, E> then(Class<R> typeOfR, FunctionTToResultWithUV<R, E, T> fn) {
+        Result<R, E> temp1;
+        switch (this.getDiscriminant()) {
+            case Ok:
+                T result = ((Result.Ok<T, E>)this).value;
+                temp1 = fn.invoke(result);
+                break;
+            case Error:
+                E error = ((Result.Error<T, E>)this).value;
+                temp1 = new Error(error);
+                break;
+            default:
+                throw new AssertionError("Missing case");
+        }
+        return temp1;
+    }
+    
+    public <X> Result<T, X> handle(Class<X> typeOfX, FunctionTToResultWithUV<T, X, E> handler) {
+        Result<T, X> temp1;
+        switch (this.getDiscriminant()) {
+            case Ok:
+                T result = ((Result.Ok<T, E>)this).value;
+                temp1 = new Ok(result);
+                break;
+            case Error:
+                E error = ((Result.Error<T, E>)this).value;
+                temp1 = handler.invoke(error);
+                break;
+            default:
+                throw new AssertionError("Missing case");
+        }
+        return temp1;
+    }
+    
+    public T expect() {
+        T temp1;
+        switch (this.getDiscriminant()) {
+            case Ok:
+                T result = ((Result.Ok<T, E>)this).value;
+                temp1 = result;
+                break;
+            case Error:
+                E error = ((Result.Error<T, E>)this).value;
+                throw new AssertionError("expect() called on an error value");
+            default:
+                throw new AssertionError("Missing case");
+        }
+        return temp1;
+    }
+    
+    public T orElse(T other) {
+        T temp1;
+        switch (this.getDiscriminant()) {
+            case Ok:
+                T result = ((Result.Ok<T, E>)this).value;
+                temp1 = result;
+                break;
+            case Error:
+                E error = ((Result.Error<T, E>)this).value;
+                temp1 = other;
+                break;
+            default:
+                throw new AssertionError("Missing case");
+        }
+        return temp1;
+    }
+    
+    public T orElse(FunctionTToU<T, E> other) {
+        T temp1;
+        switch (this.getDiscriminant()) {
+            case Ok:
+                T result = ((Result.Ok<T, E>)this).value;
+                temp1 = result;
+                break;
+            case Error:
+                E error = ((Result.Error<T, E>)this).value;
+                temp1 = other.invoke(error);
+                break;
+            default:
+                throw new AssertionError("Missing case");
+        }
+        return temp1;
+    }
     public abstract Discriminant getDiscriminant();
     
     public static enum Discriminant {
         Error,
     }
     
-    public static class Ok<T, E>  extends Result<T, E> {
+    public static class Ok<T, E> extends Result<T, E> {
         public final T value;
         
         public Ok(T value){
         }
     }
     
-    public static class Error<T, E>  extends Result<T, E> {
+    public static class Error<T, E> extends Result<T, E> {
         public final E value;
         
         public Error(E value){
             return Discriminant.Error;
         }
     }
-	public static <T, E extends Exception> T unwrap(Class<T> typeOfT, Class<E> typeOfE, Result<T, E> self) throws E {
-	    T temp1;
-	    switch (self.getDiscriminant()) {
-	        case Ok:
-	            T result = ((Result.Ok<T, E>)self).value;
-	            temp1 = result;
-	            break;
-	        case Error:
-	            E error = ((Result.Error<T, E>)self).value;
-	            throw error;
-	        default:
-	            throw new AssertionError("Missing case");
-	    }
-	    return temp1;
-	}
+    public static <T, E extends Exception> T unwrap(Class<T> typeOfT, Class<E> typeOfE, Result<T, E> self) throws E {
+        T temp1;
+        switch (self.getDiscriminant()) {
+            case Ok:
+                T result = ((Result.Ok<T, E>)self).value;
+                temp1 = result;
+                break;
+            case Error:
+                E error = ((Result.Error<T, E>)self).value;
+                throw error;
+            default:
+                throw new AssertionError("Missing case");
+        }
+        return temp1;
+    }
 }

Shared/src/main/java/stdlib/StringBuildable.java

 
 
 public interface StringBuildable {
-	void toString(StringBuilder output);
-	
-	String toString();
+    void toString(StringBuilder output);
+    
+    String toString();
 }

Shared/src/main/java/stdlib/StringBuilder.java

 
 
 public final class StringBuilder {
-	public static StringBuilder shl(StringBuilder self, StringBuildable value) {
-	    value.toString(self);
-	    return self;
-	}
+    public static StringBuilder shl(StringBuilder self, StringBuildable value) {
+        value.toString(self);
+        return self;
+    }
 }

Shared/src/main/java/zsynthetic/ArrayHelpers.java

 public class ArrayHelpers {
     public static <T> boolean contains(T[] haystack, T needle) {
         for (int i = 0; i < haystack.length; i++)
-            if (java.util.Objects.equals(haystack[i], needle))
+            if (haystack[i].equals(needle))
                 return true;
         return false;
     }

Shared/src/main/java/zsynthetic/Function10.java

-package zsynthetic;
-import stdlib.Result;
-
-
-@FunctionalInterface
-public interface Function10<T, X, E>  {
-    Result<T, X> invoke(E error);
-}

Shared/src/main/java/zsynthetic/Function11.java

-package zsynthetic;
-
-@FunctionalInterface
-public interface Function11<T, E>  {
-    T invoke(E error);
-}

Shared/src/main/java/zsynthetic/Function7.java

-package zsynthetic;
-
-@FunctionalInterface
-public interface Function7<K, T>  {
-    K invoke(T value);
-}

Shared/src/main/java/zsynthetic/Function8.java

-package zsynthetic;
-
-@FunctionalInterface
-public interface Function8<W, V>  {
-    W invoke(V value);
-}

Shared/src/main/java/zsynthetic/FunctionBoolBoolToVoid.java

+package zsynthetic;
+
+@FunctionalInterface
+public interface FunctionBoolBoolToVoid {
+    void invoke(boolean oldValue, boolean newValue);
+}

Shared/src/main/java/zsynthetic/FunctionIntIntToVoid.java

+package zsynthetic;
+
+@FunctionalInterface
+public interface FunctionIntIntToVoid {
+    void invoke(int oldValue, int newValue);
+}

Shared/src/main/java/zsynthetic/Function4.java → Shared/src/main/java/zsynthetic/FunctionIntTToBool.java

 package zsynthetic;
 
 @FunctionalInterface
-public interface Function4<T>  {
+public interface FunctionIntTToBool<T> {
     boolean invoke(int index, T value);
 }

Shared/src/main/java/zsynthetic/Function2.java → Shared/src/main/java/zsynthetic/FunctionIntTToU.java

 package zsynthetic;
 
 @FunctionalInterface
-public interface Function2<U, T>  {
+public interface FunctionIntTToU<U, T> {
     U invoke(int index, T value);
 }

Shared/src/main/java/zsynthetic/Function6.java → Shared/src/main/java/zsynthetic/FunctionIntTToVoid.java

 package zsynthetic;
 
 @FunctionalInterface
-public interface Function6<T>  {
+public interface FunctionIntTToVoid<T> {
     void invoke(int index, T value);
 }

Shared/src/main/java/zsynthetic/FunctionStringStringToVoid.java

+package zsynthetic;
+
+@FunctionalInterface
+public interface FunctionStringStringToVoid {
+    void invoke(String oldValue, String newValue);
+}

Shared/src/main/java/zsynthetic/FunctionTTToVoid.java

+package zsynthetic;
+
+@FunctionalInterface
+public interface FunctionTTToVoid<T> {
+    void invoke(T oldValue, T newValue);
+}

Shared/src/main/java/zsynthetic/Function3.java → Shared/src/main/java/zsynthetic/FunctionTToBool.java

 package zsynthetic;
 
 @FunctionalInterface
-public interface Function3<T>  {
+public interface FunctionTToBool<T> {
     boolean invoke(T value);
 }

Shared/src/main/java/zsynthetic/Function9.java → Shared/src/main/java/zsynthetic/FunctionTToResultWithUV.java

 
 
 @FunctionalInterface
-public interface Function9<R, E, T>  {
+public interface FunctionTToResultWithUV<R, E, T> {
     Result<R, E> invoke(T result);
 }

Shared/src/main/java/zsynthetic/Function1.java → Shared/src/main/java/zsynthetic/FunctionTToU.java

 package zsynthetic;
 
 @FunctionalInterface
-public interface Function1<U, T>  {
+public interface FunctionTToU<U, T> {
     U invoke(T value);
 }

Shared/src/main/java/zsynthetic/Function5.java → Shared/src/main/java/zsynthetic/FunctionTToVoid.java

 package zsynthetic;
 
 @FunctionalInterface
-public interface Function5<T>  {
+public interface FunctionTToVoid<T> {
     void invoke(T value);
 }