diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,14 @@
+# Version 0.2
+
+* Rename 'ghashWithSalt' to 'ghashWithSaltDefault'.
+
+* Export 'RepGHashable'
+
+* Export 'GHashable' internals.
+
+* Relax dependencies.
+
+
 # Version 0.1.0.1
 
 * Raise upper bound on `instant-generics` dependency.
diff --git a/instant-hashable.cabal b/instant-hashable.cabal
--- a/instant-hashable.cabal
+++ b/instant-hashable.cabal
@@ -1,11 +1,14 @@
 name:                instant-hashable
-version:             0.1.0.1
+version:             0.2
 author:              Renzo Carbonara
 maintainer:          renzo@carbonara.com.ar
 copyright:           Renzo Carbonara 2015
 license:             BSD3
 license-file:        LICENSE.txt
-category:            Web
+stability:           Experimental
+homepage:            https://github.com/k0001/instant-hashable
+bug-reports:         https://github.com/k0001/instant-hashable/issues
+category:            Generics
 build-type:          Simple
 extra-source-files:  README.md CHANGELOG.md
 cabal-version:       >=1.18
@@ -18,7 +21,7 @@
       Generics.Instant.Functions.Hashable
   build-depends:
       hashable >=1.2 && <1.3
-    , base >=4.8 && <4.9
+    , base >=4.7 && <4.9
     , instant-generics >=0.4 && <0.6
   ghcjs-options: -Wall -O3
   ghc-options: -Wall -O2
diff --git a/src/lib/Generics/Instant/Functions/Hashable.hs b/src/lib/Generics/Instant/Functions/Hashable.hs
--- a/src/lib/Generics/Instant/Functions/Hashable.hs
+++ b/src/lib/Generics/Instant/Functions/Hashable.hs
@@ -4,12 +4,14 @@
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE TypeOperators #-}
 {-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE UndecidableInstances #-}
 
 module Generics.Instant.Functions.Hashable
   ( -- $defaults
-    ghashWithSalt
+    ghashWithSaltDefault
+  , RepGHashable
     -- * Internals
-  , GHashable
+  , GHashable(..)
   ) where
 
 import           Data.Hashable (Hashable(hashWithSalt))
@@ -18,48 +20,54 @@
 --------------------------------------------------------------------------------
 -- $defaults
 --
--- You can use 'ghashWithSalt' as your generic 'hashWithSalt' for any
+-- You can use 'ghashWithSaltDefault' as your generic 'hashWithSalt' for any
 -- 'Representable' type as follows:
 --
 -- @
--- instance 'Hashable' MyType where hashWithSalt = 'ghashWithSalt'
+-- instance 'Hashable' MyType where hashWithSalt = 'ghashWithSaltDefault'
 -- @
 
-ghashWithSalt :: (Representable a, GHashable (Rep a)) => Int -> a -> Int
-ghashWithSalt = \s a -> ghashWithSalt' s (from a)
-{-# INLINABLE ghashWithSalt #-}
+ghashWithSaltDefault :: (Representable a, GHashable (Rep a)) => Int -> a -> Int
+ghashWithSaltDefault = \s a -> ghashWithSalt s (from a)
+{-# INLINABLE ghashWithSaltDefault #-}
 
+-- | @'RepGHashable'@ is simply a synonym for
+-- @('Representable' a, 'GHashable' ('Rep' a))@ with the convenient
+-- kind @(* -> 'GHC.Exts.Constraint')@
+class (Representable a, GHashable (Rep a)) => RepGHashable a
+instance (Representable a, GHashable (Rep a)) => RepGHashable a
+
 --------------------------------------------------------------------------------
 
 class GHashable a where
-  ghashWithSalt' :: Int -> a -> Int
+  ghashWithSalt :: Int -> a -> Int
 
 instance GHashable Z where
-  ghashWithSalt' _ _ = error
-    "Generics.Instant.Functions.Hashable.GHashable Z ghashWithSalt' - impossible"
+  ghashWithSalt _ _ = error
+    "Generics.Instant.Functions.Hashable.GHashable Z ghashWithSalt - impossible"
 
 instance GHashable U where
-  ghashWithSalt' s U = hashWithSalt s ()
-  {-# INLINABLE ghashWithSalt' #-}
+  ghashWithSalt s U = hashWithSalt s ()
+  {-# INLINABLE ghashWithSalt #-}
 
 instance GHashable a => GHashable (CEq c p q a) where
-  ghashWithSalt' s (C a) = ghashWithSalt' s a
-  {-# INLINABLE ghashWithSalt' #-}
+  ghashWithSalt s (C a) = ghashWithSalt s a
+  {-# INLINABLE ghashWithSalt #-}
 
 instance (GHashable a, GHashable b) => GHashable (a :*: b) where
-  ghashWithSalt' s (a :*: b) = ghashWithSalt' (ghashWithSalt' s a) b
-  {-# INLINABLE ghashWithSalt' #-}
+  ghashWithSalt s (a :*: b) = ghashWithSalt (ghashWithSalt s a) b
+  {-# INLINABLE ghashWithSalt #-}
 
 instance (GHashable a, GHashable b) => GHashable (a :+: b) where
-  ghashWithSalt' s lr = 0 `hashWithSalt` case lr of
-    L a -> Left  (ghashWithSalt' s a)
-    R b -> Right (ghashWithSalt' s b)
-  {-# INLINABLE ghashWithSalt' #-}
+  ghashWithSalt s lr = 0 `hashWithSalt` case lr of
+    L a -> Left  (ghashWithSalt s a)
+    R b -> Right (ghashWithSalt s b)
+  {-# INLINABLE ghashWithSalt #-}
 
 instance Hashable a => GHashable (Var a) where
-  ghashWithSalt' s (Var a) = hashWithSalt s a
-  {-# INLINABLE ghashWithSalt' #-}
+  ghashWithSalt s (Var a) = hashWithSalt s a
+  {-# INLINABLE ghashWithSalt #-}
 
 instance Hashable a => GHashable (Rec a) where
-  ghashWithSalt' s (Rec a) = hashWithSalt s a
-  {-# INLINABLE ghashWithSalt' #-}
+  ghashWithSalt s (Rec a) = hashWithSalt s a
+  {-# INLINABLE ghashWithSalt #-}