Initial commit.

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) <year> <copyright holders>
+Copyright (c) 2018 Stan Hebben
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

collections/module.json

@@ -0,0 +1,4 @@
+{
+	"package": "collections",
+	"host": "universal"
+}

collections/src/HashSet.zs

@@ -0,0 +1,11 @@
+export class HashSet<T> {
+	public implements Set<T> {
+		add(value as T) as bool;
+		remove(value as T) as bool;
+		
+		get size as int;
+		
+		in(value as T) as bool;
+		for(x as T);
+	}
+}

collections/src/LinkedList.zs

@@ -0,0 +1,73 @@
+export class LinkedList<T> {
+	var first as Node?;
+	var last as Node?;
+	var size as int : get;
+	
+	public get empty as bool
+		=> first == null;
+	
+	public add(value as T) as void {
+		if first == null {
+			first = last = new Node(value);
+		} else {
+			val node = new Node(value);
+			last.next = node;
+			node.prev = last;
+			last = node;
+		}
+		size++;
+	}
+	
+	public clear() as void {
+		first = last = null;
+		size = 0;
+	}
+	
+	public [](index as int) as T {
+		var node = first;
+		while index > 0 {
+			if node == null
+				return panic<T>("index out of bounds");
+			
+			node = node.next;
+		}
+		
+		if node == null
+			return panic<T>("index out of bounds");
+		
+		return node.value;
+	}
+	
+	public implements Queue<T> {
+		poll() as T {
+			if first == null
+				return panic<T>("Cannot poll an empty queue");
+			
+			val result = first.value;
+			first = first.next;
+			if first == null
+				last = null;
+			else
+				first.prev = null;
+				
+			size--;
+		}
+		
+		peek() as T? {
+			return first.value;
+		}
+		
+		offer(value as T) as void
+			=> add(value);
+	}
+	
+	private struct Node {
+		var next as Node?;
+		var prev as Node?;
+		val value as T;
+		
+		this(value as T) {
+			this.value = value;
+		}
+	}
+}

collections/src/NoSuchElementException.zs

@@ -0,0 +1,5 @@
+export class NoSuchElementException : Exception {
+	public this(message as string) {
+		super(message);
+	}
+}

collections/src/Queue.zs

@@ -0,0 +1,7 @@
+export interface Queue<T> {
+	get empty as bool;
+	
+	poll() as T;
+	peek() as T;
+	push(value as T) as void;
+}

collections/src/Set.zs

@@ -0,0 +1,12 @@
+export interface Set<T> {
+	add(value as T) as bool;
+	remove(value as T) as bool;
+	
+	get size as int;
+	
+	toArray();
+	toArray(comparator as function(a as T, b as T) as int);
+	
+	in(value as T) as bool;
+	for(x as T);
+}

collections/src/Stack.zs

@@ -0,0 +1,21 @@
+export class Stack<T> {
+	var values as T[] = new T[](8);
+	var size as int : get = 0;
+	
+	public push(value as T) as void {
+		if size == values.length
+			values = values.copy(values.length * 2);
+			
+		values[size++] = value;
+	}
+	
+	public pop() as T {
+		if size == 0
+			throw new NoSuchElementException("Stack is empty!");
+		
+		return values[--size];
+	}
+	
+	public get empty as bool
+		=> size == 0;
+}

io/module.json

@@ -0,0 +1,4 @@
+{
+	"package": "collections",
+	"host": "universal"
+}

io/src/IOException.zs

@@ -0,0 +1,9 @@
+public class IOException : Exception {
+	public this(message as string) {
+		super(message);
+	}
+	
+	/*public this(message as string, cause as Exception) {
+		super(message, cause);
+	}*/
+}

io/src/Reader.zs

@@ -0,0 +1,10 @@
+export interface Reader {
+	~this;
+	
+	read() as int throws IOException;
+	
+	read(buffer as char[]) as int throws IOException
+		=> read(buffer, 0, buffer.length);
+	
+	read(buffer as char[], offset as int, length as int) as int throws IOException;
+}

io/src/StringReader.zs

@@ -0,0 +1,22 @@
+export class StringReader {
+	val data as char[];
+	var offset as int;
+	
+	public this(value as string) {
+		data = value.characters;
+	}
+	
+	public implements Reader {
+		~this {}
+	
+		read() as int
+			=> 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);
+			data.copyTo(buffer, this.offset, offset, length);
+			this.offset += length;
+			return length;
+		}
+	}
+}

stdlib/module.json

@@ -0,0 +1,14 @@
+{
+	"package": "stdlib",
+	"host": "universal",
+	"globals": {
+		"Comparable": {"type": "Definition", "definition": "Comparable"},
+		"Exception": {"type": "Definition", "definition": "Exception"},
+		"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

@@ -0,0 +1,124 @@
+export expand <T : Comparable<T>> T[] {
+	public extern sort() as void;
+	public extern sorted() as T[];
+}
+
+export expand <T : Hashable<T>> T[] {
+	public implements Hashable<T[]> {
+		public extern hashCode() as int;
+		public extern == (other as T) as bool;
+	}
+}
+
+export expand <T> T[] {
+	public extern sort(comparator as function(a as T, b as T) as int) as void;
+	public extern sorted(comparator as function(a as T, b as T) as int) as T[];
+	public extern copy() as T[];
+	public extern copy(newSize as int) as T[];
+	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 map<U>(projection as function(value as T) as U) as U[] {
+		return new U[]<T>(this, projection);
+	}
+	
+	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[];
+	
+	public each(consumer as function(value as T) as void) as void {
+		for value in this
+			consumer(value);
+	}
+	
+	public each(consumer as function(index as int, value as T) as void) as void {
+		for i, value in this
+			consumer(i, value);
+	}
+	
+	public contains(predicate as function(value as T) as bool) as bool {
+		for value in this
+			if predicate(value)
+				return true;
+		
+		return false;
+	}
+	
+	public contains(predicate as function(index as int, value as T) as bool) as bool {
+		for i, value in this
+			if predicate(i, value)
+				return true;
+		
+		return false;
+	}
+	
+	public all(predicate as function(value as T) as bool) as bool {
+		for value in this
+			if !predicate(value)
+				return false;
+		
+		return true;
+	}
+	
+	public all(predicate as function(i as int, value as T) as bool) as bool {
+		for i, value in this
+			if !predicate(i, value)
+				return false;
+		
+		return true;
+	}
+	
+	public first(predicate as function(value as T) as bool) as T? {
+		for value in this
+			if predicate(value)
+				return value;
+		
+		return null;
+	}
+	
+	public first(predicate as function(i as int, value as T) as bool) as T? {
+		for i, value in this
+			if predicate(i, value)
+				return value;
+		
+		return null;
+	}
+	
+	public last(predicate as function(value as T) as bool) as T? {
+		for i, value in this.reversed
+			if predicate(value)
+				return value;
+		
+		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;
+		
+		return null;
+	}
+	
+	public count(predicate as function(value as T) as bool) as int {
+		var result = 0;
+		for value in this
+			if predicate(value)
+				result++;
+		return result;
+	}
+	
+	public count(predicate as function(index as int, value as T) as bool) as int {
+		var result = 0;
+		for i, value in this
+			if predicate(i, value)
+				result++;
+		return result;
+	}
+}

stdlib/src/Assoc.zs

@@ -0,0 +1,8 @@
+export expand <K, V> V[K] {
+	mapValues<W>(projection as function(value as V) as W) as W[K] {
+		val result = new W[K];
+		for k, v in this
+			result[k] = projection(v);
+		return result;
+	}
+}

stdlib/src/Chars.zs

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

stdlib/src/Comparable.zs

@@ -0,0 +1,3 @@
+export interface Comparable<T> {
+	compareTo(other as T) as int;
+}

stdlib/src/EnforcementLevel.zs

@@ -0,0 +1,5 @@
+public enum EnforcementLevel {
+	INFO,
+	ENFORCE,
+	PROVE
+}

stdlib/src/Exception.zs

@@ -0,0 +1,4 @@
+export virtual class Exception {
+	public this(message as string) {}
+	public this(message as string, cause as Exception) {}
+}

stdlib/src/Hashable.zs

@@ -0,0 +1,4 @@
+public interface Hashable<T> {
+	hashCode() as int;
+	== (other as T) as bool;
+}

stdlib/src/IllegalArgumentException.zs

@@ -0,0 +1,5 @@
+export class IllegalArgumentException : Exception {
+	public this(message as string) {
+		super(message);
+	}
+}

stdlib/src/Integers.zs

@@ -0,0 +1,8 @@
+expand int {
+	public extern toHexString() as string;
+	
+	public static min(a as int, b as int) as int
+		=> a < b ? a : b;
+	public static max(a as int, b as int) as int
+		=> a > b ? a : b;
+}

stdlib/src/List.zs

@@ -0,0 +1,17 @@
+[Native("stdlib::List")]
+export class List<T> {
+	[Native("constructor")]
+	public this() {}
+	[Native("add")]
+	public add(value as T) as void;
+	[Native("getIndex")]
+	public [](index as int) as T;
+	[Native("setIndex")]
+	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

@@ -0,0 +1,4 @@
+// TODO: function overloading on global functions
+//extern function panic() as void;
+
+extern function panic<T>(message as string) as T;

stdlib/src/Result.zs

@@ -0,0 +1,48 @@
+export variant Result<T, E> {
+	Ok(T),
+	Error(E);
+	
+	public then<R>(fn as function(result as T) as Result<R, E>) as Result<R, E> {
+		return match this {
+			Ok(result) => fn(result),
+			Error(error) => Error(error)
+		};
+	}
+	
+	public handle<X>(handler as function(error as E) as Result<T, X>) as Result<T, X> {
+		return match this {
+			Ok(result) => Ok(result),
+			Error(error) => handler(error)
+		};
+	}
+	
+	public expect() as T {
+		return match this {
+			Ok(result) => result,
+			Error(error) => panic<T>("expect() called on an error value")
+		};
+	}
+	
+	public orElse(other as T) as T {
+		return match this {
+			Ok(result) => result,
+			Error(error) => other
+		};
+	}
+	
+	public orElse(other as function(error as E) as T) as T {
+		return match this {
+			Ok(result) => result,
+			Error(error) => other(error)
+		};
+	}
+}
+
+export expand <T, E : Exception> Result<T, E> {
+	public unwrap() as T {
+		return match this {
+			Ok(result) => result,
+			Error(error) => throw error
+		};
+	}
+}

stdlib/src/StringBuildable.zs

@@ -0,0 +1,6 @@
+export interface StringBuildable {
+	toString(output as StringBuilder) as void;
+	
+	as string
+		=> new StringBuilder() << this;
+}

stdlib/src/StringBuilder.zs

@@ -0,0 +1,49 @@
+[Native("stdlib::StringBuilder")]
+export class StringBuilder {
+	[Native("constructor")]
+	public extern this();
+	[Native("constructorWithCapacity")]
+	public extern this(capacity as int);
+	[Native("constructorWithValue")]
+	public extern this(value as string);
+	
+	[Native("isEmpty")]
+	public extern get isEmpty as bool;
+	[Native("length")]
+	public extern get length as int;
+	
+	[Native("appendBool")]
+	public extern <<(value as bool) as StringBuilder;
+	[Native("appendByte")]
+	public extern <<(value as byte) as StringBuilder;
+	[Native("appendSByte")]
+	public extern <<(value as sbyte) as StringBuilder;
+	[Native("appendShort")]
+	public extern <<(value as short) as StringBuilder;
+	[Native("appendUShort")]
+	public extern <<(value as ushort) as StringBuilder;
+	[Native("appendInt")]
+	public extern <<(value as int) as StringBuilder;
+	[Native("appendUInt")]
+	public extern <<(value as uint) as StringBuilder;
+	[Native("appendLong")]
+	public extern <<(value as long) as StringBuilder;
+	[Native("appendULong")]
+	public extern <<(value as ulong) as StringBuilder;
+	[Native("appendFloat")]
+	public extern <<(value as float) as StringBuilder;
+	[Native("appendDouble")]
+	public extern <<(value as double) as StringBuilder;
+	[Native("appendChar")]
+	public extern <<(value as char) as StringBuilder;
+	[Native("appendString")]
+	public extern <<(value as string) as StringBuilder;
+	
+	public <<(value as StringBuildable) as StringBuilder {
+		value.toString(this);
+		return this;
+	}
+	
+	[Native("asString")]
+	public extern implicit as string;
+}

stdlib/src/Strings.zs

@@ -0,0 +1,74 @@
+export expand string {
+	public const in(c as char) as bool
+		=> indexOf(c) >= 0;
+	
+	public const indexOf(c as char) as int {
+		for i in 0 .. length {
+			if this[i] == c
+				return i;
+		}
+		
+		return -1;
+	}
+	
+	public const indexOf(c as char, from as int) as int {
+		for i in from .. length {
+			if this[i] == c
+				return i;
+		}
+		
+		return -1;
+	}
+	
+	public const lastIndexOf(c as char) as int {
+		var i = length;
+		while i > 0 {
+			i--;
+			if this[i] == c
+				return i;
+		}
+		
+		return -1;
+	}
+	
+	public const lastIndexOf(c as char, until as int) as int {
+		var i = until;
+		while i > 0 {
+			i--;
+			if this[i] == c
+				return i;
+		}
+		
+		return -1;
+	}
+	
+	public const split(delimiter as char) as string[] {
+		val result = new List<string>();
+		var start = 0;
+		for i in 0 .. this.length {
+			if this[i] == delimiter {
+				result.add(this[start .. i]);
+				start = i + 1;
+			}
+		}
+		result.add(this[start .. $]);
+		return result as string[];
+	}
+	
+	public const trim() as string {
+		var from = 0;
+		while from < this.length && this[from] in [' ', '\t', '\r', '\n']
+			from++;
+		var to = this.length;
+		while to > 0 && this[to - 1] in [' ', '\t', '\r', '\n']
+			to--;
+		
+		return to < from ? "" : this[from .. to];
+	}
+	
+	public const lpad(length as int, c as char) as string
+		=> this.length >= length ? this : c.times(length - this.length) + this;
+	
+	public const rpad(length as int, c as char) as string
+		=> this.length >= length ? this : this + c.times(length - this.length);
+}