Added many missing modules and files.

collections/src/HashSet.zs

@@ -3,7 +3,7 @@ export class HashSet<T> {
 		add(value as T) as bool;
 		remove(value as T) as bool;
 		
-		get size as int;
+		get size as usize;
 		
 		in(value as T) as bool;
 		for(x as T);

collections/src/LinkedList.zs

@@ -1,9 +1,9 @@
 export class LinkedList<T> {
 	var first as Node?;
 	var last as Node?;
-	var size as int : get;
+	var size as usize : get;
 	
-	public get empty as bool
+	public get isEmpty as bool
 		=> first == null;
 	
 	public add(value as T) as void {
@@ -23,26 +23,21 @@ export class LinkedList<T> {
 		size = 0;
 	}
 	
-	public [](index as int) as T {
+	[Precondition(ENFORCE, index < size, "Index out of bounds")]
+	public [](index as usize) as T {
 		var node = first;
-		while index > 0 {
-			if node == null
-				return panic<T>("index out of bounds");
-			
+		while index > 0 && node != null
 			node = node.next;
-		}
 		
 		if node == null
-			return panic<T>("index out of bounds");
+			panic "index out of bounds";
 		
 		return node.value;
 	}
 	
 	public implements Queue<T> {
+		[Precondition(ENFORCE, first != null, "Cannot poll an empty queue")]
 		poll() as T {
-			if first == null
-				return panic<T>("Cannot poll an empty queue");
-			
 			val result = first.value;
 			first = first.next;
 			if first == null
@@ -54,7 +49,7 @@ export class LinkedList<T> {
 		}
 		
 		peek() as T? {
-			return first.value;
+			return first == null ? null : first.value;
 		}
 		
 		offer(value as T) as void

collections/src/Set.zs

@@ -2,7 +2,7 @@ export interface Set<T> {
 	add(value as T) as bool;
 	remove(value as T) as bool;
 	
-	get size as int;
+	get size as usize;
 	
 	toArray();
 	toArray(comparator as function(a as T, b as T) as int);

collections/src/Stack.zs

@@ -1,21 +1,18 @@
+import stdlib.List;
+
 export class Stack<T> {
-	var values as T[] = new T[](8);
-	var size as int : get = 0;
+	var values as List<T> = new List<T>();
 	
-	public push(value as T) as void {
-		if size == values.length
-			values = values.copy(values.length * 2);
-			
-		values[size++] = value;
-	}
+	public push(value as T) as void
+		=> values.add(value);
 	
-	public pop() as T {
-		if size == 0
-			throw new NoSuchElementException("Stack is empty!");
-		
-		return values[--size];
-	}
+	public get size as usize
+		=> values.length;
 	
-	public get empty as bool
-		=> size == 0;
+	[Precondition(ENFORCE, size > 0, "Cannot pop an empty stack")]
+	public pop() as T
+		=> values.remove(values.length - 1);
+	
+	public get isEmpty as bool
+		=> values.isEmpty;
 }

compactio/module.json

@@ -0,0 +1,6 @@
+{
+	"package": "compactio",
+	"javaPackage": "org.openzen.zencode.stdlib.compactio",
+	"host": "universal",
+	"dependencies": ["io"]
+}

compactio/src/CompactBytesDataInput.zs

@@ -0,0 +1,293 @@
+export class CompactBytesDataInput {
+	private const P6 as uint = 1 << 6;
+	private const P7 as uint = 1 << 7;
+	private const P13 as uint = 1 << 13;
+	private const P14 as uint = 1 << 14;
+	private const P20 as uint = 1 << 20;
+	private const P21 as uint = 1 << 21;
+	private const P27 as uint = 1 << 27;
+	private const P28 as uint = 1 << 28;
+	private const P34 as ulong = 1UL << 34;
+	private const P35 as ulong = 1UL << 35;
+	private const P41 as ulong = 1UL << 41;
+	private const P42 as ulong = 1UL << 42;
+	private const P48 as ulong = 1UL << 48;
+	private const P49 as ulong = 1UL << 49;
+	private const P55 as ulong = 1UL << 55;
+	private const P56 as ulong = 1UL << 56;
+	
+	val data as const byte[];
+	var offset as usize : get;
+	
+	public this(data as const byte[]) {
+		this.data = data;
+		this.offset = 0;
+	}
+	
+	public this(data as const byte[], offset as usize) {
+		this.data = data;
+		this.offset = offset;
+	}
+	
+	~this {}
+	
+	public implements CompactDataInput {
+		readBool() => readByte() != 0;
+		
+		readByte() => data[offset++];
+		
+		readSByte() => data[offset++];
+		
+		readShort() {
+			val b0 = data[offset++] as uint;
+			val b1 = data[offset++] as uint;
+			return ((b0 << 8) | b1) as short;
+		}
+		
+		readUShort() => readShort();
+		
+		readInt() {
+			val b0 = data[offset++] as int;
+			val b1 = data[offset++] as int;
+			val b2 = data[offset++] as int;
+			val b3 = data[offset++] as int;
+			return (b0 << 24) | (b1 << 16) | (b2 << 8) | b3;
+    	}
+    	
+    	readUInt() => readInt();
+    	
+    	readLong() {
+    		val i0 = readUInt() as long;
+    		val i1 = readUInt() as long;
+    		return (i0 << 32) | i1;
+    	}
+    	
+    	readULong() => readLong();
+    	
+    	readVarInt() {
+    		val value = readVarUInt();
+    		return (value & 1) == 0 ? (value >> 1) : -((value >> 1) as int + 1);
+		}
+		
+		readVarUInt() {
+			var value = data[offset++] as uint;
+			if (value & P7) == 0
+				return value;
+			
+			value = (value & (P7 - 1)) | (data[offset++] as uint) << 7;
+			if (value & P14) == 0
+				return value;
+			
+			value = (value & (P14 - 1)) | (data[offset++] as uint) << 14;
+			if (value & P21) == 0
+				return value;
+			
+			value = (value & (P21 - 1)) | (data[offset++] as uint) << 21;
+			if (value & P28) == 0
+				return value;
+			
+			return (value & (P28 - 1)) | (data[offset++] as uint) << 28;
+		}
+		
+		readVarLong() {
+			val value = readVarULong();
+			return (value & 1) == 0 ? (value >> 1) : -((value >> 1) as long + 1);
+		}
+		
+		readVarULong() {
+			var value = data[offset++] as ulong;
+			if (value & P7) == 0
+				return value;
+			
+			value = (value & (P7 - 1)) | (data[offset++] as ulong) << 7;
+			if (value & P14) == 0
+				return value;
+			
+			value = (value & (P14 - 1)) | (data[offset++] as ulong) << 14;
+			if (value & P21) == 0
+				return value;
+			
+			value = (value & (P21 - 1)) | (data[offset++] as ulong) << 21;
+			if (value & P28) == 0
+				return value;
+			
+			value = (value & (P28 - 1)) | (data[offset++] as ulong) << 28;
+			if (value & P35) == 0
+				return value;
+			
+			value = (value & (P35 - 1)) | (data[offset++] as ulong) << 35;
+			if (value & P42) == 0
+				return value;
+			
+			value = (value & (P42 - 1)) | (data[offset++] as ulong) << 42;
+			if (value & P49) == 0
+				return value;
+			
+			value = (value & (P49 - 1)) | (data[offset++] as ulong) << 49;
+			if (value & P56) == 0
+				return value;
+			
+			return (value & (P56 - 1)) | (data[offset++] as ulong) << 56;
+		}
+		
+		readFloat() => float.fromBits(readUInt());
+		
+		readDouble() => double.fromBits(readULong());
+	
+		readChar() => readVarUInt() as char;
+		
+		readString() => string.fromUTF8Bytes(readBytes());
+		
+		readBytes() as byte[] {
+			val size = readVarUInt();
+			return readRawBytes(size);
+		}
+		
+		readRawBytes(size as usize) {
+			val result = data[offset .. offset + size];
+			offset += size;
+			return result;
+		}
+		
+		readBoolArray() as bool[] {
+			val size = readVarUInt() as usize;
+			val result = new bool[](size);
+			for i in 0 .. ((size + 7) / 8) {
+				val bvalue = readByte();
+				val remainingBits = result.length - 8 * i;
+				
+				if (remainingBits > 0)
+					result[i * 8 + 0] = (bvalue & 1) > 0;
+				if (remainingBits > 1)
+					result[i * 8 + 2] = (bvalue & 4) > 0;
+				if (remainingBits > 3)
+					result[i * 8 + 3] = (bvalue & 8) > 0;
+				if (remainingBits > 4)
+					result[i * 8 + 4] = (bvalue & 16) > 0;
+				if (remainingBits > 5)
+					result[i * 8 + 5] = (bvalue & 32) > 0;
+				if (remainingBits > 6)
+					result[i * 8 + 6] = (bvalue & 64) > 0;
+				if (remainingBits > 7)
+					result[i * 8 + 7] = (bvalue & 128) > 0;
+			}
+			
+			return result;
+		}
+		
+		readByteArray() => readBytes();
+		
+		readSByteArray() => readBytes();
+		
+		readShortArray() => readShortArrayRaw(readVarUInt());
+		
+		readShortArrayRaw(length) {
+			val result = new short[](length);
+			for i in 0 .. result.length
+				result[i] = readShort();
+			return result;
+		}
+		
+		readUShortArray() => readShortArray();
+		
+		readUShortArrayRaw(length) => readShortArrayRaw(length);
+		
+		readVarIntArray() => readVarIntArrayRaw(readVarUInt());
+		
+		readVarIntArrayRaw(length) {
+			val result = new int[](length);
+			for i in 0 .. result.length
+				result[i] = readVarInt();
+			return result;
+		}
+		
+		readVarUIntArray() => readVarUIntArrayRaw(readVarUInt());
+		
+		readVarUIntArrayRaw(length) {
+			val result = new uint[](length);
+			for i in 0 .. result.length
+				result[i] = readVarUInt();
+			return result;
+		}
+		
+		readIntArray() => readIntArrayRaw(readVarUInt());
+		
+		readIntArrayRaw(length) {
+			val result = new int[](length);
+			for i in 0 .. result.length
+				result[i] = readInt();
+			return result;
+		}
+		
+		readUIntArray() => readUIntArrayRaw(readVarUInt());
+		
+		readUIntArrayRaw(length) {
+			val result = new int[](length);
+			for i in 0 .. result.length
+				result[i] = readUInt();
+			return result;
+		}
+		
+		readVarLongArray() => readVarLongArrayRaw(readVarUInt());
+		
+		readVarLongArrayRaw(length) {
+			val result = new long[](length);
+			for i in 0 .. result.length
+				result[i] = readVarLong();
+			return result;
+		}
+		
+		readVarULongArray() => readVarULongArrayRaw(readVarUInt());
+		
+		readVarULongArrayRaw(length) {
+			val result = new long[](length);
+			for i in 0 .. result.length
+				result[i] = readVarULong();
+			return result;
+		}
+		
+		readLongArray() => readLongArrayRaw(readVarUInt());
+		
+		readLongArrayRaw(length) {
+			val result = new long[](length);
+			for i in 0 .. result.length
+				result[i] = readLong();
+			return result;
+		}
+		
+		readULongArray() => readLongArray();
+		
+		readULongArrayRaw(length) => readLongArrayRaw(length);
+		
+		readFloatArray() => readFloatArrayRaw(readVarUInt());
+		
+		readFloatArrayRaw(length) {
+			val result = new float[](length);
+			for i in 0 .. result.length
+				result[i] = readFloat();
+			return result;
+		}
+		
+		readDoubleArray() => readDoubleArrayRaw(readVarUInt());
+		
+		readDoubleArrayRaw(length) {
+			val result = new double[](length);
+			for i in 0 .. length
+				result[i] = readDouble();
+			return result;
+		}
+		
+		readStringArray() => readStringArrayRaw(readVarUInt());
+		
+		readStringArrayRaw(length) {
+			val result = new string[](length);
+			for i in 0 .. result.length
+				result[i] = readString();
+			return result;
+		}
+		
+		skip(bytes) => offset += bytes;
+		
+		hasMore() => offset < data.length;
+	}
+}

compactio/src/CompactBytesDataOutput.zs

@@ -0,0 +1,367 @@
+export class CompactBytesDataOutput {
+	private const P6 as uint = 1 << 6;
+	private const P7 as uint = 1 << 7;
+	private const P13 as uint = 1 << 13;
+	private const P14 as uint = 1 << 14;
+	private const P20 as uint = 1 << 20;
+	private const P21 as uint = 1 << 21;
+	private const P27 as uint = 1 << 27;
+	private const P28 as uint = 1 << 28;
+	private const P34 as ulong = 1UL << 34;
+	private const P35 as ulong = 1UL << 35;
+	private const P41 as ulong = 1UL << 41;
+	private const P42 as ulong = 1UL << 42;
+	private const P48 as ulong = 1UL << 48;
+	private const P49 as ulong = 1UL << 49;
+	private const P55 as ulong = 1UL << 55;
+	private const P56 as ulong = 1UL << 56;
+	
+	var data = new byte[](16);
+	var length as usize = 0;
+	
+	private reserve(bytes as usize) as void {
+		while length + bytes > data.length
+			data = data.copy(2 * data.length);
+	}
+	
+	public asByteArray() as byte[] => data.copy(length);
+	
+	~this {}
+	
+	public implements CompactDataOutput {
+		writeBool(value) => writeByte(value ? 1 : 0);
+		
+		writeByte(value) {
+			reserve(1);
+			data[length++] = value;
+		}
+		
+		writeSByte(value) => writeByte(value);
+		
+		writeShort(value) => writeUShort(value);
+		
+		writeUShort(value) {
+			reserve(2);
+			data[length++] = (value >> 8) as byte;
+			data[length++] = value as byte;
+		}
+		
+		writeInt(value) => writeUInt(value);
+		
+		writeUInt(value) {
+			reserve(4);
+			data[length++] = (value >> 24) as byte;
+			data[length++] = (value >> 16) as byte;
+			data[length++] = (value >> 8) as byte;
+			data[length++] = value as byte;
+		}
+		
+		writeLong(value) => writeULong(value);
+		
+		writeULong(value) {
+			reserve(8);
+			data[length++] = (value >> 56) as byte;
+			data[length++] = (value >> 48) as byte;
+			data[length++] = (value >> 40) as byte;
+			data[length++] = (value >> 32) as byte;
+			data[length++] = (value >> 24) as byte;
+			data[length++] = (value >> 16) as byte;
+			data[length++] = (value >> 8) as byte;
+			data[length++] = value as byte;
+		}
+		
+		writeVarInt(value) => writeVarUInt(value < 0 ? (((1 - (value as uint)) << 1) + 1) : (value << 1));
+		
+		writeVarUInt(value) {
+			reserve(5);
+			
+			if value < P7 {
+				data[length++] = (value & 0x7F) as byte;
+			} else if value < P14 {
+				data[length++] = ((value & 0x7F) | 0x80) as byte;
+				data[length++] = ((value >> 7) & 0x7F) as byte;
+			} else if value < P21 {
+				data[length++] = ((value & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 7) & 0x7F) | 0x80) as byte;
+				data[length++] = ((value >> 14) & 0x7F) as byte;
+			} else if value < P28 {
+				data[length++] = ((value & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 7) & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 14) & 0x7F) | 0x80) as byte;
+				data[length++] = ((value >> 21) & 0x7F) as byte;
+			} else {
+				data[length++] = ((value & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 7) & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 14) & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 21) & 0x7F) | 0x80) as byte;
+				data[length++] = ((value >> 28) & 0x7F) as byte;
+			}
+		}
+		
+		writeVarLong(value) => writeVarULong(value < 0 ? (((1 - (value as ulong)) << 1) + 1) : (value << 1));
+		
+		writeVarULong(value) {
+			reserve(9);
+			
+			if value < P7 {
+				data[length++] = (value & 0x7F) as byte;
+			} else if value < P14 {
+				data[length++] = ((value & 0x7F) | 0x80) as byte;
+				data[length++] = ((value >> 7) & 0x7F) as byte;
+			} else if value < P21 {
+				data[length++] = ((value & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 7) & 0x7F) | 0x80) as byte;
+				data[length++] = ((value >> 14) & 0x7F) as byte;
+			} else if value < P28 {
+				data[length++] = ((value & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 7) & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 14) & 0x7F) | 0x80) as byte;
+				data[length++] = ((value >> 21) & 0x7F) as byte;
+			} else if value < P35 {
+				data[length++] = ((value & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 7) & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 14) & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 21) & 0x7F) | 0x80) as byte;
+				data[length++] = ((value >> 28) & 0x7F) as byte;
+			} else if value < P42 {
+				data[length++] = ((value & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 7) & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 14) & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 21) & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 28) & 0x7F) | 0x80) as byte;
+				data[length++] = ((value >> 35) & 0x7F) as byte;
+			} else if value < P49 {
+				data[length++] = ((value & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 7) & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 14) & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 21) & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 28) & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 35) & 0x7F) | 0x80) as byte;
+				data[length++] = ((value >> 42) & 0x7F) as byte;
+			} else if value < P56 {
+				data[length++] = ((value & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 7) & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 14) & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 21) & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 28) & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 35) & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 42) & 0x7F) | 0x80) as byte;
+				data[length++] = ((value >> 49) & 0x7F) as byte;
+			} else {
+				data[length++] = ((value & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 7) & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 14) & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 21) & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 28) & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 35) & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 42) & 0x7F) | 0x80) as byte;
+				data[length++] = (((value >> 49) & 0x7F) | 0x80) as byte;
+				data[length++] = (value >> 56) as byte;
+			}
+		}
+		
+		writeFloat(value) => writeUInt(value.bits);
+		
+		writeDouble(value) => writeULong(value.bits);
+		
+		writeChar(value) => writeVarUInt(value);
+		
+		[Precondition(ENFORCE, data.length < uint.MAX_VALUE, "Array length cannot exceed uint limit")]
+		writeBytes(data) {
+			writeVarUInt(data.length as uint);
+			writeRawBytes(data);
+		}
+		
+		[Precondition(ENFORCE, length < uint.MAX_VALUE, "Array length cannot exceed uint limit")]
+		writeBytes(data, offset, length) {
+			writeVarUInt(length as uint);
+			writeRawBytes(data, offset, length);
+		}
+		
+		writeString(str) => writeBytes(str.toUTF8Bytes());
+		
+		writeRawBytes(value) {
+			reserve(value.length);
+			value.copyTo(data, 0, length, value.length);
+			length += value.length;
+		}
+		
+		writeRawBytes(value, offset, length) {
+			reserve(value.length);
+			value.copyTo(data, offset, this.length, value.length);
+			this.length += length;
+		}
+		
+		[Precondition(ENFORCE, data.length < uint.MAX_VALUE, "Array length cannot exceed uint limit")]
+		writeBoolArray(data) {
+			writeVarUInt(data.length as uint);
+			
+			var i = 0 as usize;
+			while i < data.length - 7 {
+				var bvalue as byte = 0;
+				if data[i + 0]
+					bvalue |= 1;
+				if data[i + 1]
+					bvalue |= 2;
+				if data[i + 2]
+					bvalue += 4;
+				if data[i + 3]
+					bvalue += 8;
+				if data[i + 4]
+					bvalue += 16;
+				if data[i + 5]
+					bvalue += 32;
+				if data[i + 6]
+					bvalue += 64;
+				if data[i + 7]
+					bvalue += 128;
+				writeByte(bvalue);
+				i += 8;
+			}
+			
+			if i < data.length {
+				var bvalue as byte = 0;
+				for offset in 0 .. (data.length % 7)
+					if data[i + offset]
+						bvalue += (1 << i) as byte;
+				
+				writeByte(bvalue);
+			}
+		}
+		
+		[Precondition(ENFORCE, data.length < uint.MAX_VALUE, "Array length cannot exceed uint limit")]
+		writeByteArray(data) => writeBytes(data);
+		
+		[Precondition(ENFORCE, data.length < uint.MAX_VALUE, "Array length cannot exceed uint limit")]
+		writeSByteArray(data) => writeBytes(data);
+		
+		[Precondition(ENFORCE, data.length < uint.MAX_VALUE, "Array length cannot exceed uint limit")]
+		writeShortArray(data) {
+			writeVarUInt(data.length as uint);
+			writeShortArrayRaw(data);
+		}
+		
+		writeShortArrayRaw(data) {
+			for element in data
+				writeShort(element);
+		}
+		
+		[Precondition(ENFORCE, data.length < uint.MAX_VALUE, "Array length cannot exceed uint limit")]
+		writeUShortArray(data) => writeShortArray(data);
+		
+		writeUShortArrayRaw(data) => writeShortArrayRaw(data);
+		
+		[Precondition(ENFORCE, data.length < uint.MAX_VALUE, "Array length cannot exceed uint limit")]
+		writeVarIntArray(data) {
+			writeVarUInt(data.length as uint);
+			writeVarIntArrayRaw(data);
+		}
+		
+		writeVarIntArrayRaw(data) {
+			for element in data
+				writeVarInt(element);
+		}
+		
+		[Precondition(ENFORCE, data.length < uint.MAX_VALUE, "Array length cannot exceed uint limit")]
+		writeVarUIntArray(data) {
+			writeVarUInt(data.length as uint);
+			writeVarUIntArrayRaw(data);
+		}
+		
+		writeVarUIntArrayRaw(data) {
+			for element in data
+				writeVarUInt(element);
+		}
+		
+		[Precondition(ENFORCE, data.length < uint.MAX_VALUE, "Array length cannot exceed uint limit")]
+		writeIntArray(data) {
+			writeVarUInt(data.length as uint);
+			writeIntArrayRaw(data);
+		}
+		
+		writeIntArrayRaw(data) {
+			for element in data
+				writeInt(element);
+		}
+		
+		[Precondition(ENFORCE, data.length < uint.MAX_VALUE, "Array length cannot exceed uint limit")]
+		writeUIntArray(data) => writeIntArray(data);
+		
+		writeUIntArrayRaw(data) => writeIntArrayRaw(data);
+		
+		[Precondition(ENFORCE, data.length < uint.MAX_VALUE, "Array length cannot exceed uint limit")]
+		writeVarLongArray(data) {
+			writeVarUInt(data.length as uint);
+			writeVarLongArrayRaw(data);
+		}
+		
+		writeVarLongArrayRaw(data) {
+			for element in data
+				writeVarLong(element);
+		}
+		
+		[Precondition(ENFORCE, data.length < uint.MAX_VALUE, "Array length cannot exceed uint limit")]
+		writeVarULongArray(data) {
+			writeVarUInt(data.length as uint);
+			writeVarULongArrayRaw(data);
+		}
+		
+		writeVarULongArrayRaw(data) {
+			for element in data
+				writeVarULong(element);
+		}
+		
+		[Precondition(ENFORCE, data.length < uint.MAX_VALUE, "Array length cannot exceed uint limit")]
+		writeLongArray(data) {
+			writeVarUInt(data.length as uint);
+			writeLongArrayRaw(data);
+		}
+		
+		writeLongArrayRaw(data) {
+			for element in data
+				writeLong(element);
+		}
+		
+		[Precondition(ENFORCE, data.length < uint.MAX_VALUE, "Array length cannot exceed uint limit")]
+		writeULongArray(data) => writeLongArray(data);
+		
+		writeULongArrayRaw(data) => writeLongArrayRaw(data);
+		
+		[Precondition(ENFORCE, data.length < uint.MAX_VALUE, "Array length cannot exceed uint limit")]
+		writeFloatArray(data) {
+			writeVarUInt(data.length as uint);
+			writeFloatArrayRaw(data);
+		}
+		
+		writeFloatArrayRaw(data) {
+			for element in data
+				writeFloat(element);
+		}
+		
+		[Precondition(ENFORCE, data.length < uint.MAX_VALUE, "Array length cannot exceed uint limit")]
+		writeDoubleArray(data) {
+			writeVarUInt(data.length as uint);
+			writeDoubleArrayRaw(data);
+		}
+		
+		writeDoubleArrayRaw(data) {
+			for element in data
+				writeDouble(element);
+		}
+		
+		[Precondition(ENFORCE, data.length < uint.MAX_VALUE, "Array length cannot exceed uint limit")]
+		writeStringArray(data) {
+			writeVarUInt(data.length as uint);
+			writeStringArrayRaw(data);
+		}
+		
+		writeStringArrayRaw(data) {
+			for element in data
+				writeString(element);
+		}
+		
+		flush() {
+			// nothing to do
+		}
+	}
+}

compactio/src/CompactDataInput.zs

@@ -0,0 +1,103 @@
+export interface CompactDataInput {
+	readBool() as bool;
+	
+	readByte() as sbyte;
+	
+	readSByte() as byte;
+	
+	readShort() as short;
+	
+	readUShort() as ushort;
+	
+	readInt() as int;
+	
+	readUInt() as uint;
+	
+	readLong() as long;
+	
+	readULong() as ulong;
+	
+	readVarInt() as int;
+	
+	readVarUInt() as uint;
+	
+	readVarLong() as long;
+	
+	readVarULong() as ulong;
+	
+	readFloat() as float;
+	
+	readDouble() as double;
+	
+	readChar() as char;
+	
+	readString() as string;
+	
+	readBytes() as byte[];
+	
+	readRawBytes(length as usize) as byte[];
+	
+	readBoolArray() as bool[];
+	
+	readByteArray() as byte[];
+	
+	readSByteArray() as sbyte[];
+	
+	readShortArray() as short[];
+	
+	readShortArrayRaw(length as usize) as short[];
+	
+	readUShortArray() as ushort[];
+	
+	readUShortArrayRaw(length as usize) as ushort[];
+	
+	readVarIntArray() as int[];
+	
+	readVarIntArrayRaw(length as usize) as int[];
+	
+	readVarUIntArray() as uint[];
+	
+	readVarUIntArrayRaw(length as usize) as uint[];
+	
+	readIntArray() as int[];
+	
+	readIntArrayRaw(length as usize) as int[];
+	
+	readUIntArray() as uint[];
+	
+	readUIntArrayRaw(length as usize) as uint[];
+	
+	readVarLongArray() as long[];
+	
+	readVarLongArrayRaw(length as usize) as long[];
+	
+	readVarULongArray() as ulong[];
+	
+	readVarULongArrayRaw(length as usize) as ulong[];
+	
+	readLongArray() as long[];
+	
+	readLongArrayRaw(length as usize) as long[];
+	
+	readULongArray() as ulong[];
+	
+	readULongArrayRaw(length as usize) as ulong[];
+	
+	readFloatArray() as float[];
+	
+	readFloatArrayRaw(length as usize) as float[];
+	
+	readDoubleArray() as double[];
+	
+	readDoubleArrayRaw(length as usize) as double[];
+	
+	readStringArray() as string[];
+	
+	readStringArrayRaw(length as usize) as string[];
+	
+	skip(bytes as usize) as void;
+	
+	hasMore() as bool;
+	
+	~this;
+}

compactio/src/CompactDataOutput.zs

@@ -0,0 +1,105 @@
+public interface CompactDataOutput {
+	writeBool(value as bool) as void;
+	
+	writeByte(value as byte) as void;
+	
+	writeSByte(value as sbyte) as void;
+	
+	writeShort(value as short) as void;
+	
+	writeUShort(value as ushort) as void;
+	
+	writeInt(value as int) as void;
+	
+	writeUInt(value as uint) as void;
+	
+	writeLong(value as long) as void;
+	
+	writeULong(value as ulong) as void;
+	
+	writeVarInt(value as int) as void;
+	
+	writeVarUInt(value as uint) as void;
+	
+	writeVarLong(value as long) as void;
+	
+	writeVarULong(value as ulong) as void;
+	
+    writeFloat(value as float) as void;
+	
+    writeDouble(value as double) as void;
+	
+	writeChar(value as char) as void;
+	
+	writeString(value as string) as void;
+	
+    writeBytes(data as byte[]) as void;
+	
+	writeBytes(data as byte[], offset as usize, length as usize) as void;
+	
+	writeRawBytes(value as byte[]) as void;
+	
+	writeRawBytes(value as byte[], offset as usize, length as usize) as void;
+	
+	writeBoolArray(data as bool[]) as void;
+	
+	writeByteArray(data as byte[]) as void;
+	
+	writeSByteArray(data as sbyte[]) as void;
+	
+	writeShortArray(data as short[]) as void;
+	
+	writeShortArrayRaw(data as short[]) as void;
+	
+	writeUShortArray(data as short[]) as void;
+	
+	writeUShortArrayRaw(data as short[]) as void;
+	
+	writeVarIntArray(data as int[]) as void;
+	
+	writeVarIntArrayRaw(data as int[]) as void;
+	
+	writeVarUIntArray(data as uint[]) as void;
+	
+	writeVarUIntArrayRaw(data as uint[]) as void;
+	
+	writeIntArray(data as int[]) as void;
+	
+	writeIntArrayRaw(data as int[]) as void;
+	
+	writeUIntArray(data as uint[]) as void;
+	
+	writeUIntArrayRaw(data as uint[]) as void;
+	
+	writeVarLongArray(data as long[]) as void;
+	
+	writeVarLongArrayRaw(data as long[]) as void;
+	
+	writeVarULongArray(data as ulong[]) as void;
+	
+	writeVarULongArrayRaw(data as ulong[]) as void;
+	
+	writeLongArray(data as long[]) as void;
+	
+	writeLongArrayRaw(data as long[]) as void;
+	
+	writeULongArray(data as long[]) as void;
+	
+	writeULongArrayRaw(data as long[]) as void;
+	
+	writeFloatArray(data as float[]) as void;
+	
+	writeFloatArrayRaw(data as float[]) as void;
+	
+	writeDoubleArray(data as double[]) as void;
+	
+	writeDoubleArrayRaw(data as double[]) as void;
+	
+	writeStringArray(data as string[]) as void;
+	
+	writeStringArrayRaw(data as string[]) as void;
+	
+	flush() as void;
+	
+	~this;
+}

io/module.json

@@ -1,4 +1,5 @@
 {
-	"package": "collections",
+	"package": "io",
+	"javaPackage": "org.openzen.zencode.stdlib.io",
 	"host": "universal"
 }

io/src/IOException.zs

@@ -1,4 +1,6 @@
+[Native("io::IOException")]
 public class IOException : Exception {
+	[Native("constructor")]
 	public this(message as string) {
 		super(message);
 	}

io/src/InputStream.zs

@@ -0,0 +1,14 @@
+[Native("io::InputStream")]
+export interface InputStream {
+	[Native("read")]
+	read() as int throws IOException;
+	
+	[Native("readArray")]
+	read(array as byte[]) as usize throws IOException;
+	
+	[Native("readSlice")]
+	read(array as byte[], offset as usize, length as usize) as usize throws IOException;
+	
+	[Native("destruct")]
+	~this;
+}

io/src/OutputStream.zs

@@ -0,0 +1,14 @@
+[Native("io::OutputStream")]
+export interface OutputStream {
+	[Native("write")]
+	write(value as byte) as void throws IOException;
+	
+	[Native("writeArray")]
+	write(value as byte[]) as void throws IOException;
+	
+	[Native("writeSlice")]
+	write(value as byte[], offset as usize, length as usize) as void throws IOException;
+	
+	[Native("destruct")]
+	~this;
+}

io/src/Reader.zs

@@ -1,10 +1,15 @@
+[Native("io::Reader")]
 export interface Reader {
+	[Native("destruct")]
 	~this;
 	
+	[Native("readCharacter")]
 	read() as int throws IOException;
 	
-	read(buffer as char[]) as int throws IOException
+	[Native("readArray")]
+	read(buffer as char[]) as usize throws IOException
 		=> read(buffer, 0, buffer.length);
 	
-	read(buffer as char[], offset as int, length as int) as int throws IOException;
+	[Native("readArraySlice")]
+	read(buffer as char[], offset as usize, length as usize) as usize throws IOException;
 }

io/src/StringReader.zs

@@ -1,19 +1,28 @@
+[Native("io::StringReader")]
 export class StringReader {
 	val data as char[];
-	var offset as int;
+	var offset as usize;
 	
+	[Native("constructor")]
 	public this(value as string) {
 		data = value.characters;
 	}
 	
 	public implements Reader {
+		[Native("destructor")]
 		~this {}
-	
-		read() as int
+		
+		[Native("readCharacter")]
+		read()
 			=> offset == data.length ? -1 : data[offset++];
-	
-		read(buffer as char[], offset as int, length as int) as int {
-			length = int.min(data.length - this.offset, length);
+		
+		[Native("readArray")]
+		read(buffer)
+			=> read(buffer, 0, buffer.length);
+		
+		[Native("readSlice")]
+		read(buffer, offset, length) {
+			length = usize.min(data.length - this.offset, length);
 			data.copyTo(buffer, this.offset, offset, length);
 			this.offset += length;
 			return length;

listeners/module.json

@@ -0,0 +1,5 @@
+{
+	"package": "listeners",
+	"javaPackage": "org.openzen.zencode.stdlib.listeners",
+	"host": "universal"
+}

listeners/src/DummyListenerHandle.zs

@@ -0,0 +1,9 @@
+export class DummyListenerHandle<T> {
+	val listener as T : get;
+	
+	public this(listener as T) {
+		this.listener = listener;
+	}
+	
+	public implements ListenerHandle<T> {}
+}

listeners/src/ListenerHandle.zs

@@ -0,0 +1,5 @@
+public interface ListenerHandle<T> {
+	~this;
+	
+	get listener as T;
+}

listeners/src/ListenerList.zs

@@ -0,0 +1,80 @@
+public class ListenerList<T> {
+	public const PRIORITY_HIGH = 100;
+	public const PRIORITY_DEFAULT = 0;
+	public const PRIORITY_LOW = -100;
+	
+	var first as EventListenerNode? = null;
+	var last as EventListenerNode? = null;
+	
+	public add(listener as T) as ListenerHandle<T>
+		=> add(listener, PRIORITY_DEFAULT);
+	
+	public add(listener as T, priority as int) as ListenerHandle<T> {
+		val node = new EventListenerNode(listener, priority);
+		
+		if first == null {
+			first = last = node;
+		} else {
+			// prioritized list: where to insert?
+			var previousNode = last;
+			while previousNode != null && priority > previousNode.priority
+				previousNode = previousNode.prev;
+			
+			if previousNode == null {
+				node.next = first;
+				first.prev = previousNode;
+				first = node;
+			} else {
+				if previousNode.next == null
+					last = node;
+				else
+					previousNode.next.prev = node;
+				
+				previousNode.next = node;
+				node.prev = previousNode;
+			}
+		}
+		
+		return node;
+	}
+	
+	public clear() as void {
+		first = last = null;
+	}
+	
+	public accept(consumer as function(listener as T) as void) as void {
+		var current = first;
+		while current != null {
+			consumer(current.listener);
+			current = current.next;
+		}
+	}
+	
+	public get isEmpty => first == null;
+	
+	private class EventListenerNode {
+		val listener as T : get;
+		val priority as int;
+		var next as EventListenerNode? = null;
+		var prev as EventListenerNode? = null;
+		
+		public this(listener as T, priority as int) {
+			this.listener = listener;
+			this.priority = priority;
+		}
+		
+		~this {
+			if prev == null
+				first = next;
+			else
+				prev.next = next;
+			
+			if next == null
+				last = prev;
+			else
+				next.prev = prev;
+		}
+		
+		public implements ListenerHandle<T> {}
+	}
+}

live/module.json

@@ -0,0 +1,6 @@
+{
+	"package": "live",
+	"javaPackage": "org.openzen.zencode.stdlib.live",
+	"host": "universal",
+	"dependencies": ["listeners"]
+}

live/src/ImmutableLiveBool.zs

@@ -0,0 +1,16 @@
+import listeners.DummyListenerHandle;
+
+export class ImmutableLiveBool {
+	public const TRUE = new ImmutableLiveBool(true);
+	public const FALSE = new ImmutableLiveBool(false);
+	
+	val value as bool : get;
+	
+	private this(value as bool) {
+		this.value = value;
+	}
+	
+	public implements LiveBool {
+		addListener(listener) => new DummyListenerHandle<LiveBool.Listener>(listener);
+	}
+}

live/src/ImmutableLiveObject.zs

@@ -0,0 +1,13 @@
+import listeners.DummyListenerHandle;
+
+export class ImmutableLiveObject<T> {
+	val value as T : get;
+	
+	public this(value as T) {
+		this.value = value;
+	}
+	
+	public implements LiveObject<T> {
+		addListener(listener) => new DummyListenerHandle<LiveObject<T>.Listener<T>>(listener);
+	}
+}

live/src/ImmutableLiveString.zs

@@ -0,0 +1,13 @@
+import listeners.DummyListenerHandle;
+
+export class ImmutableLiveString {
+	val value as string : get;
+	
+	public this(value as string) {
+		this.value = value;
+	}
+	
+	public implements LiveString {
+		addListener(listener) => new DummyListenerHandle<LiveString.Listener>(listener);
+	}
+}

live/src/InverseLiveBool.zs

@@ -0,0 +1,14 @@
+export class InverseLiveBool {
+	val source as LiveBool;
+	
+	public this(source as LiveBool) {
+		this.source = source;
+	}
+	
+	public implements LiveBool {
+		get value => !source.value;
+		
+		addListener(listener)
+			=> source.addListener((oldVal, newVal) => listener(!oldVal, !newVal));
+	}
+}

live/src/LiveArrayList.zs

@@ -0,0 +1,52 @@
+import listeners.ListenerList;
+
+class LiveArrayList<T> {
+	val values = new List<T>();
+	val listeners = new ListenerList<LiveList<T>.Listener<T>>();
+	
+	public implements MutableLiveList<T> {
+		add(value) {
+			val index = values.length;
+			values.add(value);
+			listeners.accept(listener => listener.onInserted(index, value));
+		}
+		
+		insert(index, value) {
+			values.insert(index, value);
+			listeners.accept(listener => listener.onInserted(index, value));
+		}
+		
+		[]=(index, value) {
+			val oldValue = values[index];
+			values[index] = value;
+			listeners.accept(listener => listener.onChanged(index, oldValue, value));
+		}
+		
+		remove(index as usize) {
+			val oldValue = values.remove(index);
+			listeners.accept(listener => listener.onRemoved(index, oldValue));
+		}
+		
+		remove(value as T) {
+			val index = indexOf(value);
+			if index == null
+				return;
+			
+			remove(index);
+		}
+		
+		clear() {
+			var i = length;
+			while i > 0 {
+				i--;
+				remove(i);
+			}
+		}
+		
+		iterate() => values.iterate();
+		indexOf(value) => values.indexOf(value);
+		get length => values.length;
+		[](index) => values[index];
+		addListener(listener) => listeners.add(listener);
+	}
+}

live/src/LiveBool.zs

@@ -0,0 +1,8 @@
+public interface LiveBool {
+	get value as bool;
+	
+	addListener(listener as Listener) as ListenerHandle;
+	
+	alias Listener as function(oldValue as bool, newValue as bool) as void;
+	alias ListenerHandle as listeners.ListenerHandle<Listener>;
+}

live/src/LiveInt.zs

@@ -0,0 +1,9 @@
+export interface LiveInt {
+	get value as int;
+	set value as int;
+	
+	addListener(listener as Listener) as ListenerHandle;
+	
+	alias Listener as function(oldValue as int, newValue as int) as void;
+	alias ListenerHandle as listeners.ListenerHandle<Listener>;
+}

live/src/LiveList.zs

@@ -0,0 +1,21 @@
+export interface LiveList<T> : Iterable<T> {
+	~this;
+	
+	get length as usize;
+	
+	indexOf(value as T) as usize?;
+	
+	//[IndexIterator]
+	//for (index as int, value as T);
+	
+	[](index as usize) as T;
+	
+	addListener(listener as Listener<T>) as ListenerHandle<T>;
+	
+	public interface Listener<T> {
+		onInserted(index as usize, value as T) as void;
+		onChanged(index as usize, oldValue as T, newValue as T) as void;
+		onRemoved(index as usize, oldValue as T) as void;
+	}
+	alias ListenerHandle<T> as listeners.ListenerHandle<Listener<T>>;
+}

live/src/LiveObject.zs

@@ -0,0 +1,8 @@
+export interface LiveObject<T> {
+	get value as T;
+	
+	addListener(listener as Listener<T>) as ListenerHandle<T>;
+	
+	alias Listener<T> as function(oldValue as T, newValue as T) as void;
+	alias ListenerHandle<T> as listeners.ListenerHandle<Listener<T>>;
+}

live/src/LiveString.zs

@@ -0,0 +1,8 @@
+export interface LiveString {
+	get value as string;
+	
+	addListener(listener as Listener) as ListenerHandle;
+	
+	alias Listener as function(oldValue as string, newValue as string) as void;
+	alias ListenerHandle as listeners.ListenerHandle<Listener>;
+}

live/src/MutableLiveList.zs

@@ -0,0 +1,13 @@
+export interface MutableLiveList<T> : LiveList<T> {
+	add(value as T) as void;
+	
+	insert(index as usize, value as T) as void;
+	
+	[]=(index as usize, value as T) as void;
+	
+	remove(index as usize) as void;
+	
+	remove(value as T) as void;
+	
+	clear() as void;
+}

stdlib/module.json

@@ -7,6 +7,9 @@
 		"EqualsComparable": {"type": "Definition", "definition": "EqualsComparable"},
 		"Hashable": {"type": "Definition", "definition": "Hashable"},
 		"IllegalArgumentException": {"type": "Definition", "definition": "IllegalArgumentException"},
+		"Iterable": {"type": "Definition", "definition": "Iterable"},
+		"Iterator": {"type": "Definition", "definition": "Iterator"},
+		"List": {"type": "Definition", "definition": "List"},
 		"StringBuilder": {"type": "Definition", "definition": "StringBuilder"},
 		"StringBuildable": {"type": "Definition", "definition": "StringBuildable"},
 		"Result": {"type": "Definition", "definition": "Result"}

stdlib/src/Arrays.zs

@@ -9,7 +9,7 @@ export expand <T : Comparable<T>> T[] {
 export expand <T : Hashable<T>> T[] {
 	public implements Hashable<T[]> {
 		public extern hashCode() as int;
-		public extern == (other as T) as bool;
+		public extern == (other as T[]) as bool;
 	}
 }
 
@@ -22,15 +22,15 @@ export expand <T> T[] {
 	[Native("copy")]
 	public extern copy() as T[];
 	[Native("copyResize")]
-	public extern copy(newSize as int) as T[];
+	public extern copy(newSize as usize) as T[];
 	[Native("copyTo")]
-	public extern copyTo(target as T[], sourceOffset as int, targetOffset as int, length as int) as void;
+	public extern copyTo(target as T[], sourceOffset as usize, targetOffset as usize, length as usize) as void;
 	
 	public get first as T?
 		=> this.isEmpty ? null : this[0];
 	
 	public get last as T?
-		=> this.isEmpty ? null : this[$ - 1];
+		=> this.isEmpty ? null : this[$ - (1 as usize)];
 	
 	[Native("reverse")]
 	public reverse() as void {
@@ -53,7 +53,7 @@ export expand <T> T[] {
 	}
 	
 	[Native("mapKeyValues")]
-	public map<U>(projection as function(index as int, value as T) as U) as U[] {
+	public map<U>(projection as function(index as usize, value as T) as U) as U[] {
 		return new U[]<T>(this, projection);
 	}
 	
@@ -67,7 +67,7 @@ export expand <T> T[] {
 	}
 	
 	[Native("filterKeyValues")]
-	public filter(predicate as function(index as int, value as T) as bool) as T[] {
+	public filter(predicate as function(index as usize, value as T) as bool) as T[] {
 		var values = new List<T>();
 		for i, value in this
 			if predicate(i, value)
@@ -80,7 +80,7 @@ export expand <T> T[] {
 			consumer(value);
 	}
 	
-	public each(consumer as function(index as int, value as T) as void) as void {
+	public each(consumer as function(index as usize, value as T) as void) as void {
 		for i, value in this
 			consumer(i, value);
 	}
@@ -93,7 +93,7 @@ export expand <T> T[] {
 		return false;
 	}
 	
-	public contains(predicate as function(index as int, value as T) as bool) as bool {
+	public contains(predicate as function(index as usize, value as T) as bool) as bool {
 		for i, value in this
 			if predicate(i, value)
 				return true;
@@ -109,7 +109,7 @@ export expand <T> T[] {
 		return true;
 	}
 	
-	public all(predicate as function(i as int, value as T) as bool) as bool {
+	public all(predicate as function(i as usize, value as T) as bool) as bool {
 		for i, value in this
 			if !predicate(i, value)
 				return false;
@@ -125,7 +125,7 @@ export expand <T> T[] {
 		return null;
 	}
 	
-	public first(predicate as function(i as int, value as T) as bool) as T? {
+	public first(predicate as function(i as usize, value as T) as bool) as T? {
 		for i, value in this
 			if predicate(i, value)
 				return value;
@@ -144,7 +144,7 @@ export expand <T> T[] {
 		return null;
 	}
 	
-	public last(predicate as function(index as int, value as T) as bool) as T? {
+	public last(predicate as function(index as usize, value as T) as bool) as T? {
 		var i = length;
 		while i > 0 {
 			i--;
@@ -155,7 +155,7 @@ export expand <T> T[] {
 		return null;
 	}
 	
-	public count(predicate as function(value as T) as bool) as int {
+	public count(predicate as function(value as T) as bool) as usize {
 		var result = 0;
 		for value in this
 			if predicate(value)
@@ -163,11 +163,18 @@ export expand <T> T[] {
 		return result;
 	}
 	
-	public count(predicate as function(index as int, value as T) as bool) as int {
+	public count(predicate as function(index as usize, value as T) as bool) as usize {
 		var result = 0;
 		for i, value in this
 			if predicate(i, value)
 				result++;
 		return result;
 	}
+	
+	public index<K>(key as function(value as T) as K) as T[K] {
+		var result = new T[K];
+		for value in this
+			result[key(value)] = value;
+		return result;
+	}
 }

stdlib/src/Chars.zs

@@ -1,5 +1,5 @@
 export expand char {
-	public times(number as int) as string {
+	public times(number as usize) as string {
 		return new string(new char[](number, this));
 	}
 }

stdlib/src/Iterable.zs

@@ -0,0 +1,5 @@
+[Native("stdlib::Iterable")]
+public interface Iterable<T> {
+	[Native("iterate")]
+	iterate() as Iterator<T>;
+}

stdlib/src/Iterator.zs

@@ -0,0 +1,8 @@
+[Native("stdlib::Iterator")]
+public interface Iterator<T> {
+	[Native("hasNext")]
+	hasNext() as bool;
+	
+	[Native("next")]
+	next() as T;
+}

stdlib/src/List.zs

@@ -7,20 +7,37 @@ export class List<T> {
 	public add(value as T) as void;
 	
 	[Native("insert")]
-	public insert(index as int, value as T) as void;
+	public insert(index as usize, value as T) as void;
+	
+	[Native("remove")]
+	public remove(value as usize) as T;
+	
+	[Native("indexOf")]
+	public indexOf(value as T) as usize;
+	
+	[Native("lastIndexOf")]
+	public lastIndexOf(value as T) as usize;
 	
 	[Native("getAtIndex")]
-	public [](index as int) as T;
+	public [](index as usize) as T;
 	
 	[Native("setAtIndex")]
-	public []=(index as int, value as T) as T;
+	public []=(index as usize, value as T) as T;
+	
+	[Native("contains")]
+	public in(value as T) as bool;
 	
 	[Native("toArray")]
 	public as T[];
 	
 	[Native("length")]
-	public get length as int;
+	public get length as usize;
 	
 	[Native("isEmpty")]
 	public get isEmpty as bool;
+	
+	public implements Iterable<T> {
+		[Native("iterate")]
+		iterate();
+	}
 }

stdlib/src/StringBuilder.zs

@@ -3,14 +3,14 @@ export class StringBuilder {
 	[Native("constructor")]
 	public extern this();
 	[Native("constructorWithCapacity")]
-	public extern this(capacity as int);
+	public extern this(capacity as usize);
 	[Native("constructorWithValue")]
 	public extern this(value as string);
 	
 	[Native("isEmpty")]
 	public extern get isEmpty as bool;
 	[Native("length")]
-	public extern get length as int;
+	public extern get length as usize;
 	
 	[Native("appendBool")]
 	public extern <<(value as bool) as StringBuilder;
@@ -30,6 +30,8 @@ export class StringBuilder {
 	public extern <<(value as long) as StringBuilder;
 	[Native("appendULong")]
 	public extern <<(value as ulong) as StringBuilder;
+	[Native("appendUSize")]
+	public extern <<(value as usize) as StringBuilder;
 	[Native("appendFloat")]
 	public extern <<(value as float) as StringBuilder;
 	[Native("appendDouble")]

stdlib/src/Strings.zs

@@ -1,31 +1,37 @@
 [Native("stdlib::String")]
 export expand string {
+	[Native("fromAsciiBytes")]
+	public static fromAsciiBytes(data as byte[]) as string;
+	
+	[Native("fromUTF8Bytes")]
+	public static fromUTF8Bytes(data as byte[]) as string;
+	
 	[Native("contains")]
 	public const in(c as char) as bool
-		=> indexOf(c) >= 0;
+		=> indexOf(c) != null;
 	
 	[Native("indexOf")]
-	public const indexOf(c as char) as int {
+	public const indexOf(c as char) as usize? {
 		for i in 0 .. length {
 			if this[i] == c
 				return i;
 		}
 		
-		return -1;
+		return null;
 	}
 	
 	[Native("indexOfFrom")]
-	public const indexOf(c as char, from as int) as int {
+	public const indexOf(c as char, from as usize) as usize? {
 		for i in from .. length {
 			if this[i] == c
 				return i;
 		}
 		
-		return -1;
+		return null;
 	}
 	
 	[Native("lastIndexOf")]
-	public const lastIndexOf(c as char) as int {
+	public const lastIndexOf(c as char) as usize? {
 		var i = length;
 		while i > 0 {
 			i--;
@@ -33,11 +39,11 @@ export expand string {
 				return i;
 		}
 		
-		return -1;
+		return null;
 	}
 	
 	[Native("lastIndexOfFrom")]
-	public const lastIndexOf(c as char, until as int) as int {
+	public const lastIndexOf(c as char, until as usize) as usize? {
 		var i = until;
 		while i > 0 {
 			i--;
@@ -45,13 +51,13 @@ export expand string {
 				return i;
 		}
 		
-		return -1;
+		return null;
 	}
 	
 	[Native("split")]
 	public const split(delimiter as char) as string[] {
 		val result = new List<string>();
-		var start = 0;
+		var start = 0 as usize;
 		for i in 0 .. this.length {
 			if this[i] == delimiter {
 				result.add(this[start .. i]);
@@ -64,7 +70,7 @@ export expand string {
 	
 	[Native("trim")]
 	public const trim() as string {
-		var from = 0;
+		var from = 0 as usize;
 		while from < this.length && this[from] in [' ', '\t', '\r', '\n']
 			from++;
 		var to = this.length;
@@ -75,10 +81,16 @@ export expand string {
 	}
 	
 	[Native("lpad")]
-	public const lpad(length as int, c as char) as string
+	public const lpad(length as usize, c as char) as string
 		=> this.length >= length ? this : c.times(length - this.length) + this;
 	
 	[Native("rpad")]
-	public const rpad(length as int, c as char) as string
+	public const rpad(length as usize, c as char) as string
 		=> this.length >= length ? this : this + c.times(length - this.length);
+		
+	[Native("toAsciiBytes")]
+	public const toAsciiBytes() as byte[];
+	
+	[Native("toUTF8Bytes")]
+	public const toUTF8Bytes() as byte[];
 }

stdlib/src/USize.zs

@@ -0,0 +1,13 @@
+[Native("stdlib::USize")]
+expand usize {
+	[Native("toHexString")]
+	public extern toHexString() as string;
+	
+	[Native("min")]
+	public static min(a as usize, b as usize) as usize
+		=> a < b ? a : b;
+	
+	[Native("max")]
+	public static max(a as usize, b as usize) as usize
+		=> a > b ? a : b;
+}