- Experimental: variant types

- Experimental: match operator
- Adding error handling with return values and monadics

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/DefinitionFormatter.java

 import org.openzen.zenscript.codemodel.definition.FunctionDefinition;
 import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
 import org.openzen.zenscript.codemodel.definition.StructDefinition;
+import org.openzen.zenscript.codemodel.definition.VariantDefinition;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 	public Void visitAlias(AliasDefinition definition) {
 		return null;
 	}
+
+	@Override
+	public Void visitVariant(VariantDefinition variant) {
+		FormattingUtils.formatModifiers(output, variant.modifiers);
+		output.append("variant ");
+		output.append(variant.name);
+		FormattingUtils.formatTypeParameters(output, variant.genericParameters, typeFormatter);
+		output.append(" ");
+		
+		if (settings.classBracketOnSameLine) {
+			output.append("{\n");
+		} else {
+			output.append("\n")
+					.append(indent)
+					.append("{\n");
+		}
+		
+		List<VariantDefinition.Option> options = variant.options;
+		boolean first = true;
+		for (VariantDefinition.Option option : options) {
+			if (first)
+				first = false;
+			else
+				output.append(",\n");
+			
+			output.append(indent).append(settings.indent).append(option.name);
+			if (option.types.length > 0) {
+				output.append("(");
+				for (int i = 0; i < option.types.length; i++) {
+					if (i > 0)
+						output.append(", ");
+					output.append(option.types[i].accept(typeFormatter));
+				}
+			}
+		}
+		
+		if (variant.members.size() > options.size()) {
+			output.append(";\n").append(indent).append(settings.indent).append("\n");
+
+			MemberFormatter memberFormatter = new MemberFormatter(settings, output, indent + settings.indent, typeFormatter);
+			for (IDefinitionMember member : variant.members) {
+				member.accept(memberFormatter);
+			}
+		}
+		
+		output.append("}\n");
+		return null;
+	}
 	
 	@Override
 	public String toString() {

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/ExpressionFormatter.java

 import org.openzen.zenscript.codemodel.expression.IsExpression;
 import org.openzen.zenscript.codemodel.expression.MakeConstExpression;
 import org.openzen.zenscript.codemodel.expression.MapExpression;
+import org.openzen.zenscript.codemodel.expression.MatchExpression;
 import org.openzen.zenscript.codemodel.expression.NewExpression;
 import org.openzen.zenscript.codemodel.expression.NullExpression;
 import org.openzen.zenscript.codemodel.expression.OrOrExpression;
 		result.append("}");
 		return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
 	}
+	
+	@Override
+	public ExpressionString visitMatch(MatchExpression expression) {
+		StringBuilder result = new StringBuilder();
+		result.append("match ");
+		result.append(expression.value.accept(this));
+		result.append(" {\n");
+		
+		throw new UnsupportedOperationException();
+	}
 
 	@Override
 	public ExpressionString visitNew(NewExpression expression) {

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

 		this.parameters = NO_PARAMETERS;
 	}
 	
+	public FunctionHeader(ITypeID returnType, ITypeID... parameterTypes) {
+		this.typeParameters = null;
+		this.returnType = returnType;
+		this.parameters = new FunctionParameter[parameterTypes.length];
+		
+		for (int i = 0; i < parameterTypes.length; i++)
+			parameters[i] = new FunctionParameter(parameterTypes[i], null);
+	}
+	
 	public FunctionHeader(ITypeID returnType, FunctionParameter... parameters) {
 		this.typeParameters = null;
 		this.returnType = returnType;

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

  * @author Hoofdgebruiker
  */
 public class FunctionParameter extends Taggable {
+	public static final FunctionParameter[] NONE = new FunctionParameter[0];
+	
 	public final ITypeID type;
 	public final String name;
 	public final Expression defaultValue;

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

 	public T visitExpansion(ExpansionDefinition definition);
 	
 	public T visitAlias(AliasDefinition definition);
+	
+	public T visitVariant(VariantDefinition variant);
 }

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

 	
 	public void setHeader(FunctionHeader header) {
 		this.header = header;
+		this.genericParameters = header.typeParameters;
+		header = new FunctionHeader(null, header.returnType, header.parameters);
 		addMember(caller = new OperatorMember(position, this, modifiers | Modifiers.STATIC, OperatorType.CALL, header));
 		callerGroup.addMethod(caller, TypeMemberPriority.SPECIFIED);
 	}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/definition/VariantDefinition.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.definition;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class VariantDefinition extends HighLevelDefinition {
+	public final List<Option> options = new ArrayList<>();
+	
+	public VariantDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		super(position, pkg, name, modifiers, outerDefinition);
+	}
+
+	@Override
+	public <T> T accept(DefinitionVisitor<T> visitor) {
+		return visitor.visitVariant(this);
+	}
+	
+	public static class Option {
+		public final String name;
+		public final ITypeID[] types;
+		
+		public Option(String name, ITypeID[] types) {
+			this.name = name;
+			this.types = types;
+		}
+		
+		public Option instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
+			ITypeID[] newTypes = new ITypeID[types.length];
+			for (int i = 0; i < types.length; i++)
+				newTypes[i] = types[i].withGenericArguments(registry, mapping);
+			
+			return new Option(name, newTypes);
+		}
+	}
+}

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

 	
 	public T visitMap(MapExpression expression);
 	
+	public T visitMatch(MatchExpression expression);
+	
 	public T visitNew(NewExpression expression);
 	
 	public T visitNull(NullExpression expression);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/MatchExpression.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.expression;
+
+import org.openzen.zenscript.codemodel.expression.switchvalue.SwitchValue;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class MatchExpression extends Expression {
+	public final Expression value;
+	public final Case[] cases;
+	
+	public MatchExpression(CodePosition position, Expression value, ITypeID type, Case[] cases) {
+		super(position, type);
+		
+		this.value = value;
+		this.cases = cases;
+	}
+
+	@Override
+	public <T> T accept(ExpressionVisitor<T> visitor) {
+		return visitor.visitMatch(this);
+	}
+	
+	public static class Case {
+		public final SwitchValue key;
+		public final FunctionExpression value;
+		
+		public Case(SwitchValue key, FunctionExpression value) {
+			this.key = key;
+			this.value = value;
+		}
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/VariantValueExpression.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.expression;
+
+import java.util.List;
+import org.openzen.zenscript.codemodel.OperatorType;
+import org.openzen.zenscript.codemodel.definition.VariantDefinition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class VariantValueExpression extends Expression {
+	public final VariantDefinition.Option option;
+	public final Expression[] arguments;
+	
+	public VariantValueExpression(CodePosition position, ITypeID variantType, VariantDefinition.Option option) {
+		this(position, variantType, option, null);
+	}
+	
+	public VariantValueExpression(CodePosition position, ITypeID variantType, VariantDefinition.Option option, Expression[] arguments) {
+		super(position, variantType);
+		
+		this.option = option;
+		this.arguments = null;
+	}
+	
+	@Override
+	public Expression call(CodePosition position, TypeScope scope, List<ITypeID> hints, CallArguments arguments) {
+		return new VariantValueExpression(position, type, option, arguments.arguments);
+	}
+
+	@Override
+	public <T> T accept(ExpressionVisitor<T> visitor) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/switchvalue/CharSwitchValue.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.expression.switchvalue;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class CharSwitchValue implements SwitchValue {
+	public final char value;
+	
+	public CharSwitchValue(char value) {
+		this.value = value;
+	}
+
+	@Override
+	public <T> T accept(SwitchValueVisitor<T> visitor) {
+		return visitor.acceptChar(this);
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/switchvalue/EnumConstantSwitchValue.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.expression.switchvalue;
+
+import org.openzen.zenscript.codemodel.member.EnumConstantMember;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class EnumConstantSwitchValue implements SwitchValue {
+	public final EnumConstantMember constant;
+	
+	public EnumConstantSwitchValue(EnumConstantMember constant) {
+		this.constant = constant;
+	}
+
+	@Override
+	public <T> T accept(SwitchValueVisitor<T> visitor) {
+		return visitor.acceptEnumConstant(this);
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/switchvalue/IntSwitchValue.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.expression.switchvalue;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class IntSwitchValue implements SwitchValue {
+	public final int value;
+	
+	public IntSwitchValue(int value) {
+		this.value = value;
+	}
+
+	@Override
+	public <T> T accept(SwitchValueVisitor<T> visitor) {
+		return visitor.acceptInt(this);
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/switchvalue/StringSwitchValue.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.expression.switchvalue;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class StringSwitchValue implements SwitchValue {
+	public final String value;
+	
+	public StringSwitchValue(String value) {
+		this.value = value;
+	}
+
+	@Override
+	public <T> T accept(SwitchValueVisitor<T> visitor) {
+		return visitor.acceptString(this);
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/switchvalue/SwitchValue.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.expression.switchvalue;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface SwitchValue {
+	public <T> T accept(SwitchValueVisitor<T> visitor);
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/switchvalue/SwitchValueVisitor.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.expression.switchvalue;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface SwitchValueVisitor <T> {
+	public T acceptInt(IntSwitchValue value);
+	
+	public T acceptChar(CharSwitchValue value);
+	
+	public T acceptString(StringSwitchValue value);
+	
+	public T acceptEnumConstant(EnumConstantSwitchValue value);
+	
+	public T acceptVariantOption(VariantOptionSwitchValue value);
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/switchvalue/VariantOptionSwitchValue.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.expression.switchvalue;
+
+import org.openzen.zenscript.codemodel.definition.VariantDefinition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class VariantOptionSwitchValue implements SwitchValue {
+	public final VariantDefinition.Option option;
+	public final String[] parameters;
+	
+	public VariantOptionSwitchValue(VariantDefinition.Option option, String[] parameters) {
+		this.option = option;
+		this.parameters = parameters;
+	}
+	
+	@Override
+	public <T> T accept(SwitchValueVisitor<T> visitor) {
+		return visitor.acceptVariantOption(this);
+	}
+}

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

 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.expression.LambdaClosure;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
 	public ITypeID[] getGenericCallTypes() {
 		return null;
 	}
+	
+	@Override
+	public IPartialExpression capture(CodePosition position, LambdaClosure closure) {
+		return this;
+	}
 }

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

 import java.util.Map;
 import java.util.Objects;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.definition.EnumDefinition;
+import org.openzen.zenscript.codemodel.definition.VariantDefinition;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 
 /**
 		return true;
 	}
 
+	@Override
+	public boolean isEnum() {
+		return definition instanceof EnumDefinition;
+	}
+	
+	@Override
+	public boolean isVariant() {
+		return definition instanceof VariantDefinition;
+	}
+	
 	@Override
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {
 		if (typeParameters != null) {

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

 	
 	public boolean isObjectType();
 	
+	public default boolean isEnum() {
+		return false;
+	}
+	
+	public default boolean isVariant() {
+		return false;
+	}
+	
 	public ITypeID withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments);
 	
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters);

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

 import org.openzen.zenscript.codemodel.definition.EnumDefinition;
 import org.openzen.zenscript.codemodel.definition.FunctionDefinition;
 import org.openzen.zenscript.codemodel.definition.StructDefinition;
+import org.openzen.zenscript.codemodel.definition.VariantDefinition;
 import org.openzen.zenscript.codemodel.expression.CallTranslator;
 import org.openzen.zenscript.codemodel.expression.ConstantCharExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantUIntExpression;
 import org.openzen.zenscript.codemodel.member.builtin.ConstantGetterMember;
 import org.openzen.zenscript.codemodel.member.builtin.RangeIterator;
 import org.openzen.zenscript.codemodel.member.builtin.StringCharIterator;
-import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ArrayTypeID;
 import org.openzen.zenscript.codemodel.type.AssocTypeID;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 		HighLevelDefinition definition = type.definition;
 		if (type.hasTypeParameters() || !type.outerTypeParameters.isEmpty()) {
 			Map<TypeParameter, ITypeID> mapping = new HashMap<>();
-			if (type.typeParameters != null)
-				for (int i = 0; i < type.typeParameters.length; i++)
-					mapping.put(definition.genericParameters[i], type.typeParameters[i]);
+			if (type.typeParameters != null) {
+				if (definition.genericParameters == null)
+					System.out.println("Type parameters but no generic parameters");
+				else
+					for (int i = 0; i < type.typeParameters.length; i++)
+						mapping.put(definition.genericParameters[i], type.typeParameters[i]);
+			}
 			
 			if (!type.definition.isStatic())
 				for (Map.Entry<TypeParameter, ITypeID> entry : type.outerTypeParameters.entrySet())
 			for (IDefinitionMember member : definition.members) {
 				member.instance(cache.getRegistry(), mapping).registerTo(members, TypeMemberPriority.SPECIFIED);
 			}
+			
+			if (definition instanceof VariantDefinition) {
+				VariantDefinition variant = (VariantDefinition) definition;
+				for (VariantDefinition.Option option : variant.options)
+					members.addVariantOption(option.instance(registry, mapping));
+			}
 		} else {
 			for (IDefinitionMember member : definition.members) {
 				member.registerTo(members, TypeMemberPriority.SPECIFIED);
 			}
+			
+			if (definition instanceof VariantDefinition) {
+				VariantDefinition variant = (VariantDefinition) definition;
+				for (VariantDefinition.Option option : variant.options)
+					members.addVariantOption(option);
+			}
 		}
 
 		DefinitionMemberGroup constructors = members.getOrCreateGroup(OperatorType.CONSTRUCTOR);
 				// add default struct constructors
 				constructors.addMethod(new ConstructorMember(BUILTIN, definition, Modifiers.PUBLIC, new FunctionHeader(VOID)), TypeMemberPriority.SPECIFIED);
 				
-				List<FieldMember> fields = ((StructDefinition)definition).getFields();
+				List<FieldMember> fields = definition.getFields();
 				if (!fields.isEmpty()) {
 					FunctionParameter[] parameters = new FunctionParameter[fields.size()];
 					for (int i = 0; i < parameters.length; i++) {

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

 import java.util.Map;
 import org.openzen.zenscript.codemodel.CompareType;
 import org.openzen.zenscript.codemodel.OperatorType;
+import org.openzen.zenscript.codemodel.definition.VariantDefinition;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.CallExpression;
 import org.openzen.zenscript.codemodel.expression.CheckNullExpression;
 	private final List<TypeMember<IIteratorMember>> iterators = new ArrayList<>();
 	
 	private final Map<String, EnumConstantMember> enumMembers = new HashMap<>();
+	private final Map<String, VariantDefinition.Option> variantOptions = new HashMap<>();
 	private final Map<String, DefinitionMemberGroup> members = new HashMap<>();
 	private final Map<String, InnerDefinition> innerTypes = new HashMap<>();
 	private final Map<OperatorType, DefinitionMemberGroup> operators = new HashMap<>();
 		
 		for (Map.Entry<String, EnumConstantMember> entry : enumMembers.entrySet())
 			other.addEnumMember(entry.getValue(), priority);
+		for (Map.Entry<String, VariantDefinition.Option> entry : variantOptions.entrySet())
+			other.addVariantOption(entry.getValue());
 		for (Map.Entry<String, DefinitionMemberGroup> entry : members.entrySet())
 			other.getOrCreateGroup(entry.getKey(), entry.getValue().isStatic).merge(position, entry.getValue(), priority);
 		for (Map.Entry<String, InnerDefinition> entry : innerTypes.entrySet())
 		group.addMethod(member, priority);
 	}
 	
+	public void addVariantOption(VariantDefinition.Option option) {
+		variantOptions.put(option.name, option);
+	}
+	
 	public void addIterator(IIteratorMember iterator, TypeMemberPriority priority) {
 		for (int i = 0; i < iterators.size(); i++) {
 			if (iterators.get(i).member.getLoopVariableCount() == iterator.getLoopVariableCount()) {
 		return enumMembers.get(name);
 	}
 	
+	public VariantDefinition.Option getVariantOption(String name) {
+		return variantOptions.get(name);
+	}
+	
 	public Expression compare(CodePosition position, TypeScope scope, CompareType operator, Expression left, Expression right) {
 		if (operator == CompareType.SAME) {
 			if (left.type.isObjectType() && right.type.isObjectType())

Constructor/libraries/stdlib/module.json

 		"Hashable": {"type": "Definition", "definition": "Hashable"},
 		"IllegalArgumentException": {"type": "Definition", "definition": "IllegalArgumentException"},
 		"StringBuilder": {"type": "Definition", "definition": "StringBuilder"},
-		"StringBuildable": {"type": "Definition", "definition": "StringBuildable"}
+		"StringBuildable": {"type": "Definition", "definition": "StringBuildable"},
+		"panic": {"type": "Definition", "definition": "panic"}
 	}
 }

Constructor/libraries/stdlib/src/Panic.zs

+// TODO: function overloading on global functions
+//extern function panic() as void;
+
+extern function panic<T>(message as string) as T;

Constructor/libraries/stdlib/src/Result.zs

+export variant Result<T, E> {
+	Success(T),
+	Failure(E);
+	
+	public then<R>(fn as function(result as T) as R) as Result<R, E> {
+		return match this {
+			Success(result) => Success(fn(result)),
+			Failure(error) => Failure(error)
+		};
+	}
+	
+	public handle<X>(handler as function(error as E) as Result<T, X>) as Result<T, X> {
+		return match this {
+			Success(result) => Success(result),
+			Failure(error) => handler(error)
+		};
+	}
+	
+	public expect() as T {
+		return match this {
+			Success(result) => result,
+			Failure(error) => panic<T>("demand with error value")
+		};
+	}
+}
+
+export expand <T, E : Exception> Result<T, E> {
+	public unwrap() as T {
+		return match this {
+			Success(result) => result,
+			Failure(error) => { throw error; }
+		};
+	}
+}

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaExpressionVisitor.java

         }
         return null;
     }
+	
+	@Override
+	public Void visitMatch(MatchExpression expression) {
+		throw new UnsupportedOperationException();
+	}
 
     @Override
     public Void visitNew(NewExpression expression) {

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaPreDecrementVisitor.java

 import org.openzen.zenscript.codemodel.expression.IsExpression;
 import org.openzen.zenscript.codemodel.expression.MakeConstExpression;
 import org.openzen.zenscript.codemodel.expression.MapExpression;
+import org.openzen.zenscript.codemodel.expression.MatchExpression;
 import org.openzen.zenscript.codemodel.expression.NewExpression;
 import org.openzen.zenscript.codemodel.expression.NullExpression;
 import org.openzen.zenscript.codemodel.expression.OrOrExpression;
 		throw new UnsupportedOperationException("Invalid increment target");
 	}
 
+	@Override
+	public Void visitMatch(MatchExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
 	@Override
 	public Void visitNew(NewExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaPreIncrementVisitor.java

 import org.openzen.zenscript.codemodel.expression.IsExpression;
 import org.openzen.zenscript.codemodel.expression.MakeConstExpression;
 import org.openzen.zenscript.codemodel.expression.MapExpression;
+import org.openzen.zenscript.codemodel.expression.MatchExpression;
 import org.openzen.zenscript.codemodel.expression.NewExpression;
 import org.openzen.zenscript.codemodel.expression.NullExpression;
 import org.openzen.zenscript.codemodel.expression.OrOrExpression;
 		throw new UnsupportedOperationException("Invalid increment target");
 	}
 
+	@Override
+	public Void visitMatch(MatchExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
+
 	@Override
 	public Void visitNew(NewExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/definitions/JavaDefinitionVisitor.java

 package org.openzen.zenscript.javabytecode.compiler.definitions;
 
-import java.util.List;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
 import org.openzen.zenscript.codemodel.definition.*;
-import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
     public byte[] visitAlias(AliasDefinition definition) {
         return null;
     }
+
+	@Override
+	public byte[] visitVariant(VariantDefinition variant) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
 }

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

 	private final Map<String, TypeParameter> genericParameters = new HashMap<>();
 	
 	public DefinitionScope(BaseScope outer, HighLevelDefinition definition) {
+		this(outer, definition, true);
+	}
+	
+	public DefinitionScope(BaseScope outer, HighLevelDefinition definition, boolean withMembers) {
 		this.outer = outer;
 		this.definition = definition;
 		
 		} else {
 			type = outer.getTypeRegistry().getForDefinition(definition, genericParameterList);
 		}
-		members = outer.getMemberCache().get(type);
+		
+		members = withMembers ? outer.getMemberCache().get(type) : null;
 	}
 	
 	@Override
 
 	@Override
 	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.hasArguments())
-			return members.getMemberExpression(position, new ThisExpression(position, type), name, true);
+		if (members != null) {
+			if (members.hasInnerType(name.name))
+				return new PartialTypeExpression(position, members.getInnerType(position, name));
+			if (members.hasMember(name.name) && !name.hasArguments())
+				return members.getMemberExpression(position, new ThisExpression(position, type), name, true);
+		}
 		if (genericParameters.containsKey(name.name) && !name.hasArguments())
 			return new PartialTypeExpression(position, getTypeRegistry().getGeneric(genericParameters.get(name.name)));
 		
 
 	@Override
 	public ITypeID getType(CodePosition position, List<GenericName> name) {
-		if (members.hasInnerType(name.get(0).name)) {
+		if (members != null && members.hasInnerType(name.get(0).name)) {
 			ITypeID result = members.getInnerType(position, name.get(0));
 			for (int i = 1; i < name.size(); i++) {
 				result = getTypeMembers(result).getInnerType(position, name.get(i));

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

 		KEYWORDS.put("struct", K_STRUCT);
 		KEYWORDS.put("expand", K_EXPAND);
 		KEYWORDS.put("function", K_FUNCTION);
+		KEYWORDS.put("variant", K_VARIANT);
 		
 		KEYWORDS.put("abstract", K_ABSTRACT);
 		KEYWORDS.put("final", K_FINAL);
 		KEYWORDS.put("in", K_IN);
 		KEYWORDS.put("is", K_IS);
 		KEYWORDS.put("as", K_AS);
+		KEYWORDS.put("match", K_MATCH);
 		
 		KEYWORDS.put("this", K_THIS);
 		KEYWORDS.put("super", K_SUPER);

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

 	K_ENUM,
 	K_STRUCT,
 	K_EXPAND,
+	K_VARIANT,
 	
 	K_ABSTRACT,
 	K_FINAL,
 	K_IN,
 	K_IS,
 	K_AS,
+	K_MATCH,
 	
 	K_SUPER,
 	K_THIS,

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

 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.shared.CodePosition;
 import org.openzen.zenscript.lexer.ZSTokenStream;
-import static org.openzen.zenscript.lexer.ZSTokenType.K_ALIAS;
-import static org.openzen.zenscript.lexer.ZSTokenType.K_CLASS;
-import static org.openzen.zenscript.lexer.ZSTokenType.K_ENUM;
-import static org.openzen.zenscript.lexer.ZSTokenType.K_EXPAND;
-import static org.openzen.zenscript.lexer.ZSTokenType.K_FUNCTION;
-import static org.openzen.zenscript.lexer.ZSTokenType.K_INTERFACE;
-import static org.openzen.zenscript.lexer.ZSTokenType.K_STRUCT;
+import static org.openzen.zenscript.lexer.ZSTokenType.*;
 import org.openzen.zenscript.linker.BaseScope;
 import org.openzen.zenscript.parser.definitions.ParsedAlias;
 import org.openzen.zenscript.parser.definitions.ParsedClass;
 import org.openzen.zenscript.parser.definitions.ParsedFunction;
 import org.openzen.zenscript.parser.definitions.ParsedInterface;
 import org.openzen.zenscript.parser.definitions.ParsedStruct;
+import org.openzen.zenscript.parser.definitions.ParsedVariant;
 
 /**
  *
 			return ParsedFunction.parseFunction(pkg, position, modifiers, tokens, outerDefinition);
 		} else if (tokens.optional(K_EXPAND) != null) {
 			return ParsedExpansion.parseExpansion(pkg, position, modifiers, tokens, outerDefinition);
+		} else if (tokens.optional(K_VARIANT) != null) {
+			return ParsedVariant.parseVariant(pkg, position, modifiers, tokens, outerDefinition);
 		} else {
 			//tokens.required(EOF, "An import, class, interface, enum, struct, function or alias expected.");
 			return null;

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

 					case K_EXPORT:
 						modifiers |= Modifiers.EXPORT;
 						break;
+					case K_EXTERN:
+						modifiers |= Modifiers.EXTERN;
+						break;
 					case K_ABSTRACT:
 						modifiers |= Modifiers.ABSTRACT;
 						break;

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

 import org.openzen.zenscript.lexer.ZSTokenStream;
 import org.openzen.zenscript.lexer.ZSTokenType;
 import org.openzen.zenscript.linker.BaseScope;
-import org.openzen.zenscript.linker.DefinitionScope;
 import org.openzen.zenscript.linker.GenericFunctionScope;
 import org.openzen.zenscript.parser.member.ParsedDefinitionMember;
 import org.openzen.zenscript.parser.type.IParsedType;

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

 		return result;
 	}
 	
-	private final List<ParsedGenericParameter> genericParameters;
+	private final List<ParsedGenericParameter> typeParameters;
 	private final List<IParsedType> superInterfaces;
 	
 	private final InterfaceDefinition compiled;
 	
-	public ParsedInterface(ZSPackage pkg, CodePosition position, int modifiers, String name, List<ParsedGenericParameter> genericParameters, List<IParsedType> superInterfaces, HighLevelDefinition outerDefinition) {
+	public ParsedInterface(ZSPackage pkg, CodePosition position, int modifiers, String name, List<ParsedGenericParameter> typeParameters, List<IParsedType> superInterfaces, HighLevelDefinition outerDefinition) {
 		super(position, modifiers);
 		
-		this.genericParameters = genericParameters;
+		this.typeParameters = typeParameters;
 		this.superInterfaces = superInterfaces;
 		
 		compiled = new InterfaceDefinition(position, pkg, name, modifiers, outerDefinition);
-		compiled.setTypeParameters(ParsedGenericParameter.getCompiled(genericParameters));
+		compiled.setTypeParameters(ParsedGenericParameter.getCompiled(typeParameters));
 	}
 
 	@Override
 
 	@Override
 	public void compileMembers(BaseScope scope) {
+		ParsedGenericParameter.compile(scope, compiled.genericParameters, typeParameters);
+		
 		for (IParsedType superInterface : superInterfaces)
 			compiled.addBaseInterface(superInterface.compile(scope));
 		

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedVariant.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.parser.definitions;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.definition.VariantDefinition;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.lexer.ZSTokenStream;
+import org.openzen.zenscript.lexer.ZSTokenType;
+import org.openzen.zenscript.linker.BaseScope;
+import org.openzen.zenscript.linker.DefinitionScope;
+import org.openzen.zenscript.parser.member.ParsedDefinitionMember;
+import org.openzen.zenscript.parser.type.IParsedType;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ParsedVariant extends BaseParsedDefinition {
+	public static ParsedVariant parseVariant(ZSPackage pkg, CodePosition position, int modifiers, ZSTokenStream tokens, HighLevelDefinition outerDefinition) {
+		String name = tokens.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
+		List<ParsedGenericParameter> typeParameters = ParsedGenericParameter.parseAll(tokens);
+		tokens.required(ZSTokenType.T_AOPEN, "{ expected");
+		
+		ParsedVariant result = new ParsedVariant(pkg, position, modifiers, name, typeParameters, outerDefinition);
+		
+		while (!tokens.isNext(ZSTokenType.T_ACLOSE) && !tokens.isNext(ZSTokenType.T_SEMICOLON)) {
+			String optionName = tokens.required(ZSTokenType.T_IDENTIFIER, "identifier expected").content;
+			List<IParsedType> types = new ArrayList<>();
+			if (tokens.optional(ZSTokenType.T_BROPEN) != null) {
+				types.add(IParsedType.parse(tokens));
+				while (tokens.optional(ZSTokenType.T_COMMA) != null) {
+					types.add(IParsedType.parse(tokens));
+				}
+				tokens.required(ZSTokenType.T_BRCLOSE, ") expected");
+			}
+			result.addVariant(new ParsedVariantOption(optionName, types));
+			if (tokens.optional(ZSTokenType.T_COMMA) == null)
+				break;
+		}
+		
+		if (tokens.optional(ZSTokenType.T_SEMICOLON) != null) {
+			while (tokens.optional(ZSTokenType.T_ACLOSE) == null) {
+				result.addMember(ParsedDefinitionMember.parse(tokens, result.compiled));
+			}
+		} else {
+			tokens.required(ZSTokenType.T_ACLOSE, "} expected");
+		}
+		return result;
+	}
+	
+	private final List<ParsedGenericParameter> typeParameters;
+	private final List<ParsedVariantOption> variants = new ArrayList<>();
+	
+	private final VariantDefinition compiled;
+	
+	public ParsedVariant(ZSPackage pkg, CodePosition position, int modifiers, String name, List<ParsedGenericParameter> typeParameters, HighLevelDefinition outerDefinition) {
+		super(position, modifiers);
+		
+		this.typeParameters = typeParameters;
+		compiled = new VariantDefinition(position, pkg, name, modifiers, outerDefinition);
+		compiled.setTypeParameters(ParsedGenericParameter.getCompiled(typeParameters));
+	}
+	
+	public void addVariant(ParsedVariantOption value) {
+		variants.add(value);
+	}
+
+	@Override
+	public HighLevelDefinition getCompiled() {
+		return compiled;
+	}
+	
+	@Override
+	public void compileTypes(BaseScope scope) {
+		DefinitionScope innerScope = new DefinitionScope(scope, getCompiled(), false);
+		for (ParsedVariantOption variant : variants) {
+			compiled.options.add(variant.compile(innerScope));
+		}
+	}
+	
+	@Override
+	public void compileMembers(BaseScope scope) {
+		ParsedGenericParameter.compile(scope, compiled.genericParameters, typeParameters);
+		super.compileMembers(scope);
+	}
+}

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedVariantOption.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.parser.definitions;
+
+import java.util.List;
+import org.openzen.zenscript.codemodel.definition.VariantDefinition;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.linker.BaseScope;
+import org.openzen.zenscript.parser.type.IParsedType;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ParsedVariantOption {
+	public final String name;
+	public final List<IParsedType> types;
+	
+	public ParsedVariantOption(String name, List<IParsedType> types) {
+		this.name = name;
+		this.types = types;
+	}
+	
+	public VariantDefinition.Option compile(BaseScope scope) {
+		ITypeID[] cTypes = new ITypeID[types.size()];
+		for (int i = 0; i < cTypes.length; i++)
+			cTypes[i] = types.get(i).compile(scope);
+		
+		return new VariantDefinition.Option(name, cTypes);
+	}
+}

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

 		return new CallArguments(typeParameters, cArguments);
 	}
 	
+	
+	public CallArguments compileCall(
+			CodePosition position,
+			ExpressionScope scope,
+			ITypeID[] genericParameters,
+			FunctionHeader function)
+	{
+		ExpressionScope innerScope = scope.forCall(function);
+		
+		List<ITypeID>[] predictedTypes = new List[arguments.size()];
+		for (int i = 0; i < predictedTypes.length; i++) {
+			predictedTypes[i] = new ArrayList<>();
+			predictedTypes[i].add(function.parameters[i].type);
+		}
+		
+		Expression[] cArguments = new Expression[arguments.size()];
+		for (int i = 0; i < cArguments.length; i++) {
+			IPartialExpression cArgument = arguments.get(i).compile(innerScope.withHints(predictedTypes[i]));
+			cArguments[i] = cArgument.eval();
+		}
+		
+		ITypeID[] typeParameters = genericParameters;
+		if (typeParameters == null) {
+			if (function.typeParameters != null) {
+				typeParameters = new ITypeID[function.typeParameters.length];
+				for (int i = 0; i < typeParameters.length; i++) {
+					if (innerScope.genericInferenceMap.get(function.typeParameters[i]) == null)
+						throw new CompileException(position, CompileExceptionCode.TYPE_ARGUMENTS_NOT_INFERRABLE, "Could not infer type parameter " + function.typeParameters[i].name);
+					else
+						typeParameters[i] = innerScope.genericInferenceMap.get(function.typeParameters[i]);
+				}
+			}
+		}
+		
+		return new CallArguments(typeParameters, cArguments);
+	}
+	
 	private CallArguments compileCallNaive(CodePosition position, ExpressionScope scope) {
 		Expression[] cArguments = new Expression[arguments.size()];
 		for (int i = 0; i < cArguments.length; i++) {

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

 import org.openzen.zenscript.codemodel.CompareType;
 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.expression.switchvalue.SwitchValue;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.lexer.ZSToken;
  * @author Stanneke
  */
 public abstract class ParsedExpression {
+	public static class ParsingOptions {
+		public static final ParsingOptions DEFAULT = new ParsingOptions(true);
+		
+		public final boolean allowLambda;
+		
+		public ParsingOptions(boolean allowLambda) {
+			this.allowLambda = allowLambda;
+		}
+	}
+	
 	public static ParsedExpression parse(ZSTokenStream parser) {
-		return readAssignExpression(parser);
+		return readAssignExpression(parser, ParsingOptions.DEFAULT);
+	}
+	
+	public static ParsedExpression parse(ZSTokenStream parser, ParsingOptions options) {
+		return readAssignExpression(parser, options);
 	}
 
-	private static ParsedExpression readAssignExpression(ZSTokenStream parser) {
+	private static ParsedExpression readAssignExpression(ZSTokenStream parser, ParsingOptions options) {
 		CodePosition position = parser.getPosition();
-		ParsedExpression left = readConditionalExpression(position, parser);
+		ParsedExpression left = readConditionalExpression(position, parser, options);
 
 		switch (parser.peek().type) {
 			case T_ASSIGN:
 				parser.next();
-				return new ParsedExpressionAssign(position, left, readAssignExpression(parser));
+				return new ParsedExpressionAssign(position, left, readAssignExpression(parser, options));
 			case T_ADDASSIGN:
 				parser.next();
-				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser), OperatorType.ADDASSIGN);
+				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser, options), OperatorType.ADDASSIGN);
 			case T_SUBASSIGN:
 				parser.next();
-				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser), OperatorType.SUBASSIGN);
+				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser, options), OperatorType.SUBASSIGN);
 			case T_CATASSIGN:
 				parser.next();
-				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser), OperatorType.CATASSIGN);
+				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser, options), OperatorType.CATASSIGN);
 			case T_MULASSIGN:
 				parser.next();
-				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser), OperatorType.MULASSIGN);
+				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser, options), OperatorType.MULASSIGN);
 			case T_DIVASSIGN:
 				parser.next();
-				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser), OperatorType.DIVASSIGN);
+				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser, options), OperatorType.DIVASSIGN);
 			case T_MODASSIGN:
 				parser.next();
-				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser), OperatorType.MODASSIGN);
+				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser, options), OperatorType.MODASSIGN);
 			case T_ORASSIGN:
 				parser.next();
-				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser), OperatorType.ORASSIGN);
+				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser, options), OperatorType.ORASSIGN);
 			case T_ANDASSIGN:
 				parser.next();
-				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser), OperatorType.ANDASSIGN);
+				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser, options), OperatorType.ANDASSIGN);
 			case T_XORASSIGN:
 				parser.next();
-				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser), OperatorType.XORASSIGN);
+				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser, options), OperatorType.XORASSIGN);
 			case T_SHLASSIGN:
 				parser.next();
-				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser), OperatorType.SHLASSIGN);
+				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser, options), OperatorType.SHLASSIGN);
 			case T_SHRASSIGN:
 				parser.next();
-				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser), OperatorType.SHRASSIGN);
+				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser, options), OperatorType.SHRASSIGN);
 			case T_USHRASSIGN:
 				parser.next();
-				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser), OperatorType.USHRASSIGN);
+				return new ParsedExpressionOpAssign(position, left, readAssignExpression(parser, options), OperatorType.USHRASSIGN);
 		}
 
 		return left;
 	}
 
-	private static ParsedExpression readConditionalExpression(CodePosition position, ZSTokenStream parser) {
-		ParsedExpression left = readOrOrExpression(position, parser);
+	private static ParsedExpression readConditionalExpression(CodePosition position, ZSTokenStream parser, ParsingOptions options) {
+		ParsedExpression left = readOrOrExpression(position, parser, options);
 
 		if (parser.optional(T_QUEST) != null) {
-			ParsedExpression onIf = readOrOrExpression(parser.peek().position, parser);
+			ParsedExpression onIf = readOrOrExpression(parser.peek().position, parser, options);
 			parser.required(T_COLON, ": expected");
-			ParsedExpression onElse = readConditionalExpression(parser.peek().position, parser);
+			ParsedExpression onElse = readConditionalExpression(parser.peek().position, parser, options);
 			return new ParsedExpressionConditional(position, left, onIf, onElse);
 		}
 
 		return left;
 	}
 
-	private static ParsedExpression readOrOrExpression(CodePosition position, ZSTokenStream parser) {
-		ParsedExpression left = readAndAndExpression(position, parser);
+	private static ParsedExpression readOrOrExpression(CodePosition position, ZSTokenStream parser, ParsingOptions options) {
+		ParsedExpression left = readAndAndExpression(position, parser, options);
 
 		while (parser.optional(T_OROR) != null) {
-			ParsedExpression right = readAndAndExpression(parser.peek().position, parser);
+			ParsedExpression right = readAndAndExpression(parser.peek().position, parser, options);
 			left = new ParsedExpressionOrOr(position, left, right);
 		}
 		
 		while (parser.optional(T_COALESCE) != null) {
-			ParsedExpression right = readAndAndExpression(parser.peek().position, parser);
+			ParsedExpression right = readAndAndExpression(parser.peek().position, parser, options);
 			left = new ParsedExpressionCoalesce(position, left, right);
 		}
 		
 		return left;
 	}
 
-	private static ParsedExpression readAndAndExpression(CodePosition position, ZSTokenStream parser) {
-		ParsedExpression left = readOrExpression(position, parser);
+	private static ParsedExpression readAndAndExpression(CodePosition position, ZSTokenStream parser, ParsingOptions options) {
+		ParsedExpression left = readOrExpression(position, parser, options);
 
 		while (parser.optional(T_ANDAND) != null) {
-			ParsedExpression right = readOrExpression(parser.peek().position, parser);
+			ParsedExpression right = readOrExpression(parser.peek().position, parser, options);
 			left = new ParsedExpressionAndAnd(position, left, right);
 		}
 		return left;
 	}
 
-	private static ParsedExpression readOrExpression(CodePosition position, ZSTokenStream parser) {
-		ParsedExpression left = readXorExpression(position, parser);
+	private static ParsedExpression readOrExpression(CodePosition position, ZSTokenStream parser, ParsingOptions options) {
+		ParsedExpression left = readXorExpression(position, parser, options);
 
 		while (parser.optional(T_OR) != null) {
-			ParsedExpression right = readXorExpression(parser.peek().position, parser);
+			ParsedExpression right = readXorExpression(parser.peek().position, parser, options);
 			left = new ParsedExpressionBinary(position, left, right, OperatorType.OR);
 		}
 		return left;
 	}
 
-	private static ParsedExpression readXorExpression(CodePosition position, ZSTokenStream parser) {
-		ParsedExpression left = readAndExpression(position, parser);
+	private static ParsedExpression readXorExpression(CodePosition position, ZSTokenStream parser, ParsingOptions options) {
+		ParsedExpression left = readAndExpression(position, parser, options);
 
 		while (parser.optional(T_XOR) != null) {
-			ParsedExpression right = readAndExpression(parser.peek().position, parser);
+			ParsedExpression right = readAndExpression(parser.peek().position, parser, options);
 			left = new ParsedExpressionBinary(position, left, right, OperatorType.XOR);
 		}
 		return left;
 	}
 
-	private static ParsedExpression readAndExpression(CodePosition position, ZSTokenStream parser) {
-		ParsedExpression left = readCompareExpression(position, parser);
+	private static ParsedExpression readAndExpression(CodePosition position, ZSTokenStream parser, ParsingOptions options) {
+		ParsedExpression left = readCompareExpression(position, parser, options);
 
 		while (parser.optional(T_AND) != null) {
-			ParsedExpression right = readCompareExpression(parser.peek().position, parser);
+			ParsedExpression right = readCompareExpression(parser.peek().position, parser, options);
 			left = new ParsedExpressionBinary(position, left, right, OperatorType.AND);
 		}
 		return left;
 	}
 
-	private static ParsedExpression readCompareExpression(CodePosition position, ZSTokenStream parser) {
-		ParsedExpression left = readShiftExpression(position, parser);
+	private static ParsedExpression readCompareExpression(CodePosition position, ZSTokenStream parser, ParsingOptions options) {
+		ParsedExpression left = readShiftExpression(position, parser, options);
 
 		switch (parser.peek().getType()) {
 			case T_EQUAL2: {
 				parser.next();
-				ParsedExpression right = readShiftExpression(parser.peek().position, parser);
+				ParsedExpression right = readShiftExpression(parser.peek().position, parser, options);
 				return new ParsedExpressionCompare(position, left, right, CompareType.EQ);
 			}
 			case T_EQUAL3: {
 				parser.next();
-				ParsedExpression right = readShiftExpression(parser.peek().position, parser);
+				ParsedExpression right = readShiftExpression(parser.peek().position, parser, options);
 				return new ParsedExpressionCompare(position, left, right, CompareType.SAME);
 			}
 			case T_NOTEQUAL: {
 				parser.next();
-				ParsedExpression right = readShiftExpression(parser.peek().position, parser);
+				ParsedExpression right = readShiftExpression(parser.peek().position, parser, options);
 				return new ParsedExpressionCompare(position, left, right, CompareType.NE);
 			}
 			case T_NOTEQUAL2: {
 				parser.next();
-				ParsedExpression right = readShiftExpression(parser.peek().position, parser);
+				ParsedExpression right = readShiftExpression(parser.peek().position, parser, options);
 				return new ParsedExpressionCompare(position, left, right, CompareType.NOTSAME);
 			}
 			case T_LESS: {
 				parser.next();
-				ParsedExpression right = readShiftExpression(parser.peek().position, parser);
+				ParsedExpression right = readShiftExpression(parser.peek().position, parser, options);
 				return new ParsedExpressionCompare(position, left, right, CompareType.LT);
 			}
 			case T_LESSEQ: {
 				parser.next();
-				ParsedExpression right = readShiftExpression(parser.peek().position, parser);
+				ParsedExpression right = readShiftExpression(parser.peek().position, parser, options);
 				return new ParsedExpressionCompare(position, left, right, CompareType.LE);
 			}
 			case T_GREATER: {
 				parser.next();
-				ParsedExpression right = readShiftExpression(parser.peek().position, parser);
+				ParsedExpression right = readShiftExpression(parser.peek().position, parser, options);
 				return new ParsedExpressionCompare(position, left, right, CompareType.GT);
 			}
 			case T_GREATEREQ: {
 				parser.next();
-				ParsedExpression right = readShiftExpression(parser.peek().position, parser);
+				ParsedExpression right = readShiftExpression(parser.peek().position, parser, options);
 				return new ParsedExpressionCompare(position, left, right, CompareType.GE);
 			}
 			case K_IN: {
 				parser.next();
-				ParsedExpression right = readShiftExpression(parser.peek().position, parser);
+				ParsedExpression right = readShiftExpression(parser.peek().position, parser, options);
 				return new ParsedExpressionBinary(position, right, left, OperatorType.CONTAINS);
 			}
 			case K_IS: {
 			case T_NOT: {
 				parser.next();
 				if (parser.optional(K_IN) != null) {
-					ParsedExpression right = readShiftExpression(parser.peek().position, parser);
+					ParsedExpression right = readShiftExpression(parser.peek().position, parser, options);
 					return new ParsedExpressionUnary(position, new ParsedExpressionBinary(position, right, left, OperatorType.CONTAINS), OperatorType.NOT);
 				} else if (parser.optional(K_IS) != null) {
 					IParsedType type = IParsedType.parse(parser);
 		return left;
 	}
 	
-	private static ParsedExpression readShiftExpression(CodePosition position, ZSTokenStream parser) {
-		ParsedExpression left = readAddExpression(position, parser);
+	private static ParsedExpression readShiftExpression(CodePosition position, ZSTokenStream parser, ParsingOptions options) {
+		ParsedExpression left = readAddExpression(position, parser, options);
 		
 		while (true) {
 			if (parser.optional(T_SHL) != null) {
-				ParsedExpression right = readAddExpression(parser.peek().position, parser);
+				ParsedExpression right = readAddExpression(parser.peek().position, parser, options);
 				left = new ParsedExpressionBinary(position, left, right, OperatorType.SHL);
 			} else if (parser.optional(T_SHR) != null) {
-				ParsedExpression right = readAddExpression(parser.peek().position, parser);
+				ParsedExpression right = readAddExpression(parser.peek().position, parser, options);
 				left = new ParsedExpressionBinary(position, left, right, OperatorType.SHR);
 			} else if (parser.optional(T_USHR) != null) {
-				ParsedExpression right = readAddExpression(parser.peek().position, parser);
+				ParsedExpression right = readAddExpression(parser.peek().position, parser, options);
 				left = new ParsedExpressionBinary(position, left, right, OperatorType.USHR);
 			} else {
 				break;
 		return left;
 	}
 
-	private static ParsedExpression readAddExpression(CodePosition position, ZSTokenStream parser) {
-		ParsedExpression left = readMulExpression(position, parser);
+	private static ParsedExpression readAddExpression(CodePosition position, ZSTokenStream parser, ParsingOptions options) {
+		ParsedExpression left = readMulExpression(position, parser, options);
 		
 		while (true) {
 			if (parser.optional(T_ADD) != null) {
-				ParsedExpression right = readMulExpression(parser.peek().position, parser);
+				ParsedExpression right = readMulExpression(parser.peek().position, parser, options);
 				left = new ParsedExpressionBinary(position, left, right, OperatorType.ADD);
 			} else if (parser.optional(T_SUB) != null) {
-				ParsedExpression right = readMulExpression(parser.peek().position, parser);
+				ParsedExpression right = readMulExpression(parser.peek().position, parser, options);
 				left = new ParsedExpressionBinary(position, left, right, OperatorType.SUB);
 			} else if (parser.optional(T_CAT) != null) {
-				ParsedExpression right = readMulExpression(parser.peek().position, parser);
+				ParsedExpression right = readMulExpression(parser.peek().position, parser, options);
 				left = new ParsedExpressionBinary(position, left, right, OperatorType.CAT);
 			} else {
 				break;
 		return left;
 	}
 
-	private static ParsedExpression readMulExpression(CodePosition position, ZSTokenStream parser) {
-		ParsedExpression left = readUnaryExpression(position, parser);
+	private static ParsedExpression readMulExpression(CodePosition position, ZSTokenStream parser, ParsingOptions options) {
+		ParsedExpression left = readUnaryExpression(position, parser, options);
 
 		while (true) {
 			if (parser.optional(T_MUL) != null) {
-				ParsedExpression right = readUnaryExpression(parser.peek().position, parser);
+				ParsedExpression right = readUnaryExpression(parser.peek().position, parser, options);
 				left = new ParsedExpressionBinary(position, left, right, OperatorType.MUL);
 			} else if (parser.optional(T_DIV) != null) {
-				ParsedExpression right = readUnaryExpression(parser.peek().position, parser);
+				ParsedExpression right = readUnaryExpression(parser.peek().position, parser, options);
 				left = new ParsedExpressionBinary(position, left, right, OperatorType.DIV);
 			} else if (parser.optional(T_MOD) != null) {
-				ParsedExpression right = readUnaryExpression(parser.peek().position, parser);
+				ParsedExpression right = readUnaryExpression(parser.peek().position, parser, options);
 				left = new ParsedExpressionBinary(position, left, right, OperatorType.MOD);
 			} else {
 				break;
 		return left;
 	}
 
-	private static ParsedExpression readUnaryExpression(CodePosition position, ZSTokenStream parser) {
+	private static ParsedExpression readUnaryExpression(CodePosition position, ZSTokenStream parser, ParsingOptions options) {
 		switch (parser.peek().getType()) {
 			case T_NOT:
 				parser.next();
 				return new ParsedExpressionUnary(
 						position,
-						readUnaryExpression(parser.peek().position, parser),
+						readUnaryExpression(parser.peek().position, parser, options),
 						OperatorType.NOT);
 			case T_SUB:
 				parser.next();
 				return new ParsedExpressionUnary(
 						position,
-						readUnaryExpression(parser.peek().position, parser),
+						readUnaryExpression(parser.peek().position, parser, options),
 						OperatorType.NEG);
 			case T_CAT:
 				parser.next();
 				return new ParsedExpressionUnary(
 						position,
-						readUnaryExpression(parser.peek().position, parser),
+						readUnaryExpression(parser.peek().position, parser, options),
 						OperatorType.CAT);
 			case T_INCREMENT:
 				parser.next();
 				return new ParsedExpressionUnary(
 						position,
-						readUnaryExpression(parser.peek().position, parser),
+						readUnaryExpression(parser.peek().position, parser, options),
 						OperatorType.INCREMENT);
 			case T_DECREMENT:
 				parser.next();
 				return new ParsedExpressionUnary(
 						position,
-						readUnaryExpression(parser.peek().position, parser),
+						readUnaryExpression(parser.peek().position, parser, options),
 						OperatorType.DECREMENT);
 			default:
-				return readPostfixExpression(position, parser);
+				return readPostfixExpression(position, parser, options);
 		}
 	}
 
-	private static ParsedExpression readPostfixExpression(CodePosition position, ZSTokenStream parser) {
-		ParsedExpression base = readPrimaryExpression(position, parser);
+	private static ParsedExpression readPostfixExpression(CodePosition position, ZSTokenStream parser, ParsingOptions options) {
+		ParsedExpression base = readPrimaryExpression(position, parser, options);
 
 		while (true) {
 			if (parser.optional(T_DOT) != null) {
 					}
 				}
 			} else if (parser.optional(T_DOT2) != null) {
-				ParsedExpression to = readAssignExpression(parser);
+				ParsedExpression to = readAssignExpression(parser, options);
 				return new ParsedExpressionRange(position, base, to);
 			} else if (parser.optional(T_SQOPEN) != null) {
 				List<ParsedExpression> indexes = new ArrayList<>();
 				do {
-					indexes.add(readAssignExpression(parser));
+					indexes.add(readAssignExpression(parser, options));
 				} while (parser.optional(ZSTokenType.T_COMMA) != null);
 				parser.required(T_SQCLOSE, "] expected");
 				base = new ParsedExpressionIndex(position, base, indexes);
 				base = new ParsedExpressionPostCall(position, base, OperatorType.INCREMENT);
 			} else if (parser.optional(T_DECREMENT) != null) {
 				base = new ParsedExpressionPostCall(position, base, OperatorType.DECREMENT);
-			} else if (parser.optional(T_LAMBDA) != null) {
+			} else if (options.allowLambda && parser.optional(T_LAMBDA) != null) {
 				ParsedFunctionBody body = ParsedStatement.parseLambdaBody(parser, true);
 				base = new ParsedExpressionFunction(position, base.toLambdaHeader(), body);
 			} else {
 		return base;
 	}
 	
-	private static ParsedExpression readPrimaryExpression(CodePosition position, ZSTokenStream parser) {
+	private static ParsedExpression readPrimaryExpression(CodePosition position, ZSTokenStream parser, ParsingOptions options) {
 		switch (parser.peek().getType()) {
 			case T_INT:
 				return new ParsedExpressionInt(position, Long.parseLong(parser.next().content));
 				List<ParsedExpression> contents = new ArrayList<>();
 				if (parser.optional(T_SQCLOSE) == null) {
 					while (parser.optional(T_SQCLOSE) == null) {
-						contents.add(readAssignExpression(parser));
+						contents.add(readAssignExpression(parser, options));
 						if (parser.optional(T_COMMA) == null) {
 							parser.required(T_SQCLOSE, "] or , expected");
 							break;
 				List<ParsedExpression> keys = new ArrayList<>();
 				List<ParsedExpression> values = new ArrayList<>();
 				while (parser.optional(T_ACLOSE) == null) {
-					ParsedExpression expression = readAssignExpression(parser);
+					ParsedExpression expression = readAssignExpression(parser, options);
 					if (parser.optional(T_COLON) == null) {
 						keys.add(null);
 						values.add(expression);
 					} else {
 						keys.add(expression);
-						values.add(readAssignExpression(parser));
+						values.add(readAssignExpression(parser, options));
 					}
 
 					if (parser.optional(T_COMMA) == null) {
 				parser.next();
 				List<ParsedExpression> expressions = new ArrayList<>();
 				do {
-					expressions.add(readAssignExpression(parser));
+					expressions.add(readAssignExpression(parser, options));
 				} while (parser.optional(ZSTokenType.T_COMMA) != null);
 				parser.required(T_BRCLOSE, ") expected");
 				return new ParsedExpressionBracket(position, expressions);
 				
 				return new ParsedNewExpression(position, type, newArguments);
 			}
+			case K_MATCH: {
+				parser.next();
+				ParsedExpression source = parse(parser);
+				parser.required(T_AOPEN, "{ expected");
+				
+				List<ParsedMatchExpression.Case> cases = new ArrayList<>();
+				while (parser.optional(T_ACLOSE) == null) {
+					ParsedExpression key = null;
+					if (parser.optional(K_DEFAULT) == null)
+						key = parse(parser, new ParsingOptions(false));
+					
+					parser.required(T_LAMBDA, "=> expected");
+					ParsedFunctionBody body = ParsedStatement.parseLambdaBody(parser, true);
+					cases.add(new ParsedMatchExpression.Case(key, body));
+					
+					if (parser.optional(T_COMMA) == null)
+						break;
+				}
+				parser.required(T_ACLOSE, "} expected");
+				return new ParsedMatchExpression(position, source, cases);
+			}
 			default: {
 				IParsedType type = IParsedType.parse(parser);
 				if (type == null) {
 		return compile(scope).eval();
 	}
 	
+	public SwitchValue compileToSwitchValue(ITypeID type, ExpressionScope scope) {
+		throw new CompileException(position, CompileExceptionCode.INVALID_SWITCH_CASE, "Invalid switch case");
+	}
+	
 	public ParsedFunctionHeader toLambdaHeader() {
 		throw new ParseException(position, "Not a valid lambda header");
 	}

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

 import java.util.List;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.OperatorType;
+import org.openzen.zenscript.codemodel.definition.VariantDefinition;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.ConstructorThisCallExpression;
+import org.openzen.zenscript.codemodel.expression.VariantValueExpression;
+import org.openzen.zenscript.codemodel.expression.switchvalue.SwitchValue;
+import org.openzen.zenscript.codemodel.expression.switchvalue.VariantOptionSwitchValue;
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
 import org.openzen.zenscript.codemodel.member.ICallableMember;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.DefinitionMemberGroup;
+import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.linker.ExpressionScope;
+import org.openzen.zenscript.parser.definitions.ParsedFunctionParameter;
 import org.openzen.zenscript.shared.CodePosition;
 import org.openzen.zenscript.shared.CompileException;
 import org.openzen.zenscript.shared.CompileExceptionCode;
 
 	@Override
 	public IPartialExpression compile(ExpressionScope scope) {
-		IPartialExpression cReceiver = receiver.compile(scope.withoutHints());
+		if (receiver instanceof ParsedExpressionVariable) {
+			ParsedExpressionVariable variable = (ParsedExpressionVariable) receiver;
+			for (ITypeID hint : scope.hints) {
+				TypeMembers members = scope.getTypeMembers(hint);
+				if (members.getVariantOption(variable.name) != null) {
+					VariantDefinition.Option variantOption = members.getVariantOption(variable.name);
+					FunctionHeader header = new FunctionHeader(BasicTypeID.VOID, variantOption.types);
+					CallArguments cArguments = arguments.compileCall(position, scope, null, header);
+					return new VariantValueExpression(position, hint, variantOption, cArguments.arguments);
+				}
+			}
+		}
 		
 		if (receiver instanceof ParsedExpressionSuper) {
 			// super call (intended as first call in constructor)
 			
 			return new ConstructorThisCallExpression(position, scope.getThisType(), (ConstructorMember) member, callArguments, scope);
 		}
-
+		
+		IPartialExpression cReceiver = receiver.compile(scope.withoutHints());
 		List<FunctionHeader> headers = cReceiver.getPossibleFunctionHeaders(scope, scope.hints, arguments.arguments.size());
 		CallArguments callArguments = arguments.compileCall(position, scope, cReceiver.getGenericCallTypes(), headers);
 		return cReceiver.call(position, scope, scope.hints, callArguments);
 	}
+	
+	@Override
+	public SwitchValue compileToSwitchValue(ITypeID type, ExpressionScope scope) {
+		if (!(receiver instanceof ParsedExpressionVariable))
+			throw new CompileException(position, CompileExceptionCode.INVALID_SWITCH_CASE, "Invalid switch case");
+		
+		String name = ((ParsedExpressionVariable)receiver).name;
+		TypeMembers members = scope.getTypeMembers(type);
+		if (type.isVariant()) {
+			VariantDefinition.Option option = members.getVariantOption(name);
+			if (option == null)
+				throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "Variant option does not exist: " + name);
+			
+			String[] values = new String[arguments.arguments.size()];
+			for (int i = 0; i < values.length; i++) {
+				ParsedExpression argument = arguments.arguments.get(i);
+				ParsedFunctionParameter lambdaHeader = argument.toLambdaParameter();
+				values[i] = lambdaHeader.name;
+			}
+			
+			return new VariantOptionSwitchValue(option, values);
+		} else {
+			throw new CompileException(position, CompileExceptionCode.INVALID_SWITCH_CASE, "Invalid switch case");
+		}
+	}
 
 	@Override
 	public boolean hasStrongType() {

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

  * @author Stan
  */
 public class ParsedExpressionFunction extends ParsedExpression {
-	private final ParsedFunctionHeader header;
-	private final ParsedFunctionBody body;
+	public final ParsedFunctionHeader header;
+	public final ParsedFunctionBody body;
 	
 	public ParsedExpressionFunction(CodePosition position, ParsedFunctionHeader header, ParsedFunctionBody body) {
 		super(position);

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

 
 import java.util.Collections;
 import java.util.List;
+import org.openzen.zenscript.codemodel.definition.VariantDefinition;
 import org.openzen.zenscript.codemodel.expression.ConstantStringExpression;
 import org.openzen.zenscript.codemodel.expression.EnumConstantExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.expression.VariantValueExpression;
+import org.openzen.zenscript.codemodel.expression.switchvalue.EnumConstantSwitchValue;
+import org.openzen.zenscript.codemodel.expression.switchvalue.SwitchValue;
+import org.openzen.zenscript.codemodel.expression.switchvalue.VariantOptionSwitchValue;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.type.GenericName;
 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.parser.definitions.ParsedFunctionHeader;
 import org.openzen.zenscript.parser.definitions.ParsedFunctionParameter;
  * @author Stanneke
  */
 public class ParsedExpressionVariable extends ParsedExpression {
-	private final String name;
+	public final String name;
 	private final List<IParsedType> genericParameters;
 	
 	public ParsedExpressionVariable(CodePosition position, String name, List<IParsedType> 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);
+				TypeMembers members = scope.getTypeMembers(hint);
+				EnumConstantMember member = members.getEnumMember(name);
 				if (member != null)
 					return new EnumConstantExpression(position, hint, member);
+				
+				VariantDefinition.Option option = members.getVariantOption(name);
+				if (option != null)
+					return new VariantValueExpression(position, hint, option);
 			}
 			
 			throw new CompileException(position, CompileExceptionCode.UNDEFINED_VARIABLE, "No such symbol: " + name);
 		return new ConstantStringExpression(position, name);
 	}
 	
+	@Override
+	public SwitchValue compileToSwitchValue(ITypeID type, ExpressionScope scope) {
+		TypeMembers members = scope.getTypeMembers(type);
+		if (type.isEnum()) {
+			EnumConstantMember member = members.getEnumMember(name);
+			if (member == null)
+				throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "Enum member does not exist: " + name);
+				
+			return new EnumConstantSwitchValue(member);
+		} else if (type.isVariant()) {
+			VariantDefinition.Option option = members.getVariantOption(name);
+			if (option == null)
+				throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "Variant option does not exist: " + name);
+			if (option.types.length > 0)
+				throw new CompileException(position, CompileExceptionCode.MISSING_VARIANT_CASEPARAMETERS, "Variant case is missing parameters");
+			
+			return new VariantOptionSwitchValue(option, new String[0]);
+		} else {
+			throw new CompileException(position, CompileExceptionCode.INVALID_SWITCH_CASE, "Invalid switch case");
+		}
+	}
+	
 	@Override
 	public ParsedFunctionHeader toLambdaHeader() {
 		return new ParsedFunctionHeader(Collections.singletonList(toLambdaParameter()), ParsedTypeBasic.ANY);

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedMatchExpression.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.parser.expression;
+
+import java.util.List;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.expression.FunctionExpression;
+import org.openzen.zenscript.codemodel.expression.LambdaClosure;
+import org.openzen.zenscript.codemodel.expression.MatchExpression;
+import org.openzen.zenscript.codemodel.expression.switchvalue.SwitchValue;
+import org.openzen.zenscript.codemodel.expression.switchvalue.VariantOptionSwitchValue;
+import org.openzen.zenscript.codemodel.partial.IPartialExpression;
+import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.linker.ExpressionScope;
+import org.openzen.zenscript.linker.LambdaScope;
+import org.openzen.zenscript.linker.StatementScope;
+import org.openzen.zenscript.parser.statements.ParsedFunctionBody;
+import org.openzen.zenscript.shared.CodePosition;
+import org.openzen.zenscript.shared.CompileException;
+import org.openzen.zenscript.shared.CompileExceptionCode;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ParsedMatchExpression extends ParsedExpression {
+	public final ParsedExpression value;
+	public final List<Case> cases;
+	
+	public ParsedMatchExpression(CodePosition position, ParsedExpression value, List<Case> cases) {
+		super(position);
+		
+		this.value = value;
+		this.cases = cases;
+	}
+
+	@Override
+	public IPartialExpression compile(ExpressionScope scope) {
+		Expression cValue = value.compileKey(scope);
+		MatchExpression.Case[] cCases = new MatchExpression.Case[cases.size()];
+		for (int i = 0; i < cases.size(); i++) {
+			Case matchCase = cases.get(i);
+			cCases[i] = matchCase.compile(cValue.type, scope);
+		}
+		
+		ITypeID result = cCases[0].value.header.returnType;
+		for (int i = 1; i < cCases.length; i++) {
+			result = scope.getTypeMembers(result).union(cCases[i].value.header.returnType);
+		}
+		
+		return new MatchExpression(position, cValue, result, cCases);
+	}
+
+	@Override
+	public boolean hasStrongType() {
+		return false;
+	}
+	
+	public static class Case {
+		public final ParsedExpression name;
+		public final ParsedFunctionBody body;
+		
+		public Case(ParsedExpression name, ParsedFunctionBody body) {
+			this.name = name;
+			this.body = body;
+		}
+		
+		public MatchExpression.Case compile(ITypeID valueType, ExpressionScope scope) {
+			ITypeID result = BasicTypeID.ANY;
+			if (scope.getResultTypeHints().size() == 1)
+				result = scope.getResultTypeHints().get(0);
+			
+			if (name == null) {
+				FunctionHeader header = new FunctionHeader(result, FunctionParameter.NONE);
+				LambdaClosure closure = new LambdaClosure();
+				StatementScope innerScope = new LambdaScope(scope, closure, header);
+				Statement contents = body.compile(innerScope, header);
+				return new MatchExpression.Case(null, new FunctionExpression(name.position, scope.getTypeRegistry().getFunction(header), closure, contents));
+			}
+			
+			SwitchValue switchValue = name.compileToSwitchValue(valueType, scope.withHint(valueType));
+			FunctionParameter[] parameters = FunctionParameter.NONE;
+			if (switchValue instanceof VariantOptionSwitchValue) {
+				VariantOptionSwitchValue variantSwitchValue = (VariantOptionSwitchValue)switchValue;
+				
+				parameters = new FunctionParameter[variantSwitchValue.option.types.length];
+				for (int i = 0; i < parameters.length; i++)
+					parameters[i] = new FunctionParameter(variantSwitchValue.option.types[i], variantSwitchValue.parameters[i]);
+			}
+			
+			FunctionHeader header = new FunctionHeader(result, parameters);
+			LambdaClosure closure = new LambdaClosure();
+			StatementScope innerScope = new LambdaScope(scope, closure, header);
+			Statement contents = body.compile(innerScope, header);
+			return new MatchExpression.Case(switchValue, new FunctionExpression(name.position, scope.getTypeRegistry().getFunction(header), closure, contents));
+		}
+	}
+}

Shared/src/main/java/org/openzen/zenscript/shared/CompileExceptionCode.java

 	INTERNAL_ERROR,
 	CANNOT_SET_FINAL_VARIABLE,
 	MISSING_PARAMETER,
-	STATEMENT_OUTSIDE_SWITCH_CASE
+	STATEMENT_OUTSIDE_SWITCH_CASE,
+	MISSING_VARIANT_CASEPARAMETERS,
+	INVALID_SWITCH_CASE
 }

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

 import org.openzen.zenscript.codemodel.definition.FunctionDefinition;
 import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
 import org.openzen.zenscript.codemodel.definition.StructDefinition;
+import org.openzen.zenscript.codemodel.definition.VariantDefinition;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.validator.Validator;
 import org.openzen.zenscript.validator.analysis.StatementScope;
 		}
 		return isValid;
 	}
+
+	@Override
+	public Boolean visitVariant(VariantDefinition variant) {
+		boolean isValid = true;
+		isValid &= ValidationUtils.validateModifiers(
+				validator,
+				variant.modifiers,
+				PUBLIC | EXPORT | PROTECTED | PRIVATE,
+				variant.position,
+				"Invalid variant modifier");
+		isValid &= ValidationUtils.validateIdentifier(
+				validator,
+				variant.position,
+				variant.name);
+		
+		isValid &= validateMembers(variant);
+		return isValid;
+	}
 	
 	private class FunctionStatementScope implements StatementScope {
 		private final FunctionHeader header;

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

 import org.openzen.zenscript.codemodel.expression.IsExpression;
 import org.openzen.zenscript.codemodel.expression.MakeConstExpression;
 import org.openzen.zenscript.codemodel.expression.MapExpression;
+import org.openzen.zenscript.codemodel.expression.MatchExpression;
 import org.openzen.zenscript.codemodel.expression.NewExpression;
 import org.openzen.zenscript.codemodel.expression.NullExpression;
 import org.openzen.zenscript.codemodel.expression.OrOrExpression;
 		return isValid;
 	}
 
+	@Override
+	public Boolean visitMatch(MatchExpression expression) {
+		// TODO
+		return true;
+	}
+
 	@Override
 	public Boolean visitNew(NewExpression expression) {
 		boolean isValid = checkCallArguments(

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

 import org.openzen.zenscript.codemodel.definition.FunctionDefinition;
 import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
 import org.openzen.zenscript.codemodel.definition.StructDefinition;
+import org.openzen.zenscript.codemodel.definition.VariantDefinition;
+import org.openzen.zenscript.shared.CodePosition;
 import org.openzen.zenscript.validator.ValidationLogEntry;
 import org.openzen.zenscript.validator.Validator;
 
  */
 public class SuperclassValidator implements DefinitionVisitor<Boolean> {
 	private final Validator validator;
+	private final CodePosition position;
 	
-	public SuperclassValidator(Validator validator) {
+	public SuperclassValidator(Validator validator, CodePosition position) {
 		this.validator = validator;
+		this.position = position;
 	}
 
 	@Override
 
 	@Override
 	public Boolean visitAlias(AliasDefinition definition) {
-		throw new AssertionError();
+		return definition.type.accept(new SupertypeValidator(validator, position));
+	}
+
+	@Override
+	public Boolean visitVariant(VariantDefinition variant) {
+		validator.logError(
+				ValidationLogEntry.Code.SUPERCLASS_NOT_A_CLASS,
+				variant.position,
+				"Superclass cannot be a variant");
+		return false;
 	}
 }