diff --git a/Data/Hashable/Generic.hs b/Data/Hashable/Generic.hs
--- a/Data/Hashable/Generic.hs
+++ b/Data/Hashable/Generic.hs
@@ -1,4 +1,5 @@
 {-# LANGUAGE TypeOperators, FlexibleContexts, BangPatterns #-}
+{-# OPTIONS_GHC -Wall #-}
 -- | Stability:   stable
 --   Portability: GHC
 module Data.Hashable.Generic ( gHashWithSalt
@@ -42,15 +43,22 @@
 -- > --       a non-generic implementation. If you use this method, the generic
 -- > --       hashWithSalt will generate the exact same code as a hand-rolled
 -- > --       one.
+-- > --
+-- > --       Also, the INLINEABLE pragma is there to help hashable data
+-- > --       structures in other modules write more efficient generic hashable
+-- > --       instances too. This is the best way to get extremely performant,
+-- > --       fully generic hash functions.
 -- > instance Hashable AccountId
 -- > instance Hashable Foo where
 -- >     hashWithSalt s x = gHashWithSalt s x
+-- >     {-# INLINEABLE hashWithSalt #-}
 -- >
 -- > -- recursive list-like type
 -- > data N = Z | S N deriving Generic
 -- >
 -- > instance Hashable N where
 -- >     hashWithSalt s x = gHashWithSalt s x
+-- >     {-# INLINEABLE hashWithSalt #-}
 -- >
 -- > -- parametric and recursive type
 -- > data Bar a = Bar0 | Bar1 a | Bar2 (Bar a)
@@ -58,11 +66,16 @@
 -- >
 -- > instance Hashable a => Hashable (Bar a) where
 -- >     hashWithSalt s x = gHashWithSalt s x
+-- >     {-# INLINEABLE hashWithSalt #-}
 --
+-- I intend for 'gHashWithSalt' to be just as fast as a hand-rolled
+-- implementation. Benchmarks are currently showing a 1.3x slowdown. Patches
+-- to improve performance are welcome!
+--
 -- Note: The 'GHashable' type-class showing up in the type-signature is
 --       used internally and not exported on purpose.
 gHashWithSalt :: (Generic a, GHashable (Rep a)) => Int -> a -> Int
-gHashWithSalt salt x = gHashWithSalt_ salt $ from x
+gHashWithSalt salt = gHashWithSalt_ salt . from
 {-# INLINE gHashWithSalt #-}
 
 -- | A value with bit pattern (01)* (or 5* in hexa), for any size of Int.
@@ -79,22 +92,22 @@
     gHashWithSalt_ :: Int -> f a -> Int
 
 instance GHashable U1 where
-    gHashWithSalt_ salt _ = hashWithSalt salt ()
+    gHashWithSalt_ = const
     {-# INLINE gHashWithSalt_ #-}
 
 instance Hashable a => GHashable (K1 i a) where
-    gHashWithSalt_ !salt = hashWithSalt salt . unK1
+    gHashWithSalt_ salt = hashWithSalt salt . unK1
     {-# INLINE gHashWithSalt_ #-}
 
 instance GHashable a => GHashable (M1 i c a) where
-    gHashWithSalt_ !salt = gHashWithSalt_ salt . unM1
+    gHashWithSalt_ salt = gHashWithSalt_ salt . unM1
     {-# INLINE gHashWithSalt_ #-}
 
 instance (GHashable a, GHashable b) => GHashable (a :*: b) where
-    gHashWithSalt_ !salt (x :*: y) = gHashWithSalt_ (gHashWithSalt_ salt x) y
+    gHashWithSalt_ salt (x :*: y) = gHashWithSalt_ (gHashWithSalt_ salt x) y
     {-# INLINE gHashWithSalt_ #-}
 
 instance (GHashable a, GHashable b) => GHashable (a :+: b) where
-    gHashWithSalt_ !salt (L1 x) = gHashWithSalt_ (salt `combine` 0) x
-    gHashWithSalt_ !salt (R1 x) = gHashWithSalt_ (salt `combine` distinguisher) x
+    gHashWithSalt_ !salt (L1 x) = gHashWithSalt_ (combine salt 0) x
+    gHashWithSalt_ !salt (R1 x) = gHashWithSalt_ (combine salt distinguisher) x
     {-# INLINE gHashWithSalt_ #-}
diff --git a/bench/Bench.hs b/bench/Bench.hs
--- a/bench/Bench.hs
+++ b/bench/Bench.hs
@@ -37,7 +37,27 @@
                       i = HR2 e f
                       j = HR2 g h
                       k = HR2 i j
-                   in HR2 k k
+                      l = HR2 k k
+                      m = HR2 l l
+                      n = HR2 m m
+                      o = HR2 n n
+                      p = HR2 o o
+                      q = HR2 p p
+                      r = HR2 q q
+                      s = HR2 r r
+                      t = HR2 s s
+                      u = HR2 t t
+                      v = HR2 u u
+                      w = HR2 v v
+                      x = HR2 w w
+                      y = HR2 x x
+                      z = HR2 y y
+                      za = HR2 z z
+                      zb = HR2 za za
+                      zc = HR2 zb zb
+                      zd = HR2 zc zc
+                      ze = HR2 zd zd
+                   in ze
 
 bigGenericRolledDS :: GenericRolled
 bigGenericRolledDS = f bigHandRolledDS
diff --git a/hashable-generics.cabal b/hashable-generics.cabal
--- a/hashable-generics.cabal
+++ b/hashable-generics.cabal
@@ -1,5 +1,5 @@
 name:                hashable-generics
-version:             1.1.6
+version:             1.1.7
 synopsis:            Automatically generates Hashable instances with GHC.Generics.
 description:
     This package provides a "GHC.Generics"-based 'Data.Hashable.Generic.gHashWithSalt'
@@ -18,7 +18,7 @@
 category:            Data
 build-type:          Simple
 cabal-version:       >=1.8
-tested-with:         GHC >=7.4
+tested-with:         GHC ==7.4.1, GHC ==7.6.1
 
 source-repository head
     type: git
diff --git a/test/Suite.hs b/test/Suite.hs
--- a/test/Suite.hs
+++ b/test/Suite.hs
@@ -51,7 +51,8 @@
     arbitrary = AccountId <$> arbitrary
 
 instance Hashable FooA where
-    hashWithSalt = gHashWithSalt
+    hashWithSalt s x = gHashWithSalt s x
+    {-# INLINEABLE hashWithSalt #-}
 
 instance Hashable FooB where
     hashWithSalt salt (FooB ac n ad) = hashWithSalt
@@ -74,9 +75,10 @@
 
 instance Hashable NA where
     hashWithSalt s x = gHashWithSalt s x
+    {-# INLINEABLE hashWithSalt #-}
 
 instance Hashable NB where
-    hashWithSalt !salt ZB      = hashWithSalt (salt `combine` 0) ()
+    hashWithSalt !salt ZB      = combine salt 0
     hashWithSalt !salt (SB xs) = hashWithSalt (salt `combine` distinguisher) xs
 
 instance Arbitrary NA where
@@ -107,9 +109,10 @@
 
 instance Hashable a => Hashable (BarA a) where
     hashWithSalt s x = gHashWithSalt s x
+    {-# INLINEABLE hashWithSalt #-}
 
 instance Hashable a => Hashable (BarB a) where
-    hashWithSalt !salt BarB0 = hashWithSalt (salt `combine` 0) ()
+    hashWithSalt !salt BarB0 = salt `combine` 0
     hashWithSalt !salt (BarB1 x) = hashWithSalt (salt `combine` distinguisher `combine` 0) x
     hashWithSalt !salt (BarB2 x) = hashWithSalt (salt `combine` distinguisher `combine` distinguisher) x