Updated libraries to use the storage tags properly.

compactio/src/CompactBytesDataInput.zs

 	private const P55 as ulong = 1UL << 55;
 	private const P56 as ulong = 1UL << 56;
 	
-	val data as const byte[];
+	val data as byte[]`borrow:this;
 	var offset as usize : get;
 	
-	public this(data as const byte[]) {
+	public this(data as byte[]`borrow:this) {
 		this.data = data;
 		this.offset = 0;
 	}
 	
-	public this(data as const byte[], offset as usize) {
+	public this(data as byte[]`borrow:this, offset as usize) {
 		this.data = data;
 		this.offset = offset;
 	}

compactio/src/CompactDataInput.zs

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

listeners/src/ListenerList.zs

 	public const PRIORITY_DEFAULT = 0;
 	public const PRIORITY_LOW = -100;
 	
-	var first as EventListenerNode? = null;
-	var last as EventListenerNode? = null;
+	var first as EventListenerNode`borrow? = null;
+	var last as EventListenerNode`borrow? = null;
 	
-	public add(listener as T) as ListenerHandle<T>
+	public add(listener as T) as ListenerHandle<T>`unique
 		=> add(listener, PRIORITY_DEFAULT);
 	
-	public add(listener as T, priority as int) as ListenerHandle<T> {
-		val node = new EventListenerNode(listener, priority);
+	public add(listener as T, priority as int) as ListenerHandle<T>`unique {
+		val node = new EventListenerNode`unique(listener, priority);
 		
 		if first == null {
 			first = last = node;
 	private class EventListenerNode {
 		val listener as T : get;
 		val priority as int;
-		var next as EventListenerNode? = null;
-		var prev as EventListenerNode? = null;
+		var next as EventListenerNode`borrow? = null;
+		var prev as EventListenerNode`borrow? = null;
 		
 		public this(listener as T, priority as int) {
 			this.listener = listener;

live/src/ImmutableLiveBool.zs

 	}
 	
 	public implements LiveBool {
-		addListener(listener) => new DummyListenerHandle<LiveBool.Listener>(listener);
+		addListener(listener) => new DummyListenerHandle<LiveBool.Listener>`unique(listener);
 	}
 }

live/src/ImmutableLiveObject.zs

 	}
 	
 	public implements LiveObject<T> {
-		addListener(listener) => new DummyListenerHandle<LiveObject<T>.Listener<T>>(listener);
+		addListener(listener) => new DummyListenerHandle<LiveObject<T>.Listener<T>>`unique(listener);
 	}
 }

live/src/ImmutableLiveString.zs

 	}
 	
 	public implements LiveString {
-		addListener(listener) => new DummyListenerHandle<LiveString.Listener>(listener);
+		addListener(listener) => new DummyListenerHandle<LiveString.Listener>`unique(listener);
 	}
 }

live/src/LiveBool.zs

 public interface LiveBool {
 	get value as bool;
 	
-	addListener(listener as Listener) as ListenerHandle;
+	addListener(listener as Listener) as ListenerHandle`unique;
 	
 	alias Listener as function(oldValue as bool, newValue as bool) as void;
 	alias ListenerHandle as listeners.ListenerHandle<Listener>;

live/src/LiveInt.zs

 	get value as int;
 	set value as int;
 	
-	addListener(listener as Listener) as ListenerHandle;
+	addListener(listener as Listener) as ListenerHandle`unique;
 	
 	alias Listener as function(oldValue as int, newValue as int) as void;
 	alias ListenerHandle as listeners.ListenerHandle<Listener>;

live/src/LiveList.zs

 	
 	[](index as usize) as T;
 	
-	addListener(listener as Listener<T>) as ListenerHandle<T>;
+	addListener(listener as Listener<T>) as ListenerHandle<T>`unique;
 	
 	public interface Listener<T> {
 		onInserted(index as usize, value as T) as void;

live/src/LiveObject.zs

 export interface LiveObject<T> {
 	get value as T;
 	
-	addListener(listener as Listener<T>) as ListenerHandle<T>;
+	addListener(listener as Listener<T>) as ListenerHandle<T>`unique;
 	
 	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

 export interface LiveString {
 	get value as string;
 	
-	addListener(listener as Listener) as ListenerHandle;
+	addListener(listener as Listener) as ListenerHandle`unique;
 	
 	alias Listener as function(oldValue as string, newValue as string) as void;
 	alias ListenerHandle as listeners.ListenerHandle<Listener>;

stdlib/src/Arrays.zs

 		}
 	}
 	
-	// TODO: fix compilation for this
+	// TODO: fix compilation for these
 	/*[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);
-	}
+	public map<U>(projection as function(value as T`borrow) as U) as U[]
+		=> new U[]<T>(this, projection);
 	
 	[Native("mapKeyValues")]
-	public map<U>(projection as function(index as usize, value as T) as U) as U[] {
-		return new U[]<T>(this, projection);
-	}
+	public map<U>(projection as function(index as usize, value as T`borrow) as U) as U[]
+		=> new U[]<T>(this, projection);
 	
 	[Native("filterValues")]
-	public filter(predicate as function(value as T) as bool) as T[] {
+	public filter(predicate as function(value as T`borrow) as bool) as T[] {
 		var values = new List<T>();
 		for value in this
 			if predicate(value)

stdlib/src/Chars.zs

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

stdlib/src/StringBuildable.zs

 export interface StringBuildable {
-	toString(output as StringBuilder) as void;
+	toString(output as StringBuilder`borrow) as void;
 	
 	as string
 		=> new StringBuilder() << this;

stdlib/src/StringBuilder.zs

 	[Native("appendString")]
 	public extern <<(value as string) as StringBuilder;
 	
-	public <<(value as StringBuildable) as StringBuilder {
+	public <<`shared(value as StringBuildable`borrow) as StringBuilder`shared {
 		value.toString(this);
 		return this;
 	}

stdlib/src/Strings.zs

 		=> this.length >= length ? this : this + c.times(length - this.length);
 		
 	[Native("toAsciiBytes")]
-	public const toAsciiBytes() as byte[];
+	public const toAsciiBytes() as byte[]`unique;
 	
 	[Native("toUTF8Bytes")]
-	public const toUTF8Bytes() as byte[];
+	public const toUTF8Bytes() as byte[]`unique;
 }