diff --git a/wurst/Wurst.wurst b/wurst/Wurst.wurst
index dbb85a22..a9c82e6b 100644
--- a/wurst/Wurst.wurst
+++ b/wurst/Wurst.wurst
@@ -8,4 +8,5 @@ import public Basics
 import public Wurstunit
 import public TypeCasting
 import public Colors
-import public Annotations
\ No newline at end of file
+import public Annotations
+import public BasicTypeClasses
\ No newline at end of file
diff --git a/wurst/_handles/_Handles.wurst b/wurst/_handles/_Handles.wurst
index 181f47fa..9643dc8b 100755
--- a/wurst/_handles/_Handles.wurst
+++ b/wurst/_handles/_Handles.wurst
@@ -29,3 +29,8 @@ import public Trigger
 import public Unit
 import public Weather
 import public Widget
+import BasicTypeClasses
+
+public implements Default<handle>
+	override function defaultValue() returns handle
+		return null
\ No newline at end of file
diff --git a/wurst/_handles/primitives/Boolean.wurst b/wurst/_handles/primitives/Boolean.wurst
index cccfe965..6320af98 100644
--- a/wurst/_handles/primitives/Boolean.wurst
+++ b/wurst/_handles/primitives/Boolean.wurst
@@ -1,10 +1,15 @@
 package Boolean
 import NoWurst
+import BasicTypeClasses
 
 /** Converts this boolean into a string */
 public function boolean.toString() returns string
 	return this ? "true" : "false"
 
+public implements Show<bool>
+	override function toString(bool b) returns string
+		return b.toString()
+
 /** Converts this string into a boolean */
 public function string.toBool() returns boolean
 	return this == "1" or this == "true" ? true : false
@@ -16,3 +21,7 @@ public function boolean.toInt() returns int
 /** Converts this int into a boolean */
 public function int.toBool() returns boolean
 	return this != 0
+
+public implements Default<bool>
+	override function defaultValue() returns bool
+		return false
\ No newline at end of file
diff --git a/wurst/_handles/primitives/Integer.wurst b/wurst/_handles/primitives/Integer.wurst
index 21519ddc..61f5a261 100644
--- a/wurst/_handles/primitives/Integer.wurst
+++ b/wurst/_handles/primitives/Integer.wurst
@@ -1,6 +1,7 @@
 package Integer
 import NoWurst
 import Real
+import BasicTypeClasses
 
 public constant INT_MAX = 2147483647
 public constant INT_MIN = -2147483648
@@ -29,6 +30,10 @@ public function int.toReal() returns real
 public function int.toString() returns string
 	return I2S(this)
 
+public implements Show<int>
+	override function toString(int b) returns string
+		return b.toString()
+
 /** Returns this int to the power of the argument int */
 public function int.pow(int x) returns int
 	int result = 1
@@ -55,3 +60,7 @@ public function int.bitOr(int other) returns int
 /** Returns the result of a bitwise exclusive OR operation performed on this int and the argument int. */
 public function int.bitXor(int other) returns int
 	return BlzBitXor(this, other)
+
+public implements Default<int>
+	override function defaultValue() returns int
+		return 0
\ No newline at end of file
diff --git a/wurst/_handles/primitives/Real.wurst b/wurst/_handles/primitives/Real.wurst
index 77236daf..79e7e093 100644
--- a/wurst/_handles/primitives/Real.wurst
+++ b/wurst/_handles/primitives/Real.wurst
@@ -1,5 +1,6 @@
 package Real
 import NoWurst
+import BasicTypeClasses
 
 public constant REAL_MAX = 340282366920938000000000000000000000000.
 public constant REAL_MIN = -340282366920938000000000000000000000000.
@@ -52,6 +53,10 @@ public function real.toInt() returns int
 public function real.toString() returns string
 	return R2S(this)
 
+public implements Show<real>
+	override function toString(real b) returns string
+		return b.toString()	
+
 /** Returns the string representation of this real with the given amount if digits precision */
 public function real.toString(int precision) returns string
 	return R2SW(this, precision, precision)
@@ -97,3 +102,7 @@ public function real.lerp(real target, real alpha) returns real
 /** Checks if this real is between low and high value */
 public function real.isBetween(real low, real high) returns bool
 	return this >= low and this <= high
+
+public implements Default<real>
+	override function defaultValue() returns real
+		return 0.
\ No newline at end of file
diff --git a/wurst/_handles/primitives/String.wurst b/wurst/_handles/primitives/String.wurst
index c97da4bd..ed9a1841 100644
--- a/wurst/_handles/primitives/String.wurst
+++ b/wurst/_handles/primitives/String.wurst
@@ -1,6 +1,7 @@
 package String
 import NoWurst
 import Integer
+import BasicTypeClasses
 
 constant charset = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
 constant numberset = "0123456789"
@@ -271,3 +272,12 @@ public class StringLines
 /** Returns a StringLines Object of the given string for iteration */
 public function string.toLines() returns StringLines
 	return new StringLines(this, 0, this.countOccurences("\n") + 1)
+
+
+public implements Show<string>
+	override function toString(string s) returns string
+		return s
+
+public implements Default<string>
+	override function defaultValue() returns string
+		return ""
diff --git a/wurst/_wurst/BasicTypeClasses.wurst b/wurst/_wurst/BasicTypeClasses.wurst
new file mode 100644
index 00000000..1fcb88b6
--- /dev/null
+++ b/wurst/_wurst/BasicTypeClasses.wurst
@@ -0,0 +1,38 @@
+package BasicTypeClasses
+import NoWurst
+
+/**
+  T is a type that can be converted to an integer.
+  The toIndex function must be injective.
+ */
+public interface ToIndex<T:>
+    function toIndex(T x) returns int
+        
+/**
+  T is a type that can be created from an integer T.
+  */
+public interface FromIndex<T:>
+    function fromIndex(int index) returns T
+
+public interface ConvertIndex<T:> extends ToIndex<T>, FromIndex<T>
+
+/**
+  T is a type with a default value.
+ */
+public interface Default<T:>      
+    function defaultValue() returns T
+
+/**
+    AnyRef is the type class for all reference types (interfaces and classes).
+  */
+public interface AnyRef<T:> extends ConvertIndex<T>, Default<T>
+
+/**
+  T is a type that can be converted to a string.
+  */
+public interface Show<T:>
+    function toString(T t) returns string
+
+/** returns a string representation */
+public function T.toString<T: Show>() returns string
+    return T.toString(this)
diff --git a/wurst/_wurst/TypeCasting.wurst b/wurst/_wurst/TypeCasting.wurst
index a11b28b2..a7240550 100644
--- a/wurst/_wurst/TypeCasting.wurst
+++ b/wurst/_wurst/TypeCasting.wurst
@@ -3,6 +3,7 @@ import NoWurst
 import _Handles
 import Table
 import Annotations
+import BasicTypeClasses
 
 constant typecastdata = new Table()
 /** How many decimals to preserve for reals */
@@ -244,3 +245,169 @@ public function booleanToIndex(boolean u) returns int
 public function booleanFromIndex(int index) returns boolean
 	return index == 1
 
+// instances
+public implements ConvertIndex<real>
+	override function toIndex(real x) returns int
+		return realToIndex(x)
+	override function fromIndex(int i) returns real
+		return realFromIndex(i)
+public implements ConvertIndex<string>
+	override function toIndex(string x) returns int
+		return stringToIndex(x)
+	override function fromIndex(int i) returns string
+		return stringFromIndex(i)
+public implements ConvertIndex<player>
+	override function toIndex(player x) returns int
+		return playerToIndex(x)
+	override function fromIndex(int i) returns player
+		return playerFromIndex(i)
+public implements ConvertIndex<widget>
+	override function toIndex(widget x) returns int
+		return widgetToIndex(x)
+	override function fromIndex(int i) returns widget
+		return widgetFromIndex(i)
+public implements ConvertIndex<unit>
+	override function toIndex(unit x) returns int
+		return unitToIndex(x)
+	override function fromIndex(int i) returns unit
+		return unitFromIndex(i)
+public implements ConvertIndex<destructable>
+	override function toIndex(destructable x) returns int
+		return destructableToIndex(x)
+	override function fromIndex(int i) returns destructable
+		return destructableFromIndex(i)
+public implements ConvertIndex<item>
+	override function toIndex(item x) returns int
+		return itemToIndex(x)
+	override function fromIndex(int i) returns item
+		return itemFromIndex(i)
+public implements ConvertIndex<ability>
+	override function toIndex(ability x) returns int
+		return abilityToIndex(x)
+	override function fromIndex(int i) returns ability
+		return abilityFromIndex(i)
+public implements ConvertIndex<force>
+	override function toIndex(force x) returns int
+		return forceToIndex(x)
+	override function fromIndex(int i) returns force
+		return forceFromIndex(i)
+public implements ConvertIndex<group>
+	override function toIndex(group x) returns int
+		return groupToIndex(x)
+	override function fromIndex(int i) returns group
+		return groupFromIndex(i)
+public implements ConvertIndex<trigger>
+	override function toIndex(trigger x) returns int
+		return triggerToIndex(x)
+	override function fromIndex(int i) returns trigger
+		return triggerFromIndex(i)
+public implements ConvertIndex<triggeraction>
+	override function toIndex(triggeraction x) returns int
+		return triggeractionToIndex(x)
+	override function fromIndex(int i) returns triggeraction
+		return triggeractionFromIndex(i)
+public implements ConvertIndex<triggercondition>
+	override function toIndex(triggercondition x) returns int
+		return triggerconditionToIndex(x)
+	override function fromIndex(int i) returns triggercondition
+		return triggerconditionFromIndex(i)
+public implements ConvertIndex<timer>
+	override function toIndex(timer x) returns int
+		return timerToIndex(x)
+	override function fromIndex(int i) returns timer
+		return timerFromIndex(i)
+public implements ConvertIndex<location>
+	override function toIndex(location x) returns int
+		return locationToIndex(x)
+	override function fromIndex(int i) returns location
+		return locationFromIndex(i)
+public implements ConvertIndex<region>
+	override function toIndex(region x) returns int
+		return regionToIndex(x)
+	override function fromIndex(int i) returns region
+		return regionFromIndex(i)
+public implements ConvertIndex<rect>
+	override function toIndex(rect x) returns int
+		return rectToIndex(x)
+	override function fromIndex(int i) returns rect
+		return rectFromIndex(i)
+public implements ConvertIndex<sound>
+	override function toIndex(sound x) returns int
+		return soundToIndex(x)
+	override function fromIndex(int i) returns sound
+		return soundFromIndex(i)
+public implements ConvertIndex<effect>
+	override function toIndex(effect x) returns int
+		return effectToIndex(x)
+	override function fromIndex(int i) returns effect
+		return effectFromIndex(i)
+public implements ConvertIndex<dialog>
+	override function toIndex(dialog x) returns int
+		return dialogToIndex(x)
+	override function fromIndex(int i) returns dialog
+		return dialogFromIndex(i)
+public implements ConvertIndex<button>
+	override function toIndex(button x) returns int
+		return buttonToIndex(x)
+	override function fromIndex(int i) returns button
+		return buttonFromIndex(i)
+public implements ConvertIndex<quest>
+	override function toIndex(quest x) returns int
+		return questToIndex(x)
+	override function fromIndex(int i) returns quest
+		return questFromIndex(i)
+public implements ConvertIndex<questitem>
+	override function toIndex(questitem x) returns int
+		return questitemToIndex(x)
+	override function fromIndex(int i) returns questitem
+		return questitemFromIndex(i)
+public implements ConvertIndex<leaderboard>
+	override function toIndex(leaderboard x) returns int
+		return leaderboardToIndex(x)
+	override function fromIndex(int i) returns leaderboard
+		return leaderboardFromIndex(i)
+public implements ConvertIndex<multiboard>
+	override function toIndex(multiboard x) returns int
+		return multiboardToIndex(x)
+	override function fromIndex(int i) returns multiboard
+		return multiboardFromIndex(i)
+public implements ConvertIndex<trackable>
+	override function toIndex(trackable x) returns int
+		return trackableToIndex(x)
+	override function fromIndex(int i) returns trackable
+		return trackableFromIndex(i)
+public implements ConvertIndex<lightning>
+	override function toIndex(lightning x) returns int
+		return lightningToIndex(x)
+	override function fromIndex(int i) returns lightning
+		return lightningFromIndex(i)
+public implements ConvertIndex<image>
+	override function toIndex(image x) returns int
+		return imageToIndex(x)
+	override function fromIndex(int i) returns image
+		return imageFromIndex(i)
+public implements ConvertIndex<ubersplat>
+	override function toIndex(ubersplat x) returns int
+		return ubersplatToIndex(x)
+	override function fromIndex(int i) returns ubersplat
+		return ubersplatFromIndex(i)
+public implements ConvertIndex<framehandle>
+	override function toIndex(framehandle x) returns int
+		return framehandleToIndex(x)
+	override function fromIndex(int i) returns framehandle
+		return framehandleFromIndex(i)
+public implements ConvertIndex<oskeytype>
+	override function toIndex(oskeytype x) returns int
+		return oskeytypeToIndex(x)
+	override function fromIndex(int i) returns oskeytype
+		return oskeytypeFromIndex(i)
+public implements ConvertIndex<boolean>
+	override function toIndex(boolean x) returns int
+		return booleanToIndex(x)
+	override function fromIndex(int i) returns boolean
+		return booleanFromIndex(i)
+public implements ConvertIndex<int>
+	override function toIndex(int x) returns int
+		return x
+	override function fromIndex(int i) returns int
+		return i
\ No newline at end of file
diff --git a/wurst/data/BitSet.wurst b/wurst/data/BitSet.wurst
index 7c3c9a76..4f8fac8b 100644
--- a/wurst/data/BitSet.wurst
+++ b/wurst/data/BitSet.wurst
@@ -3,6 +3,7 @@ import NoWurst
 import Integer
 import Wurstunit
 import Annotations
+import BasicTypeClasses
 
 public constant BITSET_SIZE = 32
 
@@ -94,6 +95,13 @@ public function bitsetToIndex(bitset object) returns int
 public function bitsetFromIndex(int index) returns bitset
 	return bitset(index)
 	
+public implements ConvertIndex<bitset>
+	override function toIndex(bitset x) returns int
+		return x.toInt()
+
+	override function fromIndex(int index) returns bitset
+		return bitset(index)
+
 // Tests
 
 @test function testGet()
diff --git a/wurst/data/HashList.wurst b/wurst/data/HashList.wurst
index 3eda03c6..17f80f89 100644
--- a/wurst/data/HashList.wurst
+++ b/wurst/data/HashList.wurst
@@ -5,7 +5,7 @@ package HashList
  * on a large list object. LinkedLists should be generally used, but are slow in this regard.
  * Removing elements from a HashList is slower than of LinkedLists.
 */
-public class HashList<T>
+public class HashList<T: ConvertIndex>
 	private static hashtable ht = compiletime(InitHashtable())
 	private static hashtable occurences = compiletime(InitHashtable())
 
@@ -22,35 +22,35 @@ public class HashList<T>
 
 	/** Returns the number of occurences of an element in this list */
 	function count(T elem) returns int
-		return occurences.loadInt(this castTo int, elem castTo int)
+		return occurences.loadInt(this castTo int, T.toIndex(elem))
 
 	private function addOccurences(T elem, int delta)
-		occurences.saveInt(this castTo int, elem castTo int, count(elem) + delta)
+		occurences.saveInt(this castTo int, T.toIndex(elem), count(elem) + delta)
 
 	private function incrOccurences(T elem)
-		occurences.saveInt(this castTo int, elem castTo int, count(elem) + 1)
+		occurences.saveInt(this castTo int, T.toIndex(elem), count(elem) + 1)
 
 	private function decrOccurences(T elem)
-		occurences.saveInt(this castTo int, elem castTo int, count(elem) - 1)
+		occurences.saveInt(this castTo int, T.toIndex(elem), count(elem) - 1)
 
 	/** Add an element to the end of the list */
 	function add(vararg T elems)
 		for elem in elems
-			ht.saveInt(this castTo int, size, elem castTo int)
+			ht.saveInt(this castTo int, size, T.toIndex(elem))
 			incrOccurences(elem)
 			size++
 
 	/** Set an element at the given index.
 		If the index is higher than the list's size,
-		the list will be resized with null elements added between 
+		the list will be resized with tNull elements added between 
 		the index and the previous size. */
-	function set(int index, T elem)
+	function set(int index, T elem, T tNull)
 		if index < size
 			decrOccurences(get(index))
 		else
-			addOccurences(null, index - size)
+			addOccurences(tNull, index - size)
 			size = index + 1
-		ht.saveInt(this castTo int, index, elem castTo int)
+		ht.saveInt(this castTo int, index, T.toIndex(elem))
 		incrOccurences(elem)
 
 	/** Add all elements from elems to this list */
@@ -70,8 +70,8 @@ public class HashList<T>
 
 	/** Removes and returns the element at the given index */
 	function removeAt(int index) returns T
-		decrOccurences(ht.loadInt(this castTo int, index) castTo T)
-		let tmp = ht.loadInt(this castTo int, index) castTo T
+		decrOccurences(T.fromIndex(ht.loadInt(this castTo int, index)))
+		let tmp = T.fromIndex(ht.loadInt(this castTo int, index))
 		for i = index to size
 			ht.saveInt(this castTo int, i, ht.loadInt(this castTo int, i + 1))
 		size--
@@ -82,7 +82,7 @@ public class HashList<T>
 	function remove(T t) returns boolean
 		var result = false
 		for i = 0 to size - 1
-			if t castTo int == ht.loadInt(this castTo int, i)
+			if T.toIndex(t) == ht.loadInt(this castTo int, i)
 				result = true
 				removeAt(i)
 				break
@@ -98,7 +98,7 @@ public class HashList<T>
 
 	/** Get the element at the given index from this list */
 	function get(int index) returns T
-		return ht.loadInt(this castTo int, index) castTo T
+		return T.fromIndex(ht.loadInt(this castTo int, index))
 
 	/** Return whether the element exists in the list */
 	function has(T elem) returns bool
@@ -146,13 +146,20 @@ public class HashList<T>
 	ondestroy
 		clear()
 
-public interface RemovePredicate<T>
+/** Set an element at the given index.
+  If the index is higher than the list's size,
+  the list will be resized with default elements added between 
+  the index and the previous size. */
+public function HashList<T>.set<T: ConvertIndex and Default>(int index, T elem)
+	this.set(index, elem, T.defaultValue())
+
+public interface RemovePredicate<T:>
 	function shouldRemove(T element) returns boolean
 
-public interface HLItrClosure<T>
+public interface HLItrClosure<T:>
 	function run(T t)
 
-public class HLIterator<Q>
+public class HLIterator<Q: ConvertIndex>
 	protected int i = 0
 	protected HashList<Q> list
 
diff --git a/wurst/data/HashMap.wurst b/wurst/data/HashMap.wurst
index c379b3fa..a0eedc05 100644
--- a/wurst/data/HashMap.wurst
+++ b/wurst/data/HashMap.wurst
@@ -3,31 +3,32 @@ import NoWurst
 import HashList
 import public TypeCasting
 import public Table
+import BasicTypeClasses
 
 /** Generic Table Wrapper */
-public class HashMap<K,V> extends Table
+public class HashMap<K: ToIndex, V: ConvertIndex> extends Table
 
 	protected int size = 0
 
 	/** Whether a value exists under the given key or not */
 	function has(K key) returns boolean
-		return hasInt(key castTo int)
+		return hasInt(K.toIndex(key))
 
 	/** Saves the given value under the given key */
 	function put(K key, V value)
 		if not has(key)
 			size++
-		saveInt(key castTo int, value castTo int)
+		saveInt(K.toIndex(key), V.toIndex(value))
 
 	/** Retrieves the value saved under the given key */
 	function get(K key) returns V
-		return loadInt(key castTo int) castTo V
+		return V.fromIndex(loadInt(K.toIndex(key)))
 
 	/** Removes the value saved under the given key */
 	function remove(K key)
 		if has(key)
 			size--
-		removeInt(key castTo int)
+		removeInt(K.toIndex(key))
 
 	/** Retrieves the value saved under the given key and removes it */
 	function getAndRemove(K key) returns V
@@ -43,7 +44,7 @@ public class HashMap<K,V> extends Table
 		super.flush()
 
 /** Iterable generic Table Wrapper */
-public class IterableMap<K,V> extends HashMap<K, V>
+public class IterableMap<K: ConvertIndex, V: ConvertIndex> extends HashMap<K, V>
 	protected let keys = new HashList<K>
 	private bool _destroyed = false
 
@@ -133,5 +134,5 @@ public class IterableMap<K,V> extends HashMap<K, V>
 		// since .flush() is called after this destructor
 		_destroyed = true
 
-public interface IMItrClosure<K, V>
+public interface IMItrClosure<K: , V: >
 	function run(K key, V value)
diff --git a/wurst/data/HashSet.wurst b/wurst/data/HashSet.wurst
index 251565f3..19c39816 100644
--- a/wurst/data/HashSet.wurst
+++ b/wurst/data/HashSet.wurst
@@ -2,29 +2,29 @@ package HashSet
 import public HashList
 
 /** Generic set implementation */
-public class HashSet<T> extends HashList<T>
+public class HashSet<T: ConvertIndex> extends HashList<T>
 	private static constant position = compiletime(InitHashtable())
 
 	/** Adds an element to this set */
 	override function add(vararg T elems)
 		for elem in elems
 			if count(elem) <= 0
-				position.saveInt(this castTo int, elem castTo int, size())
+				position.saveInt(this castTo int, T.toIndex(elem), size())
 				super.add(elem)
 
 	/** Removes an element from this set if present */
 	override function remove(T elem) returns boolean
 		var result = false
 		if count(elem) > 0
-			removeAt(position.loadInt(this castTo int, elem castTo int))
+			removeAt(position.loadInt(this castTo int, T.toIndex(elem)))
 			result = true
 		return result
 
 	/** Remove the element at the given index */
 	override function removeAt(int index) returns T
-		position.removeInt(this castTo int, get(index) castTo int)
+		position.removeInt(this castTo int, T.toIndex(get(index)))
 		for i = index + 1 to size()
-			position.saveInt(this castTo int, get(i) castTo int, position.loadInt(this castTo int, get(i) castTo int) - 1)
+			position.saveInt(this castTo int, T.toIndex(get(i)), position.loadInt(this castTo int, T.toIndex(get(i))) - 1)
 		return super.removeAt(index)
 
 	override function clear()
diff --git a/wurst/data/LinkedList.wurst b/wurst/data/LinkedList.wurst
index f14f8a34..338f7afb 100644
--- a/wurst/data/LinkedList.wurst
+++ b/wurst/data/LinkedList.wurst
@@ -1,11 +1,12 @@
 package LinkedList
 import NoWurst
 import TypeCasting
-import Integer
 import String
 import ClosureForGroups
 import Real
 import Annotations
+import BasicTypeClasses
+import ErrorHandling
 
 /**
  * Doubly-linked list implementation that implements all common list, stack and queue operations.
@@ -15,8 +16,8 @@ import Annotations
  * and fast in common operations. If you need faster contains or access operations on big lists,
  * use HashList. If you want to limit each element's occurance to one, consider HashSet.
  */
-public class LinkedList<T>
-	private var dummy = new LLEntry<T>(null, null, null)
+public class LinkedList<T:>
+	private var dummy = new LLEntry<T>(null, null)
 	protected var size = 0
 
 	private LLIterator<T> staticItr = null
@@ -89,18 +90,18 @@ public class LinkedList<T>
 		return dummy.next.elem
 
 	/** Returns and removes the first added Element (FIFO) */
-	function dequeue() returns T
+	function dequeue(T defaultValue) returns T
 		let top = dummy.next
-		T result = null
+		T result = defaultValue
 		if top != dummy
 			result = top.elem
 			removeEntry(top)
 		return result
 
 	/** Returns and removes the last added Element (LIFO) */
-	function pop() returns T
+	function pop(T defaultValue) returns T
 		let top = dummy.prev
-		T result = null
+		T result = defaultValue
 		if top != dummy
 			result = top.elem
 			removeEntry(top)
@@ -363,11 +364,6 @@ public class LinkedList<T>
 		halfRef.next = dummy
 		return tmp
 
-	/** Prints the content of the list */
-	function toString() returns string
-		let fold = foldl<string>("[", (i, q) -> q + (i castTo int).toString() + ",")
-		return fold.substring(0, fold.length()-1) + "]"
-
 	/** Removes all elements from the list */
 	function clear()
 		var current = dummy.next
@@ -406,23 +402,44 @@ public class LinkedList<T>
 			destroy current.prev
 		destroy dummy
 
+/** Returns and removes the first added Element (FIFO) */
+public function LinkedList<T>.dequeue<T: Default>() returns T
+	return this.dequeue(T.defaultValue())
+
+/** Returns and removes the last added Element (LIFO) */
+public function LinkedList<T>.pop<T: Default>() returns T
+	return this.pop(T.defaultValue())	
+
+/** Prints the content of the list */
+public implements Show<LinkedList<X>> for X: Show
+	override function toString(LinkedList<X> list) returns string
+		let fold = list.foldl<string>("[", (i, q) -> q + (X.toString(i)) + ",")
+		return fold.substring(0, fold.length()-1) + "]"
+
+
+	
+
 public function asList<T>(vararg T ts) returns LinkedList<T>
 	let ll = new LinkedList<T>
 	for t in ts
 		ll.add(t)
 	return ll
 
-class LLEntry<T>
+class LLEntry<T:>
 	T elem
 	LLEntry<T> prev
 	LLEntry<T> next
 
+	construct(LLEntry<T> prev, LLEntry<T> next)
+		this.prev = prev
+		this.next = next
+
 	construct(T elem, LLEntry<T> prev, LLEntry<T> next)
 		this.elem = elem
 		this.prev = prev
 		this.next = next
 
-public class LLIterator<T>
+public class LLIterator<T:>
 	LLEntry<T>	dummy
 	LLEntry<T>	current
 	LinkedList<T> parent
@@ -449,7 +466,8 @@ public class LLIterator<T>
 			let removed = current.elem
 			current = current.prev
 			return removed
-		return null
+		error("Called remove on invalid iterator position.")
+		return dummy.elem
 
 	/** Modifies the last element that was returned by next() (optional operation). */
 	function modify(T newval)
@@ -463,8 +481,8 @@ public class LLIterator<T>
 		current = current.next
 		return current.elem
 
-	function lookahead() returns T
-		T retVal = null
+	function lookahead(T defaultValue) returns T
+		T retVal = defaultValue
 		if hasNext()
 			retVal = current.next.elem
 		return retVal
@@ -473,7 +491,11 @@ public class LLIterator<T>
 		if destroyOnClose
 			destroy this
 
-public class LLBackIterator<T>
+public function LLIterator<T>.lookahead<T: Default>() returns T
+	return this.lookahead(T.defaultValue())
+
+
+public class LLBackIterator<T:>
 	LLEntry<T> dummy
 	LLEntry<T> current
 	protected bool destroyOnClose = true
@@ -502,8 +524,8 @@ public class LLBackIterator<T>
 		current = current.prev
 		return current.elem
 
-	function lookahead() returns T
-		T retVal = null
+	function lookahead(T defaultValue) returns T
+		T retVal = defaultValue
 		if hasNext()
 			retVal = current.prev.elem
 		return retVal
@@ -512,13 +534,16 @@ public class LLBackIterator<T>
 		if destroyOnClose
 			destroy this
 
-public interface LinkedListPredicate<T>
+public function LLBackIterator<T>.lookahead<T: Default>() returns T
+	return this.lookahead(T.defaultValue())
+
+public interface LinkedListPredicate<T:>
 	function isTrueFor(T t) returns boolean
 
-public interface LLItrClosure<T>
+public interface LLItrClosure<T:>
 	function run(T t)
 
-public interface LinkedListUpdater<T>
+public interface LinkedListUpdater<T:>
 	function update(T t) returns T
 
 public interface MapClosure<T, Q>
@@ -527,7 +552,7 @@ public interface MapClosure<T, Q>
 public interface FoldClosure<T, Q>
 	function run(T t, Q q) returns Q
 
-public interface Comparator<T>
+public interface Comparator<T:>
 	function compare(T o1, T o2) returns int
 
 constant Comparator<real> realComparator = (r1, r2) -> (r1 - r2).toInt()
@@ -560,7 +585,7 @@ public function LinkedList<string>.joinBy(string separator) returns string
 	iter.close()
 	return joined
 
-interface ToStringClosure<T>
+interface ToStringClosure<T:>
 	function toString(T elem) returns string
 
 public function LinkedList<T>.joinBy<T>(ToStringClosure<T> cls, string separator) returns string
diff --git a/wurst/math/Matrices.wurst b/wurst/math/Matrices.wurst
index 7346c53c..8989046b 100644
--- a/wurst/math/Matrices.wurst
+++ b/wurst/math/Matrices.wurst
@@ -4,6 +4,7 @@ import public Vectors
 import Maths
 import ErrorHandling
 import Wurstunit
+import BasicTypeClasses
 
 /** Matrix 2x2
 00 01
@@ -150,6 +151,10 @@ public function mat2.toString() returns string
 		this.m00.toString(), this.m01.toString(),
 		this.m10.toString(), this.m11.toString())
 
+public implements Show<mat2>
+	override function toString(mat2 x) returns string
+		return x.toString()
+
 /** Creates rotation matrix from angle. */
 public function angle.toRotation() returns mat2
 	return mat2(this.cos(), -this.sin(),
@@ -327,6 +332,10 @@ public function mat3.toString() returns string
 		this.m10.toString(), this.m11.toString(), this.m12.toString(),
 		this.m20.toString(), this.m21.toString(), this.m22.toString())
 
+public implements Show<mat3>
+	override function toString(mat3 x) returns string
+		return x.toString()
+
 /** Creates 3x3 rotation matrix from axis and angle. */
 public function vec3.toRotation(angle angl) returns mat3
 	let v = this.norm()
@@ -534,6 +543,10 @@ public function mat4.toString() returns string
 		this.m20.toString(), this.m21.toString(), this.m22.toString(), this.m23.toString(),
 		this.m30.toString(), this.m31.toString(), this.m32.toString(), this.m33.toString())
 
+public implements Show<mat4>
+	override function toString(mat4 x) returns string
+		return x.toString()
+
 /* =========== TESTING =========== */
 
 public function mat2.assertEquals(mat2 expected)
diff --git a/wurst/math/Quaternion.wurst b/wurst/math/Quaternion.wurst
index f2d0b001..38b473b9 100644
--- a/wurst/math/Quaternion.wurst
+++ b/wurst/math/Quaternion.wurst
@@ -4,6 +4,7 @@ import NoWurst
 import String
 import Maths
 import Wurstunit
+import BasicTypeClasses
 
 public tuple quat(real x, real y, real z, real w)
 
@@ -187,6 +188,10 @@ public function quat.slerpLong(quat q, real p) returns quat
 public function quat.toString() returns string
 	return "Quaternion [X {0}, Y {1}, Z {2}, W {3}]".format(this.x.toString(), this.y.toString(), this.z.toString(), this.w.toString())
 
+public implements Show<quat>
+	override function toString(quat x) returns string
+		return x.toString()
+
 /** Gimbal lock detection.
 Returns 1 for north, -1 for south, 0 if no gimbal lock. */
 public function quat.getGimbalPole() returns int
diff --git a/wurst/math/Vectors.wurst b/wurst/math/Vectors.wurst
index 32fc1e38..2c915a70 100644
--- a/wurst/math/Vectors.wurst
+++ b/wurst/math/Vectors.wurst
@@ -6,6 +6,7 @@ import public Angle
 import String
 import initlater Printing
 import Annotations
+import BasicTypeClasses
 
 /** A vector is a geometric object that has a length and direction.
 	Vectors can be added to other vectors according to vector algebra.
@@ -132,6 +133,10 @@ public function vec2.inRange(vec2 v2, real radius) returns boolean
 public function vec2.toString() returns string
 	return "Vector2 [" + this.x.toString() + ", " + this.y.toString() + "]"
 
+public implements Show<vec2>
+	override function toString(vec2 x) returns string
+		return "(" + x.x.toString() + ", " + x.y.toString() + ")"
+
 /** Get this vetor's angle to another one */
 public function vec2.angleTo(vec2 v) returns angle
 	return Atan2(v.y - this.y, v.x - this.x).asAngleRadians()
@@ -365,6 +370,10 @@ public function vec3.distanceToSq(vec3 v) returns real
 public function vec3.toString() returns string
 	return "Vector3 [ " + this.x.toString() + ", " + this.y.toString() + ", " + this.z.toString() + " ]"
 
+public implements Show<vec3>
+	override function toString(vec3 x) returns string
+		return "(" + x.x.toString() + ", " + x.y.toString() + ", " + x.z.toString() + ")"
+
 /** Rotate this vector around an axis */
 public function vec3.rotate(vec3 axis, angle ang) returns vec3
 	return this.rotate(axis, ang.radians)
diff --git a/wurst/util/Colors.wurst b/wurst/util/Colors.wurst
index 167952aa..27617284 100644
--- a/wurst/util/Colors.wurst
+++ b/wurst/util/Colors.wurst
@@ -8,6 +8,7 @@ import Playercolor
 import Annotations
 import Maths
 import Real
+import BasicTypeClasses
 
 public constant COLOR_WHITE = colorA(255,255,255,255)
 public constant COLOR_BLACK = colorA(0,0,0,0)
@@ -217,6 +218,19 @@ public function colorA.toString() returns string
 public function colorHSV.toString() returns string
 	return "colorHSV(" + (this.h).toString() + ", " + (this.s).toString() + ", " + (this.v).toString() + ")"
 
+
+public implements Show<color>
+	override function toString(color x) returns string
+		return x.toString()
+
+public implements Show<colorA>
+	override function toString(colorA x) returns string
+		return x.toString()
+
+public implements Show<colorHSV>
+	override function toString(colorHSV x) returns string
+		return x.toString()
+
 /** Hexadecimal numbers */
 public constant hexs = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"]
 constant decs = new Table()
diff --git a/wurst/util/StringUtils.wurst b/wurst/util/StringUtils.wurst
index df941e39..b99e08fa 100644
--- a/wurst/util/StringUtils.wurst
+++ b/wurst/util/StringUtils.wurst
@@ -6,6 +6,7 @@ import Interpolation
 import TypeCasting
 import Annotations
 import ErrorHandling
+import BasicTypeClasses
 
 /**
  * Credits go here: http://www.hiveworkshop.com/forums/jass-resources-412/snippet-ascii-190746/
@@ -59,6 +60,10 @@ public function char.toString() returns string
 		return DEFAULT_STRING
 	return c2s[this.c]
 
+public implements Show<char>
+	override function toString(char x) returns string
+		return x.toString()
+
 public function char.toInt() returns int
 	return this.c
 
@@ -85,6 +90,12 @@ public function charToIndex(char c) returns int
 public function charFromIndex(int index) returns char
 	return char(index)
 
+public implements ConvertIndex<char>
+	override function toIndex(char x) returns int
+		return x.toInt()
+	override function fromIndex(int index) returns char	
+		return char(index)
+	
 /** Splits the string by another string
 	"this..is..an..example" split by the string ".." splits into a list containing four strings ["this", "is", "an", "example"] */
 public function string.split(string splitBy) returns LinkedList<string>
diff --git a/wurst/util/TerrainUtils.wurst b/wurst/util/TerrainUtils.wurst
index ba2394ea..0de37c16 100644
--- a/wurst/util/TerrainUtils.wurst
+++ b/wurst/util/TerrainUtils.wurst
@@ -5,6 +5,7 @@ import Rect
 import MapBounds
 import Wurstunit
 import Colors
+import BasicTypeClasses
 
 // Terrain API
 
@@ -92,6 +93,12 @@ function tileToIndex(tile t) returns int
 function tileFromIndex(int i) returns tile
 	return tile(i)
 
+public implements ConvertIndex<tile>
+	override function toIndex(tile x) returns int
+		return x.id
+	override function fromIndex(int index) returns tile
+		return tile(index)
+
 // coordinate
 
 let TILES_X = (boundMax.x - boundMin.x).toInt() div 128 + 1