diff --git a/macros/Cargo.toml b/macros/Cargo.toml
index f4df0bf..c555ff1 100644
--- a/macros/Cargo.toml
+++ b/macros/Cargo.toml
@@ -10,7 +10,4 @@ edition = "2018"
 proc-macro = true
 
 [dependencies]
-quote = "1"
-proc-macro2 = "1.0"
-syn = "1.0"
 map = { path = "../map" }
\ No newline at end of file
diff --git a/macros/src/lib.rs b/macros/src/lib.rs
index 4fb4ff7..d61f3e2 100644
--- a/macros/src/lib.rs
+++ b/macros/src/lib.rs
@@ -6,49 +6,51 @@ use std::iter::Peekable;
 
 type Tokens = Peekable<IntoIter>;
 
-fn entry(input: &mut Tokens) -> Option<MapEntry<String, TokenStream>> {
+fn brackets(stream: TokenStream) -> TokenStream {
+    TokenStream::from(TokenTree::Group(Group::new(Delimiter::Brace,stream)))
+}
+
+fn entry(input: &mut Tokens) -> Option<MapEntry<String,TokenStream>> {
     if input.peek().is_some() {
-        let index = match input.next() {
-            // Take one literal as an index
-            Some(TokenTree::Literal(literal)) => literal.to_string(),
-            Some(_) => panic!("Expected literal index"),
+        let index = match input.next() { // Take one literal as an index
+            Some(TokenTree::Literal(literal)) => literal.span().source_text().unwrap(),
+            Some(index) => panic!(format!("Expected literal index {:?}",index)),
             None => return None,
         };
-        match input.next() {
-            // Look for '=' in "=>"
-            Some(TokenTree::Punct(punct)) if punct.as_char() == '=' => {}
+        match input.next() { // Look for '=' in "=>"
+            Some(TokenTree::Punct(punct)) if punct.as_char() == '=' => {},
             _ => panic!("Expected '=>'"),
         };
-        match input.next() {
-            // Look for '>' in "=>"
-            Some(TokenTree::Punct(punct)) if punct.as_char() == '>' => {}
+        match input.next() { // Look for '>' in "=>"
+            Some(TokenTree::Punct(punct)) if punct.as_char() == '>' => {},
             _ => panic!("Expected '=>'"),
         };
         let mut value = Vec::new();
         let mut closure = false;
-        loop {
-            // Accumulate value token stream until ',' is found
+        loop { // Accumulate value token stream until ',' is found
             match input.next() {
                 Some(TokenTree::Punct(punct)) if punct.as_char() == ',' && !closure => break,
-                Some(ref it @ TokenTree::Punct(ref punct)) if punct.as_char() == '|' => {
+                Some(ref it@TokenTree::Punct(ref punct)) if punct.as_char() == '|' => {
                     value.push(it.clone());
                     closure = !closure
-                }
+                },
                 Some(it) => value.push(it),
                 None => break,
             }
         }
         let mut value_stream = TokenStream::new();
         value_stream.extend(value);
-        Some(MapEntry(Some((index, value_stream))))
+        Some(MapEntry(Some((
+            index,
+            value_stream,
+        ))))
     } else {
         None
     }
 }
 
 #[proc_macro]
-pub fn map(input: TokenStream) -> TokenStream {
-    // todo: only works for string literals right now
+pub fn map(input: TokenStream) -> TokenStream { // todo: only works for string literals right now
     let mut tokens = input.into_iter().peekable();
     let mut entries = DisplacementSet::new();
     while let Some(entry) = entry(&mut tokens) {
@@ -60,35 +62,34 @@ pub fn map(input: TokenStream) -> TokenStream {
             let mut inner = TokenStream::new();
             inner.extend(vec![
                 TokenTree::Literal(Literal::string(entry.0.as_str())),
-                TokenTree::Punct(Punct::new(',', Spacing::Alone)),
+                TokenTree::Punct(Punct::new(',',Spacing::Alone)),
             ]);
             inner.extend(entry.1);
-            let inner =
-                TokenStream::from(TokenTree::Group(Group::new(Delimiter::Parenthesis, inner)));
+            let inner = TokenStream::from(TokenTree::Group(Group::new(Delimiter::Parenthesis,inner)));
             let mut option = TokenStream::new();
             option.extend(vec![
-                TokenTree::Ident(Ident::new("Some", Span::mixed_site())),
-                TokenTree::Group(Group::new(Delimiter::Parenthesis, inner)),
+                TokenTree::Ident(Ident::new("Some",Span::mixed_site())),
+                TokenTree::Group(Group::new(Delimiter::Parenthesis,inner))
             ]);
             option
         } else {
-            TokenStream::from(TokenTree::Ident(Ident::new("None", Span::mixed_site())))
+            TokenStream::from(TokenTree::Ident(Ident::new("None",Span::mixed_site())))
         };
         let mut set_entry = TokenStream::new();
         set_entry.extend(vec![
-            TokenTree::Ident(Ident::new("entry", Span::mixed_site())),
-            TokenTree::Punct(Punct::new(':', Spacing::Alone)),
-            TokenTree::Ident(Ident::new("MapEntry", Span::mixed_site())),
-            TokenTree::Group(Group::new(Delimiter::Parenthesis, option)),
-            TokenTree::Punct(Punct::new(',', Spacing::Alone)),
-            TokenTree::Ident(Ident::new("home", Span::mixed_site())),
-            TokenTree::Punct(Punct::new(':', Spacing::Alone)),
+            TokenTree::Ident(Ident::new("entry",Span::mixed_site())),
+            TokenTree::Punct(Punct::new(':',Spacing::Alone)),
+            TokenTree::Ident(Ident::new("MapEntry",Span::mixed_site())),
+            TokenTree::Group(Group::new(Delimiter::Parenthesis,option)),
+            TokenTree::Punct(Punct::new(',',Spacing::Alone)),
+            TokenTree::Ident(Ident::new("home",Span::mixed_site())),
+            TokenTree::Punct(Punct::new(':',Spacing::Alone)),
             TokenTree::Literal(Literal::usize_unsuffixed(entry.home)),
-            TokenTree::Punct(Punct::new(',', Spacing::Alone)),
-            TokenTree::Ident(Ident::new("displacement", Span::mixed_site())),
-            TokenTree::Punct(Punct::new(':', Spacing::Alone)),
+            TokenTree::Punct(Punct::new(',',Spacing::Alone)),
+            TokenTree::Ident(Ident::new("displacement",Span::mixed_site())),
+            TokenTree::Punct(Punct::new(':',Spacing::Alone)),
             TokenTree::Literal(Literal::usize_unsuffixed(entry.displacement as usize)),
-            TokenTree::Punct(Punct::new(',', Spacing::Alone)),
+            TokenTree::Punct(Punct::new(',',Spacing::Alone)),
         ]);
         elements.extend(vec![
             /*TokenTree::Ident(Ident::new("deimos",Span::mixed_site())),
@@ -97,10 +98,11 @@ pub fn map(input: TokenStream) -> TokenStream {
             TokenTree::Ident(Ident::new("map",Span::mixed_site())),
             TokenTree::Punct(Punct::new(':',Spacing::Joint)),
             TokenTree::Punct(Punct::new(':',Spacing::Joint)),*/
-            TokenTree::Ident(Ident::new("Entry", Span::mixed_site())),
-            TokenTree::Group(Group::new(Delimiter::Brace, set_entry)),
-            TokenTree::Punct(Punct::new(',', Spacing::Alone)),
+            TokenTree::Ident(Ident::new("Entry",Span::mixed_site())),
+            TokenTree::Group(Group::new(Delimiter::Brace,set_entry)),
+            TokenTree::Punct(Punct::new(',',Spacing::Alone)),
         ])
     }
-    TokenStream::from(TokenTree::Group(Group::new(Delimiter::Bracket, elements)))
-}
+    let mut array = TokenStream::from(TokenTree::Group(Group::new(Delimiter::Bracket,elements)));
+    array
+}
\ No newline at end of file
diff --git a/map/src/lib.rs b/map/src/lib.rs
index c7f806c..e083a58 100644
--- a/map/src/lib.rs
+++ b/map/src/lib.rs
@@ -251,7 +251,7 @@ impl<E: TableEntry> DisplacementSet<E> {
                     if neighbour.entry.matches(&index) {
                         neighbour.entry = E::VACANT;
                         self.map_count -= 1;
-                        #[cfg(feature = "assertions")]
+                           #[cfg(feature = "assertions")]
                         {
                             assert!(!finished);
                             finished = true;
diff --git a/src/gc.rs b/src/gc.rs
index 18cdbf4..9e9a54a 100644
--- a/src/gc.rs
+++ b/src/gc.rs
@@ -32,7 +32,7 @@ impl<T> From<AnyId> for Id<T> {
 }
 
 #[derive(Debug)]
-pub struct Id<T> {
+pub struct Id<T: ?Sized> {
     pub(crate) index: Index,
     phantom_data: PhantomData<T>,
 }
diff --git a/src/lib.rs b/src/lib.rs
index 2ce8d2f..c0435dc 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -4,7 +4,7 @@ pub use map;
 
 #[cfg(test)]
 mod tests {
-  use map::{Entry, MapEntry};
+  use map::{TableEntry,MapEntry,Entry};
   extern crate self as deimos;
 
   // Makes a constant map