- Added some functions to Arrays

- Added native tags where needed
- Added EqualsComparable to designate types that have an equality operator

stdlib/module.json

 	"globals": {
 		"Comparable": {"type": "Definition", "definition": "Comparable"},
 		"Exception": {"type": "Definition", "definition": "Exception"},
+		"EqualsComparable": {"type": "Definition", "definition": "EqualsComparable"},
 		"Hashable": {"type": "Definition", "definition": "Hashable"},
 		"IllegalArgumentException": {"type": "Definition", "definition": "IllegalArgumentException"},
 		"StringBuilder": {"type": "Definition", "definition": "StringBuilder"},
 		"StringBuildable": {"type": "Definition", "definition": "StringBuildable"},
-		"panic": {"type": "Definition", "definition": "panic"},
 		"Result": {"type": "Definition", "definition": "Result"}
 	}
 }

stdlib/src/Arrays.zs

+[Native("stdlib::Arrays")]
 export expand <T : Comparable<T>> T[] {
+	[Native("sort")]
 	public extern sort() as void;
+	[Native("sorted")]
 	public extern sorted() as T[];
 }
 
 	}
 }
 
+[Native("stdlib::Arrays")]
 export expand <T> T[] {
+	[Native("sortWithComparator")]
 	public extern sort(comparator as function(a as T, b as T) as int) as void;
+	[Native("sortedWithComparator")]
 	public extern sorted(comparator as function(a as T, b as T) as int) as T[];
+	[Native("copy")]
 	public extern copy() as T[];
+	[Native("copyResize")]
 	public extern copy(newSize as int) as T[];
+	[Native("copyTo")]
 	public extern copyTo(target as T[], sourceOffset as int, targetOffset as int, length as int) as void;
 	
-	public get first as T?;
-	public get last as T?;
-	public get reversed as T[];
+	public get first as T?
+		=> this.isEmpty ? null : this[0];
 	
+	public get last as T?
+		=> this.isEmpty ? null : this[$ - 1];
+	
+	[Native("reverse")]
+	public reverse() as void {
+		for i in 0 .. length / 2 {
+			var temp = this[i];
+			this[i] = this[length - i - 1];
+			this[length - i - 1] = temp;
+		}
+	}
+	
+	// TODO: fix compilation for this
+	/*[Native("reversed")]
+	public reversed() as T[] {
+		return new T[](this, (i, value) => this[length - i - 1]);
+	}*/
+	
+	[Native("mapValues")]
 	public map<U>(projection as function(value as T) as U) as U[] {
 		return new U[]<T>(this, projection);
 	}
 	
+	[Native("mapKeyValues")]
 	public map<U>(projection as function(index as int, value as T) as U) as U[] {
 		return new U[]<T>(this, projection);
 	}
 	
-	public extern filter(predicate as function(value as T) as bool) as T[];
-	public extern filter(predicate as function(index as int, value as T) as bool) as T[];
+	[Native("filterValues")]
+	public filter(predicate as function(value as T) as bool) as T[] {
+		var values = new List<T>();
+		for value in this
+			if predicate(value)
+				values.add(value);
+		return values as T[];
+	}
+	
+	[Native("filterKeyValues")]
+	public filter(predicate as function(index as int, value as T) as bool) as T[] {
+		var values = new List<T>();
+		for i, value in this
+			if predicate(i, value)
+				values.add(value);
+		return values as T[];
+	}
 	
 	public each(consumer as function(value as T) as void) as void {
 		for value in this
 	}
 	
 	public last(predicate as function(value as T) as bool) as T? {
-		for i, value in this.reversed
-			if predicate(value)
-				return value;
+		var i = length;
+		while i > 0 {
+			i--;
+			if predicate(this[i])
+				return this[i];
+		}
 		
 		return null;
 	}
 	
 	public last(predicate as function(index as int, value as T) as bool) as T? {
-		for i, value in this.reversed
-			if predicate(i, value)
-				return value;
+		var i = length;
+		while i > 0 {
+			i--;
+			if predicate(i, this[i])
+				return this[i];
+		}
 		
 		return null;
 	}

stdlib/src/Comparable.zs

+[Native("stdlib::Comparable")]
 export interface Comparable<T> {
+	[Native("compareTo")]
 	compareTo(other as T) as int;
 }

stdlib/src/EqualsComparable.zs

+public interface EqualsComparable<T> {
+	==(other as T) as bool;
+}

stdlib/src/Exception.zs

+[Native("stdlib::Exception")]
 export virtual class Exception {
+	[Native("constructor")]
 	public this(message as string) {}
+	
+	[Native("constructorWithCause")]
 	public this(message as string, cause as Exception) {}
 }

stdlib/src/IllegalArgumentException.zs

+[Native("stdlib::IllegalArgumentException")]
 export class IllegalArgumentException : Exception {
+	[Native("constructor")]
 	public this(message as string) {
 		super(message);
 	}

stdlib/src/Integers.zs

+[Native("stdlib::Integer")]
 expand int {
+	[Native("toHexString")]
 	public extern toHexString() as string;
 	
+	[Native("min")]
 	public static min(a as int, b as int) as int
 		=> a < b ? a : b;
+	
+	[Native("max")]
 	public static max(a as int, b as int) as int
 		=> a > b ? a : b;
 }

stdlib/src/List.zs

 export class List<T> {
 	[Native("constructor")]
 	public this() {}
+	
 	[Native("add")]
 	public add(value as T) as void;
-	[Native("getIndex")]
+	
+	[Native("insert")]
+	public insert(index as int, value as T) as void;
+	
+	[Native("getAtIndex")]
 	public [](index as int) as T;
-	[Native("setIndex")]
+	
+	[Native("setAtIndex")]
 	public []=(index as int, value as T) as T;
+	
 	[Native("toArray")]
 	public as T[];
+	
 	[Native("length")]
 	public get length as int;
+	
 	[Native("isEmpty")]
 	public get isEmpty as bool;
 }

stdlib/src/Panic.zs

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

stdlib/src/Result.zs

 	public expect() as T {
 		return match this {
 			Ok(result) => result,
-			Error(error) => panic<T>("expect() called on an error value")
+			Error(error) => panic "expect() called on an error value"
 		};
 	}
 	
 }
 
 export expand <T, E : Exception> Result<T, E> {
-	public unwrap() as T {
+	public unwrap() as T throws E {
 		return match this {
 			Ok(result) => result,
 			Error(error) => throw error

stdlib/src/Strings.zs

+[Native("stdlib::String")]
 export expand string {
+	[Native("contains")]
 	public const in(c as char) as bool
 		=> indexOf(c) >= 0;
 	
+	[Native("indexOf")]
 	public const indexOf(c as char) as int {
 		for i in 0 .. length {
 			if this[i] == c
 		return -1;
 	}
 	
+	[Native("indexOfFrom")]
 	public const indexOf(c as char, from as int) as int {
 		for i in from .. length {
 			if this[i] == c
 		return -1;
 	}
 	
+	[Native("lastIndexOf")]
 	public const lastIndexOf(c as char) as int {
 		var i = length;
 		while i > 0 {
 		return -1;
 	}
 	
+	[Native("lastIndexOfFrom")]
 	public const lastIndexOf(c as char, until as int) as int {
 		var i = until;
 		while i > 0 {
 		return -1;
 	}
 	
+	[Native("split")]
 	public const split(delimiter as char) as string[] {
 		val result = new List<string>();
 		var start = 0;
 		return result as string[];
 	}
 	
+	[Native("trim")]
 	public const trim() as string {
 		var from = 0;
 		while from < this.length && this[from] in [' ', '\t', '\r', '\n']
 		return to < from ? "" : this[from .. to];
 	}
 	
+	[Native("lpad")]
 	public const lpad(length as int, 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
 		=> this.length >= length ? this : this + c.times(length - this.length);
 }