- Added (key, value) iterator for associative arrays

- Added type bounds checking code
- Fixed definitions not being added to the respective packages
- Fixed various bugs with generics
- Added some things to stdlib and created collections library

CodeModel/src/main/java/org/openzen/zenscript/codemodel/FunctionHeader.java

 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 
 /**
  *
 		return new FunctionHeader(genericParameters, returnType, parameters);
 	}
 	
-	public ITypeID[] inferTypes(CallArguments arguments, List<ITypeID> resultHint) {
+	public ITypeID[] inferTypes(LocalMemberCache cache, CallArguments arguments, List<ITypeID> resultHint) {
 		if (arguments.arguments.length != this.parameters.length)
 			return null;
 		
 		if (!resultHint.isEmpty()) {
 			Map<TypeParameter, ITypeID> temp = new HashMap<>();
 			for (ITypeID hint : resultHint) {
-				if (returnType.inferTypeParameters(hint, temp)) {
+				if (returnType.inferTypeParameters(cache, hint, temp)) {
 					mapping = temp;
 					break;
 				}
 		
 		// TODO: lambda header inference
 		for (int i = 0; i < parameters.length; i++)
-			if (!parameters[i].type.inferTypeParameters(arguments.arguments[i].type, mapping))
+			if (!parameters[i].type.inferTypeParameters(cache, arguments.arguments[i].type, mapping))
 				return null;
 		
 		if (mapping.size() > typeParameters.length)

CodeModel/src/main/java/org/openzen/zenscript/codemodel/HighLevelDefinition.java

 import org.openzen.zenscript.codemodel.definition.DefinitionVisitor;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.member.ConstructorMember;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
  * @author Hoofdgebruiker
  */
 public abstract class HighLevelDefinition extends Taggable {
-	private static final TypeParameter[] NO_PARAMETERS = new TypeParameter[0];
-	
 	public final CodePosition position;
 	public final ZSPackage pkg;
 	public final String name;
 	public final int modifiers;
 	public final List<IDefinitionMember> members = new ArrayList<>();
-	public TypeParameter[] genericParameters = NO_PARAMETERS;
+	public TypeParameter[] genericParameters = null;
 	
 	public HighLevelDefinition outerDefinition;
 	public ITypeID superType;
 		this.name = name;
 		this.modifiers = modifiers;
 		this.outerDefinition = outerDefinition;
+		
+		if (pkg != null)
+			pkg.register(this);
+	}
+	
+	public int getNumberOfGenericParameters() {
+		return genericParameters == null ? 0 : genericParameters.length;
 	}
 	
 	public void setOuterDefinition(HighLevelDefinition outerDefinition) {
 		return enumMembers;
 	}
 	
+	public boolean hasEmptyConstructor() {
+		for (IDefinitionMember member : members) {
+			if (member instanceof ConstructorMember) {
+				if (((ConstructorMember) member).header.parameters.length == 0)
+					return true;
+			}
+		}
+		
+		return false;
+	}
+	
 	public boolean isStatic() {
 		return (modifiers & Modifiers.STATIC) > 0;
 	}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/definition/ZSPackage.java

 		if (subPackages.containsKey(name))
 			throw new RuntimeException("Such package already exists: " + name);
 		
-		subPackages.put(name, this);
+		subPackages.put(name, subPackage);
 	}
 	
 	public IPartialExpression getMember(CodePosition position, GlobalTypeRegistry registry, GenericName name) {
-		if (subPackages.containsKey(name.name) && name.arguments.isEmpty())
+		if (subPackages.containsKey(name.name) && name.hasNoArguments())
 			return new PartialPackageExpression(position, subPackages.get(name.name));
 		
 		if (types.containsKey(name.name)) {
-			if (types.get(name.name).genericParameters.length != name.arguments.size())
+			if (types.get(name.name).genericParameters.length != name.getNumberOfArguments())
 				throw new CompileException(position, CompileExceptionCode.TYPE_ARGUMENTS_INVALID_NUMBER, "Invalid number of type arguments");
 			
 			return new PartialTypeExpression(position, registry.getForDefinition(types.get(name.name), name.arguments));
 			return null;
 		
 		GenericName name = nameParts.get(depth);
-		if (subPackages.containsKey(name.name) && name.arguments.isEmpty())
+		if (subPackages.containsKey(name.name) && name.hasNoArguments())
 			return subPackages.get(name.name).getType(position, scope, nameParts, depth + 1);
 		
 		if (types.containsKey(name.name)) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/CallArguments.java

 	
 	public CallArguments(ITypeID[] typeArguments, Expression[] arguments) {
 		if (typeArguments == null)
-			throw new IllegalArgumentException("Type arguments cannot be null!");
+			typeArguments = NO_TYPE_ARGUMENTS;
 		if (arguments == null)
 			throw new IllegalArgumentException("Arguments cannot be null!");
 		

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/CallExpression.java

 	public final Expression target;
 	public final FunctionalMember member;
 	public final CallArguments arguments;
+	public final FunctionHeader instancedHeader;
 	
 	public CallExpression(CodePosition position, Expression target, FunctionalMember member, FunctionHeader instancedHeader, CallArguments arguments) {
 		super(position, instancedHeader.returnType);
 		this.target = target;
 		this.member = member;
 		this.arguments = arguments;
+		this.instancedHeader = instancedHeader;
 	}
 	
 	public Expression getFirstArgument() {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/CallStaticExpression.java

  */
 package org.openzen.zenscript.codemodel.expression;
 
+import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.member.FunctionalMember;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
 	public final FunctionalMember member;
 	public final ITypeID target;
 	public final CallArguments arguments;
+	public final FunctionHeader instancedHeader;
 	
-	public CallStaticExpression(CodePosition position, ITypeID target, FunctionalMember member, CallArguments arguments) {
+	public CallStaticExpression(CodePosition position, ITypeID target, FunctionalMember member, CallArguments arguments, FunctionHeader instancedHeader) {
 		super(position, member.header.returnType);
 		
 		this.member = member;
 		this.target = target;
 		this.arguments = arguments;
+		this.instancedHeader = instancedHeader;
 	}
 
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/EnumConstantExpression.java

  */
 package org.openzen.zenscript.codemodel.expression;
 
-import java.util.Collections;
 import org.openzen.zenscript.codemodel.definition.EnumDefinition;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 	}
 	
 	public EnumConstantExpression(CodePosition position, GlobalTypeRegistry registry, EnumDefinition type, EnumConstantMember value) {
-		super(position, registry.getForDefinition(type, Collections.emptyList()));
+		super(position, registry.getForDefinition(type, null));
 		
 		this.value = value;
 	}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/Expression.java

 		TypeMembers members = scope.getTypeMembers(type);
 		return members.getMemberExpression(position, this, name, false);
 	}
+	
+	@Override
+	public ITypeID[] getGenericCallTypes() {
+		return null;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/WrapOptionalExpression.java

 	public WrapOptionalExpression(CodePosition position, Expression value, ITypeID optionalType) {
 		super(position, optionalType);
 		
+		if (value.type.isOptional())
+			throw new IllegalArgumentException("Value is already optional");
+		
 		this.value = value;
 	}
 

CodeModel/src/main/java/org/openzen/zenscript/codemodel/generic/GenericParameterBound.java

 	
 	public abstract void registerMembers(LocalMemberCache cache, TypeMembers type);
 	
-	public abstract boolean matches(ITypeID type);
+	public abstract boolean matches(LocalMemberCache cache, ITypeID type);
 	
 	public abstract GenericParameterBound withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments);
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/generic/ParameterSuperBound.java

 	}
 
 	@Override
-	public boolean matches(ITypeID type) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	public boolean matches(LocalMemberCache cache, ITypeID type) {
+		return cache.get(this.type).extendsOrImplements(type);
 	}
 
 	@Override
 	public GenericParameterBound withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		ITypeID translated = type.withGenericArguments(registry, arguments);
+		if (translated == type)
+			return this;
+		
+		return new ParameterSuperBound(translated);
 	}
 
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/generic/ParameterTypeBound.java

 	}
 
 	@Override
-	public boolean matches(ITypeID type) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	public boolean matches(LocalMemberCache cache, ITypeID type) {
+		return cache.get(type).extendsOrImplements(this.type);
 	}
 
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/generic/TypeParameter.java

 import java.util.Map;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.shared.CodePosition;
 
 /**
 		bounds.add(bound);
 	}
 	
-	public boolean matches(ITypeID type) {
+	public boolean matches(LocalMemberCache cache, ITypeID type) {
 		for (GenericParameterBound bound : bounds) {
-			if (!bound.matches(type))
+			if (!bound.matches(cache, type))
 				return false;
 		}
 		

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/FunctionalMember.java

 	
 	@Override
 	public Expression callStatic(CodePosition position, ITypeID target, FunctionHeader instancedHeader, CallArguments arguments) {
-		return new CallStaticExpression(position, target, this, arguments);
+		return new CallStaticExpression(position, target, this, arguments, instancedHeader);
 	}
 	
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/InnerDefinition.java

 package org.openzen.zenscript.codemodel.member;
 
 import java.util.Collections;
-import java.util.List;
 import java.util.Map;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 		this.outerTypeArguments = outerTypeArguments;
 	}
 	
-	public DefinitionTypeID instance(GlobalTypeRegistry registry, List<ITypeID> typeArguments) {
+	public DefinitionTypeID instance(GlobalTypeRegistry registry, ITypeID[] typeArguments) {
 		return registry.getForDefinition(definition, typeArguments, outerTypeArguments);
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/builtin/AssocIterator.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.zenscript.codemodel.member.builtin;
+
+import java.util.Map;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.iterator.ForeachIteratorVisitor;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.member.IIteratorMember;
+import org.openzen.zenscript.codemodel.member.MemberVisitor;
+import org.openzen.zenscript.codemodel.type.AssocTypeID;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
+import org.openzen.zenscript.codemodel.type.member.TypeMembers;
+import org.openzen.zenscript.shared.CodePosition;
+import org.openzen.zenscript.shared.Taggable;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class AssocIterator extends Taggable implements IIteratorMember {
+	private final AssocTypeID type;
+	private final ITypeID[] loopVariableTypes;
+	
+	public AssocIterator(AssocTypeID type) {
+		this.type = type;
+		
+		loopVariableTypes = new ITypeID[2];
+		loopVariableTypes[0] = type.keyType;
+		loopVariableTypes[1] = type.valueType;
+	}
+	
+	@Override
+	public CodePosition getPosition() {
+		return CodePosition.BUILTIN;
+	}
+
+	@Override
+	public int getLoopVariableCount() {
+		return loopVariableTypes.length;
+	}
+
+	@Override
+	public ITypeID[] getLoopVariableTypes() {
+		return loopVariableTypes;
+	}
+
+	@Override
+	public String describe() {
+		return "iterator for key/value pairs in an associative array";
+	}
+
+	@Override
+	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
+		type.addIterator(this, priority);
+	}
+
+	@Override
+	public IDefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
+		return new AssocIterator(type.withGenericArguments(registry, mapping));
+	}
+
+	@Override
+	public <T> T accept(MemberVisitor<T> visitor) {
+		throw new UnsupportedOperationException("Not a compilable member");
+	}
+
+	@Override
+	public <T> T acceptForIterator(ForeachIteratorVisitor<T> visitor) {
+		return visitor.visitArrayKeyValueIterator();
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/IPartialExpression.java

 	
 	Expression call(CodePosition position, TypeScope scope, List<ITypeID> hints, CallArguments arguments);
 	
+	ITypeID[] getGenericCallTypes();
+	
 	default Expression assign(CodePosition position, TypeScope scope, Expression value) {
 		throw new CompileException(position, CompileExceptionCode.CANNOT_ASSIGN, "This expression is not assignable");
 	}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialGlobalExpression.java

 	private final CodePosition position;
 	private final String name;
 	private final IPartialExpression resolution;
+	private final ITypeID[] typeParameters;
 	
-	public PartialGlobalExpression(CodePosition position, String name, IPartialExpression resolution) {
+	public PartialGlobalExpression(CodePosition position, String name, IPartialExpression resolution, ITypeID[] typeParameters) {
 		this.position = position;
 		this.name = name;
 		this.resolution = resolution;
+		this.typeParameters = typeParameters;
 	}
 	
 	@Override
 	public Expression call(CodePosition position, TypeScope scope, List<ITypeID> hints, CallArguments arguments) {
 		return new GlobalCallExpression(position, name, arguments, resolution.call(position, scope, hints, arguments));
 	}
+
+	@Override
+	public ITypeID[] getGenericCallTypes() {
+		return typeParameters;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialMemberGroupExpression.java

 	private final CodePosition position;
 	private final Expression target;
 	private final DefinitionMemberGroup group;
+	private final ITypeID[] typeArguments;
 	private final boolean allowStaticUsage;
 	
-	public PartialMemberGroupExpression(CodePosition position, Expression target, DefinitionMemberGroup group, boolean allowStaticMembers) {
+	public PartialMemberGroupExpression(CodePosition position, Expression target, DefinitionMemberGroup group, ITypeID[] typeArguments, boolean allowStaticMembers) {
 		this.position = position;
 		this.target = target;
 		this.group = group;
+		this.typeArguments = typeArguments;
 		this.allowStaticUsage = allowStaticMembers;
 	}
 	
-	public PartialMemberGroupExpression(CodePosition position, Expression target, ICallableMember member, boolean allowStaticMembers) {
+	public PartialMemberGroupExpression(CodePosition position, Expression target, ICallableMember member, ITypeID[] typeArguments, boolean allowStaticMembers) {
 		this.position = position;
 		this.target = target;
 		this.group = DefinitionMemberGroup.forMethod(member);
+		this.typeArguments = typeArguments;
 		this.allowStaticUsage = allowStaticMembers;
 	}
 
 	
 	@Override
 	public IPartialExpression capture(CodePosition position, LambdaClosure closure) {
-		return new PartialMemberGroupExpression(position, target.capture(position, closure).eval(), group, allowStaticUsage);
+		return new PartialMemberGroupExpression(position, target.capture(position, closure).eval(), group, typeArguments, allowStaticUsage);
+	}
+
+	@Override
+	public ITypeID[] getGenericCallTypes() {
+		return typeArguments;
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialPackageExpression.java

 	public Expression call(CodePosition position, TypeScope scope, List<ITypeID> hints, CallArguments arguments) {
 		throw new CompileException(position, CompileExceptionCode.USING_PACKAGE_AS_CALL_TARGET, "Cannot call a package");
 	}
+
+	@Override
+	public ITypeID[] getGenericCallTypes() {
+		return null;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialStaticMemberGroupExpression.java

  * @author Hoofdgebruiker
  */
 public class PartialStaticMemberGroupExpression implements IPartialExpression {
-	public static PartialStaticMemberGroupExpression forMethod(CodePosition position, ITypeID target, ICallableMember method) {
+	public static PartialStaticMemberGroupExpression forMethod(CodePosition position, ITypeID target, ICallableMember method, ITypeID[] typeArguments) {
 		DefinitionMemberGroup group = new DefinitionMemberGroup(true);
 		group.addMethod(method, TypeMemberPriority.SPECIFIED);
-		return new PartialStaticMemberGroupExpression(position, target, group);
+		return new PartialStaticMemberGroupExpression(position, target, group, typeArguments);
 	}
 	
 	private final CodePosition position;
 	private final ITypeID target;
 	private final DefinitionMemberGroup group;
+	private final ITypeID[] typeArguments;
 	
-	public PartialStaticMemberGroupExpression(CodePosition position, ITypeID target, DefinitionMemberGroup group) {
+	public PartialStaticMemberGroupExpression(CodePosition position, ITypeID target, DefinitionMemberGroup group, ITypeID[] typeArguments) {
 		this.position = position;
 		this.group = group;
 		this.target = target;
+		this.typeArguments = typeArguments;
 	}
 	
 	@Override
 	public Expression assign(CodePosition position, TypeScope scope, Expression value) {
 		return group.staticSetter(position, scope, value);
 	}
+
+	@Override
+	public ITypeID[] getGenericCallTypes() {
+		return typeArguments;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialTypeExpression.java

 	public Expression call(CodePosition position, TypeScope scope, List<ITypeID> hints, CallArguments arguments) {
 		return scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CALL).callStatic(position, type, scope, arguments);
 	}
+
+	@Override
+	public ITypeID[] getGenericCallTypes() {
+		return null;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/scope/TypeScope.java

 
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 
 /**
 public interface TypeScope {
 	public GlobalTypeRegistry getTypeRegistry();
 	
+	public LocalMemberCache getMemberCache();
+	
 	public TypeMembers getTypeMembers(ITypeID type);
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/ArrayTypeID.java

 		return elementType.hasInferenceBlockingTypeParameters(parameters);
 	}
 
+	@Override
+	public boolean hasDefaultValue() {
+		return false;
+	}
+
 	@Override
 	public int hashCode() {
 		int hash = 7;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/AssocTypeID.java

 	}
 	
 	@Override
-	public ITypeID withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments) {
+	public AssocTypeID withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments) {
 		return registry.getAssociative(
 				keyType.withGenericArguments(registry, arguments),
 				valueType.withGenericArguments(registry, arguments));
 		return keyType.hasInferenceBlockingTypeParameters(parameters) || valueType.hasInferenceBlockingTypeParameters(parameters);
 	}
 
+	@Override
+	public boolean hasDefaultValue() {
+		return true;
+	}
+
 	@Override
 	public int hashCode() {
 		int hash = 7;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/BasicTypeID.java

 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {
 		return false;
 	}
+
+	@Override
+	public boolean hasDefaultValue() {
+		return true;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/ConstTypeID.java

 	public String toString() {
 		return "const " + baseType.toString();
 	}
+
+	@Override
+	public boolean hasDefaultValue() {
+		return baseType.hasDefaultValue();
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/DefinitionTypeID.java

  */
 package org.openzen.zenscript.codemodel.type;
 
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 		if (definition.genericParameters.length > 0)
 			throw new IllegalArgumentException("Definition has type arguments!");
 		
-		return new DefinitionTypeID(definition, NO_TYPE_PARAMETERS);
+		return new DefinitionTypeID(definition, null);
 	}
 	
 	private static final OuterTypeEntry[] NO_OUTER_ENTRIES = new OuterTypeEntry[0];
-	private static final ITypeID[] NO_TYPE_PARAMETERS = new ITypeID[0];
 	
 	public final HighLevelDefinition definition;
 	public final ITypeID[] typeParameters;
 			Arrays.sort(outerTypeEntries, (a, b) -> a.parameter.name.compareTo(b.parameter.name));
 		}
 		
-		if (typeParameters.length != definition.genericParameters.length)
+		if ((typeParameters == null ? 0 : typeParameters.length) != definition.getNumberOfGenericParameters())
 			throw new RuntimeException("Invalid number of type parameters");
 	}
 	
+	public boolean hasTypeParameters() {
+		return typeParameters != null && typeParameters.length > 0;
+	}
+	
 	public void init(GlobalTypeRegistry registry) {
 		ITypeID superType = definition.superType;
-		if (superType != null && typeParameters.length > 0) {
+		if (superType != null && hasTypeParameters()) {
 			Map<TypeParameter, ITypeID> genericSuperArguments = new HashMap<>();
 			for (int i = 0; i < typeParameters.length; i++)
 				genericSuperArguments.put(definition.genericParameters[i], typeParameters[i]);
 	// To be used exclusively by StaticDefinitionTypeID
 	protected DefinitionTypeID(HighLevelDefinition definition) {
 		this.definition = definition;
-		this.typeParameters = new ITypeID[0];
+		this.typeParameters = null;
 		this.superType = definition.superType;
 		this.outerTypeParameters = Collections.emptyMap();
 		this.outerTypeEntries = NO_OUTER_ENTRIES;
 	
 	@Override
 	public ITypeID withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments) {
-		if (typeParameters.length == 0 && outerTypeParameters.isEmpty())
+		if (!hasTypeParameters() && outerTypeParameters.isEmpty())
 			return this;
 		
-		List<ITypeID> instancedArguments = new ArrayList<>();
-		for (int i = 0; i < typeParameters.length; i++) {
-			instancedArguments.add(arguments.containsKey(definition.genericParameters[i]) ? arguments.get(definition.genericParameters[i]) : typeParameters[i].withGenericArguments(registry, arguments));
+		ITypeID[] instancedArguments = null;
+		if (typeParameters != null) {
+			instancedArguments = new ITypeID[typeParameters.length];
+			for (int i = 0; i < typeParameters.length; i++) {
+				instancedArguments[i] = arguments.containsKey(definition.genericParameters[i]) ? arguments.get(definition.genericParameters[i]) : typeParameters[i].withGenericArguments(registry, arguments);
+			}
 		}
+		
 		Map<TypeParameter, ITypeID> instancedOuter;
 		if (outerTypeParameters.isEmpty()) {
 			instancedOuter = Collections.emptyMap();
 
 	@Override
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {
-		for (ITypeID typeParameter : typeParameters)
-			if (typeParameter.hasInferenceBlockingTypeParameters(parameters))
-				return true;
+		if (typeParameters != null) {
+			for (ITypeID typeParameter : typeParameters)
+				if (typeParameter.hasInferenceBlockingTypeParameters(parameters))
+					return true;
+		}
 		
 		return superType != null && superType.hasInferenceBlockingTypeParameters(parameters);
 	}
 	
 	@Override
 	public String toString() {
-		if (typeParameters.length == 0) {
+		if (typeParameters == null) {
 			return definition.name;
 		} else {
 			StringBuilder result = new StringBuilder();
 			return result.toString();
 		}
 	}
+
+	@Override
+	public boolean hasDefaultValue() {
+		return definition.hasEmptyConstructor();
+	}
 	
 	private class OuterTypeEntry {
 		private final TypeParameter parameter;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/FunctionTypeID.java

 		return header.hasInferenceBlockingTypeParameters(parameters);
 	}
 
+	@Override
+	public boolean hasDefaultValue() {
+		return false;
+	}
+
 	@Override
 	public int hashCode() {
 		int hash = 5;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/GenericMapTypeID.java

 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {
 		return value.hasInferenceBlockingTypeParameters(parameters);
 	}
+
+	@Override
+	public boolean hasDefaultValue() {
+		return true;
+	}
 	
 	@Override
 	public String toString() {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/GenericName.java

  */
 package org.openzen.zenscript.codemodel.type;
 
-import java.util.Collections;
-import java.util.List;
-
 /**
  *
  * @author Hoofdgebruiker
  */
 public class GenericName {
 	public final String name;
-	public final List<ITypeID> arguments;
+	public final ITypeID[] arguments;
 	
 	public GenericName(String name) {
-		this(name, Collections.emptyList());
+		this(name, null);
 	}
 	
-	public GenericName(String name, List<ITypeID> arguments) {
+	public GenericName(String name, ITypeID[] arguments) {
 		this.name = name;
 		this.arguments = arguments;
 	}
 	
+	public int getNumberOfArguments() {
+		return arguments == null ? 0 : arguments.length;
+	}
+	
+	public boolean hasArguments() {
+		return arguments != null && arguments.length > 0;
+	}
+	
+	public boolean hasNoArguments() {
+		return arguments == null || arguments.length == 0;
+	}
+	
 	@Override
 	public String toString() {
 		StringBuilder result = new StringBuilder(name);
-		if (!arguments.isEmpty()) {
+		if (arguments != null) {
 			result.append("<");
+			for (int i = 0; i < arguments.length; i++) {
+				if (i > 0)
+					result.append(", ");
+				result.append(arguments[i].toString());
+			}
 			result.append(">");
 		}
 		return result.toString();

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/GenericTypeID.java

 
 import java.util.Map;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 
 /**
  *
 		this.parameter = parameter;
 	}
 	
-	public boolean matches(ITypeID type) {
-		return parameter.matches(type);
+	public boolean matches(LocalMemberCache cache, ITypeID type) {
+		return parameter.matches(cache, type);
 	}
 	
 	@Override
 		return false;
 	}
 
+	@Override
+	public boolean hasDefaultValue() {
+		return false;
+	}
+
 	@Override
 	public int hashCode() {
 		int hash = 7;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/GlobalTypeRegistry.java

 
 import java.util.Collections;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 		}
 	}
 	
-	public DefinitionTypeID getForDefinition(HighLevelDefinition definition, List<ITypeID> genericArguments) {
+	public DefinitionTypeID getForDefinition(HighLevelDefinition definition, ITypeID[] genericArguments) {
 		return this.getForDefinition(definition, genericArguments, Collections.emptyMap());
 	}
 	
-	public DefinitionTypeID getForDefinition(HighLevelDefinition definition, List<ITypeID> typeParameters, Map<TypeParameter, ITypeID> outerInstance) {
+	public DefinitionTypeID getForDefinition(HighLevelDefinition definition, ITypeID[] typeParameters, Map<TypeParameter, ITypeID> outerInstance) {
 		DefinitionTypeID id;
-		if (definition.genericParameters.length > 0 && typeParameters.isEmpty() && outerInstance.isEmpty()) {
+		if (definition.genericParameters == null && typeParameters == null && outerInstance.isEmpty()) {
 			// make it a static one
 			id = new StaticDefinitionTypeID(definition);
 		} else {
-			id = new DefinitionTypeID(definition, typeParameters.toArray(new ITypeID[typeParameters.size()]), outerInstance);
+			id = new DefinitionTypeID(definition, typeParameters, outerInstance);
 		}
 		
 		if (definitionTypes.containsKey(id)) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/ITypeID.java

 
 import java.util.Map;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 
 /**
  *
 		return this;
 	}
 	
+	public boolean hasDefaultValue();
+	
 	public ITypeID withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments);
 	
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters);
 	
 	// Infers type parameters for this type so it matches with targetType
 	// returns false if that isn't possible
-	public default boolean inferTypeParameters(ITypeID targetType, Map<TypeParameter, ITypeID> mapping) {
-		return accept(new MatchingTypeVisitor(targetType, mapping));
+	public default boolean inferTypeParameters(LocalMemberCache cache, ITypeID targetType, Map<TypeParameter, ITypeID> mapping) {
+		return accept(new MatchingTypeVisitor(cache, targetType, mapping));
 	}
 	
 	public static class MatchingTypeVisitor implements ITypeVisitor<Boolean> {
 		private final ITypeID type;
 		private final Map<TypeParameter, ITypeID> mapping;
+		private final LocalMemberCache cache;
 		
-		public MatchingTypeVisitor(ITypeID type, Map<TypeParameter, ITypeID> mapping) {
+		public MatchingTypeVisitor(LocalMemberCache cache, ITypeID type, Map<TypeParameter, ITypeID> mapping) {
 			this.type = type;
 			this.mapping = mapping;
+			this.cache = cache;
 		}
 
 		@Override
 		public Boolean visitGeneric(GenericTypeID generic) {
 			if (mapping.containsKey(generic.parameter)) {
 				return mapping.get(generic.parameter) == type;
-			} else if (generic.matches(type)) {
+			} else if (generic.matches(cache, type)) {
 				mapping.put(generic.parameter, type);
 				return true;
 			} else {
 			if (type == pattern)
 				return true;
 			
-			return pattern.accept(new MatchingTypeVisitor(type, mapping));
+			return pattern.accept(new MatchingTypeVisitor(cache, type, mapping));
 		}
 
 		@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/IteratorTypeID.java

 		return false;
 	}
 
+	@Override
+	public boolean hasDefaultValue() {
+		return false;
+	}
+
 	@Override
 	public int hashCode() {
 		int hash = 5;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/OptionalTypeID.java

 		return baseType.hasInferenceBlockingTypeParameters(parameters);
 	}
 
+	@Override
+	public boolean hasDefaultValue() {
+		return true;
+	}
+
 	@Override
 	public int hashCode() {
 		int hash = 7;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/RangeTypeID.java

 		return from.hasInferenceBlockingTypeParameters(parameters) || to.hasInferenceBlockingTypeParameters(parameters);
 	}
 
+	@Override
+	public boolean hasDefaultValue() {
+		return false;
+	}
+
 	@Override
 	public int hashCode() {
 		int hash = 5;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/member/BuiltinTypeMembers.java

 	public static final OperatorMember STRING_INDEXGET = new OperatorMember(BUILTIN, T_STRING, Modifiers.EXPORT | Modifiers.EXTERN, OperatorType.INDEXGET, new FunctionHeader(CHAR, new FunctionParameter(INT)));
 	public static final OperatorMember STRING_RANGEGET = new OperatorMember(BUILTIN, T_STRING, Modifiers.EXPORT | Modifiers.EXTERN, OperatorType.INDEXGET, new FunctionHeader(STRING, new FunctionParameter(RangeTypeID.INT)));
 	public static final GetterMember STRING_LENGTH = new GetterMember(BUILTIN, T_STRING, Modifiers.EXPORT | Modifiers.EXTERN, "length", INT);
+	public static final GetterMember STRING_CHARACTERS = new GetterMember(BUILTIN, T_STRING, Modifiers.PUBLIC | Modifiers.EXTERN, "characters", ArrayTypeID.CHAR);
 	
 	private static OperatorMember not(ClassDefinition cls, ITypeID result) {
 		return new OperatorMember(BUILTIN, cls, 0, OperatorType.NOT, new FunctionHeader(result));

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/member/DefinitionMemberGroup.java

 			if (header.typeParameters.length > 0) {
 				for (ITypeID resultHint : typeHints) {
 					Map<TypeParameter, ITypeID> mapping = new HashMap<>();
-					if (header.returnType.inferTypeParameters(resultHint, mapping)) {
+					if (header.returnType.inferTypeParameters(scope.getMemberCache(), resultHint, mapping)) {
 						header = header.withGenericArguments(scope.getTypeRegistry(), mapping);
 						break;
 					}
 	
 	public Expression call(CodePosition position, TypeScope scope, Expression target, CallArguments arguments, boolean allowStaticUsage) {
 		ICallableMember method = selectMethod(position, scope, arguments, true, allowStaticUsage);
+		FunctionHeader instancedHeader = method.getHeader().withGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
 		for (int i = 0; i < arguments.arguments.length; i++) {
-			arguments.arguments[i] = arguments.arguments[i].castImplicit(position, scope, method.getHeader().parameters[i].type);
+			arguments.arguments[i] = arguments.arguments[i].castImplicit(position, scope, instancedHeader.parameters[i].type);
 		}
 		
-		FunctionHeader instancedHeader = method.getHeader().withGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
 		return method.call(position, target, instancedHeader, arguments);
 	}
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/member/LocalMemberCache.java

 	}
 	
 	private void registerMembers(TypeMembers members) {
-		members.type.accept(new TypeMemberBuilder(members, this));
+		members.type.accept(new TypeMemberBuilder(registry, members, this));
 		
 		for (ExpansionDefinition expansion : expansions) {
 			if (expansion.target == null)
 			return Collections.emptyMap();
 		
 		Map<TypeParameter, ITypeID> mapping = new HashMap<>();
-		if (pattern.inferTypeParameters(type, mapping))
+		if (pattern.inferTypeParameters(this, type, mapping))
 			return mapping;
 		
 		return null;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/member/TypeMemberBuilder.java

 import org.openzen.zenscript.codemodel.member.TranslatedOperatorMember;
 import org.openzen.zenscript.codemodel.member.builtin.ArrayIteratorKeyValues;
 import org.openzen.zenscript.codemodel.member.builtin.ArrayIteratorValues;
+import org.openzen.zenscript.codemodel.member.builtin.AssocIterator;
 import org.openzen.zenscript.codemodel.member.builtin.ComparatorMember;
 import org.openzen.zenscript.codemodel.member.builtin.ConstantGetterMember;
 import org.openzen.zenscript.codemodel.member.builtin.RangeIterator;
 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
 import org.openzen.zenscript.codemodel.type.GenericMapTypeID;
 import org.openzen.zenscript.codemodel.type.GenericTypeID;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.ITypeVisitor;
 import org.openzen.zenscript.codemodel.type.IteratorTypeID;
  * @author Hoofdgebruiker
  */
 public class TypeMemberBuilder implements ITypeVisitor<Void> {
+	private final GlobalTypeRegistry registry;
 	private final TypeMembers members;
 	private final LocalMemberCache cache;
 
-	public TypeMemberBuilder(TypeMembers members, LocalMemberCache cache) {
+	public TypeMemberBuilder(GlobalTypeRegistry registry, TypeMembers members, LocalMemberCache cache) {
+		this.registry = registry;
 		this.members = members;
 		this.cache = cache;
 		
 		FunctionHeader indexSetHeader = new FunctionHeader(VOID, new FunctionParameter(keyType, "key"), new FunctionParameter(valueType, "value"));
 		members.addOperator(new OperatorMember(BUILTIN, definition, 0, OperatorType.INDEXSET, indexSetHeader));
 		
-		FunctionHeader getOrDefaultHeader = new FunctionHeader(valueType, new FunctionParameter(keyType, "key"), new FunctionParameter(valueType, "defaultValue"));
+		FunctionHeader getOrDefaultHeader = new FunctionHeader(registry.getOptional(valueType), new FunctionParameter(keyType, "key"), new FunctionParameter(valueType, "defaultValue"));
 		members.addMethod(new MethodMember(BUILTIN, definition, 0, "getOrDefault", getOrDefaultHeader));
 		
 		members.addOperator(new OperatorMember(BUILTIN, definition, 0, OperatorType.CONTAINS, new FunctionHeader(BOOL, new FunctionParameter(keyType, "key"))));
 		members.addField(new FieldMember(BUILTIN, definition, Modifiers.FINAL, "size", INT));
 		members.addGetter(new GetterMember(BUILTIN, definition, 0, "empty", BOOL));
 		members.addGetter(new GetterMember(BUILTIN, definition, 0, "keys", cache.getRegistry().getArray(keyType, 1)));
+		
+		members.addIterator(new AssocIterator(assoc), TypeMemberPriority.SPECIFIED);
 		return null;
 	}
 	
 		
 		ClassDefinition definition = new ClassDefinition(BUILTIN, null, "", Modifiers.EXPORT);
 		members.addConstructor(new ConstructorMember(BUILTIN, definition, 0, new FunctionHeader(VOID)));
-		members.addMethod(new MethodMember(BUILTIN, definition, 0, "getOptional", new FunctionHeader(map.keys, valueType, new FunctionParameter[0])));
+		members.addMethod(new MethodMember(BUILTIN, definition, 0, "getOptional", new FunctionHeader(map.keys, registry.getOptional(valueType), new FunctionParameter[0])));
 		members.addMethod(new MethodMember(BUILTIN, definition, 0, "put", new FunctionHeader(map.keys, BasicTypeID.VOID, new FunctionParameter(valueType))));
 		members.addMethod(new MethodMember(BUILTIN, definition, 0, "contains", new FunctionHeader(map.keys, BasicTypeID.BOOL, new FunctionParameter[0])));
 		return null;
 	@Override
 	public Void visitDefinition(DefinitionTypeID type) {
 		HighLevelDefinition definition = type.definition;
-		if (type.typeParameters.length > 0 || !type.outerTypeParameters.isEmpty()) {
+		if (type.hasTypeParameters() || !type.outerTypeParameters.isEmpty()) {
 			Map<TypeParameter, ITypeID> mapping = new HashMap<>();
-			for (int i = 0; i < type.typeParameters.length; i++)
-				mapping.put(definition.genericParameters[i], type.typeParameters[i]);
+			if (type.typeParameters != null)
+				for (int i = 0; i < type.typeParameters.length; i++)
+					mapping.put(definition.genericParameters[i], type.typeParameters[i]);
+			
 			for (Map.Entry<TypeParameter, ITypeID> entry : type.outerTypeParameters.entrySet())
 				mapping.put(entry.getKey(), entry.getValue());
 			
 		ClassDefinition definition = new ClassDefinition(BUILTIN, null, "", Modifiers.EXPORT);
 		members.addField(new FieldMember(BUILTIN, definition, Modifiers.FINAL, "from", fromType), TypeMemberPriority.SPECIFIED);
 		members.addField(new FieldMember(BUILTIN, definition, Modifiers.FINAL, "to", toType), TypeMemberPriority.SPECIFIED);
-		members.addIterator(new RangeIterator(range), TypeMemberPriority.SPECIFIED);
+		if (range.from == range.to && (range.from == BasicTypeID.BYTE
+				|| range.from == BasicTypeID.SBYTE
+				|| range.from == BasicTypeID.SHORT
+				|| range.from == BasicTypeID.USHORT
+				|| range.from == BasicTypeID.INT
+				|| range.from == BasicTypeID.UINT
+				|| range.from == BasicTypeID.LONG
+				|| range.from == BasicTypeID.ULONG)) {
+			members.addIterator(new RangeIterator(range), TypeMemberPriority.SPECIFIED);
+		}
 		return null;
 	}
 
 		members.addOperator(STRING_INDEXGET);
 		members.addOperator(STRING_RANGEGET);
 		members.addGetter(STRING_LENGTH);
+		members.addGetter(STRING_CHARACTERS);
 
 		members.addConstructor(STRING_CONSTRUCTOR_CHARACTERS);
 		members.addConstructor(STRING_CONSTRUCTOR_CHARACTER_RANGE);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/member/TypeMembers.java

 		return cache;
 	}
 	
+	public boolean extendsOrImplements(ITypeID other) {
+		ITypeID superType = type.getSuperType();
+		if (superType != null) {
+			if (superType == other)
+				return true;
+			if (cache.get(superType).extendsOrImplements(other))
+				return true;
+		}
+		
+		for (TypeMember<ImplementationMember> implementation : implementations) {
+			if (implementation.member.type == other)
+				return true;
+			if (cache.get(implementation.member.type).extendsOrImplements(other))
+				return true;
+		}
+		
+		return false;
+	}
+	
 	public GlobalTypeRegistry getTypeRegistry() {
 		return cache.getRegistry();
 	}
 	
 	public void copyMembersTo(CodePosition position, TypeMembers other, TypeMemberPriority priority) {
 		other.casters.addAll(casters);
+		other.iterators.addAll(iterators);
 		
 		for (Map.Entry<String, EnumConstantMember> entry : enumMembers.entrySet())
 			other.addEnumMember(entry.getValue(), priority);
 		if (members.containsKey(name.name)) {
 			DefinitionMemberGroup group = members.get(name.name);
 			
-			if (!name.arguments.isEmpty()) {
-				/* ... */
-			}
-			
 			if (group.isStatic)
-				return new PartialStaticMemberGroupExpression(position, type, group);
+				return new PartialStaticMemberGroupExpression(position, type, group, name.arguments);
 			else
-				return new PartialMemberGroupExpression(position, target, group, allowStatic);
+				return new PartialMemberGroupExpression(position, target, group, name.arguments, allowStatic);
 		}
 		
 		return null;
 	
 	public IPartialExpression getStaticMemberExpression(CodePosition position, GenericName name) {
 		if (members.containsKey(name.name))
-			return new PartialStaticMemberGroupExpression(position, type, members.get(name.name));
+			return new PartialStaticMemberGroupExpression(position, type, members.get(name.name), name.arguments);
 		if (innerTypes.containsKey(name.name))
 			return new PartialTypeExpression(position, innerTypes.get(name.name).instance(cache.getRegistry(), name.arguments));
 		

Constructor/libraries/collections/module.json

+{
+	"package": "collections",
+	"host": "universal"
+}

Constructor/libraries/collections/src/HashSet.zs

+export class HashSet<T> {
+	public implements Set<T> {
+		add(value as T) as bool;
+		remove(value as T) as bool;
+		
+		in(value as T) as bool;
+		for(x as T);
+	}
+}

Constructor/libraries/collections/src/LinkedList.zs

+export class LinkedList<T> {
+	var first as Node?;
+	var last as Node?;
+	
+	public get empty as bool
+		=> first == null;
+	
+	public add(value as T) as void {
+		if first == null {
+			first = last = new Node(value);
+		} else {
+			val node = new Node(value);
+			last.next = node;
+			node.prev = last;
+			last = node;
+		}
+	}
+	
+	public implements Queue<T> {
+		poll() as T?
+			=> first == null ? null : first.value;
+		
+		peek() as T {
+			if first == null
+				throw new NoSuchElementException("Cannot peek an empty queue");
+			
+			return first.value;
+		}
+		
+		offer(value as T) as void
+			=> add(value);
+	}
+	
+	private struct Node {
+		var next as Node?;
+		var prev as Node?;
+		val value as T;
+		
+		this(value as T) {
+			this.value = value;
+		}
+	}
+}

Constructor/libraries/collections/src/NoSuchElementException.zs

+export class NoSuchElementException : Exception {
+	public this(message as string) {
+		super(message);
+	}
+}

Constructor/libraries/collections/src/Queue.zs

+export interface Queue<T> {
+	get empty as bool;
+	
+	poll() as T;
+	peek() as T;
+	push(value as T) as void;
+}

Constructor/libraries/collections/src/Set.zs

+export interface Set<T> {
+	add(value as T) as bool;
+	remove(value as T) as bool;
+	
+	in(value as T) as bool;
+	
+	for(x as T);
+}

Constructor/libraries/stdlib/module.json

 	"package": "stdlib",
 	"host": "universal",
 	"globals": {
+		"Comparable": {"type": "Definition", "definition": "Comparable"},
 		"Exception": {"type": "Definition", "definition": "Exception"},
 		"IllegalArgumentException": {"type": "Definition", "definition": "IllegalArgumentException"},
-		"StringBuilder": {"type": "Definition", "definition": "StringBuilder"}
+		"StringBuilder": {"type": "Definition", "definition": "StringBuilder"},
+		"StringBuildable": {"type": "Definition", "definition": "StringBuildable"}
 	}
 }

Constructor/libraries/stdlib/src/Comparable.zs

+export interface Comparable<T> {
+	compareTo(other as T) as int;
+}

Constructor/libraries/stdlib/src/StringBuildable.zs

+export interface StringBuildable {
+	toString(output as StringBuilder) as void;
+	
+	as string
+		=> new StringBuilder() << this;
+}

Constructor/libraries/stdlib/src/StringBuilder.zs

 	public extern this(capacity as int);
 	public extern this(value as string);
 	
-	public extern +=(value as string);
-	public extern +=(value as char);
+	public extern <<(value as bool) as StringBuilder;
+	public extern <<(value as char) as StringBuilder;
+	public extern <<(value as byte) as StringBuilder;
+	public extern <<(value as sbyte) as StringBuilder;
+	public extern <<(value as short) as StringBuilder;
+	public extern <<(value as ushort) as StringBuilder;
+	public extern <<(value as int) as StringBuilder;
+	public extern <<(value as uint) as StringBuilder;
+	public extern <<(value as float) as StringBuilder;
+	public extern <<(value as double) as StringBuilder;
+	public extern <<(value as string) as StringBuilder;
+	
+	public <<(value as StringBuildable) as StringBuilder {
+		value.toString(this);
+		return this;
+	}
 	
 	public extern implicit as string;
 }

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

 import java.io.File;
 import java.io.IOException;
 import org.openzen.zenscript.constructor.module.DirectoryModuleLoader;
+import org.openzen.zenscript.constructor.module.ModuleReference;
 
 public class Main {
     /**
 		}
 		
 		File currentDirectory = new File(arguments.directory);
-		File projectJson = new File(currentDirectory, "project.json");
-		if (!projectJson.exists()) {
-			System.out.println("Error: not a valid project (missing project.json)");
-			return;
-		}
-		
 		ModuleLoader moduleLoader = new ModuleLoader();
 		moduleLoader.register("stdlib", new DirectoryModuleLoader(moduleLoader, "stdlib", new File("libraries/stdlib"), true));
 		
-		Project project = new Project(projectJson);
-		for (String moduleName : project.modules) {
-			moduleLoader.register(moduleName, new DirectoryModuleLoader(moduleLoader, moduleName, new File(currentDirectory, moduleName), false));
+		Project project = new Project(moduleLoader, currentDirectory);
+		for (ModuleReference module : project.modules) {
+			moduleLoader.register(module.getName(), module);
 		}
 		
 		// TODO: compile targets
-		for (String moduleName : project.modules) {
-			moduleLoader.getModule(moduleName);
+		for (ModuleReference module : project.modules) {
+			moduleLoader.getModule(module.getName());
 		}
     }
 	

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

 import java.io.IOException;
 import org.json.JSONArray;
 import org.json.JSONObject;
+import org.openzen.zenscript.constructor.module.DirectoryModuleLoader;
+import org.openzen.zenscript.constructor.module.ModuleReference;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class Project {
-	public final String[] modules;
+	public final ModuleReference[] modules;
 	
-	public Project(File projectFile) throws IOException {
+	public Project(ModuleLoader loader, File directory) throws IOException {
+		if (!directory.exists())
+			throw new ConstructorException("Project directory doesn't exist");
+		if (!directory.isDirectory())
+			throw new ConstructorException("Project directory isn't a directory");
+		
+		File projectFile = new File(directory, "project.json");
+		if (!projectFile.exists())
+			throw new ConstructorException("Missing project.json file in project directory");
+		
 		JSONObject json = JSONUtils.load(projectFile);
 		
 		JSONArray jsonModules = json.getJSONArray("modules");
-		modules = new String[jsonModules.length()];
-		for (int i = 0; i < jsonModules.length(); i++)
-			modules[i] = jsonModules.getString(i);
+		modules = new ModuleReference[jsonModules.length()];
+		for (int i = 0; i < jsonModules.length(); i++) {
+			Object module = jsonModules.get(i);
+			if (module instanceof String) {
+				modules[i] = new DirectoryModuleLoader(loader, module.toString(), new File(directory, module.toString()), false);
+			} else if (module instanceof JSONObject) {
+				JSONObject jsonModule = (JSONObject) module;
+				String name = jsonModule.getString("name");
+				switch (jsonModule.getString("type")) {
+					case "directory":
+						modules[i] = new DirectoryModuleLoader(loader, name, new File(directory, jsonModule.getString("directory")), false);
+						break;
+					default:
+						throw new ConstructorException("Invalid module type: " + jsonModule.getString("type"));
+				}
+			}
+		}
 	}
 }

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

 		this.directory = directory;
 		this.isStdlib = isStdlib;
 	}
+	
+	@Override
+	public String getName() {
+		return moduleName;
+	}
 
 	@Override
 	public SemanticModule load() {

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

  * @author Hoofdgebruiker
  */
 public interface ModuleReference {
+	public String getName();
+	
 	public SemanticModule load();
 }

Linker/src/main/java/org/openzen/zenscript/linker/DefinitionScope.java

  */
 package org.openzen.zenscript.linker;
 
-import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 		this.outer = outer;
 		this.definition = definition;
 		
-		List<ITypeID> genericParameterList = new ArrayList<>();
-		for (TypeParameter parameter : definition.genericParameters) {
-			genericParameterList.add(outer.getTypeRegistry().getGeneric(parameter));
-			genericParameters.put(parameter.name, parameter);
+		ITypeID[] genericParameterList = null;
+		if (definition.genericParameters != null) {
+			genericParameterList = new ITypeID[definition.genericParameters.length];
+			for (int i = 0; i < definition.genericParameters.length; i++) {
+				TypeParameter parameter = definition.genericParameters[i];
+				genericParameterList[i] = outer.getTypeRegistry().getGeneric(parameter);
+				genericParameters.put(parameter.name, parameter);
+			}
 		}
 		
 		if (definition instanceof ExpansionDefinition) {
 	public IPartialExpression get(CodePosition position, GenericName name) {
 		if (members.hasInnerType(name.name))
 			return new PartialTypeExpression(position, members.getInnerType(position, name));
-		if (members.hasMember(name.name) && name.arguments.isEmpty())
+		if (members.hasMember(name.name) && !name.hasArguments())
 			return members.getMemberExpression(position, new ThisExpression(position, type), name, true);
-		if (genericParameters.containsKey(name.name) && name.arguments.isEmpty())
+		if (genericParameters.containsKey(name.name) && !name.hasArguments())
 			return new PartialTypeExpression(position, getTypeRegistry().getGeneric(genericParameters.get(name.name)));
 		
 		return outer.get(position, name);
 				result = getTypeMembers(result).getInnerType(position, name.get(i));
 			}
 			return result;
-		} else if (genericParameters.containsKey(name.get(0).name) && name.size() == 1 && name.get(0).arguments.isEmpty()) {
+		} else if (genericParameters.containsKey(name.get(0).name) && name.size() == 1 && !name.get(0).hasArguments()) {
 			return getTypeRegistry().getGeneric(genericParameters.get(name.get(0).name));
 		}
 		

Linker/src/main/java/org/openzen/zenscript/linker/FileScope.java

 		
 		if (globalSymbols.containsKey(name.name)) {
 			IPartialExpression resolution = globalSymbols.get(name.name).getExpression(position, globalRegistry, name.arguments);
-			return new PartialGlobalExpression(position, name.name, resolution);
+			return new PartialGlobalExpression(position, name.name, resolution, name.arguments);
 		}
 		
 		return rootPackage.getMember(position, globalRegistry, name);
 			}
 			
 			// TODO: take care of non-static inner classes in generic classes!
-			if (type != null && name.get(name.size() - 1).arguments.size() != type.definition.genericParameters.length)
+			if (type != null && name.get(name.size() - 1).getNumberOfArguments() != type.definition.getNumberOfGenericParameters())
 				throw new CompileException(position, CompileExceptionCode.TYPE_ARGUMENTS_INVALID_NUMBER, "Invalid number of type arguments");
 			
 			if (type != null)

Linker/src/main/java/org/openzen/zenscript/linker/ForeachScope.java

 
 	@Override
 	public IPartialExpression get(CodePosition position, GenericName name) {
-		if (name.arguments.isEmpty()) {
+		if (name.hasNoArguments()) {
 			for (VarStatement loopVariable : statement.loopVariables) {
 				if (loopVariable.name.equals(name.name))
 					return new GetLocalVariableExpression(position, loopVariable);

Linker/src/main/java/org/openzen/zenscript/linker/FunctionScope.java

 		if (fromSuper != null)
 			return fromSuper;
 		
-		if (name.arguments.isEmpty()) {
+		if (name.hasNoArguments()) {
 			for (FunctionParameter parameter : header.parameters) {
 				if (parameter.name.equals(name.name)) {
 					return new GetFunctionParameterExpression(position, parameter);
 
 	@Override
 	public ITypeID getType(CodePosition position, List<GenericName> name) {
-		if (name.size() == 1 && name.get(0).arguments.isEmpty()) {
+		if (name.size() == 1 && name.get(0).hasNoArguments()) {
 			for (TypeParameter parameter : header.typeParameters) {
 				if (parameter.name.equals(name.get(0).name))
 					return getTypeRegistry().getGeneric(parameter);

Linker/src/main/java/org/openzen/zenscript/linker/GenericFunctionScope.java

 	public GenericFunctionScope(BaseScope outer, TypeParameter[] parameters) {
 		this.outer = outer;
 		
-		for (TypeParameter parameter : parameters)
-			this.parameters.put(parameter.name, parameter);
+		if (parameters != null)
+			for (TypeParameter parameter : parameters)
+				this.parameters.put(parameter.name, parameter);
 	}
 	
 	@Override
 
 	@Override
 	public IPartialExpression get(CodePosition position, GenericName name) {
-		if (parameters.containsKey(name.name) && name.arguments.isEmpty())
+		if (parameters.containsKey(name.name) && name.hasNoArguments())
 			return new PartialTypeExpression(position, getTypeRegistry().getGeneric(parameters.get(name.name)));
 		
 		return outer.get(position, name);
 
 	@Override
 	public ITypeID getType(CodePosition position, List<GenericName> name) {
-		if (name.size() == 1 && parameters.containsKey(name.get(0).name) && name.get(0).arguments.isEmpty())
+		if (name.size() == 1 && parameters.containsKey(name.get(0).name) && name.get(0).hasNoArguments())
 			return getTypeRegistry().getGeneric(parameters.get(name.get(0).name));
 		
 		return outer.getType(position, name);

Linker/src/main/java/org/openzen/zenscript/linker/ImplementationScope.java

 	public IPartialExpression get(CodePosition position, GenericName name) {
 		if (members.hasInnerType(name.name))
 			return new PartialTypeExpression(position, members.getInnerType(position, name));
-		if (members.hasMember(name.name) && name.arguments.isEmpty())
+		if (members.hasMember(name.name))
 			return members.getMemberExpression(position, new ThisExpression(position, outer.getThisType()), name, true);
 		
 		return outer.get(position, name);

Linker/src/main/java/org/openzen/zenscript/linker/LambdaScope.java

 	public IPartialExpression get(CodePosition position, GenericName name) {
 		IPartialExpression outer = this.outer.get(position, name);
 		if (outer == null) {
-			if (name.arguments.isEmpty()) {
+			if (name.hasNoArguments()) {
 				for (FunctionParameter parameter : header.parameters) {
 					if (parameter.name.equals(name.name))
 						return new GetFunctionParameterExpression(position, parameter);

Linker/src/main/java/org/openzen/zenscript/linker/StatementScope.java

 	
 	@Override
 	public IPartialExpression get(CodePosition position, GenericName name) {
-		if (variables.containsKey(name.name) && name.arguments.isEmpty())
+		if (variables.containsKey(name.name) && name.hasNoArguments())
 			return new GetLocalVariableExpression(position, variables.get(name.name));
 		
 		return null;

Linker/src/main/java/org/openzen/zenscript/linker/symbol/ISymbol.java

  */
 package org.openzen.zenscript.linker.symbol;
 
-import java.util.List;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
  * @author Hoofdgebruiker
  */
 public interface ISymbol {
-	public IPartialExpression getExpression(CodePosition position, GlobalTypeRegistry types, List<ITypeID> typeArguments);
+	public IPartialExpression getExpression(CodePosition position, GlobalTypeRegistry types, ITypeID[] typeArguments);
 	
-	public ITypeID getType(CodePosition position, GlobalTypeRegistry types, List<ITypeID> typeArguments);
+	public ITypeID getType(CodePosition position, GlobalTypeRegistry types, ITypeID[] typeArguments);
 }

Linker/src/main/java/org/openzen/zenscript/linker/symbol/TypeSymbol.java

  */
 package org.openzen.zenscript.linker.symbol;
 
-import java.util.List;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
 	}
 	
 	@Override
-	public IPartialExpression getExpression(CodePosition position, GlobalTypeRegistry types, List<ITypeID> typeArguments) {
+	public IPartialExpression getExpression(CodePosition position, GlobalTypeRegistry types, ITypeID[] typeArguments) {
 		return new PartialTypeExpression(position, types.getForDefinition(definition, typeArguments));
 	}
 
 	@Override
-	public ITypeID getType(CodePosition position, GlobalTypeRegistry types, List<ITypeID> typeArguments) {
+	public ITypeID getType(CodePosition position, GlobalTypeRegistry types, ITypeID[] typeArguments) {
 		return types.getForDefinition(definition, typeArguments);
 	}
 }

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

 import gnu.trove.iterator.TIntIterator;
 import gnu.trove.map.hash.TIntIntHashMap;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 
 /**
 {
 	public static <T extends TokenType & Comparable<T>> CompiledDFA<T> createLexerDFA(T[] tokenTypes, Class<T> tokenClass)
 	{
-		List<T> tokens = new ArrayList<T>();
-		List<String> regexps = new ArrayList<String>();
+		List<T> tokens = new ArrayList<>();
+		List<String> regexps = new ArrayList<>();
 		for (T tokenType : tokenTypes) {
 			if (tokenType.getRegexp() != null) {
 				tokens.add(tokenType);

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

 	{
         tokenMemoryCurrent = marks.pop();
     }
+	
+	/**
+	 * Replaces the current token with another one. Used to split composite tokens.
+	 * 
+	 * @param other 
+	 */
+	public void replace(TT other) {
+		next = createToken(next.getPosition(), next.getWhitespaceBefore(), next.getContent(), other);
+	}
 
     // ===============================
     // === Iterator implementation ===

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

 		KEYWORDS.put("any", K_ANY);
 		KEYWORDS.put("bool", K_BOOL);
 		KEYWORDS.put("byte", K_BYTE);
-		KEYWORDS.put("ubyte", K_UBYTE);
+		KEYWORDS.put("sbyte", K_SBYTE);
 		KEYWORDS.put("short", K_SHORT);
 		KEYWORDS.put("ushort", K_USHORT);
 		KEYWORDS.put("int", K_INT);

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

 	K_ANY,
 	K_BOOL,
 	K_BYTE,
-	K_UBYTE,
+	K_SBYTE,
 	K_SHORT,
 	K_USHORT,
 	K_INT,

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

 	}
 	
 	public static List<ParsedGenericParameter> parseAll(ZSTokenStream tokens) {
+		if (tokens.optional(ZSTokenType.T_LESS) == null)
+			return null;
+		
 		List<ParsedGenericParameter> genericParameters = new ArrayList<>();
-		if (tokens.optional(ZSTokenType.T_LESS) != null) {
-			do {
-				genericParameters.add(ParsedGenericParameter.parse(tokens));
-			} while (tokens.optional(ZSTokenType.T_COMMA) != null);
-			tokens.required(ZSTokenType.T_GREATER, "> expected");
-		}
+		do {
+			genericParameters.add(ParsedGenericParameter.parse(tokens));
+		} while (tokens.optional(ZSTokenType.T_COMMA) != null);
+		tokens.required(ZSTokenType.T_GREATER, "> expected");
 		return genericParameters;
 	}
 	
 	public static void compile(BaseScope scope, TypeParameter[] compiled, List<ParsedGenericParameter> parameters) {
-		if (compiled.length == 0)
+		if (compiled == null)
 			return;
 		
 		GenericFunctionScope innerScope = new GenericFunctionScope(scope, compiled);
 	
 	private static TypeParameter[] NO_TYPE_PARAMETERS = new TypeParameter[0];
 	public static TypeParameter[] getCompiled(List<ParsedGenericParameter> parameters) {
-		if (parameters.isEmpty())
-			return NO_TYPE_PARAMETERS;
+		if (parameters == null)
+			return null;
 		
 		TypeParameter[] result = new TypeParameter[parameters.size()];
 		for (int i = 0; i < result.length; i++)

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

 		this.superInterfaces = superInterfaces;
 		
 		compiled = new InterfaceDefinition(position, pkg, name, modifiers, outerDefinition);
+		compiled.setTypeParameters(ParsedGenericParameter.getCompiled(genericParameters));
 	}
 
 	@Override

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedCallArguments.java

 	public CallArguments compileCall(
 			CodePosition position, 
 			ExpressionScope scope,
+			ITypeID[] genericParameters,
 			DefinitionMemberGroup member)
 	{
 		List<FunctionHeader> possibleHeaders = member.getMethodMembers().stream()
 				.map(method -> method.member.getHeader())
 				.collect(Collectors.toList());
-		return compileCall(position, scope, possibleHeaders);
+		return compileCall(position, scope, genericParameters, possibleHeaders);
 	}
 	
 	public CallArguments compileCall(
 			CodePosition position,
 			ExpressionScope scope,
+			ITypeID[] genericParameters,
 			List<FunctionHeader> candidateFunctions)
 	{
 		List<FunctionHeader> candidates = new ArrayList<>();
 		for (FunctionHeader header : candidateFunctions) {
-			if (isCompatibleWith(scope, header))
+			if (isCompatibleWith(scope, header, genericParameters))
 				candidates.add(header);
 		}
 		
 			cArguments[i] = cArgument.eval();
 		}
 		
-		ITypeID[] typeParameters = CallArguments.NO_TYPE_ARGUMENTS;
-		for (FunctionHeader candidate : candidates) {
-			if (candidate.typeParameters.length > 0) {
-				typeParameters = new ITypeID[candidate.typeParameters.length];
-				for (int i = 0; i < typeParameters.length; i++) {
-					if (innerScope.genericInferenceMap.get(candidate.typeParameters[i]) == null)
-						throw new CompileException(position, CompileExceptionCode.TYPE_ARGUMENTS_NOT_INFERRABLE, "Could not infer type parameter " + candidate.typeParameters[i].name);
-					else
-						typeParameters[i] = innerScope.genericInferenceMap.get(candidate.typeParameters[i]);
-				}
+		ITypeID[] typeParameters = genericParameters;
+		if (typeParameters == null) {
+			for (FunctionHeader candidate : candidates) {
+				if (candidate.typeParameters.length > 0) {
+					typeParameters = new ITypeID[candidate.typeParameters.length];
+					for (int i = 0; i < typeParameters.length; i++) {
+						if (innerScope.genericInferenceMap.get(candidate.typeParameters[i]) == null)
+							throw new CompileException(position, CompileExceptionCode.TYPE_ARGUMENTS_NOT_INFERRABLE, "Could not infer type parameter " + candidate.typeParameters[i].name);
+						else
+							typeParameters[i] = innerScope.genericInferenceMap.get(candidate.typeParameters[i]);
+					}
 
-				break;
+					break;
+				}
 			}
 		}
 		
 		return new CallArguments(new ITypeID[0], cArguments);
 	}
 	
-	private boolean isCompatibleWith(BaseScope scope, FunctionHeader header) {
+	private boolean isCompatibleWith(BaseScope scope, FunctionHeader header, ITypeID[] typeParameters) {
 		if (arguments.size() != header.parameters.length)
 			return false;
 		
 		for (int i = 0; i < arguments.size(); i++) {
-			if (header.parameters[i].type.hasInferenceBlockingTypeParameters(header.typeParameters))
+			if (typeParameters == null && header.parameters[i].type.hasInferenceBlockingTypeParameters(header.typeParameters))
 				return false;
 			
 			if (!arguments.get(i).isCompatibleWith(scope, header.parameters[i].type))

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedExpressionCall.java

 				throw new CompileException(position, CompileExceptionCode.SUPER_CALL_NO_SUPERCLASS, "Class has no superclass");
 			
 			DefinitionMemberGroup memberGroup = scope.getTypeMembers(targetType).getOrCreateGroup(OperatorType.CONSTRUCTOR);
-			CallArguments callArguments = arguments.compileCall(position, scope, memberGroup);
+			CallArguments callArguments = arguments.compileCall(position, scope, null, memberGroup);
 			ICallableMember member = memberGroup.selectMethod(position, scope, callArguments, true, true);
 			if (!(member instanceof ConstructorMember))
 				throw new CompileException(position, CompileExceptionCode.INTERNAL_ERROR, "Constructor is not a constructor!");
 			ITypeID targetType = scope.getThisType();
 			
 			DefinitionMemberGroup memberGroup = scope.getTypeMembers(targetType).getOrCreateGroup(OperatorType.CONSTRUCTOR);
-			CallArguments callArguments = arguments.compileCall(position, scope, memberGroup);
+			CallArguments callArguments = arguments.compileCall(position, scope, null, memberGroup);
 			ICallableMember member = memberGroup.selectMethod(position, scope, callArguments, true, true);
 			if (!(member instanceof ConstructorMember))
 				throw new CompileException(position, CompileExceptionCode.INTERNAL_ERROR, "Constructor is not a constructor!");
 		}
 
 		List<FunctionHeader> headers = cReceiver.getPossibleFunctionHeaders(scope, scope.hints, arguments.arguments.size());
-		CallArguments callArguments = arguments.compileCall(position, scope, headers);
+		CallArguments callArguments = arguments.compileCall(position, scope, cReceiver.getGenericCallTypes(), headers);
 		return cReceiver.call(position, scope, scope.hints, callArguments);
 	}
 

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedExpressionFunction.java

 			// perform type parameter inference
 			ITypeID returnType = statements.getReturnType();
 			Map<TypeParameter, ITypeID> inferredTypes = new HashMap<>();
-			if (!genericHeader.returnType.inferTypeParameters(returnType, inferredTypes))
+			if (!genericHeader.returnType.inferTypeParameters(scope.getMemberCache(), returnType, inferredTypes))
 				throw new CompileException(position, CompileExceptionCode.TYPE_ARGUMENTS_NOT_INFERRABLE, "Could not infer generic type parameters");
 			
 			for (Map.Entry<TypeParameter, ITypeID> type : inferredTypes.entrySet()) {

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedExpressionIndex.java

 		private Expression getLength(CodePosition position) {
 			return target.getMember(position, scope, scope.hints, new GenericName("length")).eval();
 		}
+
+		@Override
+		public ITypeID[] getGenericCallTypes() {
+			return null;
+		}
 	}
 }

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedExpressionMember.java

 
 package org.openzen.zenscript.parser.expression;
 
-import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.type.GenericName;
 
 	@Override
 	public IPartialExpression compile(ExpressionScope scope) {
-		List<ITypeID> genericArguments = Collections.emptyList();
-		if (!genericParameters.isEmpty()) {
-			genericArguments = new ArrayList<>();
-			for (IParsedType type : this.genericParameters) {
-				genericArguments.add(type.compile(scope));
-			}
-		}
-		
 		IPartialExpression cValue = value.compile(scope.withoutHints());
-		IPartialExpression member = cValue.getMember(position, scope, scope.hints, new GenericName(this.member, genericArguments));
+		ITypeID[] typeParameters = IParsedType.compileList(genericParameters, scope);
+		IPartialExpression member = cValue.getMember(
+				position,
+				scope,
+				scope.hints,
+				new GenericName(this.member, typeParameters));
 		if (member == null)
 			throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "Member not found: " + this.member);
 		return member;

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedExpressionVariable.java

 
 package org.openzen.zenscript.parser.expression;
 
-import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import org.openzen.zenscript.codemodel.expression.ConstantStringExpression;
 
 	@Override
 	public IPartialExpression compile(ExpressionScope scope) {
-		List<ITypeID> genericParameters = Collections.emptyList();
-		if (!this.genericParameters.isEmpty()) {
-			genericParameters = new ArrayList<>();
-			for (IParsedType genericType : this.genericParameters)
-				genericParameters.add(genericType.compile(scope));
+		ITypeID[] genericArguments = null;
+		if (genericParameters != null) {
+			genericArguments = new ITypeID[genericParameters.size()];
+			for (int i = 0; i < genericParameters.size(); i++) {
+				genericArguments[i] = genericParameters.get(i).compile(scope);
+			}
 		}
-		IPartialExpression result = scope.get(position, new GenericName(name, genericParameters));
+		
+		IPartialExpression result = scope.get(position, new GenericName(name, genericArguments));
 		if (result == null) {
 			for (ITypeID hint : scope.hints) {
 				EnumConstantMember member = scope.getTypeMembers(hint).getEnumMember(name);

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedNewExpression.java

 	public static NewExpression compile(CodePosition position, ITypeID type, ParsedCallArguments arguments, ExpressionScope scope) {
 		DefinitionMemberGroup constructors = scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CONSTRUCTOR);
 		List<ITypeID>[] predictedTypes = constructors.predictCallTypes(scope, scope.hints, arguments.arguments.size());
-		CallArguments compiledArguments = arguments.compileCall(position, scope, constructors);
+		CallArguments compiledArguments = arguments.compileCall(position, scope, null, constructors);
 		ICallableMember member = constructors.selectMethod(position, scope, compiledArguments, true, true);
 		if (member == null)
 			throw new CompileException(position, CompileExceptionCode.CALL_NO_VALID_METHOD, "No matching constructor found");

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

 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
-import org.openzen.zenscript.codemodel.member.StaticInitializerMember;
 import org.openzen.zenscript.lexer.ZSToken;
 import org.openzen.zenscript.lexer.ZSTokenStream;
 import org.openzen.zenscript.lexer.ZSTokenType;
 			case T_XORASSIGN:
 			case T_INCREMENT:
 			case T_DECREMENT:
-			case T_DOT2: {
+			case T_DOT2:
+			case T_SHL:
+			case T_SHR:
+			case T_USHR:
+			case T_SHLASSIGN:
+			case T_SHRASSIGN:
+			case T_USHRASSIGN: {
 				ZSToken token = tokens.next();
 				ParsedFunctionHeader header = ParsedFunctionHeader.parse(tokens);
 				ParsedFunctionBody body = ParsedStatement.parseFunctionBody(tokens);
 			case T_INCREMENT: return OperatorType.INCREMENT;
 			case T_DECREMENT: return OperatorType.DECREMENT;
 			case T_DOT2: return OperatorType.RANGE;
+			case T_SHL: return OperatorType.SHL;
+			case T_SHR: return OperatorType.SHR;
+			case T_USHR: return OperatorType.USHR;
+			case T_SHLASSIGN: return OperatorType.SHLASSIGN;
+			case T_SHRASSIGN: return OperatorType.SHRASSIGN;
+			case T_USHRASSIGN: return OperatorType.USHRASSIGN;
 			default:
 				throw new AssertionError("Missing switch case in getOperator");
 		}

Parser/src/main/java/org/openzen/zenscript/parser/statements/ParsedStatementForeach.java

 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.linker.ExpressionScope;
 import org.openzen.zenscript.linker.ForeachScope;
 import org.openzen.zenscript.linker.StatementScope;
 	public Statement compile(StatementScope scope) {
 		Expression list = this.list.compile(new ExpressionScope(scope)).eval();
 		
-		IIteratorMember iterator = scope.getTypeMembers(list.type).getIterator(varnames.length);
+		TypeMembers members = scope.getTypeMembers(list.type);
+		IIteratorMember iterator = members.getIterator(varnames.length);
 		if (iterator == null)
 			throw new CompileException(position, CompileExceptionCode.NO_SUCH_ITERATOR, list.type + " doesn't have an iterator with " + varnames.length + " variables");
 		

Parser/src/main/java/org/openzen/zenscript/parser/type/IParsedType.java

 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.lexer.ZSTokenStream;
 import org.openzen.zenscript.lexer.ZSTokenType;
-import static org.openzen.zenscript.lexer.ZSTokenType.T_COMMA;
-import static org.openzen.zenscript.lexer.ZSTokenType.T_GREATER;
-import static org.openzen.zenscript.lexer.ZSTokenType.T_LESS;
+import static org.openzen.zenscript.lexer.ZSTokenType.*;
 import org.openzen.zenscript.linker.BaseScope;
 import org.openzen.zenscript.parser.ParseException;
 import org.openzen.zenscript.parser.definitions.ParsedFunctionHeader;
 				break;
 			case K_BYTE:
 				tokens.next();
-				result = ParsedTypeBasic.SBYTE;
+				result = ParsedTypeBasic.BYTE;
 				break;
-			case K_UBYTE:
+			case K_SBYTE:
 				tokens.next();
-				result = ParsedTypeBasic.BYTE;
+				result = ParsedTypeBasic.SBYTE;
 				break;
 			case K_SHORT:
 				tokens.next();
 	
 	public static List<IParsedType> parseGenericParameters(ZSTokenStream tokens) {
 		if (!tokens.isNext(T_LESS))
-			return Collections.emptyList();
+			return null;
 		
 		tokens.pushMark();
 		tokens.next();
 			genericParameters.add(type);
 		} while (tokens.optional(T_COMMA) != null);
 		
-		if (tokens.optional(T_GREATER) == null) {
+		if (tokens.isNext(T_SHR)) {
+			tokens.replace(T_GREATER);
+		} else if (tokens.isNext(T_USHR)) {
+			tokens.replace(T_SHR);
+		} else if (tokens.isNext(T_SHRASSIGN)) {
+			tokens.replace(T_GREATEREQ);
+		} else if (tokens.isNext(T_USHRASSIGN)) {
+			tokens.replace(T_SHRASSIGN);
+		} else if (tokens.optional(T_GREATER) == null) {
 			tokens.reset();
 			return Collections.emptyList();
-		} else {
-			tokens.popMark();
-			return genericParameters;
 		}
+		
+		tokens.popMark();
+		return genericParameters;
+	}
+	
+	public static ITypeID[] compileList(List<IParsedType> typeParameters, BaseScope scope) {
+		ITypeID[] result = null;
+		if (typeParameters != null) {
+			result = new ITypeID[typeParameters.size()];
+			for (int i = 0; i < typeParameters.size(); i++) {
+				result[i] = typeParameters.get(i).compile(scope);
+			}
+		}
+		return result;
 	}
 	
 	public IParsedType withOptional();

Parser/src/main/java/org/openzen/zenscript/parser/type/ParsedNamedType.java

 package org.openzen.zenscript.parser.type;
 
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 		}
 		
 		private GenericName compile(BaseScope scope) {
-			if (typeArguments.isEmpty()) {
-				return new GenericName(name, Collections.emptyList());
-			} else {
-				List<ITypeID> genericTypes = new ArrayList<>();
-				for (IParsedType type : typeArguments)
-					genericTypes.add(type.compile(scope));
-				
-				return new GenericName(name, genericTypes);
-			}
+			return new GenericName(name, IParsedType.compileList(typeArguments, scope));
 		}
 		
 		@Override
 		public String toString() {
 			StringBuilder result = new StringBuilder(name);
-			if (!typeArguments.isEmpty()) {
+			if (typeArguments != null) {
 				result.append("<");
 				for (int i = 0; i < typeArguments.size(); i++) {
 					if (i > 0)

Parser/src/main/java/org/openzen/zenscript/parser/type/ParsedTypeGenericMap.java

 
 		@Override
 		public IPartialExpression get(CodePosition position, GenericName name) {
-			if (typeParameters.containsKey(name.name) && name.arguments.isEmpty())
+			if (typeParameters.containsKey(name.name) && name.hasNoArguments())
 				return new PartialTypeExpression(position, getTypeRegistry().getGeneric(typeParameters.get(name.name)));
 			
 			return outer.get(position, name);
 
 		@Override
 		public ITypeID getType(CodePosition position, List<GenericName> name) {
-			if (typeParameters.containsKey(name.get(0).name) && name.size() == 1 && name.get(0).arguments.isEmpty())
+			if (typeParameters.containsKey(name.get(0).name) && name.size() == 1 && name.get(0).hasNoArguments())
 				return getTypeRegistry().getGeneric(typeParameters.get(name.get(0).name));
 			
 			return outer.getType(position, name);

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

 	private class PrintlnSymbol implements ISymbol {
 
 		@Override
-		public IPartialExpression getExpression(CodePosition position, GlobalTypeRegistry types, List<ITypeID> typeArguments) {
+		public IPartialExpression getExpression(CodePosition position, GlobalTypeRegistry types, ITypeID[] typeArguments) {
 			//return new PartialStaticMemberGroupExpression(position, PRINTLN.callerGroup);
 			return new PartialMemberGroupExpression(
 					position,
 					new GetStaticFieldExpression(position, SYSTEM_OUT),
 					PRINTSTREAM_PRINTLN,
+					null,
 					false);
 		}
 
 		@Override
-		public ITypeID getType(CodePosition position, GlobalTypeRegistry types, List<ITypeID> typeArguments) {
+		public ITypeID getType(CodePosition position, GlobalTypeRegistry types, ITypeID[] typeArguments) {
 			// don't be fooled! this symbol is the System.out.println bound method and thus its type is a function
 			return new FunctionTypeID(PRINTSTREAM_PRINTLN.header);
 		}

Validator/src/main/java/org/openzen/zenscript/validator/visitors/DefinitionMemberValidator.java

 
 	@Override
 	public Boolean visitCustomIterator(CustomIteratorMember member) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		// TODO: validate iterators
+		return true;
 	}
 
 	@Override

Validator/src/main/java/org/openzen/zenscript/validator/visitors/ExpressionValidator.java

 	public Boolean visitCall(CallExpression expression) {
 		boolean isValid = true;
 		isValid &= expression.target.accept(this);
-		isValid &= checkCallArguments(expression.position, expression.member.header, expression.arguments);
+		isValid &= checkCallArguments(expression.position, expression.member.header, expression.instancedHeader, expression.arguments);
 		return isValid;
 	}
 
 	@Override
 	public Boolean visitCallStatic(CallStaticExpression expression) {
-		return checkCallArguments(expression.position, expression.member.header, expression.arguments);
+		return checkCallArguments(expression.position, expression.member.header, expression.instancedHeader, expression.arguments);
 	}
 
 	@Override
 			isValid = false;
 		}
 		scope.markConstructorForwarded();
-		isValid &= checkCallArguments(expression.position, expression.constructor.header, expression.arguments);
+		isValid &= checkCallArguments(expression.position, expression.constructor.header, expression.constructor.header, expression.arguments);
 		return isValid;
 	}
 
 			isValid = false;
 		}
 		scope.markConstructorForwarded();
-		isValid &= checkCallArguments(expression.position, expression.constructor.header, expression.arguments);
+		isValid &= checkCallArguments(expression.position, expression.constructor.header, expression.constructor.header, expression.arguments);
 		return isValid;
 	}
 
 
 	@Override
 	public Boolean visitFunction(FunctionExpression expression) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		// TODO
+		return true;
 	}
 
 	@Override
 		boolean isValid = checkCallArguments(
 				expression.position,
 				expression.constructor.header,
+				expression.constructor.header,
 				expression.arguments);
 		return isValid;
 	}
 	@Override
 	public Boolean visitWrapOptional(WrapOptionalExpression expression) {
 		boolean isValid = expression.value.accept(this);
-		if (expression.type.isOptional()) {
+		if (expression.value.type.isOptional()) {
 			validator.logError(ValidationLogEntry.Code.INVALID_OPERAND_TYPE, expression.position, "expression value is already optional");
 			isValid = false;
 		}
 		return isValid;
 	}
 	
-	private boolean checkCallArguments(CodePosition position, FunctionHeader header, CallArguments arguments) {
+	private boolean checkCallArguments(CodePosition position, FunctionHeader originalHeader, FunctionHeader instancedHeader, CallArguments arguments) {
 		boolean isValid = true;
-		isValid &= ValidationUtils.validateTypeArguments(validator, position, header.typeParameters, arguments.typeArguments);
+		isValid &= ValidationUtils.validateTypeArguments(validator, position, originalHeader.typeParameters, arguments.typeArguments);
 		
 		for (int i = 0; i < arguments.arguments.length; i++) {
 			Expression argument = arguments.arguments[i];
 			isValid &= argument.accept(this);
 			
-			if (i >= header.parameters.length) {
-				FunctionParameter variadic = header.getVariadicParameter();
+			if (i >= instancedHeader.parameters.length) {
+				FunctionParameter variadic = instancedHeader.getVariadicParameter();
 				if (variadic == null) {
 					validator.logError(ValidationLogEntry.Code.INVALID_CALL_ARGUMENT, position, "too many call arguments");
 					isValid = false;
 				}
 			}
 			
-			FunctionParameter parameter = header.parameters[i];
+			FunctionParameter parameter = instancedHeader.parameters[i];
 			if (parameter.type != argument.type) {
 				validator.logError(
 						ValidationLogEntry.Code.INVALID_CALL_ARGUMENT,
 			}
 		}
 		
-		for (int i = arguments.arguments.length; i < header.parameters.length; i++) {
-			FunctionParameter parameter = header.parameters[i];
+		for (int i = arguments.arguments.length; i < instancedHeader.parameters.length; i++) {
+			FunctionParameter parameter = instancedHeader.parameters[i];
 			if (parameter.defaultValue == null && !parameter.variadic) {
 				validator.logError(ValidationLogEntry.Code.INVALID_CALL_ARGUMENT, position, "missing call argument for " + parameter.name);
 				isValid = false;

Validator/src/main/java/org/openzen/zenscript/validator/visitors/ValidationUtils.java

 			TypeParameter[] typeParameters,
 			ITypeID[] typeArguments)
 	{
+		if (typeParameters == null)
+			return typeArguments == null;
+		if (typeArguments == null)
+			return false;
+		
 		if (typeParameters.length != typeArguments.length) {
 			target.logError(
 					ValidationLogEntry.Code.INVALID_TYPE_ARGUMENT,
 		for (int i = 0; i < typeParameters.length; i++) {
 			TypeParameter typeParameter = typeParameters[i];
 			for (GenericParameterBound bound : typeParameter.bounds) {
-				if (!bound.matches(typeArguments[i])) {
+				// TODO - obtain member cache for validation
+				/*if (!bound.matches(typeArguments[i])) {
 					target.logError(
 							ValidationLogEntry.Code.INVALID_TYPE_ARGUMENT,
 							position,
 							bound.accept(new TypeParameterBoundErrorVisitor(typeArguments[i], target)));
 					isValid = false;
-				}
+				}*/
 			}
 		}
 		return isValid;