Updated shared with the new generated version, fixing a bunch of code generation imperfections.

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

 package listeners;
 
-
 public final class DummyListenerHandle<T> implements ListenerHandle<T>, AutoCloseable {
     public final T listener;
     

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

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

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

 package listeners;
 
-import listeners.ListenerList;
 import zsynthetic.FunctionTToVoid;
 
 public final class ListenerList<T> {

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

 
 import listeners.DummyListenerHandle;
 import listeners.ListenerHandle;
-import live.ImmutableLiveBool;
 import zsynthetic.FunctionBoolBoolToVoid;
 
 public final class ImmutableLiveBool implements LiveBool {

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

 package live;
 
-
 public interface MutableLiveList<T> extends AutoCloseable, LiveList<T> {
     void add(T value);
     

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

 package org.openzen.zencode.shared;
 
-import org.openzen.zencode.shared.CodePosition;
-import org.openzen.zencode.shared.CompileException;
-
 public final class CompileException extends RuntimeException {
     public static CompileException internalError(String message) {
         return new CompileException(CodePosition.BUILTIN, CompileExceptionCode.INTERNAL_ERROR, message);

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

 package org.openzen.zencode.shared;
 
 public enum CompileExceptionCode {
-	UNEXPECTED_TOKEN(),
-	IMPORT_NOT_FOUND(),
-	NO_OUTER_BECAUSE_NOT_INNER(),
-	NO_OUTER_BECAUSE_STATIC(),
-	NO_OUTER_BECAUSE_OUTSIDE_TYPE(),
-	TYPE_ARGUMENTS_INVALID_NUMBER(),
-	TYPE_ARGUMENTS_NOT_INFERRABLE(),
-	USING_STATIC_ON_INSTANCE(),
-	CANNOT_ASSIGN(),
-	UNAVAILABLE_IN_CLOSURE(),
-	USING_PACKAGE_AS_EXPRESSION(),
-	USING_PACKAGE_AS_CALL_TARGET(),
-	USING_TYPE_AS_EXPRESSION(),
-	MEMBER_NO_SETTER(),
-	MEMBER_NO_GETTER(),
-	MEMBER_NOT_STATIC(),
-	MEMBER_IS_FINAL(),
-	MEMBER_DUPLICATE(),
-	CALL_AMBIGUOUS(),
-	CALL_NO_VALID_METHOD(),
-	ENUM_VALUE_DUPLICATE(),
-	INVALID_CAST(),
-	NO_SUCH_INNER_TYPE(),
-	NO_DOLLAR_HERE(),
-	UNSUPPORTED_XML_EXPRESSIONS(),
-	UNSUPPORTED_NAMED_ARGUMENTS(),
-	TYPE_CANNOT_UNITE(),
-	BRACKET_MULTIPLE_EXPRESSIONS(),
-	SUPER_CALL_NO_SUPERCLASS(),
-	LAMBDA_HEADER_INVALID(),
-	COALESCE_TARGET_NOT_OPTIONAL(),
-	MULTIPLE_MATCHING_HINTS(),
-	MISSING_MAP_KEY(),
-	NO_SUCH_MEMBER(),
-	USING_THIS_OUTSIDE_TYPE(),
-	USING_THIS_STATIC(),
-	UNDEFINED_VARIABLE(),
-	METHOD_BODY_REQUIRED(),
-	BREAK_OUTSIDE_LOOP(),
-	CONTINUE_OUTSIDE_LOOP(),
-	NO_SUCH_ITERATOR(),
-	NO_SUCH_TYPE(),
-	RETURN_VALUE_REQUIRED(),
-	RETURN_VALUE_VOID(),
-	INVALID_CONDITION(),
-	INTERNAL_ERROR(),
-	CANNOT_SET_FINAL_VARIABLE(),
-	MISSING_PARAMETER(),
-	STATEMENT_OUTSIDE_SWITCH_CASE(),
-	MISSING_VARIANT_CASEPARAMETERS(),
-	INVALID_SWITCH_CASE(),
-	TRY_CONVERT_OUTSIDE_FUNCTION(),
-	TRY_CONVERT_ILLEGAL_TARGET(),
-	TRY_RETHROW_NOT_A_RESULT(),
-	DIFFERENT_EXCEPTIONS(),
-	UNKNOWN_ANNOTATION(),
-	OVERRIDE_WITHOUT_BASE(),
-	OVERRIDE_AMBIGUOUS(),
-	OVERRIDE_CONSTRUCTOR(),
-	PRECOMPILE_FAILED(),
-	UNTYPED_EMPTY_ARRAY(),
-	UNTYPED_EMPTY_MAP(),
-	VAR_WITHOUT_TYPE_OR_INITIALIZER(),
-	NO_BRACKET_PARSER(),
-	INVALID_BRACKET_EXPRESSION(),
+	UNEXPECTED_TOKEN,
+	IMPORT_NOT_FOUND,
+	NO_OUTER_BECAUSE_NOT_INNER,
+	NO_OUTER_BECAUSE_STATIC,
+	NO_OUTER_BECAUSE_OUTSIDE_TYPE,
+	TYPE_ARGUMENTS_INVALID_NUMBER,
+	TYPE_ARGUMENTS_NOT_INFERRABLE,
+	USING_STATIC_ON_INSTANCE,
+	CANNOT_ASSIGN,
+	UNAVAILABLE_IN_CLOSURE,
+	USING_PACKAGE_AS_EXPRESSION,
+	USING_PACKAGE_AS_CALL_TARGET,
+	USING_TYPE_AS_EXPRESSION,
+	MEMBER_NO_SETTER,
+	MEMBER_NO_GETTER,
+	MEMBER_NOT_STATIC,
+	MEMBER_IS_FINAL,
+	MEMBER_DUPLICATE,
+	CALL_AMBIGUOUS,
+	CALL_NO_VALID_METHOD,
+	ENUM_VALUE_DUPLICATE,
+	INVALID_CAST,
+	NO_SUCH_INNER_TYPE,
+	NO_DOLLAR_HERE,
+	UNSUPPORTED_XML_EXPRESSIONS,
+	UNSUPPORTED_NAMED_ARGUMENTS,
+	TYPE_CANNOT_UNITE,
+	BRACKET_MULTIPLE_EXPRESSIONS,
+	SUPER_CALL_NO_SUPERCLASS,
+	LAMBDA_HEADER_INVALID,
+	COALESCE_TARGET_NOT_OPTIONAL,
+	MULTIPLE_MATCHING_HINTS,
+	MISSING_MAP_KEY,
+	NO_SUCH_MEMBER,
+	USING_THIS_OUTSIDE_TYPE,
+	USING_THIS_STATIC,
+	UNDEFINED_VARIABLE,
+	METHOD_BODY_REQUIRED,
+	BREAK_OUTSIDE_LOOP,
+	CONTINUE_OUTSIDE_LOOP,
+	NO_SUCH_ITERATOR,
+	NO_SUCH_TYPE,
+	RETURN_VALUE_REQUIRED,
+	RETURN_VALUE_VOID,
+	INVALID_CONDITION,
+	INTERNAL_ERROR,
+	CANNOT_SET_FINAL_VARIABLE,
+	MISSING_PARAMETER,
+	STATEMENT_OUTSIDE_SWITCH_CASE,
+	MISSING_VARIANT_CASEPARAMETERS,
+	INVALID_SWITCH_CASE,
+	TRY_CONVERT_OUTSIDE_FUNCTION,
+	TRY_CONVERT_ILLEGAL_TARGET,
+	TRY_RETHROW_NOT_A_RESULT,
+	DIFFERENT_EXCEPTIONS,
+	UNKNOWN_ANNOTATION,
+	OVERRIDE_WITHOUT_BASE,
+	OVERRIDE_AMBIGUOUS,
+	OVERRIDE_CONSTRUCTOR,
+	PRECOMPILE_FAILED,
+	UNTYPED_EMPTY_ARRAY,
+	UNTYPED_EMPTY_MAP,
+	VAR_WITHOUT_TYPE_OR_INITIALIZER,
+	NO_BRACKET_PARSER,
+	INVALID_BRACKET_EXPRESSION,
 	VARIANT_OPTION_NOT_AN_EXPRESSION,
 	DUPLICATE_GLOBAL,
 	CANNOT_INFER_RETURN_TYPE

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

 package org.openzen.zencode.shared;
 
-import org.openzen.zencode.shared.ConcatMap;
 import stdlib.EqualsComparable;
 
 public final class ConcatMap<K extends EqualsComparable<K>, V> {

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

 
 import java.util.HashMap;
 import java.util.Map;
-import org.openzen.zencode.shared.CharacterEntity;
-import org.openzen.zencode.shared.StringExpansion;
 import stdlib.Result;
 import stdlib.Result.Error;
-import stdlib.Result.Error;
-import stdlib.Result.Ok;
 import stdlib.Result.Ok;
 import stdlib.Strings;
 import zsynthetic.ArrayHelpers;

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

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import zsynthetic.FunctionIntTToBool;
-import zsynthetic.FunctionIntTToU;
-import zsynthetic.FunctionIntTToVoid;
 import zsynthetic.FunctionTToBool;
 import zsynthetic.FunctionTToU;
 import zsynthetic.FunctionTToVoid;
+import zsynthetic.FunctionUSizeTToBool;
+import zsynthetic.FunctionUSizeTToU;
+import zsynthetic.FunctionUSizeTToVoid;
 
 public final class Arrays {
     private Arrays() {}
         return temp1;
     }
     
-    public static <U, T> U[] map(Class<T> typeOfT, T[] self, Class<U> typeOfU, FunctionIntTToU<U, T> projection) {
+    public static <U, T> U[] map(Class<T> typeOfT, T[] self, Class<U> typeOfU, FunctionUSizeTToU<U, T> projection) {
         U[] temp1 = (U[])(Array.newInstance(typeOfU, self.length));
         for (int temp2 = 0; temp2 < temp1.length; temp2++)
             temp1[temp2] = projection.invoke(temp2, self[temp2]);
         return values.toArray((T[])(Array.newInstance(typeOfT, values.size())));
     }
     
-    public static <T> T[] filter(Class<T> typeOfT, T[] self, FunctionIntTToBool<T> predicate) {
+    public static <T> T[] filter(Class<T> typeOfT, T[] self, FunctionUSizeTToBool<T> predicate) {
         List<T> values = new ArrayList<T>();
         for (int i = 0; i < self.length; i++) {
             T value = self[i];
             consumer.invoke(value);
     }
     
-    public static <T> void each(Class<T> typeOfT, T[] self, FunctionIntTToVoid<T> consumer) {
+    public static <T> void each(Class<T> typeOfT, T[] self, FunctionUSizeTToVoid<T> consumer) {
         for (int i = 0; i < self.length; i++) {
             T value = self[i];
             consumer.invoke(i, value);
         return false;
     }
     
-    public static <T> boolean contains(Class<T> typeOfT, T[] self, FunctionIntTToBool<T> predicate) {
+    public static <T> boolean contains(Class<T> typeOfT, T[] self, FunctionUSizeTToBool<T> predicate) {
         for (int i = 0; i < self.length; i++) {
             T value = self[i];
             if (predicate.invoke(i, value))
         return true;
     }
     
-    public static <T> boolean all(Class<T> typeOfT, T[] self, FunctionIntTToBool<T> predicate) {
+    public static <T> boolean all(Class<T> typeOfT, T[] self, FunctionUSizeTToBool<T> predicate) {
         for (int i = 0; i < self.length; i++) {
             T value = self[i];
             if (!predicate.invoke(i, value))
         return null;
     }
     
-    public static <T> T first(Class<T> typeOfT, T[] self, FunctionIntTToBool<T> predicate) {
+    public static <T> T first(Class<T> typeOfT, T[] self, FunctionUSizeTToBool<T> predicate) {
         for (int i = 0; i < self.length; i++) {
             T value = self[i];
             if (predicate.invoke(i, value))
         return null;
     }
     
-    public static <T> T last(Class<T> typeOfT, T[] self, FunctionIntTToBool<T> predicate) {
+    public static <T> T last(Class<T> typeOfT, T[] self, FunctionUSizeTToBool<T> predicate) {
         int i = self.length;
         while (i > 0) {
             i--;
         return result;
     }
     
-    public static <T> int count(Class<T> typeOfT, T[] self, FunctionIntTToBool<T> predicate) {
+    public static <T> int count(Class<T> typeOfT, T[] self, FunctionUSizeTToBool<T> predicate) {
         int result = 0;
         for (int i = 0; i < self.length; i++) {
             T value = self[i];

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

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

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

 package stdlib;
 
-import stdlib.Result;
-import stdlib.Result.Error;
-import stdlib.Result.Ok;
 import zsynthetic.FunctionTToResultWithUV;
 import zsynthetic.FunctionTToU;
 
                 break;
             case Error:
                 E error = ((Result.Error<T, E>)this).value;
-                temp1 = new Error(error);
+                temp1 = new Result.Error(error);
                 break;
             default:
                 throw new AssertionError("Missing case");
         switch (this.getDiscriminant()) {
             case Ok:
                 T result = ((Result.Ok<T, E>)this).value;
-                temp1 = new Ok(result);
+                temp1 = new Result.Ok(result);
                 break;
             case Error:
                 E error = ((Result.Error<T, E>)this).value;

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

 package stdlib;
 
-
 public interface StringBuildable {
     void toString(StringBuilder output);
     

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

 package stdlib;
 
-
 public final class StringBuilder {
     public static StringBuilder shl(StringBuilder self, StringBuildable value) {
         value.toString(self);

Shared/src/main/java/stdlib/Strings.java

 
 import java.util.ArrayList;
 import java.util.List;
-import stdlib.Chars;
 
 public final class Strings {
     private Strings() {}

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

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