diff --git a/src/generics.rs b/src/generics.rs
index 50b9802..732baa3 100644
--- a/src/generics.rs
+++ b/src/generics.rs
@@ -19,6 +19,11 @@
 #[derive(Debug)]
 pub struct TyGenerics<'a>(&'a Generics);
 
+#[cfg(feature = "printing")]
+/// Returned by `TyGenerics::as_turbofish`.
+#[derive(Debug)]
+pub struct Turbofish<'a>(&'a Generics);
+
 impl Generics {
     #[cfg(feature = "printing")]
     /// Split a type's generics into the pieces required for impl'ing a trait
@@ -45,6 +50,14 @@
     }
 }
 
+impl<'a> TyGenerics<'a> {
+    #[cfg(feature = "printing")]
+    /// Turn a type's generics like `<X, Y>` into a turbofish like `::<X, Y>`.
+    pub fn as_turbofish(&self) -> Turbofish {
+        Turbofish(self.0)
+    }
+}
+
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub struct Lifetime {
     pub ident: Ident,
@@ -360,6 +373,17 @@
         }
     }
 
+    impl<'a> ToTokens for Turbofish<'a> {
+        fn to_tokens(&self, tokens: &mut Tokens) {
+            let has_lifetimes = !self.0.lifetimes.is_empty();
+            let has_ty_params = !self.0.ty_params.is_empty();
+            if has_lifetimes || has_ty_params {
+                tokens.append("::");
+                TyGenerics(self.0).to_tokens(tokens);
+            }
+        }
+    }
+
     impl ToTokens for Lifetime {
         fn to_tokens(&self, tokens: &mut Tokens) {
             self.ident.to_tokens(tokens);
diff --git a/src/lib.rs b/src/lib.rs
index e365491..fe80c6b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -41,7 +41,7 @@
                    WhereBoundPredicate, WhereClause, WhereEqPredicate, WherePredicate,
                    WhereRegionPredicate};
 #[cfg(feature = "printing")]
-pub use generics::{ImplGenerics, TyGenerics};
+pub use generics::{ImplGenerics, Turbofish, TyGenerics};
 
 mod ident;
 pub use ident::Ident;
@@ -90,11 +90,11 @@
 #[cfg(feature = "parsing")]
 mod parsing {
     use super::*;
-    use {derive, generics, ident, space, ty};
+    use {derive, generics, ident, mac, space, ty};
     use nom::IResult;
 
     #[cfg(feature = "full")]
-    use {expr, item, krate, mac};
+    use {expr, item, krate};
 
     pub fn parse_derive_input(input: &str) -> Result<DeriveInput, String> {
         unwrap("derive input", derive::parsing::derive_input, input)
diff --git a/tests/test_generics.rs b/tests/test_generics.rs
index 3e2fd42..822d22d 100644
--- a/tests/test_generics.rs
+++ b/tests/test_generics.rs
@@ -58,15 +58,19 @@
     };
 
     let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
-
     let tokens = quote! {
         impl #impl_generics MyTrait for Test #ty_generics #where_clause {}
     };
-
     let expected = concat!("impl < 'a , 'b : 'a , # [ may_dangle ] T : 'a > ",
                            "MyTrait for Test < 'a , 'b , T > ",
                            "where T : Debug { }");
+    assert_eq!(expected, tokens.to_string());
 
+    let turbofish = ty_generics.as_turbofish();
+    let tokens = quote! {
+        Test #turbofish
+    };
+    let expected = "Test :: < 'a , 'b , T >";
     assert_eq!(expected, tokens.to_string());
 }