diff --git a/changelog.md b/changelog.md
--- a/changelog.md
+++ b/changelog.md
@@ -1,3 +1,7 @@
+0.0.8
+
+* Put specialisations back
+
 0.0.7
 
 * More generalising
diff --git a/reader.cabal b/reader.cabal
--- a/reader.cabal
+++ b/reader.cabal
@@ -1,5 +1,5 @@
 name:                 reader
-version:              0.0.7
+version:              0.0.8
 synopsis:             A reader data type with all the bits
 description:          A reader data type with all the bits and type constructor rearrangements
 license:              BSD3
diff --git a/src/Data/Reader/Reader1.hs b/src/Data/Reader/Reader1.hs
--- a/src/Data/Reader/Reader1.hs
+++ b/src/Data/Reader/Reader1.hs
@@ -9,15 +9,26 @@
 module Data.Reader.Reader1(
   Reader1T(..)
 , Reader1
+, Reader1Lens
+, reader1
+, reader1Lens
+, reader1'
+, star1
+, kleisli1
+, liftReader1
+, pureReader1
+, homReader1
 ) where
 
 import Control.Applicative
     ( Applicative((<*>), pure), Alternative((<|>), empty) )
+import Control.Arrow ( Kleisli )
 import Control.Category ( Category(..) )
 import Control.Lens
-    ( view, iso, over, _Wrapped, Rewrapped, Wrapped(..) )
+    ( LensLike, view, iso, over, _Wrapped, Iso, Rewrapped, Wrapped(..) )
 import Control.Monad
     ( Monad(return, (>>=)), MonadPlus(..) )
+import qualified Control.Monad.Reader as Reader( ReaderT )
 import Control.Monad.Reader.Class ( MonadReader )
 import qualified Control.Monad.Reader.Class as Reader ( MonadReader(..) )
 import Control.Monad.State.Class ( MonadState(..) )
@@ -38,6 +49,16 @@
 import Data.Functor.Identity ( Identity(..) )
 import Data.Functor.Plus ( Plus(..) )
 import Data.Monoid(Monoid(mempty))
+import Data.Profunctor ( Star )
+import Data.Reader.Reader
+    ( pureReader,
+      homReader,
+      reader,
+      readerLens,
+      star,
+      kleisli,
+      reader',
+      liftReader )
 import Data.Semigroup ( Semigroup((<>)) )
 
 newtype Reader1T a f b =
@@ -54,6 +75,78 @@
 
 type Reader1 a b =
   Reader1T a Identity b
+
+reader1 ::
+  Iso
+    (Reader1 a b)
+    (Reader1 a' b')
+    (a -> b)
+    (a' -> b')
+reader1 =
+  reader
+
+type Reader1Lens f s t a b =
+  Reader1T a f b
+  -> Reader1T s f t
+
+reader1Lens ::
+  Iso
+    (LensLike f s t a b)
+    (LensLike f' s' t' a' b')
+    (Reader1Lens f s t a b)
+    (Reader1Lens f' s' t' a' b')
+reader1Lens =
+  readerLens
+
+reader1' ::
+  Iso
+    (Reader.ReaderT a f b)
+    (Reader.ReaderT a' f' b')
+    (Reader1T a f b)
+    (Reader1T a' f' b')
+reader1' =
+  reader'
+
+star1 ::
+  Iso
+    (Star f a b)
+    (Star f' a' b')
+    (Reader1T a f b)
+    (Reader1T a' f' b')
+star1 =
+  star
+
+kleisli1 ::
+  Iso
+    (Kleisli f a b)
+    (Kleisli f' a' b')
+    (Reader1T a f b)
+    (Reader1T a' f' b')
+kleisli1 =
+  kleisli
+
+liftReader1 ::
+  Iso
+    (Reader1T a f b)
+    (Reader1T a' f' b')
+    (Reader1 a (f b))
+    (Reader1 a' (f' b'))
+liftReader1 =
+  liftReader
+
+pureReader1 ::
+  Applicative f =>
+  Reader1 a b
+  -> Reader1T a f b
+pureReader1 =
+  pureReader
+
+homReader1 ::
+  (forall x. f x -> g x)
+  -> Reader1T a f b
+  -> Reader1T a g b
+homReader1 =
+  homReader
 
 instance Functor f => Functor (Reader1T a f) where
   fmap f (Reader1T g) =
diff --git a/src/Data/Reader/Reader2.hs b/src/Data/Reader/Reader2.hs
--- a/src/Data/Reader/Reader2.hs
+++ b/src/Data/Reader/Reader2.hs
@@ -10,6 +10,15 @@
 module Data.Reader.Reader2(
   Reader2T(..)
 , Reader2
+, Reader2Lens
+, reader2
+, reader2Lens
+, reader2'
+, star2
+, kleisli2
+, liftReader2
+, pureReader2
+, homReader2
 ) where
 
 import Control.Applicative
@@ -21,12 +30,14 @@
       (>>>),
       ArrowApply(..),
       ArrowChoice(..),
-      ArrowLoop(..) )
+      ArrowLoop(..),
+      Kleisli )
 import Control.Category ( Category(..) )
 import Control.Lens
-    ( view, iso, over, _Wrapped, Rewrapped, Wrapped(..) )
+    ( LensLike, view, iso, over, _Wrapped, Iso, Rewrapped, Wrapped(..) )
 import Control.Monad
     ( Monad(return, (>>=)), sequence, MonadPlus(..), (>=>) )
+import qualified Control.Monad.Reader as Reader( ReaderT )
 import Control.Monad.Reader.Class ( MonadReader )
 import qualified Control.Monad.Reader.Class as Reader ( MonadReader(..) )
 import Control.Monad.State.Class ( MonadState(..) )
@@ -50,12 +61,22 @@
 import Data.Profunctor
     ( Choice(..),
       Profunctor(dimap),
+      Star,
       Closed(..),
       Costrong(unfirst),
       Strong(..),
       Mapping(..),
       Cochoice(unright) )
 import Data.Profunctor.Traversing ( Traversing(..) )
+import Data.Reader.Reader
+    ( pureReader,
+      homReader,
+      reader,
+      readerLens,
+      star,
+      kleisli,
+      reader',
+      liftReader )
 import Data.Semigroup ( Semigroup((<>)) )
 import Data.Semigroupoid ( Semigroupoid(..) )
 import Data.Traversable ( Traversable(traverse) )
@@ -75,6 +96,78 @@
 
 type Reader2 a b =
   Reader2T Identity a b
+
+reader2 ::
+  Iso
+    (Reader2 a b)
+    (Reader2 a' b')
+    (a -> b)
+    (a' -> b')
+reader2 =
+  reader
+
+reader2' ::
+  Iso
+    (Reader.ReaderT a f b)
+    (Reader.ReaderT a' f' b')
+    (Reader2T f a b)
+    (Reader2T f' a' b')
+reader2' =
+  reader'
+
+type Reader2Lens f s t a b =
+  Reader2T f a b
+  -> Reader2T f s t
+
+reader2Lens ::
+  Iso
+    (LensLike f s t a b)
+    (LensLike f' s' t' a' b')
+    (Reader2Lens f s t a b)
+    (Reader2Lens f' s' t' a' b')
+reader2Lens =
+  readerLens
+
+star2 ::
+  Iso
+    (Star f a b)
+    (Star f' a' b')
+    (Reader2T f a b)
+    (Reader2T f' a' b')
+star2 =
+  star
+
+kleisli2 ::
+  Iso
+    (Kleisli f a b)
+    (Kleisli f' a' b')
+    (Reader2T f a b)
+    (Reader2T f' a' b')
+kleisli2 =
+  kleisli
+
+liftReader2 ::
+  Iso
+    (Reader2T f a b)
+    (Reader2T f' a' b')
+    (Reader2 a (f b))
+    (Reader2 a' (f' b'))
+liftReader2 =
+  liftReader
+
+pureReader2 ::
+  Applicative f =>
+  Reader2 a b
+  -> Reader2T f a b
+pureReader2 =
+  pureReader
+
+homReader2 ::
+  (forall x. f x -> g x)
+  -> Reader2T f a b
+  -> Reader2T g a b
+homReader2 =
+  homReader
 
 instance Functor f => Functor (Reader2T f a) where
   fmap f (Reader2T g) =
diff --git a/src/Data/Reader/Reader3.hs b/src/Data/Reader/Reader3.hs
--- a/src/Data/Reader/Reader3.hs
+++ b/src/Data/Reader/Reader3.hs
@@ -9,20 +9,41 @@
 module Data.Reader.Reader3(
   Reader3T(..)
 , Reader3
+, Reader3Lens
+, reader3
+, reader3Lens
+, reader3'
+, star3
+, kleisli3
+, liftReader3
+, pureReader3
+, homReader3
 ) where
 
 import Control.Applicative
     ( Applicative(pure), liftA2 )
+import Control.Arrow ( Kleisli )
 import Control.Category ( Category(..) )
 import Control.Lens
-    ( iso, over, _Wrapped, Rewrapped, Wrapped(..) )
+    ( LensLike, iso, over, _Wrapped, Iso, Rewrapped, Wrapped(..) )
+import qualified Control.Monad.Reader as Reader( ReaderT )
 import Data.Either ( either )
 import Data.Functor.Apply ( Apply(liftF2) )
 import Data.Functor.Contravariant ( Contravariant(contramap) )
 import Data.Functor.Contravariant.Divisible
     ( Decidable(..), Divisible(..) )
 import Data.Functor.Identity ( Identity(..) )
+import Data.Profunctor ( Star )
 import Data.Monoid(Monoid(mempty, mappend))
+import Data.Reader.Reader
+    ( pureReader,
+      homReader,
+      reader,
+      readerLens,
+      star,
+      kleisli,
+      reader',
+      liftReader )
 import Data.Semigroup ( Semigroup((<>)) )
 import Data.Void ( absurd )
 
@@ -40,6 +61,78 @@
 
 type Reader3 a b =
   Reader3T Identity b a
+
+reader3 ::
+  Iso
+    (Reader3 a b)
+    (Reader3 a' b')
+    (a -> b)
+    (a' -> b')
+reader3 =
+  reader
+
+reader3' ::
+  Iso
+    (Reader.ReaderT a f b)
+    (Reader.ReaderT a' f' b')
+    (Reader3T f b a)
+    (Reader3T f' b' a')
+reader3' =
+  reader'
+
+type Reader3Lens f s t a b =
+  Reader3T f b a
+  -> Reader3T f t s
+
+reader3Lens ::
+  Iso
+    (LensLike f s t a b)
+    (LensLike f' s' t' a' b')
+    (Reader3Lens f s t a b)
+    (Reader3Lens f' s' t' a' b')
+reader3Lens =
+  readerLens
+
+star3 ::
+  Iso
+    (Star f a b)
+    (Star f' a' b')
+    (Reader3T f b a)
+    (Reader3T f' b' a')
+star3 =
+  star
+
+kleisli3 ::
+  Iso
+    (Kleisli f a b)
+    (Kleisli f' a' b')
+    (Reader3T f b a)
+    (Reader3T f' b' a')
+kleisli3 =
+  kleisli
+
+liftReader3 ::
+  Iso
+    (Reader3T f b a)
+    (Reader3T f' b' a')
+    (Reader3 a (f b))
+    (Reader3 a' (f' b'))
+liftReader3 =
+  liftReader
+
+pureReader3 ::
+  Applicative f =>
+  Reader3 a b
+  -> Reader3T f b a
+pureReader3 =
+  pureReader
+
+homReader3 ::
+  (forall x. f x -> g x)
+  -> Reader3T f b a
+  -> Reader3T g b a
+homReader3 =
+  homReader
 
 instance Contravariant (Reader3T f b) where
   contramap f =