diff --git a/examples/unstable/Cargo.toml b/examples/unstable/Cargo.toml
new file mode 100644
index 0000000..0671dbf
--- /dev/null
+++ b/examples/unstable/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "unstable"
+version = "0.1.0"
+authors = ["Sergio Benitez <sb@sergio.bz>"]
+
+[lib]
+proc-macro = true
+
+[[bin]]
+name = "unstable"
+path = "src/main.rs"
+
+[dependencies]
+syn = { path = "../../", features = ["full", "unstable"] }
+
+[patch.crates-io]
+proc-macro2 = { path = "../../../proc-macro2" }
diff --git a/examples/unstable/src/lib.rs b/examples/unstable/src/lib.rs
new file mode 100644
index 0000000..87e1c05
--- /dev/null
+++ b/examples/unstable/src/lib.rs
@@ -0,0 +1,91 @@
+#![feature(proc_macro, core_intrinsics)]
+
+extern crate syn;
+extern crate proc_macro;
+
+use proc_macro::{TokenStream, Span, Diagnostic};
+
+use syn::*;
+use syn::spanned::Spanned;
+use syn::synom::{Synom, Cursor, SynomBuffer};
+
+struct Parser {
+    buffer: Box<SynomBuffer>,
+    cursor: Cursor<'static>,
+}
+
+impl Parser {
+    fn new(tokens: TokenStream) -> Parser {
+        let buffer = Box::new(SynomBuffer::new(tokens.into()));
+        let cursor = unsafe {
+            let buffer: &'static SynomBuffer = ::std::mem::transmute(&*buffer);
+            buffer.begin()
+        };
+
+        Parser {
+            buffer: buffer,
+            cursor: cursor,
+        }
+    }
+
+    fn current_span(&self) -> Span {
+        self.cursor.current_span()
+            .map(|sp| sp.into_inner())
+            .unwrap_or_else(|| Span::def_site())
+    }
+
+    fn parse<T: Synom>(&mut self) -> Result<T, Diagnostic> {
+        let (cursor, val) = T::parse(self.cursor)
+            .map_err(|e| {
+                let expected = match T::description() {
+                    Some(desc) => desc,
+                    None => unsafe { ::std::intrinsics::type_name::<T>() }
+                };
+
+                self.current_span().error(format!("{}: expected {}", e, expected))
+            })?;
+
+        self.cursor = cursor;
+        Ok(val)
+    }
+
+    fn eof(&mut self) -> Result<(), Diagnostic> {
+        if !self.cursor.is_eof() {
+            return Err(self.current_span()
+                       .error("trailing characters; expected eof"));
+        }
+
+        Ok(())
+    }
+}
+
+fn eval(input: TokenStream) -> Result<TokenStream, Diagnostic> {
+    let mut parser = Parser::new(input);
+
+    let a = parser.parse::<ExprTuple>()?;
+    parser.parse::<token::Eq>()?;
+    let b = parser.parse::<ExprTuple>()?;
+    parser.eof()?;
+
+    let (a_len, b_len) = (a.elems.len(), b.elems.len());
+    if a_len != b_len {
+        let diag = b.span()
+            .error(format!("expected {} element(s), got {}", a_len, b_len))
+            .span_note(a.span(), "because of this");
+
+        return Err(diag);
+    }
+
+    Ok("println!(\"All good!\")".parse().unwrap())
+}
+
+#[proc_macro]
+pub fn demo(input: TokenStream) -> TokenStream {
+    match eval(input) {
+        Ok(val) => val,
+        Err(diag) => {
+            diag.emit();
+            "".parse().unwrap()
+        }
+    }
+}
diff --git a/examples/unstable/src/main.rs b/examples/unstable/src/main.rs
new file mode 100644
index 0000000..6b4c3cf
--- /dev/null
+++ b/examples/unstable/src/main.rs
@@ -0,0 +1,12 @@
+#[macro_use]
+extern crate unstable;
+
+pub fn main() {
+    demo!((a, b) = (1, 2, 3));
+    demo!((a, b, c) = (1, 2, 3));
+    demo!((c) = (1, 2, 3));
+    demo!((c) ? (1, 2, 3));
+    demo!(c = (1, 2, 3));
+    demo!((a, b, c) = (1, 2, 3) hi);
+}
+
diff --git a/src/cursor.rs b/src/cursor.rs
index ce8934d..f4fe859 100644
--- a/src/cursor.rs
+++ b/src/cursor.rs
@@ -231,10 +231,10 @@
 
     /// If the cursor is pointing at a Term, return it and a cursor pointing at
     /// the next `TokenTree`.
-    pub fn word(mut self) -> Option<(Cursor<'a>, Span, Term)> {
+    pub fn term(mut self) -> Option<(Cursor<'a>, Span, Term)> {
         self.ignore_none();
         match *self.entry() {
-            Entry::Term(span, sym) => Some((unsafe { self.bump() }, span, sym)),
+            Entry::Term(span, term) => Some((unsafe { self.bump() }, span, term)),
             _ => None,
         }
     }
@@ -244,7 +244,7 @@
     pub fn op(mut self) -> Option<(Cursor<'a>, Span, char, Spacing)> {
         self.ignore_none();
         match *self.entry() {
-            Entry::Op(span, chr, kind) => Some((unsafe { self.bump() }, span, chr, kind)),
+            Entry::Op(span, chr, spacing) => Some((unsafe { self.bump() }, span, chr, spacing)),
             _ => None,
         }
     }
@@ -293,9 +293,9 @@
                 span: span,
                 kind: TokenNode::Term(sym),
             },
-            Entry::Op(span, chr, kind) => TokenTree {
+            Entry::Op(span, chr, spacing) => TokenTree {
                 span: span,
-                kind: TokenNode::Op(chr, kind),
+                kind: TokenNode::Op(chr, spacing),
             },
             Entry::End(..) => {
                 return None;
diff --git a/src/ident.rs b/src/ident.rs
index f93fb43..f370e34 100644
--- a/src/ident.rs
+++ b/src/ident.rs
@@ -87,7 +87,7 @@
 /// ```
 #[derive(Copy, Clone, Debug)]
 pub struct Ident {
-    sym: Term,
+    term: Term,
     pub span: Span,
 }
 
@@ -132,7 +132,7 @@
         }
 
         Ident {
-            sym: Term::intern(s),
+            term: Term::intern(s),
             span: span,
         }
     }
@@ -182,13 +182,13 @@
 
 impl AsRef<str> for Ident {
     fn as_ref(&self) -> &str {
-        self.sym.as_str()
+        self.term.as_str()
     }
 }
 
 impl Display for Ident {
     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        self.sym.as_str().fmt(formatter)
+        self.term.as_str().fmt(formatter)
     }
 }
 
@@ -231,14 +231,14 @@
 
     impl Synom for Ident {
         fn parse(input: Cursor) -> PResult<Self> {
-            let (rest, span, sym) = match input.word() {
-                Some(word) => word,
+            let (rest, span, term) = match input.term() {
+                Some(term) => term,
                 _ => return parse_error(),
             };
-            if sym.as_str().starts_with('\'') {
+            if term.as_str().starts_with('\'') {
                 return parse_error();
             }
-            match sym.as_str() {
+            match term.as_str() {
                 // From https://doc.rust-lang.org/grammar.html#keywords
                 "abstract" | "alignof" | "as" | "become" | "box" | "break" | "const"
                 | "continue" | "crate" | "do" | "else" | "enum" | "extern" | "false" | "final"
@@ -254,7 +254,7 @@
                 rest,
                 Ident {
                     span: span,
-                    sym: sym,
+                    term: term,
                 },
             ))
         }
@@ -275,7 +275,7 @@
         fn to_tokens(&self, tokens: &mut Tokens) {
             tokens.append(TokenTree {
                 span: self.span,
-                kind: TokenNode::Term(self.sym),
+                kind: TokenNode::Term(self.term),
             })
         }
     }
diff --git a/src/lifetime.rs b/src/lifetime.rs
index dabe581..65f3f37 100644
--- a/src/lifetime.rs
+++ b/src/lifetime.rs
@@ -8,13 +8,13 @@
 #[cfg_attr(feature = "extra-traits", derive(Debug))]
 #[cfg_attr(feature = "clone-impls", derive(Clone))]
 pub struct Lifetime {
-    sym: Term,
+    term: Term,
     pub span: Span,
 }
 
 impl Lifetime {
-    pub fn new(sym: Term, span: Span) -> Self {
-        let s = sym.as_str();
+    pub fn new(term: Term, span: Span) -> Self {
+        let s = term.as_str();
 
         if !s.starts_with('\'') {
             panic!(
@@ -51,7 +51,7 @@
         }
 
         Lifetime {
-            sym: sym,
+            term: term,
             span: span,
         }
     }
@@ -59,13 +59,13 @@
 
 impl Display for Lifetime {
     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        self.sym.as_str().fmt(formatter)
+        self.term.as_str().fmt(formatter)
     }
 }
 
 impl PartialEq for Lifetime {
     fn eq(&self, other: &Lifetime) -> bool {
-        self.sym.as_str() == other.sym.as_str()
+        self.term.as_str() == other.term.as_str()
     }
 }
 
@@ -79,13 +79,13 @@
 
 impl Ord for Lifetime {
     fn cmp(&self, other: &Lifetime) -> Ordering {
-        self.sym.as_str().cmp(other.sym.as_str())
+        self.term.as_str().cmp(other.term.as_str())
     }
 }
 
 impl Hash for Lifetime {
     fn hash<H: Hasher>(&self, h: &mut H) {
-        self.sym.as_str().hash(h)
+        self.term.as_str().hash(h)
     }
 }
 
@@ -99,18 +99,18 @@
 
     impl Synom for Lifetime {
         fn parse(input: Cursor) -> PResult<Self> {
-            let (rest, span, sym) = match input.word() {
-                Some(word) => word,
+            let (rest, span, term) = match input.term() {
+                Some(term) => term,
                 _ => return parse_error(),
             };
-            if !sym.as_str().starts_with('\'') {
+            if !term.as_str().starts_with('\'') {
                 return parse_error();
             }
 
             Ok((
                 rest,
                 Lifetime {
-                    sym: sym,
+                    term: term,
                     span: span,
                 },
             ))
@@ -132,7 +132,7 @@
         fn to_tokens(&self, tokens: &mut Tokens) {
             tokens.append(TokenTree {
                 span: self.span,
-                kind: TokenNode::Term(self.sym),
+                kind: TokenNode::Term(self.term),
             })
         }
     }
diff --git a/src/lit.rs b/src/lit.rs
index 83d9f9d..b7b1e3e 100644
--- a/src/lit.rs
+++ b/src/lit.rs
@@ -112,11 +112,11 @@
                         value: LitKind::Other(lit),
                     },
                 )),
-                _ => match input.word() {
-                    Some((rest, span, sym)) => {
-                        let kind = if sym.as_str() == "true" {
+                _ => match input.term() {
+                    Some((rest, span, term)) => {
+                        let kind = if term.as_str() == "true" {
                             LitKind::Bool(true)
-                        } else if sym.as_str() == "false" {
+                        } else if term.as_str() == "false" {
                             LitKind::Bool(false)
                         } else {
                             return parse_error();
diff --git a/src/token.rs b/src/token.rs
index d3e320a..a41b6e8 100644
--- a/src/token.rs
+++ b/src/token.rs
@@ -9,23 +9,23 @@
 
 macro_rules! tokens {
     (
-        ops: {
-            $($op:tt pub struct $op_name:ident/$len:tt #[$op_doc:meta])*
+        punct: {
+            $($punct:tt pub struct $punct_name:ident/$len:tt #[$punct_doc:meta])*
         }
-        delim: {
-            $($delim:tt pub struct $delim_name:ident #[$delim_doc:meta])*
+        delimiter: {
+            $($delimiter:tt pub struct $delimiter_name:ident #[$delimiter_doc:meta])*
         }
-        syms: {
-            $($sym:tt pub struct $sym_name:ident #[$sym_doc:meta])*
+        keyword: {
+            $($keyword:tt pub struct $keyword_name:ident #[$keyword_doc:meta])*
         }
     ) => (
-        $(op! { #[$op_doc] $op pub struct $op_name/$len })*
-        $(delim! { #[$delim_doc] $delim pub struct $delim_name })*
-        $(sym! { #[$sym_doc] $sym pub struct $sym_name })*
+        $(token_punct! { #[$punct_doc] $punct pub struct $punct_name/$len })*
+        $(token_delimiter! { #[$delimiter_doc] $delimiter pub struct $delimiter_name })*
+        $(token_keyword! { #[$keyword_doc] $keyword pub struct $keyword_name })*
     )
 }
 
-macro_rules! op {
+macro_rules! token_punct {
     (#[$doc:meta] $s:tt pub struct $name:ident/$len:tt) => {
         #[cfg_attr(feature = "clone-impls", derive(Copy, Clone))]
         #[derive(Default)]
@@ -65,14 +65,14 @@
         #[cfg(feature = "printing")]
         impl ::quote::ToTokens for $name {
             fn to_tokens(&self, tokens: &mut ::quote::Tokens) {
-                printing::op($s, &self.0, tokens);
+                printing::punct($s, &self.0, tokens);
             }
         }
 
         #[cfg(feature = "parsing")]
         impl ::Synom for $name {
             fn parse(tokens: $crate::synom::Cursor) -> $crate::synom::PResult<$name> {
-                parsing::op($s, tokens, $name)
+                parsing::punct($s, tokens, $name)
             }
 
             fn description() -> Option<&'static str> {
@@ -82,7 +82,7 @@
     }
 }
 
-macro_rules! sym {
+macro_rules! token_keyword {
     (#[$doc:meta] $s:tt pub struct $name:ident) => {
         #[cfg_attr(feature = "clone-impls", derive(Copy, Clone))]
         #[derive(Default)]
@@ -116,20 +116,20 @@
         #[cfg(feature = "printing")]
         impl ::quote::ToTokens for $name {
             fn to_tokens(&self, tokens: &mut ::quote::Tokens) {
-                printing::sym($s, &self.0, tokens);
+                printing::keyword($s, &self.0, tokens);
             }
         }
 
         #[cfg(feature = "parsing")]
         impl ::Synom for $name {
             fn parse(tokens: $crate::synom::Cursor) -> $crate::synom::PResult<$name> {
-                parsing::sym($s, tokens, $name)
+                parsing::keyword($s, tokens, $name)
             }
         }
     }
 }
 
-macro_rules! delim {
+macro_rules! token_delimiter {
     (#[$doc:meta] $s:tt pub struct $name:ident) => {
         #[cfg_attr(feature = "clone-impls", derive(Copy, Clone))]
         #[derive(Default)]
@@ -181,7 +181,7 @@
 }
 
 tokens! {
-    ops: {
+    punct: {
         "+"        pub struct Add/1        /// `+`
         "+="       pub struct AddEq/2      /// `+=`
         "&"        pub struct And/1        /// `&`
@@ -228,13 +228,13 @@
         "-="       pub struct SubEq/2      /// `-=`
         "_"        pub struct Underscore/1 /// `_`
     }
-    delim: {
+    delimiter: {
         "{"        pub struct Brace        /// `{...}`
         "["        pub struct Bracket      /// `[...]`
         "("        pub struct Paren        /// `(...)`
         " "        pub struct Group        /// None-delimited group
     }
-    syms: {
+    keyword: {
         "as"       pub struct As           /// `as`
         "auto"     pub struct Auto         /// `auto`
         "box"      pub struct Box          /// `box`
@@ -500,7 +500,7 @@
         }
     }
 
-    pub fn op<'a, T, R>(s: &str, mut tokens: Cursor<'a>, new: fn(T) -> R) -> PResult<'a, R>
+    pub fn punct<'a, T, R>(s: &str, mut tokens: Cursor<'a>, new: fn(T) -> R) -> PResult<'a, R>
     where
         T: FromSpans,
     {
@@ -526,9 +526,9 @@
         Ok((tokens, new(T::from_spans(&spans))))
     }
 
-    pub fn sym<'a, T>(sym: &str, tokens: Cursor<'a>, new: fn(Span) -> T) -> PResult<'a, T> {
-        if let Some((rest, span, s)) = tokens.word() {
-            if s.as_str() == sym {
+    pub fn keyword<'a, T>(keyword: &str, tokens: Cursor<'a>, new: fn(Span) -> T) -> PResult<'a, T> {
+        if let Some((rest, span, term)) = tokens.term() {
+            if term.as_str() == keyword {
                 return Ok((rest, new(span)));
             }
         }
@@ -553,11 +553,11 @@
             _ => panic!("unknown delimiter: {}", delim),
         };
 
-        if let Some(seqinfo) = tokens.group(delim) {
-            match f(seqinfo.inside) {
+        if let Some(group) = tokens.group(delim) {
+            match f(group.inside) {
                 Ok((remaining, ret)) => {
                     if remaining.eof() {
-                        return Ok((seqinfo.outside, (new(seqinfo.span), ret)));
+                        return Ok((group.outside, (new(group.span), ret)));
                     }
                 }
                 Err(err) => return Err(err),
@@ -572,7 +572,7 @@
     use proc_macro2::{Spacing, Span, Term, TokenNode, TokenTree};
     use quote::Tokens;
 
-    pub fn op(s: &str, spans: &[Span], tokens: &mut Tokens) {
+    pub fn punct(s: &str, spans: &[Span], tokens: &mut Tokens) {
         assert_eq!(s.len(), spans.len());
 
         let mut chars = s.chars();
@@ -592,7 +592,7 @@
         });
     }
 
-    pub fn sym(s: &str, span: &Span, tokens: &mut Tokens) {
+    pub fn keyword(s: &str, span: &Span, tokens: &mut Tokens) {
         tokens.append(TokenTree {
             span: *span,
             kind: TokenNode::Term(Term::intern(s)),