- Modified export to public

- Added some utility methods to StringBuilder
- Added new classes to live module

collections/src/HashSet.zs

-export class HashSet<T> {
+public class HashSet<T> {
 	public implements Set<T> {
 		add(value as T) as bool;
 		remove(value as T) as bool;

collections/src/LinkedList.zs

-export class LinkedList<T> {
+public class LinkedList<T> {
 	var first as Node?;
 	var last as Node?;
 	var size as usize : get;

collections/src/NoSuchElementException.zs

-export class NoSuchElementException : Exception {
+public class NoSuchElementException : Exception {
 	public this(message as string) {
 		super(message);
 	}

collections/src/Queue.zs

-export interface Queue<T> {
+public interface Queue<T> {
 	get empty as bool;
 	
 	poll() as T;

collections/src/Set.zs

-export interface Set<T> {
+public interface Set<T> {
 	add(value as T) as bool;
 	remove(value as T) as bool;
 	

collections/src/Stack.zs

-import stdlib.List;
-
-export class Stack<T> {
+public class Stack<T> {
 	var values as List<T> = new List<T>();
 	
 	public push(value as T) as void

compactio/src/CompactBytesDataInput.zs

-export class CompactBytesDataInput {
+public class CompactBytesDataInput {
 	private const P6 as uint = 1 << 6;
 	private const P7 as uint = 1 << 7;
 	private const P13 as uint = 1 << 13;

compactio/src/CompactBytesDataOutput.zs

-export class CompactBytesDataOutput {
+public class CompactBytesDataOutput {
 	private const P6 as uint = 1 << 6;
 	private const P7 as uint = 1 << 7;
 	private const P13 as uint = 1 << 13;

compactio/src/CompactDataInput.zs

-export interface CompactDataInput {
+public interface CompactDataInput {
 	readBool`mutable() as bool;
 	
 	readByte`mutable() as byte;

io/src/InputStream.zs

 [Native("io::InputStream")]
-export interface InputStream {
+public interface InputStream {
 	[Native("read")]
 	read() as int throws IOException;
 	

io/src/OutputStream.zs

 [Native("io::OutputStream")]
-export interface OutputStream {
+public interface OutputStream {
 	[Native("write")]
 	write(value as byte) as void throws IOException;
 	

io/src/Reader.zs

 [Native("io::Reader")]
-export interface Reader {
+public interface Reader {
 	[Native("destruct")]
 	~this;
 	

io/src/StringReader.zs

 [Native("io::StringReader")]
-export class StringReader {
+public class StringReader {
 	val data as char[];
 	var offset as usize;
 	

listeners/src/DummyListenerHandle.zs

-export class DummyListenerHandle<T> {
+public class DummyListenerHandle<T> {
 	val listener as T : get;
 	
 	public this(listener as T) {

live/src/ImmutableLiveBool.zs

 import listeners.DummyListenerHandle;
 
-export class ImmutableLiveBool {
+public class ImmutableLiveBool {
 	public const TRUE = new ImmutableLiveBool(true);
 	public const FALSE = new ImmutableLiveBool(false);
 	

live/src/ImmutableLiveObject.zs

 import listeners.DummyListenerHandle;
 
-export class ImmutableLiveObject<T> {
+public class ImmutableLiveObject<T> {
 	val value as T : get;
 	
 	public this(value as T) {

live/src/ImmutableLiveString.zs

 import listeners.DummyListenerHandle;
 
-export class ImmutableLiveString {
+public class ImmutableLiveString {
 	val value as string : get;
 	
 	public this(value as string) {

live/src/InverseLiveBool.zs

-export class InverseLiveBool {
+public class InverseLiveBool {
 	val source as LiveBool;
 	
 	public this(source as LiveBool) {

live/src/LiveArrayList.zs

 import listeners.ListenerList;
 
-class LiveArrayList<T> {
+public class LiveArrayList<T> {
 	val values = new List<T>();
 	val listeners = new ListenerList<LiveList<T>.Listener<T>>();
 	

live/src/LiveInt.zs

-export interface LiveInt {
+public interface LiveInt {
 	get value as int;
 	set value as int;
 	

live/src/LiveList.zs

-export interface LiveList<T> : Iterable<T> {
+public interface LiveList<T> : Iterable<T> {
 	~this;
 	
 	get length as usize;

live/src/LiveObject.zs

-export interface LiveObject<T> {
+public interface LiveObject<T> {
 	get value as T;
 	
 	addListener(listener as Listener<T>) as ListenerHandle<T>`unique;

live/src/LiveString.zs

-export interface LiveString {
+public interface LiveString {
 	get value as string;
 	
 	addListener(listener as Listener) as ListenerHandle`unique;

live/src/MutableLiveBool.zs

+public interface MutableLiveBool : LiveBool {
+	set value as bool;
+}

live/src/MutableLiveInt.zs

+public interface MutableLiveInt : LiveInt {
+	set value as int;
+}

live/src/MutableLiveList.zs

-export interface MutableLiveList<T> : LiveList<T> {
+public interface MutableLiveList<T> : LiveList<T> {
 	add(value as T) as void;
 	
 	insert(index as usize, value as T) as void;

live/src/MutableLiveString.zs

+public interface MutableLiveString : LiveString {
+	set value as string;
+}

live/src/SimpleLiveBool.zs

+import listeners.ListenerList;
+
+public class SimpleLiveBool {
+	val listeners = new ListenerList<LiveBool.Listener>;
+	
+	var value as bool : get;
+	
+	public this(value as bool) {
+		this.value = value;
+	}
+	
+	public implements MutableLiveBool {
+		addListener(listener) => listeners.add(listener);
+		
+		set value {
+			if $ == this.value
+				return;
+			
+			val oldValue = $value;
+			$value = $;
+			listeners.accept(listener => listener(oldValue, $value));
+		}
+	}
+}

live/src/SimpleLiveInt.zs

+import listeners.ListenerList;
+
+public class SimpleLiveInt {
+	val listeners = new ListenerList<LiveInt.Listener>;
+	
+	var value as int : get;
+	
+	public this(value as int) {
+		this.value = value;
+	}
+	
+	public implements MutableLiveInt {
+		addListener(listener) => listeners.add(listener);
+		
+		set value {
+			if $ == this.value
+				return;
+			
+			val oldValue = $value;
+			$value = $;
+			listeners.accept(listener => listener(oldValue, $value));
+		}
+	}
+}

live/src/SimpleLiveString.zs

+import listeners.ListenerList;
+
+public class SimpleLiveString {
+	val listeners = new ListenerList<LiveString.Listener>;
+	
+	var value as string : get;
+	
+	public this(value as string) {
+		this.value = value;
+	}
+	
+	public implements MutableLiveString {
+		addListener(listener) => listeners.add(listener);
+		
+		set value {
+			if $ == this.value
+				return;
+			
+			val oldValue = $value;
+			$value = $;
+			listeners.accept(listener => listener(oldValue, $value));
+		}
+	}
+}

stdlib/src/Arrays.zs

 [Native("stdlib::Arrays")]
-export expand <T : Comparable<T>> T[] {
+public expand <T : Comparable<T>> T[] {
 	[Native("sort")]
 	public extern sort() as void;
 	[Native("sorted")]
 	public extern sorted() as T[];
 }
 
-export expand <T : Hashable<T>> T[] {
+public expand <T : Hashable<T>> T[] {
 	public implements Hashable<T[]> {
 		public extern hashCode() as int;
 		public extern == (other as T[]) as bool;
 }
 
 [Native("stdlib::Arrays")]
-export expand <T> T[] {
+public expand <T> T[] {
 	[Native("sortWithComparator")]
 	public extern sort(comparator as function(a as T, b as T) as int) as void;
 	[Native("sortedWithComparator")]

stdlib/src/Assoc.zs

-export expand <K, V> V[K] {
+public 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

stdlib/src/Chars.zs

-export expand char {
+public expand char {
 	public times(number as usize) as string
 		=> new string(new char[](number, this));
 }

stdlib/src/Comparable.zs

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

stdlib/src/Exception.zs

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

stdlib/src/IllegalArgumentException.zs

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

stdlib/src/Integers.zs

 [Native("stdlib::Integer")]
-expand int {
+public expand int {
 	[Native("toHexString")]
 	public extern toHexString() as string;
 	

stdlib/src/List.zs

 [Native("stdlib::List")]
-export class List<T> {
+public class List<T> {
 	[Native("constructor")]
 	public this() {}
 	

stdlib/src/Result.zs

-export variant Result<T, E> {
+public variant Result<T, E> {
 	Ok(T),
 	Error(E);
 	
 	}
 }
 
-export expand <T, E : Exception> Result<T, E> {
+public expand <T, E : Exception> Result<T, E> {
 	public unwrap() as T throws E {
 		return match this {
 			Ok(result) => result,

stdlib/src/StringBuildable.zs

-export interface StringBuildable {
+public interface StringBuildable {
 	toString(output as StringBuilder`borrow) as void;
 	
 	as string

stdlib/src/StringBuilder.zs

 [Native("stdlib::StringBuilder")]
-export class StringBuilder {
+public class StringBuilder {
 	[Native("constructor")]
 	public extern this();
 	[Native("constructorWithCapacity")]
 	[Native("appendString")]
 	public extern <<(value as string) as StringBuilder;
 	
-	public <<`shared(value as StringBuildable`borrow) as StringBuilder`shared {
+	public <<(value as StringBuildable`borrow) as StringBuilder {
 		value.toString(this);
 		return this;
 	}
 	
+	public append<T : StringBuildable>(values as T[]`borrow, separator as string) as StringBuilder {
+		for i, value in values {
+			if i > 0
+				this << separator;
+			value.toString(this);
+		}
+		return this;
+	}
+	
+	public append<T>(values as T[]`borrow, stringer as function(value as T) as string, separator as string) as StringBuilder {
+		for i, value in values {
+			if i > 0
+				this << separator;
+			this << stringer(value);
+		}
+		return this;
+	}
+	
 	[Native("asString")]
 	public extern implicit as string;
 }

stdlib/src/Strings.zs

 [Native("stdlib::String")]
-export expand string {
+public expand string {
 	[Native("fromAsciiBytes")]
 	public static fromAsciiBytes(data as byte[]) as string;
 	

stdlib/src/USize.zs

 [Native("stdlib::USize")]
-expand usize {
+public expand usize {
 	[Native("toHexString")]
 	public extern toHexString() as string;