Regeneration of shared (with manual fixes)

Shared/src/main/java/compactio/CompactBytesDataInput.java

     
     @Override
     public boolean readBool() {
-        return this.readByte() != (byte)0;
+        return (this.readByte() & 0xFF) != (0 & 0xFF);
     }
     
     @Override
     public int readByte() {
-        return (data[offset++]) & 0xFF;
+        return data[offset++];
     }
     
     @Override
     public byte readSByte() {
-        return data[offset++];
+        return (byte)(data[offset++]);
     }
     
     @Override
             int bvalue = this.readByte();
             int remainingBits = result.length - 8 * i;
             if (remainingBits > 0)
-                result[i * 8 + 0] = (bvalue & (byte)1) > (byte)0;
+                result[i * 8 + 0] = ((bvalue & 1) & 0xFF) > (0 & 0xFF);
             if (remainingBits > 1)
-                result[i * 8 + 2] = (bvalue & (byte)4) > (byte)0;
+                result[i * 8 + 2] = ((bvalue & 4) & 0xFF) > (0 & 0xFF);
             if (remainingBits > 3)
-                result[i * 8 + 3] = (bvalue & (byte)8) > (byte)0;
+                result[i * 8 + 3] = ((bvalue & 8) & 0xFF) > (0 & 0xFF);
             if (remainingBits > 4)
-                result[i * 8 + 4] = (bvalue & (byte)16) > (byte)0;
+                result[i * 8 + 4] = ((bvalue & 16) & 0xFF) > (0 & 0xFF);
             if (remainingBits > 5)
-                result[i * 8 + 5] = (bvalue & (byte)32) > (byte)0;
+                result[i * 8 + 5] = ((bvalue & 32) & 0xFF) > (0 & 0xFF);
             if (remainingBits > 6)
-                result[i * 8 + 6] = (bvalue & (byte)64) > (byte)0;
+                result[i * 8 + 6] = ((bvalue & 64) & 0xFF) > (0 & 0xFF);
             if (remainingBits > 7)
-                result[i * 8 + 7] = (bvalue & (byte)-128) > (byte)0;
+                result[i * 8 + 7] = ((bvalue & 128) & 0xFF) > (0 & 0xFF);
         }
         return result;
     }

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

 package listeners;
 
-import zsynthetic.FunctionTToVoid;
+import java.util.function.Consumer;
 
 public final class ListenerList<T> {
     public static final int PRIORITY_HIGH = 100;
         this.first = this.last = null;
     }
     
-    public void accept(FunctionTToVoid<T> consumer) {
+    public void accept(Consumer<T> consumer) {
         ListenerList<T>.EventListenerNode current = first;
         while (current != null) {
-            consumer.invoke(current.getListener());
+            consumer.accept(current.getListener());
             current = current.next;
         }
     }

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

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

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

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

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

 package live;
 
+import java.util.function.BiConsumer;
 import listeners.ListenerHandle;
-import zsynthetic.FunctionTTToVoid;
 
 public interface LiveObject<T> {
     T getValue();
     
-    ListenerHandle<FunctionTTToVoid<T>> addListener(FunctionTTToVoid<T> listener);
+    ListenerHandle<BiConsumer<T, T>> addListener(BiConsumer<T, T> listener);
 }

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

 package live;
 
+import java.util.function.BiConsumer;
 import listeners.ListenerHandle;
-import zsynthetic.FunctionStringStringToVoid;
 
 public interface LiveString {
     String getValue();
     
-    ListenerHandle<FunctionStringStringToVoid> addListener(FunctionStringStringToVoid listener);
+    ListenerHandle<BiConsumer<String, String>> addListener(BiConsumer<String, String> listener);
 }

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

 public final class CodePosition {
     public static final CodePosition BUILTIN = new CodePosition(new VirtualSourceFile("builtin"), 0, 0, 0, 0);
     public static final CodePosition NATIVE = new CodePosition(new VirtualSourceFile("native"), 0, 0, 0, 0);
-	public static final CodePosition META = new CodePosition(new VirtualSourceFile("meta"), 0, 0, 0, 0);
+    public static final CodePosition META = new CodePosition(new VirtualSourceFile("meta"), 0, 0, 0, 0);
 	public static final CodePosition UNKNOWN = new CodePosition(new VirtualSourceFile("unknown"), 0, 0, 0, 0);
-	
     public final SourceFile file;
     public final int fromLine;
     public final int fromLineOffset;

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

 	VARIANT_OPTION_NOT_AN_EXPRESSION,
 	DUPLICATE_GLOBAL,
 	CANNOT_INFER_RETURN_TYPE,
-	INVALID_SUFFIX,
-	NO_SUCH_MODULE,
-	
-	NO_SUCH_STORAGE_TYPE,
-	INVALID_STORAGE_TYPE_ARGUMENTS,
-	STORAGE_NOT_SUPPORTED,
-	INCOMPATIBLE_STORAGE_TAG,
-	INVALID_TYPE_ARGUMENTS
+	INVALID_SUFFIX
 }

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

 	public static Result<String, String> unescape(String self) {
 	    if (!(self.charAt(0) == self.charAt(self.length() - 1)))
 	        throw new AssertionError("Unbalanced quotes");
-	    if (!(self.charAt(0) == '@' && ArrayHelpers.contains(new String[] {"\"", "'"}, Character.toString(self.charAt(1))) || ArrayHelpers.contains(new String[] {"\"", "'"}, Character.toString(self.charAt(0)))))
+	    if (!(self.charAt(0) == '@' && ArrayHelpers.contains(new char[] {'"', '\''}, self.charAt(1)) || ArrayHelpers.contains(new char[] {'"', '\''}, self.charAt(0))))
 	        throw new AssertionError("String is not quoted");
 	    if (!(self.length() >= 2))
 	        throw new AssertionError("String is not quoted");
 	                        return new Result.Error<>(((Result.Error<Integer, String>)temp5).value);
 	                    int hex3 = ((Result.Ok<Integer, String>)temp5).value;
 	                    i = i + 5;
-	                    result.append((char)hex0 << 12 | hex1 << 8 | hex2 << 4 | hex3);
+	                    result.append((char)(hex0 << 12 | hex1 << 8 | hex2 << 4 | hex3));
 	                    break;
 	                default:
 	                    return new Error("Illegal escape sequence");

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

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import zsynthetic.FunctionTToBool;
-import zsynthetic.FunctionTToU;
-import zsynthetic.FunctionTToVoid;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
 import zsynthetic.FunctionUSizeTToBool;
 import zsynthetic.FunctionUSizeTToU;
 import zsynthetic.FunctionUSizeTToVoid;
         }
     }
     
-    public static <U, T> U[] map(Class<T> typeOfT, T[] self, Class<U> typeOfU, FunctionTToU<U, T> projection) {
+    public static <U, T> U[] map(Class<T> typeOfT, T[] self, Class<U> typeOfU, Function<T, U> projection) {
         U[] temp1 = (U[])(Array.newInstance(typeOfU, self.length));
         for (int temp2 = 0; temp2 < temp1.length; temp2++)
-            temp1[temp2] = projection.invoke(self[temp2]);
+            temp1[temp2] = projection.apply(self[temp2]);
         return temp1;
     }
     
-    public static <U, T> U[] map(Class<T> typeOfT, T[] self, Class<U> typeOfU, FunctionUSizeTToU<U, T> projection) {
+    public static <U, T> U[] map(Class<T> typeOfT, T[] self, Class<U> typeOfU, FunctionUSizeTToU<T, U> projection) {
         U[] temp1 = (U[])(Array.newInstance(typeOfU, self.length));
         for (int temp2 = 0; temp2 < temp1.length; temp2++)
             temp1[temp2] = projection.invoke(temp2, self[temp2]);
         return temp1;
     }
     
-    public static <T> T[] filter(Class<T> typeOfT, T[] self, FunctionTToBool<T> predicate) {
+    public static <T> T[] filter(Class<T> typeOfT, T[] self, Predicate<T> predicate) {
         List<T> values = new ArrayList<T>();
         for (T value : self)
-            if (predicate.invoke(value))
+            if (predicate.test(value))
                 values.add(value);
         return values.toArray((T[])(Array.newInstance(typeOfT, values.size())));
     }
         return values.toArray((T[])(Array.newInstance(typeOfT, values.size())));
     }
     
-    public static <T> void each(Class<T> typeOfT, T[] self, FunctionTToVoid<T> consumer) {
+    public static <T> void each(Class<T> typeOfT, T[] self, Consumer<T> consumer) {
         for (T value : self)
-            consumer.invoke(value);
+            consumer.accept(value);
     }
     
     public static <T> void each(Class<T> typeOfT, T[] self, FunctionUSizeTToVoid<T> consumer) {
         }
     }
     
-    public static <T> boolean contains(Class<T> typeOfT, T[] self, FunctionTToBool<T> predicate) {
+    public static <T> boolean contains(Class<T> typeOfT, T[] self, Predicate<T> predicate) {
         for (T value : self)
-            if (predicate.invoke(value))
+            if (predicate.test(value))
                 return true;
         return false;
     }
         return false;
     }
     
-    public static <T> boolean all(Class<T> typeOfT, T[] self, FunctionTToBool<T> predicate) {
+    public static <T> boolean all(Class<T> typeOfT, T[] self, Predicate<T> predicate) {
         for (T value : self)
-            if (!predicate.invoke(value))
+            if (!predicate.test(value))
                 return false;
         return true;
     }
         return true;
     }
     
-    public static <T> T first(Class<T> typeOfT, T[] self, FunctionTToBool<T> predicate) {
+    public static <T> T first(Class<T> typeOfT, T[] self, Predicate<T> predicate) {
         for (T value : self)
-            if (predicate.invoke(value))
+            if (predicate.test(value))
                 return value;
         return null;
     }
         return null;
     }
     
-    public static <T> T last(Class<T> typeOfT, T[] self, FunctionTToBool<T> predicate) {
+    public static <T> T last(Class<T> typeOfT, T[] self, Predicate<T> predicate) {
         int i = self.length;
         while (i > 0) {
             i--;
-            if (predicate.invoke(self[i]))
+            if (predicate.test(self[i]))
                 return self[i];
         }
         return null;
         return null;
     }
     
-    public static <T> int count(Class<T> typeOfT, T[] self, FunctionTToBool<T> predicate) {
+    public static <T> int count(Class<T> typeOfT, T[] self, Predicate<T> predicate) {
         int result = 0;
         for (T value : self)
-            if (predicate.invoke(value))
+            if (predicate.test(value))
                 result++;
         return result;
     }
         return result;
     }
     
-    public static <K, T> Map<K, T> index(Class<T> typeOfT, T[] self, Class<K> typeOfK, FunctionTToU<K, T> key) {
+    public static <K, T> Map<K, T> index(Class<T> typeOfT, T[] self, Class<K> typeOfK, Function<T, K> key) {
         Map<K, T> result = new HashMap<>();
         for (T value : self)
-            result.put(key.invoke(value), value);
+            result.put(key.apply(value), value);
         return result;
     }
 }

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

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

Shared/src/main/java/stdlib/Integers.java

+package stdlib;
+
+final class Integers {
+    private Integers() {}
+}

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

 package stdlib;
 
-import zsynthetic.FunctionTToResultWithUV;
-import zsynthetic.FunctionTToU;
+import java.util.function.Function;
 
 public abstract class Result<T, E> {
-    public <R> Result<R, E> then(Class<R> typeOfR, FunctionTToResultWithUV<R, E, T> fn) {
+    public <R> Result<R, E> then(Class<R> typeOfR, Function<T, Result<R, E>> fn) {
         Result<R, E> temp1;
         switch (this.getDiscriminant()) {
             case Ok:
                 T result = ((Result.Ok<T, E>)this).value;
-                temp1 = fn.invoke(result);
+                temp1 = fn.apply(result);
                 break;
             case Error:
                 E error = ((Result.Error<T, E>)this).value;
         return temp1;
     }
     
-    public <X> Result<T, X> handle(Class<X> typeOfX, FunctionTToResultWithUV<T, X, E> handler) {
+    public <X> Result<T, X> handle(Class<X> typeOfX, Function<E, Result<T, X>> handler) {
         Result<T, X> temp1;
         switch (this.getDiscriminant()) {
             case Ok:
                 break;
             case Error:
                 E error = ((Result.Error<T, E>)this).value;
-                temp1 = handler.invoke(error);
+                temp1 = handler.apply(error);
                 break;
             default:
                 throw new AssertionError("Missing case");
         return temp1;
     }
     
-    public T orElse(FunctionTToU<T, E> other) {
+    public T orElse(Function<E, T> other) {
         T temp1;
         switch (this.getDiscriminant()) {
             case Ok:
                 break;
             case Error:
                 E error = ((Result.Error<T, E>)this).value;
-                temp1 = other.invoke(error);
+                temp1 = other.apply(error);
                 break;
             default:
                 throw new AssertionError("Missing case");

Shared/src/main/java/stdlib/USize.java

+package stdlib;
+
+final class USize {
+    private USize() {}
+}

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

                 return true;
         return false;
     }
+	
+	public static boolean contains(char[] haystack, char needle) {
+        for (int i = 0; i < haystack.length; i++)
+            if (haystack[i] == needle)
+                return true;
+        return false;
+    }
 }

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

 
 @FunctionalInterface
 public interface FunctionBoolBoolToVoid {
-    void invoke(boolean oldValue, boolean newValue);
+    void invoke(boolean a, boolean b);
 }

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

 
 @FunctionalInterface
 public interface FunctionIntIntToVoid {
-    void invoke(int oldValue, int newValue);
+    void invoke(int a, int b);
 }

Shared/src/main/java/zsynthetic/FunctionUSizeTToBool.java

 
 @FunctionalInterface
 public interface FunctionUSizeTToBool<T> {
-    boolean invoke(int index, T value);
+    boolean invoke(int a, T b);
 }

Shared/src/main/java/zsynthetic/FunctionUSizeTToU.java

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

Shared/src/main/java/zsynthetic/FunctionUSizeTToVoid.java

 
 @FunctionalInterface
 public interface FunctionUSizeTToVoid<T> {
-    void invoke(int index, T value);
+    void invoke(int a, T b);
 }

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

+package zsynthetic;
+
+public final class Shared<T extends AutoCloseable> {
+    private final T value;
+    private int refcount = 1;
+    
+    public Shared(T value) {
+        this.value = value;
+    }
+    
+    public synchronized void addRef() {
+        refcount++;
+    }
+    
+    public synchronized void release() {
+        refcount--;
+        if (refcount == 0) {
+            try {
+                value.close();
+            } catch (Exception ex) {}
+        }
+    }
+}