diff --git a/src/lib.rs b/src/lib.rs
index c28e09a..541e070 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -5,7 +5,6 @@
 extern crate synom;
 
 use std::fmt;
-use std::ops;
 use std::str::FromStr;
 use std::iter::FromIterator;
 
@@ -140,10 +139,8 @@
     }
 }
 
-impl ops::Deref for Symbol {
-    type Target = str;
-
-    fn deref(&self) -> &str {
+impl Symbol {
+    fn as_str(&self) -> &str {
         &self.0
     }
 }
@@ -164,20 +161,28 @@
 }
 
 impl Literal {
-    pub fn bytechar(b: u8) -> Literal {
-        Literal(imp::Literal::bytechar(b))
+    pub fn byte_char(b: u8) -> Literal {
+        Literal(imp::Literal::byte_char(b))
     }
 
-    pub fn bytestring(s: &[u8]) -> Literal {
-        Literal(imp::Literal::bytestring(s))
+    pub fn byte_string(s: &[u8]) -> Literal {
+        Literal(imp::Literal::byte_string(s))
     }
 
     pub fn doccomment(s: &str) -> Literal {
         Literal(imp::Literal::doccomment(s))
     }
+
+    pub fn float(s: &str) -> Literal {
+        Literal(imp::Literal::float(s))
+    }
+
+    pub fn integer(s: &str) -> Literal {
+        Literal(imp::Literal::integer(s))
+    }
 }
 
-macro_rules! tys {
+macro_rules! froms {
     ($($t:ty,)*) => {$(
         impl<'a> From<$t> for Literal {
             fn from(t: $t) -> Literal {
@@ -187,7 +192,7 @@
     )*}
 }
 
-tys! {
+froms! {
     u8, u16, u32, u64, usize,
     i8, i16, i32, i64, isize,
     f32, f64, char, &'a str,
diff --git a/src/stable.rs b/src/stable.rs
index ebff2e9..3c93888 100644
--- a/src/stable.rs
+++ b/src/stable.rs
@@ -75,7 +75,7 @@
                         write!(f, "{} {} {}", start, stream, end)?
                     }
                 }
-                TokenKind::Word(ref sym) => write!(f, "{}", &**sym)?,
+                TokenKind::Word(ref sym) => write!(f, "{}", sym.as_str())?,
                 TokenKind::Op(ch, ref op) => {
                     write!(f, "{}", ch)?;
                     match *op {
@@ -214,7 +214,7 @@
 pub struct Literal(String);
 
 impl Literal {
-    pub fn bytechar(byte: u8) -> Literal {
+    pub fn byte_char(byte: u8) -> Literal {
         match byte {
             0 => Literal(format!("b'\\0'")),
             b'\"' => Literal(format!("b'\"'")),
@@ -227,7 +227,7 @@
         }
     }
 
-    pub fn bytestring(bytes: &[u8]) -> Literal {
+    pub fn byte_string(bytes: &[u8]) -> Literal {
         let mut escaped = "b\"".to_string();
         for b in bytes {
             match *b {
@@ -248,6 +248,14 @@
     pub fn doccomment(s: &str) -> Literal {
         Literal(s.to_string())
     }
+
+    pub fn float(s: &str) -> Literal {
+        Literal(s.to_string())
+    }
+
+    pub fn integer(s: &str) -> Literal {
+        Literal(s.to_string())
+    }
 }
 
 impl fmt::Display for Literal {
@@ -256,7 +264,7 @@
     }
 }
 
-macro_rules! numbers {
+macro_rules! ints {
     ($($t:ty,)*) => {$(
         impl From<$t> for Literal {
             fn from(t: $t) -> Literal {
@@ -266,9 +274,24 @@
     )*}
 }
 
-numbers! {
+ints! {
     u8, u16, u32, u64, usize,
     i8, i16, i32, i64, isize,
+}
+
+macro_rules! floats {
+    ($($t:ty,)*) => {$(
+        impl From<$t> for Literal {
+            fn from(t: $t) -> Literal {
+                assert!(!t.is_nan());
+                assert!(!t.is_infinite());
+                Literal(format!(concat!("{}", stringify!($t)), t))
+            }
+        }
+    )*}
+}
+
+floats! {
     f32, f64,
 }